private static IntermediateQuery createFact(DBMetadata dbMetadata, ConstructionNode rootNode, DistinctVariableOnlyDataAtom projectionAtom, ExecutorRegistry executorRegistry, IntermediateQueryFactory modelFactory) { IntermediateQueryBuilder queryBuilder = modelFactory.createIQBuilder(dbMetadata, executorRegistry); queryBuilder.init(projectionAtom, rootNode); queryBuilder.addChild(rootNode, modelFactory.createTrueNode()); return queryBuilder.build(); }
@Override public IntermediateQuery enforceRootCn(IntermediateQuery query) { QueryNode root = query.getRootNode(); if(root instanceof ConstructionNode){ return query; } IntermediateQueryBuilder builder = iqFactory.createIQBuilder( query.getDBMetadata(), query.getExecutorRegistry() ); ConstructionNode rootCn = iqFactory.createConstructionNode(query.getVariables(root)); builder.init(query.getProjectionAtom(), rootCn); builder.addChild(rootCn, root); builder.appendSubtree(root, query); return builder.build(); }
/** * Recursive */ private void insertChildren(QueryNode parentNode, ImmutableList<IQTree> childrenTrees, IntermediateQueryBuilder queryBuilder) { AtomicInteger i = new AtomicInteger(0); childrenTrees.stream() .map(IQTree::getRootNode) .map(n -> queryBuilder.contains(n) ? n.clone() : n) .forEach(t -> insertChildTree(parentNode, t, childrenTrees.get(i.get()), queryBuilder, i.getAndIncrement())); }
@Override public IntermediateQuery getSubquery(QueryNode subQueryRoot, DistinctVariableOnlyDataAtom projectionAtom) { IntermediateQueryBuilder builder = iqFactory.createIQBuilder(dbMetadata, executorRegistry); builder.init(projectionAtom, subQueryRoot); builder.appendSubtree(subQueryRoot, this); return builder.build(); }
private void append(IntermediateQueryBuilder builder, Optional<QueryNode> parentInBuilder, QueryNode currentnode, DistinctVariableOnlyDataAtom projectionAtom) { if (parentInBuilder.isPresent()) { builder.addChild(parentInBuilder.get(), currentnode); } else { builder.init(projectionAtom, currentnode); } }
private void insertChildTree(QueryNode parent, QueryNode child, IQTree childTree, IntermediateQueryBuilder queryBuilder, int position) { if (parent instanceof BinaryOrderedOperatorNode) { queryBuilder.addChild(parent, child, (position == 0)? LEFT : RIGHT); } else { queryBuilder.addChild(parent, child); } insertChildren(child, childTree.getChildren(), queryBuilder); } }
@Override public IntermediateQuery convert(IQ query, DBMetadata dbMetadata, ExecutorRegistry executorRegistry) throws EmptyQueryException { if (query.getTree().isDeclaredAsEmpty()) throw new EmptyQueryException(); IntermediateQueryBuilder queryBuilder = iqFactory.createIQBuilder(dbMetadata, executorRegistry); IQTree topTree = query.getTree(); QueryNode rootNode = topTree.getRootNode(); queryBuilder.init(query.getProjectionAtom(), rootNode); insertChildren(rootNode, topTree.getChildren(), queryBuilder); return queryBuilder.build(); }
FilterNode filterNode = queryBuilder.getFactory().createFilterNode(optionalFilterCondition.get()); queryBuilder.addChild(parentNodeOfTheJoinNode, filterNode, optionalPosition); InnerJoinNode joinNode = queryBuilder.getFactory().createInnerJoinNode(optionalFilterCondition); queryBuilder.addChild(parentNodeOfTheJoinNode, joinNode, optionalPosition);
@Override public IntermediateQuery transform(IntermediateQuery originalQuery) { DistinctVariableOnlyDataAtom transformedProjectionDataAtom = transformProjectionAtom(originalQuery.getProjectionAtom()); IntermediateQueryBuilder builder = convertToBuilderAndTransform(originalQuery, nodeTransformer, transformedProjectionDataAtom); return builder.build(); }
/** * TODO: explain * <p> * TODO: avoid the use of a recursive method. Use a stack instead. */ protected IntermediateQueryBuilder convertToBuilderAndTransform(IntermediateQuery originalQuery, HomogeneousQueryNodeTransformer nodeTransformer, DistinctVariableOnlyDataAtom transformedProjectionAtom) { IntermediateQueryBuilder queryBuilder = originalQuery.newBuilder(); // Clone the original root node and apply the transformer if available. QueryNode originalRootNode = originalQuery.getRootNode(); QueryNode newRootNode; newRootNode = originalRootNode.acceptNodeTransformer(nodeTransformer); queryBuilder.init(transformedProjectionAtom, newRootNode); return copyChildrenNodesToBuilder(originalQuery, queryBuilder, originalRootNode, newRootNode, nodeTransformer); }
@Override public IntermediateQuery getSubquery(QueryNode subQueryRoot, DistinctVariableOnlyDataAtom projectionAtom) { IntermediateQueryBuilder builder = iqFactory.createIQBuilder(dbMetadata, executorRegistry); builder.init(projectionAtom, subQueryRoot); builder.appendSubtree(subQueryRoot, this); return builder.build(); }
@Override public IntermediateQueryBuilder initBuilder(IntermediateQueryFactory iqFactory, IntermediateQueryBuilder queryBuilder, DistinctVariableOnlyDataAtom projectionAtom, QueryNode childNode) { ImmutableList<UnaryOperatorNode> modifierNodes = extractModifierNodes(iqFactory); if (modifierNodes.isEmpty()) queryBuilder.init(projectionAtom, childNode); else { queryBuilder.init(projectionAtom, modifierNodes.get(0)); IntStream.range(1, modifierNodes.size()) .forEach(i -> queryBuilder.addChild(modifierNodes.get(i - 1), modifierNodes.get(i))); queryBuilder.addChild(modifierNodes.get(modifierNodes.size() - 1), childNode); } return queryBuilder; }
/** * Appends the first definition which is known to BE SAFE. * * Side-effect on the queryBuilder * */ private static void appendFirstDefinition(IntermediateQueryBuilder queryBuilder, UnionNode topUnionNode, IntermediateQuery subQuery) { // First add the root of the sub-query queryBuilder.addChild(topUnionNode, subQuery.getRootNode()); subQuery.getNodesInTopDownOrder().stream() .skip(1) .forEach(node -> queryBuilder.addChild( subQuery.getParent(node).orElseThrow(()-> new IllegalStateException("Unknown parent")), node, subQuery.getOptionalPosition(node))); }
private static IntermediateQueryBuilder convertLeftJoinAtom(IntermediateQueryBuilder queryBuilder, QueryNode parentNodeOfTheLJ, List<Function> subAtomsOfTheLJ, Optional<ArgumentPosition> optionalPosition, Collection<Predicate> tablePredicates) throws DatalogProgram2QueryConverterImpl.InvalidDatalogProgramException, IntermediateQueryBuilderException { P2<List<Function>, List<Function>> decomposition = PullOutEqualityNormalizerImpl.splitLeftJoinSubAtoms(subAtomsOfTheLJ); final List<Function> leftAtoms = decomposition._1(); final List<Function> rightAtoms = decomposition._2(); /* * TODO: explain why we just care about the right */ AtomClassification rightSubAtomClassification = new AtomClassification(rightAtoms); Optional<ImmutableExpression> optionalFilterCondition = createFilterExpression( rightSubAtomClassification.booleanAtoms); LeftJoinNode ljNode = queryBuilder.getFactory().createLeftJoinNode(optionalFilterCondition); queryBuilder.addChild(parentNodeOfTheLJ, ljNode, optionalPosition); /* * Adds the left part */ queryBuilder = convertJoinAtom(queryBuilder, ljNode, leftAtoms, LEFT_POSITION, tablePredicates); /* * Adds the right part */ return convertDataOrCompositeAtoms(rightSubAtomClassification.dataAndCompositeAtoms, queryBuilder, ljNode, RIGHT_POSITION, tablePredicates); }
@Override public IntermediateQuery transform(IntermediateQuery originalQuery) { DistinctVariableOnlyDataAtom transformedProjectionDataAtom = transformProjectionAtom(originalQuery.getProjectionAtom()); IntermediateQueryBuilder builder = convertToBuilderAndTransform(originalQuery, nodeTransformer, transformedProjectionDataAtom); return builder.build(); }
/** * TODO: explain * <p> * TODO: avoid the use of a recursive method. Use a stack instead. */ protected IntermediateQueryBuilder convertToBuilderAndTransform(IntermediateQuery originalQuery, HomogeneousQueryNodeTransformer nodeTransformer, DistinctVariableOnlyDataAtom transformedProjectionAtom) { IntermediateQueryBuilder queryBuilder = originalQuery.newBuilder(); // Clone the original root node and apply the transformer if available. QueryNode originalRootNode = originalQuery.getRootNode(); QueryNode newRootNode; newRootNode = originalRootNode.acceptNodeTransformer(nodeTransformer); queryBuilder.init(transformedProjectionAtom, newRootNode); return copyChildrenNodesToBuilder(originalQuery, queryBuilder, originalRootNode, newRootNode, nodeTransformer); }
private IntermediateQuery split(IntermediateQuery originalQuery, UnionNode unionNode, QueryNode replacingChildNode) { IntermediateQueryBuilder queryBuilder = originalQuery.newBuilder(); QueryNode rootNode = originalQuery.getRootNode(); queryBuilder.init(originalQuery.getProjectionAtom(), rootNode); Queue<QueryNode> parentNodes = new LinkedList<>(); parentNodes.add(rootNode); while(!parentNodes.isEmpty()) { QueryNode parentNode = parentNodes.poll(); for(QueryNode originalChildNode : originalQuery.getChildren(parentNode)) { QueryNode childNode = originalChildNode == unionNode ? replacingChildNode : originalChildNode; queryBuilder.addChild(parentNode, childNode, originalQuery.getOptionalPosition( parentNode, originalChildNode)); parentNodes.add(childNode); } } return queryBuilder.build(); }
/** * Appends a definition under the union node after renaming it. */ private void appendDefinition(IntermediateQueryBuilder queryBuilder, UnionNode unionNode, IntermediateQuery definition, InjectiveVar2VarSubstitution renamingSubstitution) { QueryNodeRenamer nodeRenamer = new QueryNodeRenamer(iqFactory, renamingSubstitution); ImmutableList<QueryNode> originalNodesInTopDownOrder = definition.getNodesInTopDownOrder(); /** * Renames all the nodes (new objects) and maps them to original nodes */ ImmutableMap<QueryNode, QueryNode> renamedNodeMap = originalNodesInTopDownOrder.stream() .map(n -> new AbstractMap.SimpleEntry<>(n, n.acceptNodeTransformer(nodeRenamer))) .collect(ImmutableCollectors.toMap()); /** * Adds the renamed root of the definition */ queryBuilder.addChild(unionNode, renamedNodeMap.get(definition.getRootNode())); /** * Add the other renamed nodes */ originalNodesInTopDownOrder.stream() .skip(1) .forEach(node -> queryBuilder.addChild( renamedNodeMap.get(definition.getParent(node) .orElseThrow(()-> new IllegalStateException("Unknown parent"))), renamedNodeMap.get(node), definition.getOptionalPosition(node))); }
ImmutableSubstitution<ImmutableTerm> bindings = targetAtom.getSubstitution(); DataAtom dataAtom = bindings.applyToDataAtom(targetAtom.getProjectionAtom()); DataNode currentNode = DatalogConversionTools.createDataNode(queryBuilder.getFactory(), dataAtom, tablePredicates); queryBuilder.addChild(parentNode, currentNode, optionalPosition);
private IntermediateQuery liftUnionsAboveCn(IntermediateQuery query) { if(query.getChildren(query.getRootNode()).isEmpty()){ return query; } IntermediateQueryBuilder builder = iqFactory.createIQBuilder( query.getDBMetadata(), query.getExecutorRegistry() ); lift(builder, query.getRootNode(), Optional.empty(), query, query.getRootNode(), query.getProjectionAtom()); return builder.build(); }