@Override public FilterNode changeFilterCondition(ImmutableExpression newFilterCondition) { return iqFactory.createFilterNode(newFilterCondition); }
/** * TODO: explain */ private QueryNode insertFilterNode(QueryTreeComponent treeComponent, QueryNode child, ImmutableExpression newEqualities) throws IllegalTreeUpdateException { FilterNode newFilterNode = iqFactory.createFilterNode(newEqualities); treeComponent.insertParent(child, newFilterNode); return newFilterNode; }
@Override public FilterNode clone() { return iqFactory.createFilterNode(getFilterCondition()); }
private FilterNode createFilter(DataAtom da, ImmutableList<Optional<Variable>> replacementVars) { Iterator<Optional<Variable>> it = replacementVars.iterator(); return iqFactory.createFilterNode( getConjunction(da.getArguments().stream() .map(a -> getEquality((VariableOrGroundTerm) a, it.next())) .filter(e -> ((Optional) e).isPresent()) .map(e -> ((Optional) e).get()) )); }
private Optional<CommutativeJoinOrFilterNode> getProviderReplacementNode(CommutativeJoinOrFilterNode providerNode, Optional<ImmutableExpression> nonPropagatedExpression) { if (providerNode instanceof InnerJoinNode) { return Optional.of(iqFactory.createInnerJoinNode(nonPropagatedExpression)); } if (providerNode instanceof FilterNode) { if (nonPropagatedExpression.isPresent()) { return Optional.of(iqFactory.createFilterNode(nonPropagatedExpression.get())); } return Optional.empty(); } throw new IllegalStateException("Invalid proposal: A CommutativeJoinOrFilterNode must be a commutative " + "join or filter node"); } }
private Optional<CommutativeJoinOrFilterNode> getProviderReplacementNode(CommutativeJoinOrFilterNode providerNode, Optional<ImmutableExpression> nonPropagatedExpression) { if (providerNode instanceof InnerJoinNode) { return Optional.of(iqFactory.createInnerJoinNode(nonPropagatedExpression)); } if (providerNode instanceof FilterNode) { if (nonPropagatedExpression.isPresent()) { return Optional.of(iqFactory.createFilterNode(nonPropagatedExpression.get())); } return Optional.empty(); } throw new IllegalStateException("Invalid proposal: A CommutativeJoinOrFilterNode must be a commutative " + "join or filter node"); } }
private void updateIndirectRecipientNode(QueryTreeComponent treeComponent, QueryNode targetNode, Collection<ImmutableExpression> additionalExpressions) { ImmutableExpression foldedExpression = immutabilityTools.foldBooleanExpressions( ImmutableList.copyOf(additionalExpressions)).get(); FilterNode newFilterNode = iqFactory.createFilterNode(foldedExpression); treeComponent.insertParent(targetNode, newFilterNode); }
private void updateIndirectRecipientNode(QueryTreeComponent treeComponent, QueryNode targetNode, Collection<ImmutableExpression> additionalExpressions) { ImmutableExpression foldedExpression = ImmutabilityTools.foldBooleanExpressions( ImmutableList.copyOf(additionalExpressions)).get(); FilterNode newFilterNode = iqFactory.createFilterNode(foldedExpression); treeComponent.insertParent(targetNode, newFilterNode); }
private JoinOrFilterNode getRecipientReplacementNode(JoinOrFilterNode replacedNode, ImmutableExpression expressionToPropagate) { ImmutableExpression combinedExpression = getCombinedExpression(expressionToPropagate, replacedNode); if (replacedNode instanceof InnerJoinNode) return iqFactory.createInnerJoinNode(Optional.of(combinedExpression)); if (replacedNode instanceof LeftJoinNode) return iqFactory.createLeftJoinNode(Optional.of(combinedExpression)); if (replacedNode instanceof FilterNode) return iqFactory.createFilterNode(combinedExpression); throw new IllegalStateException("Invalid proposal: A CommutativeJoinOrFilterNode must be a commutative join or filter node"); }
private JoinOrFilterNode getRecipientReplacementNode(JoinOrFilterNode replacedNode, ImmutableExpression expressionToPropagate) { ImmutableExpression combinedExpression = getCombinedExpression(expressionToPropagate, replacedNode); if (replacedNode instanceof InnerJoinNode) return iqFactory.createInnerJoinNode(Optional.of(combinedExpression)); if (replacedNode instanceof LeftJoinNode) return iqFactory.createLeftJoinNode(Optional.of(combinedExpression)); if (replacedNode instanceof FilterNode) return iqFactory.createFilterNode(combinedExpression); throw new IllegalStateException("Invalid proposal: A CommutativeJoinOrFilterNode must be a commutative join or filter node"); }
private Optional<JoinOrFilterNode> generateNewJoinOrFilterNode(JoinOrFilterNode formerNode, ImmutableList<ImmutableExpression> newExpressions) { Optional<ImmutableExpression> optionalExpression = immutabilityTools.foldBooleanExpressions( newExpressions); if (formerNode instanceof JoinLikeNode) { JoinOrFilterNode newNode = ((JoinLikeNode)formerNode).changeOptionalFilterCondition(optionalExpression); return Optional.of(newNode); } else if (formerNode instanceof FilterNode) { if (optionalExpression.isPresent()) { return Optional.of(iqFactory.createFilterNode(optionalExpression.get())); } else { return Optional.empty(); } } else { throw new RuntimeException("Unexpected type of JoinOrFilterNode: " + formerNode); } } }
private Optional<JoinOrFilterNode> generateNewJoinOrFilterNode(JoinOrFilterNode formerNode, ImmutableList<ImmutableExpression> newExpressions) { Optional<ImmutableExpression> optionalExpression = ImmutabilityTools.foldBooleanExpressions( newExpressions); if (formerNode instanceof JoinLikeNode) { JoinOrFilterNode newNode = ((JoinLikeNode)formerNode).changeOptionalFilterCondition(optionalExpression); return Optional.of(newNode); } else if (formerNode instanceof FilterNode) { if (optionalExpression.isPresent()) { return Optional.of(iqFactory.createFilterNode(optionalExpression.get())); } else { return Optional.empty(); } } else { throw new RuntimeException("Unexpected type of JoinOrFilterNode: " + formerNode); } } }
@Override public FilterNode transform(FilterNode filterNode) { return iqFactory.createFilterNode(renameBooleanExpression(filterNode.getFilterCondition())); }
@Override public FilterNode transform(FilterNode filterNode) { return iqFactory.createFilterNode(renameBooleanExpression(filterNode.getFilterCondition())); }
@Override public IQTree transformFilter(IQTree tree, FilterNode rootNode, IQTree child) { ImmutableList<ImmutableExpression> filterChildExpressions = getChildExpressions(ImmutableList.of(child)); if (filterChildExpressions.isEmpty()) return tree; return iqFactory.createUnaryIQTree( iqFactory.createFilterNode( updateJoinCondition( Optional.of(rootNode.getFilterCondition()), filterChildExpressions )), trimRootFilter(child) ); }
private IQTree createJoinOrFilterOrTrue(ImmutableList<IQTree> currentChildren, Optional<ImmutableExpression> currentJoiningCondition, IQProperties currentIQProperties) { switch (currentChildren.size()) { case 0: return iqFactory.createTrueNode(); case 1: IQTree uniqueChild = currentChildren.get(0); return currentJoiningCondition .map(e -> (IQTree) iqFactory.createUnaryIQTree(iqFactory.createFilterNode(e), uniqueChild)) .orElse(uniqueChild); default: InnerJoinNode newJoinNode = currentJoiningCondition.equals(getOptionalFilterCondition()) ? this : changeOptionalFilterCondition(currentJoiningCondition); return iqFactory.createNaryIQTree(newJoinNode, currentChildren, currentIQProperties.declareLifted()); } }
@Override public IQTree transformLeftJoin(IQTree tree, LeftJoinNode rootNode, IQTree leftChild, IQTree rightChild) { Optional<ImmutableExpression> leftChildChildExpression = getOptionalChildExpression(leftChild); Optional<ImmutableExpression> rightChildExpression = getOptionalChildExpression(rightChild); if(leftChildChildExpression.isPresent() || rightChildExpression.isPresent()) { IQTree leftJoinTree = iqFactory.createBinaryNonCommutativeIQTree( rightChildExpression.isPresent() ? iqFactory.createLeftJoinNode( Optional.of( updateJoinCondition( rootNode.getOptionalFilterCondition(), ImmutableList.of(rightChildExpression.get()) ))) : rootNode, trimRootFilter(leftChild), trimRootFilter(rightChild) ); return leftChildChildExpression.isPresent() ? iqFactory.createUnaryIQTree(iqFactory.createFilterNode(leftChildChildExpression.get()), leftJoinTree) : leftJoinTree; } return tree; }
@Override public IQTree applyDescendingSubstitutionWithoutOptimizing( ImmutableSubstitution<? extends VariableOrGroundTerm> descendingSubstitution, IQTree child) { FilterNode newFilterNode = iqFactory.createFilterNode( descendingSubstitution.applyToBooleanExpression(getFilterCondition())); return iqFactory.createUnaryIQTree(newFilterNode, child.applyDescendingSubstitutionWithoutOptimizing(descendingSubstitution)); }
private IQ insertFilter(IQ originalQuery, ImmutableSet<ImmutableSet<Variable>> nullableVariables) { FilterNode filterNode = iQFactory.createFilterNode(computeFilterExpression(nullableVariables)); UnaryIQTree newTree = iQFactory.createUnaryIQTree(filterNode, originalQuery.getTree()); // TODO: normalize it return iQFactory.createIQ(originalQuery.getProjectionAtom(), newTree); } }
/** * 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(); }