/** * Returns the boolean conjuncts shared by all providers. */ private ImmutableSet<ImmutableExpression> getExpressionsToPropagateAboveUnion(ImmutableSet<CommutativeJoinOrFilterNode> providers) { return providers.stream() .map(n -> n.getOptionalFilterCondition().get().flattenAND()) .reduce(this::computeIntersection).get(); }
/** * Returns the boolean conjuncts shared by all providers. */ private ImmutableSet<ImmutableExpression> getExpressionsToPropagateAboveUnion(ImmutableSet<CommutativeJoinOrFilterNode> providers) { return providers.stream() .map(n -> n.getOptionalFilterCondition().get().flattenAND()) .reduce(this::computeIntersection).get(); }
private Optional<ImmutableExpression> getRetainedSubExpression (ImmutableSet<ImmutableExpression> propagatedExpressions, CommutativeJoinOrFilterNode provider) { ImmutableExpression fullBooleanExpression = provider.getOptionalFilterCondition() .orElseThrow(() -> new IllegalStateException("The provider is expected to have a filtering condition")); // conjuncts which will not be propagated up from this child return immutabilityTools.foldBooleanExpressions( fullBooleanExpression.flattenAND().stream() .filter(e -> !propagatedExpressions.contains(e)) ); }
private Optional<ImmutableExpression> getRetainedSubExpression (ImmutableSet<ImmutableExpression> propagatedExpressions, CommutativeJoinOrFilterNode provider) { ImmutableExpression fullBooleanExpression = provider.getOptionalFilterCondition() .orElseThrow(() -> new IllegalStateException("The provider is expected to have a filtering condition")); // conjuncts which will not be propagated up from this child return ImmutabilityTools.foldBooleanExpressions( fullBooleanExpression.flattenAND().stream() .filter(e -> !propagatedExpressions.contains(e)) ); }
private ImmutableSet<ImmutableExpression> filterOuterMostConjuncts(java.util.function.Predicate<ImmutableExpression> filterMethod, ImmutableExpression expression) { ImmutableSet<ImmutableExpression> conjuncts = expression.flattenAND(); if (conjuncts.size() > 1) { ImmutableList<ImmutableExpression> filteredConjuncts = conjuncts.stream() .filter(filterMethod) .collect(ImmutableCollectors.toList()); switch (filteredConjuncts.size()) { case 0: return ImmutableSet.of(); case 1: return ImmutableSet.of(filteredConjuncts.iterator().next()); default: return ImmutableSet.copyOf(filteredConjuncts); } } return filterMethod.test(expression) ? ImmutableSet.of(expression) : ImmutableSet.of(); }
private static ImmutableSet<ImmutableExpression> filterOuterMostConjuncts(java.util.function.Predicate<ImmutableExpression> filterMethod, ImmutableExpression expression) { ImmutableSet<ImmutableExpression> conjuncts = expression.flattenAND(); if (conjuncts.size() > 1) { ImmutableList<ImmutableExpression> filteredConjuncts = conjuncts.stream() .filter(filterMethod) .collect(ImmutableCollectors.toList()); switch (filteredConjuncts.size()) { case 0: return ImmutableSet.of(); case 1: return ImmutableSet.of(filteredConjuncts.iterator().next()); default: return ImmutableSet.copyOf(filteredConjuncts); } } return filterMethod.test(expression) ? ImmutableSet.of(expression) : ImmutableSet.of(); } }
/** * TODO: explain */ protected Optional<ExpressionEvaluator.EvaluationResult> computeAndEvaluateNewCondition( ImmutableSubstitution<? extends ImmutableTerm> substitution, Optional<ImmutableExpression> optionalNewEqualities) { Optional<ImmutableExpression> updatedExistingCondition = getOptionalFilterCondition() .map(substitution::applyToBooleanExpression); Optional<ImmutableExpression> newCondition = ImmutabilityTools.foldBooleanExpressions( Stream.concat( Stream.of(updatedExistingCondition), Stream.of(optionalNewEqualities)) .filter(Optional::isPresent) .map(Optional::get) .flatMap(e -> e.flattenAND().stream())); return newCondition .map(cond -> new ExpressionEvaluator().evaluateExpression(cond)); }
/** * TODO: explain */ protected Optional<ExpressionEvaluator.EvaluationResult> computeAndEvaluateNewCondition( ImmutableSubstitution<? extends ImmutableTerm> substitution, Optional<ImmutableExpression> optionalNewEqualities) { Optional<ImmutableExpression> updatedExistingCondition = getOptionalFilterCondition() .map(substitution::applyToBooleanExpression); Optional<ImmutableExpression> newCondition = immutabilityTools.foldBooleanExpressions( Stream.concat( Stream.of(updatedExistingCondition), Stream.of(optionalNewEqualities)) .filter(Optional::isPresent) .map(Optional::get) .flatMap(e -> e.flattenAND().stream())); return newCondition .map(cond -> createExpressionEvaluator() .evaluateExpression(cond)); }
private N createNewFocusNodeWithAdditionalConditions(PullVariableOutOfSubTreeProposal<N> proposal) { N focusNode = proposal.getFocusNode(); Stream<ImmutableExpression> newConditions = proposal.getRenamingSubstitution().getImmutableMap().entrySet().stream() .map(e -> TERM_FACTORY.getImmutableExpression(EQ, e.getKey(), e.getValue())); Stream<ImmutableExpression> otherConditions = focusNode.getOptionalFilterCondition() .map(exp -> exp.flattenAND().stream()) .orElseGet(Stream::of); return (N) focusNode.changeOptionalFilterCondition( ImmutabilityTools.foldBooleanExpressions(Stream.concat(otherConditions, newConditions))); }
/** * providerNode: provides the boolean expressions */ private Optional<PushDownBooleanExpressionProposal> makeProposalForJoinOrFilterNode( IntermediateQuery currentQuery, JoinOrFilterNode providerNode, ImmutableList<QueryNode> preSelectedChildren) { /** * If there is no boolean expression, no proposal */ Optional<ImmutableExpression> optionalNestedExpression = providerNode.getOptionalFilterCondition(); if (!optionalNestedExpression.isPresent()) { return Optional.empty(); } /** * Decomposes the boolean expressions as much as possible (conjunction) */ ImmutableSet<ImmutableExpression> booleanExpressions = optionalNestedExpression.get().flattenAND(); /** * For each boolean expression, looks for recipients. */ ImmutableMultimap<Recipient, ImmutableExpression> recipientMap = booleanExpressions.stream() .flatMap(ex -> selectRecipients(currentQuery, providerNode, preSelectedChildren, ex) .map(recipient -> new SimpleEntry<>(recipient, ex))) .collect(ImmutableCollectors.toMultimap()); return buildProposal(providerNode, recipientMap); }
filter.get().flattenAND().stream() .map(immutabilityTools::convertToMutableBooleanExpression) .forEach(body::add);
} else { body.addAll(atoms); filter.get().flattenAND().stream() .map(ImmutabilityTools::convertToMutableBooleanExpression) .forEach(body::add);
/** * providerNode: provides the boolean expressions */ private Optional<PushDownBooleanExpressionProposal> makeProposalForJoinOrFilterNode( IntermediateQuery currentQuery, JoinOrFilterNode providerNode, ImmutableList<QueryNode> preSelectedChildren) { /* * If there is no boolean expression, no proposal */ Optional<ImmutableExpression> optionalNestedExpression = providerNode.getOptionalFilterCondition(); if (!optionalNestedExpression.isPresent()) { return Optional.empty(); } /* * Decomposes the boolean expressions as much as possible (conjunction) */ ImmutableSet<ImmutableExpression> booleanExpressions = optionalNestedExpression.get().flattenAND(); /* * For each boolean expression, looks for recipients. */ ImmutableMultimap<Recipient, ImmutableExpression> recipientMap = booleanExpressions.stream() .flatMap(ex -> selectPushes(currentQuery, providerNode, preSelectedChildren, ex)) .collect(ImmutableCollectors.toMultimap( p -> p.recipient, p -> p.expression)); return buildProposal(providerNode, recipientMap); }
protected Optional<ImmutableExpression> computeDownConstraint(Optional<ImmutableExpression> optionalConstraint, ExpressionAndSubstitution conditionSimplificationResults) throws UnsatisfiableConditionException { if (optionalConstraint.isPresent()) { ImmutableExpression substitutedConstraint = conditionSimplificationResults.substitution .applyToBooleanExpression(optionalConstraint.get()); ImmutableExpression combinedExpression = conditionSimplificationResults.optionalExpression .flatMap(e -> immutabilityTools.foldBooleanExpressions( Stream.concat( e.flattenAND().stream(), substitutedConstraint.flattenAND().stream()))) .orElse(substitutedConstraint); ExpressionEvaluator.EvaluationResult evaluationResults = createExpressionEvaluator() .evaluateExpression(combinedExpression); if (evaluationResults.isEffectiveFalse()) throw new UnsatisfiableConditionException(); return evaluationResults.getOptionalExpression(); } else return conditionSimplificationResults.optionalExpression; }
ImmutableSet<ImmutableExpression> expressions = expression.flattenAND(); ImmutableSet<ImmutableExpression> downSubstitutionExpressions = expressions.stream() .filter(e -> e.getFunctionSymbol().equals(EQ))
throws UnsatisfiableConditionException { ImmutableSet<ImmutableExpression> expressions = expression.flattenAND(); ImmutableSet<ImmutableExpression> functionFreeEqualities = expressions.stream() .filter(e -> e.getFunctionSymbol().equals(EQ))
.map(e -> e.flattenAND().stream()) .orElseGet(Stream::empty), newConditionStream));
body.addAll(getAtomFrom(te, listnode.get(0), heads, subQueryProjectionAtoms, true)); filter.flattenAND().stream() .map(ImmutabilityTools::convertToMutableBooleanExpression) .forEach(body::add);
body.addAll(getAtomFrom(children.get(0), heads, subQueryProjectionAtoms, true)); filter.flattenAND().stream() .map(immutabilityTools::convertToMutableBooleanExpression) .forEach(body::add);