@Override public void visit(ExtensionalDataNode extensionalDataNode) { if (query.getChildren(extensionalDataNode).size() != 0) { throw new InvalidIntermediateQueryException("DATA node "+ extensionalDataNode + " has a child.\n" + query); } }
private Stream<UnionNode> getUnionCluster(UnionNode focusNode, IntermediateQuery query) { return Stream.concat( Stream.of(focusNode), query.getChildren(focusNode).stream() .filter(n -> n instanceof UnionNode) .flatMap(n -> getUnionCluster((UnionNode) n, query) )); }
private Stream<Recipient> findRecipientsInUnionNodeRootedSubtree(IntermediateQuery query, ImmutableExpression expression, JoinOrFilterNode providerNode, UnionNode subtreeRoot) { ImmutableList<QueryNode> children = query.getChildren(subtreeRoot); if (children.isEmpty()) { throw new IllegalStateException("Children expected for " + subtreeRoot); } /** * Possible (indirect) recursion */ return selectRecipients(query, providerNode, children, expression); }
@Override public void visit(SliceNode sliceNode) { if (query.getChildren(sliceNode).size() != 1) { throw new InvalidIntermediateQueryException("SLICE node " + sliceNode + " must have ONE and ONLY ONE child.\n" + query); } }
private Stream<Recipient> findRecipientsInConstructionNodeRootedSubtree(IntermediateQuery query, ImmutableExpression expression, JoinOrFilterNode providerNode, ConstructionNode subtreeRoot) { ImmutableList<QueryNode> children = query.getChildren(subtreeRoot); if (children.size() != 1) { throw new IllegalStateException("Exactly one child expected for " + subtreeRoot); } /** Possible (indirect) recursion */ return selectRecipients(query, providerNode, children, expression); }
@Override public void visit(IntensionalDataNode intensionalDataNode) { if (query.getChildren(intensionalDataNode).size() != 0) { throw new InvalidIntermediateQueryException("DATA node "+ intensionalDataNode + " has a child.\n" + query); } }
@Override public void visit(EmptyNode emptyNode) { if (query.getChildren(emptyNode).size() != 0) { throw new InvalidIntermediateQueryException("EMPTY node " + emptyNode + " has a child.\n" + query); } }
@Override public void visit(DistinctNode distinctNode) { if (query.getChildren(distinctNode).size() != 1) { throw new InvalidIntermediateQueryException("DISTINCT node " + distinctNode + " must have ONE and ONLY ONE child.\n" + query); } }
/** * Recursive method. */ private String stringifySubTree(IntermediateQuery query, QueryNode subTreeRoot, String rootOffsetString) { StringBuilder strBuilder = new StringBuilder(); strBuilder.append(rootOffsetString + subTreeRoot + "\n"); for (QueryNode child : query.getChildren(subTreeRoot)) { strBuilder.append(stringifySubTree(query, child, rootOffsetString + TAB_STR)); } return strBuilder.toString(); } }
private FlattenUnionProposal makeFlattenProposal(UnionNode focusNode, ImmutableList<UnionNode> unionNodesToMerge, IntermediateQuery query) { return new FlattenUnionProposalImpl( focusNode, unionNodesToMerge.stream() .flatMap(n -> query.getChildren(n).stream()) .filter(n -> !(n instanceof UnionNode)) .collect(ImmutableCollectors.toSet()) ); } }
private FlattenUnionProposal makeFlattenProposal(UnionNode focusNode, ImmutableList<UnionNode> unionNodesToMerge, IntermediateQuery query) { return new FlattenUnionProposalImpl( focusNode, unionNodesToMerge.stream() .flatMap(n -> query.getChildren(n).stream()) .filter(n -> !(n instanceof UnionNode)) .collect(ImmutableCollectors.toSet()) ); } }
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 void visit(InnerJoinNode innerJoinNode) { if (query.getChildren(innerJoinNode).size() < 2) { throw new InvalidIntermediateQueryException("JOIN node " + innerJoinNode +" does not have at least 2 children.\n" + query); } innerJoinNode.getOptionalFilterCondition() .ifPresent(e -> checkExpression(innerJoinNode, e)); }
@Override public void visit(LeftJoinNode leftJoinNode) { if (query.getChildren(leftJoinNode).size() != 2) { throw new InvalidIntermediateQueryException("LEFTJOIN node " + leftJoinNode + " does not have 2 children.\n" + query); } leftJoinNode.getOptionalFilterCondition() .ifPresent(e -> checkExpression(leftJoinNode, e)); }
@Override public void visit(FilterNode filterNode) { if (query.getChildren(filterNode).size() != 1) { throw new InvalidIntermediateQueryException("FILTER node " + filterNode + " does not have single child.\n" + query); } checkExpression(filterNode, filterNode.getFilterCondition()); }
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); } }
@Override public ImmutableSet<Variable> getRequiredVariables(IntermediateQuery query) { ImmutableMultiset<Variable> childrenVariableBag = query.getChildren(this).stream() .flatMap(c -> query.getVariables(c).stream()) .collect(ImmutableCollectors.toMultiset()); Stream<Variable> cooccuringVariableStream = childrenVariableBag.entrySet().stream() .filter(e -> e.getCount() > 1) .map(Multiset.Entry::getElement); return Stream.concat(cooccuringVariableStream, getLocallyRequiredVariables().stream()) .collect(ImmutableCollectors.toSet()); }
@Override public void appendSubtree(QueryNode subQueryRoot, IntermediateQuery sourceQuery) { if(sourceQuery.contains(subQueryRoot)) { ImmutableList<QueryNode> children = sourceQuery.getChildren(subQueryRoot); addChildren(subQueryRoot, children); children.forEach(n -> appendSubtree(n, sourceQuery)); }else { throw new NodeNotInQueryException("Node " + subQueryRoot + " is not in the query"); } }
@Override public void appendSubtree(QueryNode subQueryRoot, IntermediateQuery sourceQuery) { if(sourceQuery.contains(subQueryRoot)) { ImmutableList<QueryNode> children = sourceQuery.getChildren(subQueryRoot); addChildren(subQueryRoot, children); children.forEach(n -> appendSubtree(n, sourceQuery)); }else { throw new NodeNotInQueryException("Node " + subQueryRoot + " is not in the query"); } }
private UnionNode liftUnionNode(UnionLiftProposal proposal, IntermediateQuery query, QueryTreeComponent treeComponent) { QueryNode targetNode = proposal.getTargetNode(); UnionNode focusNode = proposal.getFocusNode(); UnionNode newTopUnionNode = iqFactory.createUnionNode(query.getVariables(targetNode)); IntermediateQuery querySnapshot = query.createSnapshot(); treeComponent.replaceSubTree(targetNode, newTopUnionNode); querySnapshot.getChildren(focusNode) .forEach(c -> appendUnionChildBranch(c, focusNode, targetNode, newTopUnionNode, query, querySnapshot, treeComponent)); return newTopUnionNode; }