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); } }
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); } }
@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))); }
/** * 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))); }
private void copyChildren(IntermediateQuery sourceQuery, QueryNode sourceParent, IntermediateQueryBuilder builder, QueryNode targetParent) { for (QueryNode child : sourceQuery.getChildren(sourceParent)) { builder.addChild( targetParent, child, sourceQuery.getOptionalPosition( sourceParent, child )); copyChildren(sourceQuery, child, builder, child); } } }
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(); }
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(); }
((FilterNode) formerRootChild).getFilterCondition(), filterCondition).get()); queryBuilder.addChild(rootNode, newFilterNode); query.getChildren(formerRootChild) .forEach(c -> { queryBuilder.addChild(newFilterNode, c); parentQueue.add(c); }); InnerJoinNode newJoinNode = formerJoinNode.changeOptionalFilterCondition(Optional.of(newJoiningCondition)); queryBuilder.addChild(rootNode, newJoinNode); query.getChildren(formerJoinNode) .forEach(c -> { queryBuilder.addChild(newJoinNode, c); parentQueue.add(c); }); queryBuilder.addChild(rootNode, filterNode); queryBuilder.addChild(filterNode, formerRootChild); parentQueue.add(formerRootChild); query.getChildren(parentNode) .forEach(c -> { queryBuilder.addChild(parentNode, c, query.getOptionalPosition(parentNode, c)); parentQueue.add(c); });
((FilterNode) formerRootChild).getFilterCondition(), filterCondition).get()); queryBuilder.addChild(rootNode, newFilterNode); query.getChildren(formerRootChild) .forEach(c -> { queryBuilder.addChild(newFilterNode, c); parentQueue.add(c); }); InnerJoinNode newJoinNode = formerJoinNode.changeOptionalFilterCondition(Optional.of(newJoiningCondition)); queryBuilder.addChild(rootNode, newJoinNode); query.getChildren(formerJoinNode) .forEach(c -> { queryBuilder.addChild(newJoinNode, c); parentQueue.add(c); }); queryBuilder.addChild(rootNode, filterNode); queryBuilder.addChild(filterNode, formerRootChild); parentQueue.add(formerRootChild); query.getChildren(parentNode) .forEach(c -> { queryBuilder.addChild(parentNode, c, query.getOptionalPosition(parentNode, c)); parentQueue.add(c); });
/** * TODO: replace this implementation by a non-recursive one. */ private IntermediateQueryBuilder copyChildrenNodesToBuilder(final IntermediateQuery originalQuery, IntermediateQueryBuilder queryBuilder, final QueryNode originalParentNode, final QueryNode newParentNode, HomogeneousQueryNodeTransformer nodeTransformer) { for (QueryNode originalChildNode : originalQuery.getChildren(originalParentNode)) { QueryNode newChildNode; newChildNode = originalChildNode.acceptNodeTransformer(nodeTransformer); Optional<BinaryOrderedOperatorNode.ArgumentPosition> optionalPosition = originalQuery.getOptionalPosition(originalParentNode, originalChildNode); queryBuilder.addChild(newParentNode, newChildNode, optionalPosition); // Recursive call queryBuilder = copyChildrenNodesToBuilder(originalQuery, queryBuilder, originalChildNode, newChildNode, nodeTransformer); } return queryBuilder; }
/** * TODO: replace this implementation by a non-recursive one. */ private IntermediateQueryBuilder copyChildrenNodesToBuilder(final IntermediateQuery originalQuery, IntermediateQueryBuilder queryBuilder, final QueryNode originalParentNode, final QueryNode newParentNode, HomogeneousQueryNodeTransformer nodeTransformer) { for (QueryNode originalChildNode : originalQuery.getChildren(originalParentNode)) { QueryNode newChildNode; newChildNode = originalChildNode.acceptNodeTransformer(nodeTransformer); Optional<BinaryOrderedOperatorNode.ArgumentPosition> optionalPosition = originalQuery.getOptionalPosition(originalParentNode, originalChildNode); queryBuilder.addChild(newParentNode, newChildNode, optionalPosition); // Recursive call queryBuilder = copyChildrenNodesToBuilder(originalQuery, queryBuilder, originalChildNode, newChildNode, nodeTransformer); } return queryBuilder; }
queryBuilder.addChild(rootNode, unionNode);
if (optionalFilterOrJoinNode.isPresent()) { bottomNode = optionalFilterOrJoinNode.get(); queryBuilder.addChild(intermediateNode, bottomNode);
/** * If the root is a construction node, inserts the filter below it. * Otherwise inserts it as the root. */ private IntermediateQuery insertFilter(IntermediateQuery originalQuery, ImmutableList<Variable> nullableVariables) { FilterNode filterNode = iQFactory.createFilterNode(computeFilterExpression(nullableVariables)); IntermediateQueryBuilder builder = originalQuery.newBuilder(); QueryNode rootNode = originalQuery.getRootNode(); QueryNode newRoot = rootNode instanceof ConstructionNode ? rootNode : filterNode; QueryNode child = rootNode instanceof ConstructionNode ? filterNode : rootNode; builder.init(originalQuery.getProjectionAtom(), newRoot); builder.addChild(newRoot, child, Optional.empty()); copyChildren(originalQuery, rootNode, builder, child); return builder.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(); }
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); }
DataNode currentNode = DatalogConversionTools.createDataNode(queryBuilder.getFactory(), dataAtom, tablePredicates); queryBuilder.addChild(parentNode, currentNode, optionalPosition);