@Override public void meet(Filter node) { Set<QueryModelNode> eSet = getQNodes(node); if (eSet.containsAll(sSet)) { if (eSet.equals(sSet)) { node.replaceWith(set); indexPlaced = true; return; } else { node.getArg().visit(this); } } }
@Override public void meet(Filter node) { filterCond.add(node.getCondition()); node.replaceWith(node.getArg()); }
@Override public void meet(EmptySet node) { if (filter.getParentNode() != null) { // Remove filter from its original location filter.replaceWith(filter.getArg()); } }
@Override public void meet(EmptySet node) { if (filter.getParentNode() != null) { // Remove filter from its original location filter.replaceWith(filter.getArg()); } }
@Override public void meet(final EmptySet node) { if (filter.getParentNode() != null) { // Remove filter from its original location filter.replaceWith(filter.getArg()); } }
protected void relocate(final Filter filter, final TupleExpr newFilterArg) { if (!filter.getArg().equals(newFilterArg)) { if (filter.getParentNode() != null) { // Remove filter from its original location filter.replaceWith(filter.getArg()); } // Insert filter at the new location newFilterArg.replaceWith(filter); filter.setArg(newFilterArg); } } }
public void meet(Filter node) { if (node.getCondition() instanceof FunctionCall) { try { Optional<PeriodicQueryNode> optNode = getPeriodicQueryNode((FunctionCall) node.getCondition(), node.getArg()); if (optNode.isPresent()) { if (count > 0) { throw new IllegalArgumentException("Query cannot contain more than one PeriodicQueryNode"); } periodicNode = optNode.get(); node.replaceWith(periodicNode); count++; periodicNode.visit(this); } else { super.meet(node); } } catch (Exception e) { throw new RuntimeException(e.getMessage()); } } else { super.meet(node); } } }
@Override public void meet(Filter node) { super.meet(node); TupleExpr arg = node.getArg(); ValueExpr condition = node.getCondition(); if (arg instanceof EmptySet) { // see #meetUnaryTupleOperator } else if (condition instanceof ValueConstant) { boolean conditionValue; try { conditionValue = QueryEvaluationUtil.getEffectiveBooleanValue(((ValueConstant)condition).getValue()); } catch (ValueExprEvaluationException e) { conditionValue = false; } if (conditionValue == false) { // Constraint is always false node.replaceWith(new EmptySet()); } else { node.replaceWith(arg); } } }
@Override public void updateQueryModelNodes(boolean hasResult) { QueryModelNode replacementNode = hasResult ? new SingletonSet() : new EmptySet(); geoStatement.replaceWith(replacementNode); if(hasResult) { filter.replaceWith(filter.getArg()); } else { filter.replaceWith(new EmptySet()); } if(functionParent instanceof ExtensionElem) { Extension extension = (Extension) functionParent.getParentNode(); List<ExtensionElem> elements = extension.getElements(); if(elements.size() > 1) { elements.remove(functionParent); } else { extension.replaceWith(extension.getArg()); } } } }
@Override public void updateQueryModelNodes(boolean hasResult) { QueryModelNode replacementNode = hasResult ? new SingletonSet() : new EmptySet(); geoStatement.replaceWith(replacementNode); if(hasResult) { filter.replaceWith(filter.getArg()); } else { filter.replaceWith(new EmptySet()); } if(functionParent instanceof ExtensionElem) { Extension extension = (Extension) functionParent.getParentNode(); List<ExtensionElem> elements = extension.getElements(); if(elements.size() > 1) { elements.remove(functionParent); } else { extension.replaceWith(extension.getArg()); } } } }
protected void relocate(Filter filter, TupleExpr newFilterArg) { if (filter.getArg() != newFilterArg) { if (filter.getParentNode() != null) { // Remove filter from its original location filter.replaceWith(filter.getArg()); } // Insert filter at the new location newFilterArg.replaceWith(filter); filter.setArg(newFilterArg); } } }
private void bindVar(Var var, Value value, Filter filter) { // Set the value on all occurences of the variable filter.getArg().visit(new VarBinder(var.getName(), value)); // Get rid of the filter filter.replaceWith(filter.getArg()); } }
protected void relocate(Filter filter, TupleExpr newFilterArg) { if (filter.getArg() != newFilterArg) { if (filter.getParentNode() != null) { // Remove filter from its original location filter.replaceWith(filter.getArg()); } // Insert filter at the new location newFilterArg.replaceWith(filter); filter.setArg(newFilterArg); } } }
@Override public void meet(Filter node) throws RuntimeException { super.meet(node); if (node.getCondition() instanceof Exists) { Exists exists = (Exists) node.getCondition(); if (!readOnly) { node.replaceWith(new Join(node.getArg(), exists.getSubQuery())); } present = true; } }
@Override public void meet(Filter filterNode) throws Exception { filterNode.visitChildren(this); if (filterNode.getArg() instanceof AggregationPipelineQueryNode && filterNode.getParentNode() != null) { AggregationPipelineQueryNode pipelineNode = (AggregationPipelineQueryNode) filterNode.getArg(); if (pipelineNode.filter(filterNode.getCondition())) { filterNode.replaceWith(pipelineNode); } } } }
@Override public void meet(final Filter node) throws Exception { super.meet(node); final ValueExpr condition = node.getCondition(); final TupleExpr arg = node.getArg(); if (!(arg instanceof Join)) { return; } final Join join = (Join) arg; final TupleExpr leftArg = join.getLeftArg(); final TupleExpr rightArg = join.getRightArg(); if (leftArg instanceof StatementPattern && rightArg instanceof StatementPattern) { final Filter left = new Filter(leftArg, condition); final Filter right = new Filter(rightArg, condition); node.replaceWith(new Join(left, right)); } } }
private void renameVar(Var oldVar, Var newVar, Filter filter) { filter.getArg().visit(new VarRenamer(oldVar, newVar)); // TODO: skip this step if old variable name is not used // Replace SameTerm-filter with an Extension, the old variable name // might still be relevant to nodes higher in the tree Extension extension = new Extension(filter.getArg()); extension.addElement(new ExtensionElem(new Var(newVar.getName()), oldVar.getName())); filter.replaceWith(extension); }
private void renameVar(Var oldVar, Var newVar, Filter filter) { filter.getArg().visit(new VarRenamer(oldVar.getName(), newVar.getName())); // TODO: skip this step if old variable name is not used // Replace SameTerm-filter with an Extension, the old variable name // might still be relevant to nodes higher in the tree Extension extension = new Extension(filter.getArg()); extension.addElement(new ExtensionElem(new Var(newVar.getName()), oldVar.getName())); filter.replaceWith(extension); }
@Override public void meet(Filter node) throws RuntimeException { super.meet(node); if (node.getArg() instanceof SelectQuery) { SelectQuery query = (SelectQuery)node.getArg(); ValueExpr condition = null; for (ValueExpr expr : flatten(node.getCondition())) { try { query.addFilter(sql.createBooleanExpr(expr)); } catch (UnsupportedRdbmsOperatorException e) { if (condition == null) { condition = expr; } else { condition = new And(condition, expr); } } } if (condition == null) { node.replaceWith(node.getArg()); } else { node.setCondition(condition); } } }
@Override public void meet(Filter filter) { if (filter.getCondition() instanceof Or && containsSameTerm(filter.getCondition())) { Or orNode = (Or)filter.getCondition(); TupleExpr filterArg = filter.getArg(); ValueExpr leftConstraint = orNode.getLeftArg(); ValueExpr rightConstraint = orNode.getRightArg(); // remove filter filter.replaceWith(filterArg); // Push UNION down below other filters to avoid cloning them TupleExpr node = findNotFilter(filterArg); Filter leftFilter = new Filter(node.clone(), leftConstraint); Filter rightFilter = new Filter(node.clone(), rightConstraint); Union union = new Union(leftFilter, rightFilter); node.replaceWith(union); filter.getParentNode().visit(this); } else { super.meet(filter); } }