@Override public ImmutableSet<ImmutableTerm> extract(Variable variable, IntermediateQuery query) { return extract(variable, query.getRootNode(), query); }
private Optional<UnionNode> findFirstSplittableUnion(IntermediateQuery query) { Queue<QueryNode> nodesToVisit = new LinkedList<>(query.getChildren(query.getRootNode())); while(!nodesToVisit.isEmpty()) { QueryNode node = nodesToVisit.poll(); if (node instanceof UnionNode) { return Optional.of((UnionNode)node); } else { nodesToVisit.addAll(extractChildrenToVisit(query, node)); } } return Optional.empty(); }
@Override public IntermediateQuery optimize(IntermediateQuery query) { try { query = pushUpFromSubtree(query.getRootNode(), query); return pushAboveUnions ? pushAboveUnions(query) : query; } catch (EmptyQueryException e) { throw new IllegalStateException("This optimizer should not empty the query"); } }
@Override public IntermediateQuery optimize(IntermediateQuery query) { try { query = pushUpFromSubtree(query.getRootNode(), query); return pushAboveUnions ? pushAboveUnions(query) : query; } catch (EmptyQueryException e) { throw new IllegalStateException("This optimizer should not empty the query"); } }
private Stream<IntermediateQuery> splitRootUnion(IntermediateQuery query) { QueryNode root = query.getRootNode(); return (root instanceof UnionNode)? query.getChildren(root).stream() .map(n -> query.getSubquery( n, query.getProjectionAtom() )): Stream.of(query); } }
@Override public IntermediateQuery transform(IntermediateQuery originalQuery) throws QueryTransformationException { QueryNode rootNode = originalQuery.getRootNode(); ImmutableList<Variable> nullableVariables = extractNullableVariables(originalQuery, rootNode); return nullableVariables.isEmpty() ? originalQuery : insertFilter(originalQuery, nullableVariables); }
private boolean canPropagate(ConstructionNode constructionNode, boolean propagateThroughNextUnionNodeAncestor, IntermediateQuery query) { if (constructionNode == query.getRootNode()) { return false; } QueryNode parent = query.getParent(constructionNode) .orElseThrow(() -> new InvalidIntermediateQueryException("Node " + constructionNode + " has no parent")); if (parent instanceof UnionNode && !propagateThroughNextUnionNodeAncestor) { return false; } return true; }
@Override public String stringify(IntermediateQuery query) { return query.getProjectionAtom() + "\n" + stringifySubTree(query, query.getRootNode(), ""); }
@Override public String stringify(IntermediateQuery query) { return query.getProjectionAtom() + "\n" + stringifySubTree(query, query.getRootNode(), ""); }
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(); }
private static boolean projectNullableVariable(IntermediateQuery query) { QueryNode rootNode = query.getRootNode(); return query.getProjectionAtom().getVariableStream() .anyMatch(v -> rootNode.isVariableNullable(query, v)); }
@Override public NodeTransformationProposal reactToTrueChildRemovalProposal(IntermediateQuery query, TrueNode trueNode) { if (this.getVariables().isEmpty() && !this.equals(query.getRootNode())){ return new NodeTransformationProposalImpl(NodeTransformationProposedState.DECLARE_AS_TRUE, ImmutableSet.of()); } return new NodeTransformationProposalImpl(NodeTransformationProposedState.NO_LOCAL_CHANGE, ImmutableSet.of()); }
@Override public IQ convert(IntermediateQuery query) { IQTree tree = convertTree(query, query.getRootNode()); return iqFactory.createIQ(query.getProjectionAtom(), tree); }
@Override public IntermediateQuery optimize(IntermediateQuery query) { /* Contains all (non discarded) variables projected out by some node previously traversed, plus all variables appearing in an (explicit or implicit) condition of some join node already traversed Immutable only for safety (updated in practice). Question: shall we keep it as immutable ? */ return optimizeSubtree( query.getRootNode(), query, query.getProjectionAtom().getVariables()); }
@Override public IntermediateQuery transform(IntermediateQuery query) throws NotFilterableNullVariableException { QueryNode rootNode = query.getRootNode(); ImmutableList<Variable> nullableProjectedVariables = query.getProjectionAtom().getVariables().stream() .filter(v -> rootNode.isVariableNullable(query, v)) .collect(ImmutableCollectors.toList()); if (nullableProjectedVariables.isEmpty()) return query; ImmutableExpression filterCondition = extractFilteringCondition(query, rootNode, nullableProjectedVariables); return constructQuery(query, rootNode, filterCondition); }
private boolean isMandatoryRoot(ConstructionNode cn, IntermediateQuery query){ if(cn.equals(query.getRootNode())){ if(!query.getProjectionAtom().getVariables().equals( query.getVariables( query.getChildren(cn).iterator().next() ))){ return true; } } return false; }
@Override public IntermediateQuery transform(IntermediateQuery query) throws NotFilterableNullVariableException { QueryNode rootNode = query.getRootNode(); ImmutableList<Variable> nullableProjectedVariables = query.getProjectionAtom().getVariables().stream() .filter(v -> rootNode.isVariableNullable(query, v)) .collect(ImmutableCollectors.toList()); if (nullableProjectedVariables.isEmpty()) return query; ImmutableExpression filterCondition = extractFilteringCondition(query, rootNode, nullableProjectedVariables); return constructQuery(query, rootNode, filterCondition); }
@Override public IntermediateQuery optimize(IntermediateQuery query) throws EmptyQueryException { // Non-final NextNodeAndQuery nextNodeAndQuery = new NextNodeAndQuery( Optional.of(query.getRootNode()), query); //explore the tree lifting the bindings when it is possible while (nextNodeAndQuery.getOptionalNextNode().isPresent()) { nextNodeAndQuery = liftBindings(nextNodeAndQuery.getNextQuery(), nextNodeAndQuery.getOptionalNextNode().get()); } // remove unnecessary TrueNodes, which may have been introduced during substitution lift return new TrueNodesRemovalOptimizer().optimize(nextNodeAndQuery.getNextQuery()); }
private void validateProjectedVariables(IntermediateQuery query) throws InvalidIntermediateQueryException { ImmutableSet<Variable> projectedVariables = query.getVariables(query.getRootNode()); if (!projectedVariables.equals(query.getProjectionAtom().getVariables())) { throw new InvalidIntermediateQueryException("The variables projected by the root node" + projectedVariables + " do not match the projection atom " + query.getProjectionAtom()); } } }
private void validateProjectedVariables(IntermediateQuery query) throws InvalidIntermediateQueryException { ImmutableSet<Variable> projectedVariables = query.getVariables(query.getRootNode()); if (!projectedVariables.equals(query.getProjectionAtom().getVariables())) { throw new InvalidIntermediateQueryException("The variables projected by the root node" + projectedVariables + " do not match the projection atom " + query.getProjectionAtom()); } } }