private static int countInteractingModifiers(ImmutableQueryModifiers modifiers) { int i = 0; if(modifiers.hasOffset()){ i++; } if(modifiers.isDistinct()){ i++; } if(modifiers.hasLimit()){ i++; } if(modifiers.hasOrder()){ i++; } return i; }
return Optional.of( new ImmutableQueryModifiersImpl( parentQueryModifiers.isDistinct() || subqueryModifers.isDistinct(), mergeLimits( parentQueryModifiers.getLimit(), subqueryModifers.getLimit() ), mergeOffsets( parentQueryModifiers.getOffset(), subqueryModifers.getOffset() ), mergeSortConditions( parentQueryModifiers.getSortConditions(), subqueryModifers.getSortConditions() )));
@Override public Optional<ImmutableQueryModifiers> applyToQueryModifiers(ImmutableQueryModifiers immutableQueryModifiers) { ImmutableList.Builder<OrderCondition> orderConditionBuilder = ImmutableList.builder(); for (OrderCondition orderCondition : immutableQueryModifiers.getSortConditions()) { Variable newVariable = applyToVariable((Variable) orderCondition.getVariable()); orderConditionBuilder.add(orderCondition.newVariable(newVariable)); } return immutableQueryModifiers.newSortConditions(orderConditionBuilder.build()); }
boolean deleteConstructionNodeChain = modifiers.isIdle() && constructionNodeChainRoot.getSubstitution().isEmpty() && !isMandatoryRoot(constructionNodeChainRoot, query); new ConstructionNodeCleaningProposalImpl( constructionNodeChainRoot, modifiers.isIdle() ? Optional.empty() : Optional.of(modifiers),
/** * TODO: explain */ private static Optional<ImmutableQueryModifiers> updateOptionalModifiers( Optional<ImmutableQueryModifiers> optionalModifiers, ImmutableSubstitution<? extends ImmutableTerm> substitution1, ImmutableSubstitution<? extends ImmutableTerm> substitution2) { if (!optionalModifiers.isPresent()) { return Optional.empty(); } ImmutableQueryModifiers previousModifiers = optionalModifiers.get(); ImmutableList.Builder<OrderCondition> conditionBuilder = ImmutableList.builder(); for (OrderCondition condition : previousModifiers.getSortConditions()) { ImmutableTerm newTerm = substitution2.apply(substitution1.apply(condition.getVariable())); /** * If after applying the substitution the term is still a variable, * "updates" the OrderCondition. * * Otherwise, forgets it. */ if (newTerm instanceof Variable) { conditionBuilder.add(condition.newVariable((Variable) newTerm)); } } return previousModifiers.newSortConditions(conditionBuilder.build()); }
private static boolean areMergeable(ImmutableQueryModifiers parentQueryModifiers, ImmutableQueryModifiers subqueryModifers) { int pModCount = countInteractingModifiers(parentQueryModifiers); int sModCount = countInteractingModifiers(subqueryModifers); if(pModCount == 0 || sModCount == 0){ return true; } if(pModCount == 1 && sModCount == 1){ if(parentQueryModifiers.isDistinct() && subqueryModifers.isDistinct()){ return true; } if(parentQueryModifiers.hasOrder() && subqueryModifers.hasOrder()){ return true; } if(parentQueryModifiers.hasLimit() && subqueryModifers.hasLimit()){ return true; } if(parentQueryModifiers.hasOffset() && subqueryModifers.hasOffset()){ return true; } } return false; }