@Override public boolean isSyntacticallyEquivalentTo(QueryNode node) { return Optional.of(node) .filter(n -> n instanceof ConstructionNode) .map(n -> (ConstructionNode) n) .filter(n -> n.getVariables().equals(projectedVariables)) .filter(n -> n.getSubstitution().equals(substitution)) .filter(n -> n.getOptionalModifiers().equals(optionalModifiers)) .isPresent(); }
static Optional<DataNodeAndSubstitution> extract(ConstructionNode rightChild, IntermediateQuery query) { /* * Not supported */ if (rightChild.getOptionalModifiers().isPresent()) return Optional.empty(); QueryNode grandChild = query.getFirstChild(rightChild).get(); if (grandChild instanceof DataNode) return Optional.of(new DataNodeAndSubstitution((DataNode) grandChild, Optional.empty(), Optional.of(rightChild))); else if (grandChild instanceof FilterNode) { FilterNode filterNode = (FilterNode) grandChild; return query.getFirstChild(grandChild) .filter(n -> n instanceof DataNode) .map(n -> (DataNode)n) .map(n -> new DataNodeAndSubstitution(n, Optional.of(filterNode), Optional.of(rightChild))); } else return Optional.empty(); }
private Optional<ExplicitVariableProjectionNode> getProjectorReplacementNode(ExplicitVariableProjectionNode replacedNode, ImmutableExpression expressionToPropagate) { if (expressionToPropagate.getVariables().size() == 0) { return Optional.empty(); } ImmutableSet.Builder<Variable> allProjectedVariablesBuilder = ImmutableSet.builder(); allProjectedVariablesBuilder.addAll(replacedNode.getVariables()); allProjectedVariablesBuilder.addAll(expressionToPropagate.getVariables()); if (replacedNode instanceof UnionNode) { return Optional.of(iqFactory.createUnionNode(allProjectedVariablesBuilder.build())); } if (replacedNode instanceof ConstructionNode) { return Optional.of(iqFactory.createConstructionNode(allProjectedVariablesBuilder.build(), ((ConstructionNode) replacedNode).getSubstitution(), ((ConstructionNode) replacedNode).getOptionalModifiers())); } throw new IllegalStateException("Unsupported node type"); }
@Override protected Optional<ConstructionNodeCleaningProposal> evaluateNode(QueryNode node, IntermediateQuery query) { if (node instanceof ConstructionNode) { ConstructionNode castNode = (ConstructionNode) node; Optional<ImmutableQueryModifiers> optModifiers = castNode.getOptionalModifiers(); ImmutableQueryModifiers modifiers = optModifiers.isPresent() ? optModifiers.get() : new ImmutableQueryModifiersImpl( false, -1, -1, ImmutableList.of() ); return makeProposal( query, castNode, modifiers, castNode, query.getFirstChild(castNode) ); } return Optional.empty(); }
public static ConstructionNode merge(ConstructionNode parentConstructionNode, ConstructionNode childConstructionNode, IntermediateQueryFactory iqFactory) { ImmutableSubstitution<ImmutableTerm> composition = childConstructionNode.getSubstitution().composeWith( parentConstructionNode.getSubstitution()); ImmutableSet<Variable> projectedVariables = parentConstructionNode.getVariables(); ImmutableSubstitution<ImmutableTerm> newSubstitution = projectedVariables.containsAll( childConstructionNode.getVariables()) ? composition : SUBSTITUTION_FACTORY.getSubstitution( composition.getImmutableMap().entrySet().stream() .filter(e -> !projectedVariables.contains(e.getKey())) .collect(ImmutableCollectors.toMap())); if (parentConstructionNode.getOptionalModifiers().isPresent() && childConstructionNode.getOptionalModifiers().isPresent()) { // TODO: find a better exception throw new RuntimeException("TODO: support combination of modifiers"); } // TODO: should update the modifiers? Optional<ImmutableQueryModifiers> optionalModifiers = parentConstructionNode.getOptionalModifiers() .map(Optional::of) .orElseGet(childConstructionNode::getOptionalModifiers); return iqFactory.createConstructionNode(projectedVariables, newSubstitution, optionalModifiers); }
Optional<ImmutableQueryModifiers> combinedModifiers = combineModifiers( modifiers, castChild.getOptionalModifiers() ); if (combinedModifiers.isPresent()) {
formerConstructionNode.getOptionalModifiers());
@Override public ConstructionNode transform(ConstructionNode constructionNode) { return iqFactory.createConstructionNode(renameProjectedVars(constructionNode.getVariables()), renameSubstitution(constructionNode.getSubstitution()), renameOptionalModifiers(constructionNode.getOptionalModifiers()) ); }
retainedVariables, SUBSTITUTION_FACTORY.getSubstitution(shrinkedMap), ((ConstructionNode) focusNode).getOptionalModifiers() ); treeComponent.replaceNode(focusNode, replacingNode);
/** * TODO: explain * * TODO: refactor * */ public static BindingRemoval newNodeWithLessBindings(IntermediateQueryFactory iqFactory, ConstructionNode formerConstructionNode, ImmutableSubstitution<ImmutableTerm> bindingsToRemove) throws InconsistentBindingException { ImmutableSet<Variable> variablesToRemove = extractVariablesToRemove(formerConstructionNode, bindingsToRemove); ImmutableSet<Variable> newVariablesToProject = extractVariablesToProject(variablesToRemove, bindingsToRemove); NewSubstitutions newSubstitutions = computeSubstitutionToPropagateAndNewBindings(formerConstructionNode, bindingsToRemove, variablesToRemove, newVariablesToProject); ImmutableSubstitution<ImmutableTerm> newBindingSubstitution = computeNewBindingSubstitution(formerConstructionNode, variablesToRemove, newSubstitutions.getNewBindings()); Optional<ImmutableQueryModifiers> newOptionalModifiers = computeNewOptionalModifiers(formerConstructionNode.getOptionalModifiers(), bindingsToRemove); ConstructionNode newConstructionNode = iqFactory.createConstructionNode(newVariablesToProject, newBindingSubstitution, newOptionalModifiers); return new BindingRemoval(newConstructionNode, newSubstitutions.getOptionalSubstitutionToPropagate()); }