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"); }
@Override public LeftJoinNode transform(LeftJoinNode leftJoinNode) { return iqFactory.createLeftJoinNode(renameOptionalBooleanExpression( leftJoinNode.getOptionalFilterCondition())); }
@Override public LeftJoinNode transform(LeftJoinNode leftJoinNode) { return iqFactory.createLeftJoinNode(renameOptionalBooleanExpression( leftJoinNode.getOptionalFilterCondition())); }
@Override public IQTree transformLeftJoin(IQTree tree, LeftJoinNode rootNode, IQTree leftChild, IQTree rightChild) { ImmutableList<IQTree> children = ImmutableList.of(leftChild, rightChild); ImmutableList<InjectiveVar2VarSubstitution> substitutions = computeSubstitutions(children); if (substitutions.stream().allMatch(ImmutableSubstitution::isEmpty)) return tree; ImmutableList<IQTree> updatedChildren = updateJoinChildren(substitutions, children); return iqFactory.createUnaryIQTree( iqFactory.createConstructionNode(tree.getVariables()), iqFactory.createBinaryNonCommutativeIQTree( iqFactory.createLeftJoinNode( Optional.of( updateJoinCondition( rootNode.getOptionalFilterCondition(), substitutions ))), updatedChildren.get(0), updatedChildren.get(1) )); }
@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; }
private IQTree convertResults2IQTree(ImmutableSet<Variable> projectedVariables, ChildLiftingState liftingState, IQProperties currentIQProperties) { AscendingSubstitutionNormalization ascendingNormalization = normalizeAscendingSubstitution( liftingState.getComposedAscendingSubstitution(), projectedVariables); Optional<ConstructionNode> topConstructionNode = ascendingNormalization.generateTopConstructionNode(); IQTree subTree = ascendingNormalization.normalizeChild( Optional.of(liftingState.rightChild) .filter(rightChild -> !rightChild.isDeclaredAsEmpty()) .filter(rightChild -> !(rightChild.getRootNode() instanceof TrueNode)) // LJ .map(rightChild -> (IQTree) iqFactory.createBinaryNonCommutativeIQTree( iqFactory.createLeftJoinNode(liftingState.ljCondition), liftingState.leftChild, liftingState.rightChild, currentIQProperties.declareLifted())) // Left child .orElse(liftingState.leftChild)); return topConstructionNode .map(n -> (IQTree) iqFactory.createUnaryIQTree(n, subTree, currentIQProperties.declareLifted())) .orElse(subTree); }
? updatedLeftChild : iqFactory.createBinaryNonCommutativeIQTree( iqFactory.createLeftJoinNode(expressionAndCondition.optionalExpression), updatedLeftChild, updatedRightChild); } catch (UnsatisfiableConditionException e) {
private IQTree convertLeftJoinAtom(List<Function> subAtomsOfTheLJ, Collection<Predicate> tablePredicates, IntermediateQueryFactory iqFactory) throws DatalogProgram2QueryConverterImpl.InvalidDatalogProgramException, IntermediateQueryBuilderException { P2<List<Function>, List<Function>> decomposition = pullOutEqualityNormalizer.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, datalogTools); Optional<ImmutableExpression> optionalFilterCondition = createFilterExpression( rightSubAtomClassification.booleanAtoms); LeftJoinNode ljNode = iqFactory.createLeftJoinNode(optionalFilterCondition); IQTree leftTree = convertAtoms(leftAtoms, tablePredicates, iqFactory); IQTree rightTree = convertAtoms(rightSubAtomClassification.dataAndCompositeAtoms, tablePredicates, iqFactory); return iqFactory.createBinaryNonCommutativeIQTree(ljNode, leftTree, rightTree); }
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); }