/** {@inheritDoc} */ @Override public void insertFederatedQueryOperator( final ASTService node, final OperatorConnection connection) { SeveralSucceedingOperators sso = new SeveralSucceedingOperators(); BasicOperator federatedQuery = this.getFederatedQuery(node); Node child0 = node.jjtGetChild(0); if (child0 instanceof ASTVar) { Sort sort = new Sort(); LinkedList<Variable> listOfVars = new LinkedList<Variable>(); listOfVars.add(new Variable(((ASTVar) child0).getName())); ComparatorVariables comparator = new ComparatorVariables(listOfVars); sort.setComparator(comparator); Group group = new Group(comparator); sort.addSucceedingOperator(group); group.addSucceedingOperator(federatedQuery); sso.addSucceedingOperator(sort); } else { sso.addSucceedingOperator(federatedQuery); } Join join = new Join(); federatedQuery.addSucceedingOperator(join, 1); sso.addSucceedingOperator(join, 0); connection.connect(join); connection.setOperatorConnection(sso); }
protected void replace(HashMap<Class<?>, HashSet<BasicOperator>> _startNodes) { // remove obsolete connections... for (lupos.engine.operators.BasicOperator _parent : this.o1) { _parent.removeSucceedingOperator(this.f); this.f.removePrecedingOperator(_parent); } for (lupos.engine.operators.BasicOperator _child : this.o2) { this.f.removeSucceedingOperator(_child); _child.removePrecedingOperator(this.f); } // add new operators... lupos.rif.operator.RuleFilter rf = null; rf = new lupos.rif.operator.RuleFilter(); // add new connections... for (lupos.engine.operators.BasicOperator _parent : this.o1) { _parent.addSucceedingOperator(rf); rf.addPrecedingOperator(_parent); } for (lupos.engine.operators.BasicOperator _child : this.o2) { rf.addSucceedingOperator(_child); _child.addPrecedingOperator(rf); } // delete unreachable operators... this.deleteOperatorWithoutParentsRecursive(this.f, _startNodes); // additional replace method code... lupos.optimizations.sparql2core_sparql.SPARQLParserVisitorImplementationDumper filterDumper = new lupos.optimizations.sparql2core_sparql.SPARQLParserVisitorImplementationDumper(); String equalsString = (String) filterDumper.visit( (lupos.sparql1_1.ASTEqualsNode) this.f.getNodePointer().jjtGetChild(0)); lupos.rif.model.Equality equality = null; try { lupos.rif.generated.syntaxtree.RIFAtomic atomic = new lupos.rif.generated.parser.RIFParser( new java.io.StringReader(equalsString.substring(1, equalsString.length() - 1))) .RIFAtomic(); lupos.rif.visitor.ParseSyntaxTreeVisitor rifParser = new lupos.rif.visitor.ParseSyntaxTreeVisitor(); equality = (lupos.rif.model.Equality) atomic.accept(rifParser, null); } catch (lupos.rif.generated.parser.ParseException e) { e.printStackTrace(); return; } rf.setExpression(equality); rf.setUnionVariables(this.f.getUnionVariables()); rf.setIntersectionVariables(this.f.getIntersectionVariables()); }
/** {@inheritDoc} */ @Override public Tuple<Collection<BasicOperator>, Collection<BasicOperator>> transformOperatorGraph( final Map<String, BasicOperator> mso, final BasicOperator rootOperator) { final Collection<BasicOperator> deleted = new LinkedList<BasicOperator>(); final Collection<BasicOperator> added = new LinkedList<BasicOperator>(); final ReplaceVar replaceVar = (ReplaceVar) mso.get("replaceVar"); final LinkedList<BasicOperator> pres = (LinkedList<BasicOperator>) replaceVar.getPrecedingOperators(); final LinkedList<OperatorIDTuple> succs = (LinkedList<OperatorIDTuple>) replaceVar.getSucceedingOperators(); BasicOperator pre; OperatorIDTuple idTuple; // Connect all precessors to all successors for (int i = 0; i < pres.size(); i++) { for (int a = 0; a < succs.size(); a++) { idTuple = succs.get(a); pre = pres.get(i); pre.addSucceedingOperator(new OperatorIDTuple(idTuple.getOperator(), idTuple.getId())); pre.removeSucceedingOperator(replaceVar); } } BasicOperator succ; // And all successors to all precessors for (int i = 0; i < succs.size(); i++) { for (int a = 0; a < pres.size(); a++) { succ = succs.get(i).getOperator(); succ.addPrecedingOperator(pres.get(a)); succ.removePrecedingOperator(replaceVar); } } rootOperator.deleteParents(); rootOperator.setParents(); rootOperator.detectCycles(); // should have been done manually: rootOperator.sendMessage(new // BoundVariablesMessage()); deleted.add(replaceVar); if (deleted.size() > 0 || added.size() > 0) return new Tuple<Collection<BasicOperator>, Collection<BasicOperator>>(added, deleted); else return null; }
@Override public Tuple<Collection<BasicOperator>, Collection<BasicOperator>> transformOperatorGraph( final Map<String, BasicOperator> mso, final BasicOperator rootOperator) { final GenerateAddEnv genAdd = (GenerateAddEnv) mso.get("genAdd"); final Optional optional = (Optional) mso.get("optional"); final LinkedList<BasicOperator> pres = (LinkedList<BasicOperator>) genAdd.getPrecedingOperators(); final LinkedList<OperatorIDTuple> succs = (LinkedList<OperatorIDTuple>) optional.getSucceedingOperators(); BasicOperator pre; for (int i = 0; i < pres.size(); i++) { pre = pres.get(i); pre.addSucceedingOperator(new OperatorIDTuple(optional, 0)); pre.removeSucceedingOperator(genAdd); optional.addPrecedingOperator(pre); } optional.removePrecedingOperator(genAdd); optional.setSucceedingOperator(new OperatorIDTuple(genAdd, 0)); genAdd.setPrecedingOperator(optional); genAdd.setSucceedingOperators(succs); BasicOperator succ; for (int i = 0; i < succs.size(); i++) { succ = succs.get(i).getOperator(); succ.addPrecedingOperator(genAdd); succ.removePrecedingOperator(optional); } rootOperator.deleteParents(); rootOperator.setParents(); rootOperator.detectCycles(); rootOperator.sendMessage(new BoundVariablesMessage()); return null; }