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 ImmutableSet<Variable> getChildProjectedVariables(IntermediateQuery query, Optional<ImmutableSet<Variable>> optionalChildVariables, ArgumentPosition position) { return optionalChildVariables .orElseGet(() -> query.getVariables(query.getChild(this, position) .orElseThrow(() -> new IllegalStateException("Missing child ")))); }
/** * Returns results centered on the removed node. */ private static NodeTrackingResults<EmptyNode> reactToEmptinessDeclaration( IntermediateQuery query, QueryNode currentAncestor, QueryTreeComponent treeComponent, Optional<NodeTracker> optionalAncestryTracker) throws EmptyQueryException { ImmutableSet<Variable> nullVariables = query.getVariables(currentAncestor); EmptyNode replacingEmptyNode = query.getFactory().createEmptyNode(nullVariables); treeComponent.replaceSubTree(currentAncestor, replacingEmptyNode); RemoveEmptyNodeProposal proposal = optionalAncestryTracker.isPresent() ? new RemoveEmptyNodeProposalImpl(replacingEmptyNode, optionalAncestryTracker.get()) : new RemoveEmptyNodeProposalImpl(replacingEmptyNode, false); return query.applyProposal(proposal, true); } }
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 String stringify(IntermediateQuery query) { return query.getProjectionAtom() + "\n" + stringifySubTree(query, query.getRootNode(), ""); }
@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 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; }
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 String extractPredicateIRI(IntermediateQuery mappingAssertion) { AtomPredicate projectionAtomPredicate = mappingAssertion.getProjectionAtom().getPredicate(); if (projectionAtomPredicate.equals(PredicateImpl.QUEST_TRIPLE_PRED)) throw new RuntimeException("TODO: extract the RDF predicate from a triple atom"); else return projectionAtomPredicate.getName(); }
private IntermediateQuery liftBinding(IntermediateQuery query) throws EmptyQueryException { IQ iq = iqConverter.convert(query); return iqConverter.convert(iq.liftBinding(), query.getDBMetadata(), query.getExecutorRegistry()); } }
/** * Predicates not having a DatabaseRelationDefinition are ignored */ private ImmutableMultimap<DatabaseRelationDefinition, DataNode> extractDataNodeMap(IntermediateQuery query, InnerJoinNode joinNode) { DBMetadata dbMetadata = query.getDBMetadata(); return query.getChildren(joinNode).stream() .filter(c -> c instanceof DataNode) .map(c -> (DataNode) c) .map(c -> getDatabaseRelationByName(dbMetadata, c.getProjectionAtom().getPredicate()) .map(r -> new SimpleEntry<DatabaseRelationDefinition, DataNode>(r, c))) .filter(Optional::isPresent) .map(Optional::get) .collect(ImmutableCollectors.toMultimap()); }
@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 ? */ QueryNode rootNode = query.getRootNode(); Optional<QueryNode> rootChild = query.getFirstChild(rootNode); if (rootChild.isPresent()) { return optimizeSubtree( rootChild.get(), query, rootNode.getLocallyRequiredVariables() ); } return query; }
@Override public void visit(IntensionalDataNode intensionalDataNode) { if (query.getChildren(intensionalDataNode).size() != 0) { throw new InvalidIntermediateQueryException("DATA node "+ intensionalDataNode + " has a child.\n" + query); } }
DataNodeAndSubstitution rightComponent) { VariableGenerator variableGenerator = new VariableGenerator(query.getKnownVariables()); query.getDBMetadata(), variableGenerator); ImmutableSet<Variable> requiredVariablesAboveLJ = query.getVariablesRequiredByAncestors(leftJoinNode); ImmutableSet<Variable> leftVariables = query.getVariables(leftChild);
@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(); }
return new AnalysisResults(originalNode, query.getFactory().createTrueNode(), Optional.empty()); .flatMap(position -> query.getChild(originalNode, position)) .orElseGet(() -> query.getFirstChild(originalNode) .orElseThrow(() -> new IllegalStateException("No replacing child is available"))); return analyze(query, replacingChild, results.getSubstitutionToPropagate()); return analyze(query, query.getFactory().createEmptyNode(query.getVariables(originalNode)), substitutionToApply);
optionalSubQuery.get().getProjectionAtom()); if (intermediateQuery.contains(intensionalNode)) { intermediateQuery = rootCnEnforcer.enforceRootCn(intermediateQuery); QueryMergingProposal mergingProposal = new QueryMergingProposalImpl(intensionalNode, optionalSubQuery); intermediateQuery.applyProposal(mergingProposal);
private void checkExpression(JoinOrFilterNode node, ImmutableExpression expression) { ImmutableSet<Variable> unboundVariables = expression.getVariableStream() .filter(v -> !(query.getChildren(node).stream() .flatMap(c -> query.getVariables(c).stream()) .collect(ImmutableCollectors.toSet()) .contains(v))) .collect(ImmutableCollectors.toSet()); if (!unboundVariables.isEmpty()) { throw new InvalidIntermediateQueryException("Expression " + expression + " of " + expression + " uses unbound variables (" + unboundVariables + ").\n" + query); } }
private ImmutableList<QueryNode> extractChildrenToVisit(IntermediateQuery query, QueryNode node) { if (node instanceof BinaryNonCommutativeOperatorNode) { if (node instanceof LeftJoinNode) { return ImmutableList.of(query.getChild(node, BinaryOrderedOperatorNode.ArgumentPosition.LEFT) .orElseThrow(() -> new InvalidIntermediateQueryException("A left join must have a left child"))); } /* * Not supported BinaryNonCommutativeOperatorNode: we ignore them */ else { return ImmutableList.of(); } } else { return query.getChildren(node); } }