private boolean _checkPrivate0(BasicOperator _op) { if (_op.getClass() != lupos.engine.operators.singleinput.Filter.class) { return false; } this.f = (lupos.engine.operators.singleinput.Filter) _op; List<BasicOperator> _precedingOperators_1_0 = _op.getPrecedingOperators(); this._dim_0 = -1; this.o1 = new lupos.engine.operators.BasicOperator[_precedingOperators_1_0.size()]; for (BasicOperator _precOp_1_0 : _precedingOperators_1_0) { this._dim_0 += 1; if (!this._checkPrivate1(_precOp_1_0)) { return false; } } List<OperatorIDTuple> _succedingOperators_1_0 = _op.getSucceedingOperators(); this._dim_0 = -1; this.o2 = new lupos.engine.operators.BasicOperator[_succedingOperators_1_0.size()]; for (OperatorIDTuple _sucOpIDTup_1_0 : _succedingOperators_1_0) { this._dim_0 += 1; if (!this._checkPrivate2(_sucOpIDTup_1_0.getOperator())) { return false; } } return true; }
/** {@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); }
/** * This method returns the first found preceding operator, which is connected to this operator * with the given id * * @param id the id of the OperatorIDTuple * @return the first found preceding operator, which is connected to this operator with the given * id, otherwise null */ public BasicOperator getPrecedingOperatorWithID(final int id) { for (BasicOperator prec : this.getPrecedingOperators()) { if (prec.getOperatorIDTuple(this).getId() == id) { return prec; } } return null; }
protected void replace(HashMap<Class<?>, HashSet<BasicOperator>> _startNodes) { // remove obsolete connections... int[] _label_a = null; int _label_a_count = 0; _label_a = new int[this.o1.length]; for (lupos.engine.operators.BasicOperator _parent : this.o1) { _label_a[_label_a_count] = _parent.getOperatorIDTuple(this.p).getId(); _label_a_count += 1; _parent.removeSucceedingOperator(this.p); this.p.removePrecedingOperator(_parent); } this.p.removeSucceedingOperator(this.o2); this.o2.removePrecedingOperator(this.p); // add new operators... lupos.rif.operator.PredicatePattern[] p_new = null; p_new = new lupos.rif.operator.PredicatePattern[this.o1.length]; for (this._dim_0 = 0; this._dim_0 < p_new.length; this._dim_0 += 1) { p_new[this._dim_0] = new lupos.rif.operator.PredicatePattern(); } // add new connections... for (this._dim_0 = 0; this._dim_0 < this.o1.length; this._dim_0 += 1) { this.o1[this._dim_0].addSucceedingOperator(p_new[this._dim_0]); p_new[this._dim_0].addPrecedingOperator(this.o1[this._dim_0]); } _label_a_count = 0; for (lupos.rif.operator.PredicatePattern _parent : p_new) { _parent.addSucceedingOperator(new OperatorIDTuple(this.o2, _label_a[_label_a_count])); this.o2.addPrecedingOperator(_parent); _label_a_count += 1; } // delete unreachable operators... this.deleteOperatorWithoutParentsRecursive(this.p, _startNodes); // additional replace method code... for (lupos.rif.operator.PredicatePattern tmp_p : p_new) { tmp_p.getSucceedingOperators().get(0).setId(id); tmp_p.setUnionVariables( new java.util.HashSet<lupos.datastructures.items.Variable>(this.p.getUnionVariables())); tmp_p.setIntersectionVariables( new java.util.HashSet<lupos.datastructures.items.Variable>( this.p.getIntersectionVariables())); tmp_p.setPredicateName(this.p.getPredicateName()); tmp_p.setPatternItems(this.p.getPatternItems()); } }
public void removeFromOperatorGraph() { for (final OperatorIDTuple oidtuple : this.getSucceedingOperators()) { oidtuple.getOperator().removePrecedingOperator(this); oidtuple.getOperator().addPrecedingOperators(this.getPrecedingOperators()); } for (final BasicOperator prec : this.getPrecedingOperators()) { prec.removeSucceedingOperator(this); prec.addSucceedingOperators(this.getSucceedingOperators()); } }
public void removeFromOperatorGraphWithoutConnectingPrecedingWithSucceedingOperators() { for (final OperatorIDTuple oidtuple : this.getSucceedingOperators()) { oidtuple.getOperator().removePrecedingOperator(this); } this.succeedingOperators.clear(); for (final BasicOperator prec : this.getPrecedingOperators()) { prec.removeSucceedingOperator(this); } this.precedingOperators.clear(); }
public void logDeletedOperatorsBelow( final BasicOperator parent, final Collection<BasicOperator> deleted) { if (parent.getPrecedingOperators().size() < 2) { deleted.add(parent); final OperatorIDTuple[] opIDTuples = parent.getSucceedingOperators().toArray(new OperatorIDTuple[0]); for (final OperatorIDTuple opIDTuple : opIDTuples) { logDeletedOperatorsBelow(opIDTuple.getOperator(), deleted); } } }
/** * The clone method to clone the current operator * * @return the cloned operator */ @Override public BasicOperator clone() { BasicOperator result = null; try { result = (BasicOperator) super.clone(); result.cloneFrom(this); } catch (final CloneNotSupportedException ex) { // just return null; } return result; }
/** * applyRulesDebugByteArray. * * @param op a {@link lupos.engine.operators.BasicOperator} object. * @param mapStartNodes a {@link java.util.Map} object. * @param rules an array of {@link lupos.optimizations.logical.rules.Rule} objects. * @param untilRule a {@link lupos.optimizations.logical.rules.Rule} object. * @param prefixInstance a {@link lupos.rdf.Prefix} object. * @return a {@link java.util.List} object. */ public List<DebugContainer<BasicOperatorByteArray>> applyRulesDebugByteArray( final BasicOperator op, final Map<Class<? extends BasicOperator>, Set<BasicOperator>> mapStartNodes, final Rule[] rules, final Rule untilRule, final Prefix prefixInstance) { final List<DebugContainer<BasicOperatorByteArray>> debug = new LinkedList<DebugContainer<BasicOperatorByteArray>>(); for (final Rule r : rules) { if (untilRule != null && r.equals(untilRule)) break; while (r.applyDebug(op, mapStartNodes)) { debug.add( new DebugContainer<BasicOperatorByteArray>( r.getName(), r.getDescription(), BasicOperatorByteArray.getBasicOperatorByteArray(op.deepClone(), prefixInstance))); // mapStartNodes = RuleEngine.createStartNodeMap(op); if (checkNodeMap) { // check if all nodes of the operatorgraph are in the // map: op.visit( new SimpleOperatorGraphVisitor() { public Object visit(final BasicOperator basicOperator) { if (!checkIfInNodeMap(basicOperator, mapStartNodes)) System.err.println( "The following node is not in mapStartNodes:" + basicOperator); return null; } }); // check if all nodes of the map are in the // operatorgraph: for (final Map.Entry<Class<? extends BasicOperator>, Set<BasicOperator>> entry : mapStartNodes.entrySet()) { for (final BasicOperator bo : entry.getValue()) { final FindInOperatorGraph findInOperatorGraph = new FindInOperatorGraph(bo); op.visit(findInOperatorGraph); if (!findInOperatorGraph.getFlag()) System.err.println( "The following node for class " + entry.getKey() + " is not in the operatorgraph:" + bo); } } } Rule[] rulesToApply = r.getRulesToApply(this); if (rulesToApply == null) rulesToApply = this.rules; debug.addAll(applyRulesDebugByteArray(op, mapStartNodes, rulesToApply, r, prefixInstance)); } } return debug; }
/** * addToNodeMap. * * @param basicOperator a {@link lupos.engine.operators.BasicOperator} object. * @param mapStartNodes a {@link java.util.Map} object. */ public static void addToNodeMap( final BasicOperator basicOperator, final Map<Class<? extends BasicOperator>, Set<BasicOperator>> mapStartNodes) { Set<BasicOperator> set = mapStartNodes.get(basicOperator.getClass()); if (set == null) { set = new HashSet<BasicOperator>(); } set.add(basicOperator); mapStartNodes.put(basicOperator.getClass(), set); set = mapStartNodes.get(BasicOperator.class); if (set == null) { set = new HashSet<BasicOperator>(); } set.add(basicOperator); mapStartNodes.put(BasicOperator.class, set); if (basicOperator instanceof Join && // exclude special case: basicOperator .getClass() .getPackage() .getName() .compareTo("lupos.engine.operators.multiinput.join.parallel") != 0) { set = mapStartNodes.get(Join.class); if (set == null) { set = new HashSet<BasicOperator>(); } set.add(basicOperator); mapStartNodes.put(Join.class, set); } if (basicOperator instanceof Optional || // include special case: basicOperator .getClass() .getPackage() .getName() .compareTo("lupos.engine.operators.multiinput.optional.parallel") == 0) { set = mapStartNodes.get(Optional.class); if (set == null) { set = new HashSet<BasicOperator>(); } set.add(basicOperator); mapStartNodes.put(Optional.class, set); } }
/** * deleteFromNodeMap. * * @param basicOperator a {@link lupos.engine.operators.BasicOperator} object. * @param mapStartNodes a {@link java.util.Map} object. */ public static void deleteFromNodeMap( final BasicOperator basicOperator, final Map<Class<? extends BasicOperator>, Set<BasicOperator>> mapStartNodes) { Set<BasicOperator> set = mapStartNodes.get(basicOperator.getClass()); if (set != null) { set.remove(basicOperator); if (set.size() > 0) mapStartNodes.put(basicOperator.getClass(), set); else mapStartNodes.remove(basicOperator.getClass()); } set = mapStartNodes.get(BasicOperator.class); if (set != null) { set.remove(basicOperator); mapStartNodes.put(BasicOperator.class, set); } if (basicOperator instanceof Join && // exclude special case: basicOperator .getClass() .getPackage() .getName() .compareTo("lupos.engine.operators.multiinput.optional.parallel") != 0) { set = mapStartNodes.get(Join.class); if (set != null) { set.remove(basicOperator); if (set.size() > 0) mapStartNodes.put(Join.class, set); else mapStartNodes.remove(Join.class); } } if (basicOperator instanceof Optional || // include special case: basicOperator .getClass() .getPackage() .getName() .compareTo("lupos.engine.operators.multiinput.optional.parallel") == 0) { set = mapStartNodes.get(Optional.class); if (set != null) { set.remove(basicOperator); if (set.size() > 0) mapStartNodes.put(Optional.class, set); else mapStartNodes.remove(Optional.class); } } }
public void dump(final String prefix, final HashSet<BasicOperator> visited) { if (visited.contains(this)) { return; } visited.add(this); System.out.println(prefix + this.toString()); for (final OperatorIDTuple childIDT : this.succeedingOperators) { final BasicOperator child = childIDT.getOperator(); child.dump(prefix + "-", visited); } }
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()); }
/** * checkIfInNodeMap. * * @param basicOperator a {@link lupos.engine.operators.BasicOperator} object. * @param mapStartNodes a {@link java.util.Map} object. * @return a boolean. */ public static boolean checkIfInNodeMap( final BasicOperator basicOperator, final Map<Class<? extends BasicOperator>, Set<BasicOperator>> mapStartNodes) { Set<BasicOperator> set = mapStartNodes.get(basicOperator.getClass()); if (set == null) { return false; } if (!set.contains(basicOperator)) return false; set = mapStartNodes.get(BasicOperator.class); if (set == null) { return false; } if (!set.contains(basicOperator)) return false; if (basicOperator instanceof Join && // exclude special case: basicOperator .getClass() .getPackage() .getName() .compareTo("lupos.engine.operators.multiinput.optional.parallel") != 0) { set = mapStartNodes.get(Join.class); if (set == null) { return false; } if (!set.contains(basicOperator)) return false; } if (basicOperator instanceof Optional || // include special case: basicOperator .getClass() .getPackage() .getName() .compareTo("lupos.engine.operators.multiinput.optional.parallel") == 0) { set = mapStartNodes.get(Optional.class); if (set == null) { return false; } if (!set.contains(basicOperator)) return false; } return true; }
public void deleteAllBelow( final BasicOperator parent, final BasicOperator child, final Collection<BasicOperator> deleted) { if (child.getPrecedingOperators().size() > 1) { parent.removeSucceedingOperator(child); child.removePrecedingOperator(parent); } else { deleted.add(parent); final OperatorIDTuple[] opIDTuples = child.getSucceedingOperators().toArray(new OperatorIDTuple[0]); for (final OperatorIDTuple opIDTuple : opIDTuples) { deleteAllBelow(child, opIDTuple.getOperator(), deleted); } } }
/** {@inheritDoc} */ @SuppressWarnings("rawtypes") @Override public JSONObject serialize(final BasicOperator operator, final int node_id) throws JSONException { final JSONObject json = new JSONObject(); /* * store preceeding's and remove them from the subgraph, because they * are not to be serialized (but they are added later) */ final List<BasicOperator> storePrecds = new LinkedList<BasicOperator>(((SubgraphContainer) operator).getPrecedingOperators()); for (final BasicOperator op : storePrecds) { ((SubgraphContainer) operator).removePrecedingOperator(op); } /* * store succeeding's and remove them from the subgraph (see above) */ final List<OperatorIDTuple> storeSuccs = new LinkedList<OperatorIDTuple>(((SubgraphContainer) operator).getSucceedingOperators()); for (final OperatorIDTuple op : storeSuccs) { ((SubgraphContainer) operator).removeSucceedingOperator(op); } json.put("type", operator.getClass().getName()); json.put("node_id", node_id); /* * now serialize the subgraph container */ final SubgraphContainerFormatter serializer = new SubgraphContainerFormatter(); final JSONObject serializedGraph = serializer.serialize(((SubgraphContainer) operator).getRootOfSubgraph(), 0); json.put("subgraph", serializedGraph); /* * now serialize the subgraph container's key */ final Object key = ((SubgraphContainer) operator).getKey(); try { final String sgKey = JsonWriter.objectToJson(key); json.put("key", sgKey); } catch (final IOException e) { json.put("key", "Not serializable."); propagate( new RuntimeException( String.format("The key of subgraphContainer %s is not serialzable.", operator))); } // now add the connections ... we have removed above. for (final BasicOperator op : storePrecds) { ((SubgraphContainer) operator).addPrecedingOperator(op); } for (final OperatorIDTuple op : storeSuccs) { ((SubgraphContainer) operator).addSucceedingOperator(op); } return json; }
/** * This method clones not only the current operator, but all of its succeeding operators * recursively. * * @return the cloned operator */ public BasicOperator deepClone() { final BasicOperator op = (BasicOperator) visit( new SimpleOperatorGraphVisitor() { /** */ private static final long serialVersionUID = -2374279115052843835L; final Map<BasicOperator, BasicOperator> clones = new HashMap<BasicOperator, BasicOperator>(); @Override public Object visit(final BasicOperator basicOperator) { BasicOperator cloneCurrent; if (this.clones.containsKey(basicOperator)) { cloneCurrent = this.clones.get(basicOperator); } else { cloneCurrent = basicOperator.clone(); this.clones.put(basicOperator, cloneCurrent); } final LinkedList<OperatorIDTuple> newSucc = new LinkedList<OperatorIDTuple>(); for (final OperatorIDTuple opid : basicOperator.succeedingOperators) { BasicOperator clone = null; if (this.clones.containsKey(opid.getOperator())) { clone = this.clones.get(opid.getOperator()); } else { clone = opid.getOperator().clone(); this.clones.put(opid.getOperator(), clone); } newSucc.add(new OperatorIDTuple(clone, opid.getId())); } cloneCurrent.setSucceedingOperators(newSucc); return cloneCurrent; } }); op.deleteParents(); op.setParents(); return op; }
/** {@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; }
private boolean _checkPrivate0(BasicOperator _op) { if (_op.getClass() != lupos.rif.operator.PredicatePattern.class) { return false; } this.p = (lupos.rif.operator.PredicatePattern) _op; List<BasicOperator> _precedingOperators_1_0 = _op.getPrecedingOperators(); this._dim_0 = -1; this.o1 = new lupos.engine.operators.BasicOperator[_precedingOperators_1_0.size()]; for (BasicOperator _precOp_1_0 : _precedingOperators_1_0) { this._dim_0 += 1; if (!this._checkPrivate1(_precOp_1_0)) { return false; } } List<OperatorIDTuple> _succedingOperators_1_0 = _op.getSucceedingOperators(); if (_succedingOperators_1_0.size() != 1) { return false; } for (OperatorIDTuple _sucOpIDTup_1_0 : _succedingOperators_1_0) { if (!(_sucOpIDTup_1_0.getOperator() instanceof lupos.engine.operators.BasicOperator)) { continue; } this.o2 = (lupos.engine.operators.BasicOperator) _sucOpIDTup_1_0.getOperator(); return true; } return false; }
@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; }
public static Set<Variable> getAllVariablesOfQuery(final BasicOperator rootNode) { final Set<Variable> maxVariables = new TreeSet<Variable>(); rootNode.visit( new SimpleOperatorGraphVisitor() { @Override public Object visit(final BasicOperator basicOperator) { if (basicOperator.getUnionVariables() != null) { maxVariables.addAll(basicOperator.getUnionVariables()); } return null; } }); return maxVariables; }
public void deleteAllAbove( final BasicOperator parent, final BasicOperator child, final Collection<BasicOperator> deleted) { parent.removeSucceedingOperator(child); if (!(parent instanceof PatternMatcher)) { // log parent as deleted operator deleted.add(parent); // in addition, log all operators (other than child) below parent, that became unrechable if (parent.getSucceedingOperators().size() > 0) { final OperatorIDTuple[] opIDTuples = parent.getSucceedingOperators().toArray(new OperatorIDTuple[0]); for (final OperatorIDTuple opIDTuple : opIDTuples) { logDeletedOperatorsBelow(opIDTuple.getOperator(), deleted); } } for (final BasicOperator parentparent : parent.getPrecedingOperators()) { deleteAllAbove(parentparent, parent, deleted); } } }
private static Map<Class<? extends BasicOperator>, Set<BasicOperator>> createStartNodeMap( final BasicOperator op) { final Map<Class<? extends BasicOperator>, Set<BasicOperator>> mapStartNodes = new HashMap<Class<? extends BasicOperator>, Set<BasicOperator>>(); op.visit( new SimpleOperatorGraphVisitor() { public Object visit(final BasicOperator basicOperator) { RuleEngine.addToNodeMap(basicOperator, mapStartNodes); return null; } }); return mapStartNodes; }
@Override protected BasicOperator generateJoin( final InnerNodePlan inp, final Root root, final BasicOperator left, final BasicOperator right, final Collection<Variable> sortCriterium, final Map<TriplePattern, Map<Variable, VarBucket>> selectivity) { // left-deep-tree or right-deep-tree? if (left instanceof BasicIndexScan && right instanceof BasicIndexScan) { if (((BasicIndexScan) right).getTriplePattern().size() == 1 || ((BasicIndexScan) left).getTriplePattern().size() == 1) { final Collection<TriplePattern> ctp; if (inp.getLeft().getCost() < inp.getRight().getCost()) { ctp = ((BasicIndexScan) left).getTriplePattern(); ctp.addAll(((BasicIndexScan) right).getTriplePattern()); } else { ctp = ((BasicIndexScan) right).getTriplePattern(); ctp.addAll(((BasicIndexScan) left).getTriplePattern()); } ((BasicIndexScan) left).setTriplePatterns(ctp); root.remove((BasicIndexScan) right); return left; } } Join join = new Join(); join.setEstimatedCardinality(inp.getCardinality()); // TODO check if necessary (or is it just necessary for RDF3X???)! if (!(inp.getLeft() instanceof InnerNodePlan && ((InnerNodePlan) inp.getLeft()).getJoinType() == JoinType.DEFAULT) && (inp.getRight() instanceof InnerNodePlan && ((InnerNodePlan) inp.getRight()).getJoinType() == JoinType.DEFAULT) || (inp.getLeft() instanceof LeafNodePlan && inp.getRight() instanceof InnerNodePlan)) { moveToLeft(inp.getRight().getTriplePatterns(), root); } else if (!(inp.getRight() instanceof InnerNodePlan && ((InnerNodePlan) inp.getRight()).getJoinType() == JoinType.DEFAULT) && (inp.getLeft() instanceof InnerNodePlan && ((InnerNodePlan) inp.getLeft()).getJoinType() == JoinType.DEFAULT) || (inp.getRight() instanceof LeafNodePlan && inp.getLeft() instanceof InnerNodePlan)) { moveToLeft(inp.getLeft().getTriplePatterns(), root); } else if (inp.getLeft().getCost() > inp.getRight().getCost()) { System.out.println( "Card. of joins with estimated lower cost vs. est. higher cost:" + inp.getRight().getCardinality() + "<->" + inp.getLeft().getCardinality()); System.out.println( "Cost of joins with estimated lower cost vs. est. higher cost:" + inp.getRight().getCost() + "<->" + inp.getLeft().getCost()); moveToLeft(inp.getRight().getTriplePatterns(), root); } else { System.out.println( "Card. of joins with estimated lower cost vs. est. higher cost:" + inp.getLeft().getCardinality() + "<->" + inp.getRight().getCardinality()); System.out.println( "Cost of joins with estimated lower cost vs. est. higher cost:" + inp.getLeft().getCost() + "<->" + inp.getRight().getCost()); moveToLeft(inp.getLeft().getTriplePatterns(), root); } join.setIntersectionVariables(inp.getJoinPartner()); join.setUnionVariables(inp.getVariables()); left.setSucceedingOperator(new OperatorIDTuple(join, 0)); right.setSucceedingOperator(new OperatorIDTuple(join, 1)); join.addPrecedingOperator(left); join.addPrecedingOperator(right); return join; }
public Object visit(final BasicOperator basicOperator) { if (basicOperator.equals(toFind)) flag = true; return null; }