Package lupos.engine.operators.singleinput

Examples of lupos.engine.operators.singleinput.Projection

58
59
60
61
62
63
64
65
66
67
68
69
70
71
      Join join = new Join();
      connection.connect(join);
      SeveralSucceedingOperators sso = new SeveralSucceedingOperators();
      sso.addSucceedingOperator(join, 0);
      FederatedQueryTrivialApproach federatedQuery = new FederatedQueryTrivialApproach(node);
      Projection projection = new Projection();
      projection.addProjectionElement(new Variable(((ASTVar)child0).getName()));
      Distinct distinct = new Distinct();
      projection.addSucceedingOperator(distinct);
      distinct.addSucceedingOperator(federatedQuery);
      sso.addSucceedingOperator(projection, 0);
      federatedQuery.addSucceedingOperator(join, 1);
      connection.setOperatorConnection(sso);
    }   
View Full Code Here
76
77
78
79
80
81
82
83
84
85
86
87
    if (!(op instanceof Projection)) {
      System.err
          .println("Replace has not Projection as direct successor or after its ReplaceLit => Correct RuleOptimizeReplaceByPat!!!");
      return false;
    } else {
      final Projection proj = (Projection) op;
      final Object[] projVars = proj.getProjectedVariables().toArray();
      final Item[] patItems = pat.getItems();
      for (int i = 0; i < patItems.length; i++) {
        // Only if a variable in TriplePattern is not projected later
        // (TP creates temporary tuples)
        if (patItems[i].isVariable()) {
View Full Code Here
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
    BasicOperator op = replaceVar.getSucceedingOperators().get(0)
        .getOperator();
    if (op instanceof ReplaceLit) {
      op = op.getSucceedingOperators().get(0).getOperator();
    }
    final Projection proj = (Projection) op;

    final LinkedList<Variable> replaceVarLeft = replaceVar
        .getSubstitutionsVariableLeft();
    final LinkedList<Variable> replaceVarRight = replaceVar
        .getSubstitutionsVariableRight();
    final Object[] projVars = proj.getProjectedVariables().toArray();
    final Item[] patItems = pat.getItems();

    Variable var;
    Variable newTripleVar;
View Full Code Here
39
40
41
42
43
44
45
46
47
48
49
50
51
52
public class RuleReplaceVarUnderProjection extends Rule {

  @Override
  protected void init() {
    final Projection projection = new Projection();
    final ReplaceVar replaceVar = new ReplaceVar();

    projection.setSucceedingOperator(new OperatorIDTuple(replaceVar, 0));
    replaceVar.setPrecedingOperator(projection);

    subGraphMap = new HashMap<BasicOperator, String>();
    subGraphMap.put(projection, "projection");
    subGraphMap.put(replaceVar, "replaceVar");
View Full Code Here
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
  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 Projection projection = (Projection) mso.get("projection");
    final ReplaceVar replaceVar = (ReplaceVar) mso.get("replaceVar");

    // Clone ReplaceVar
    final ReplaceVar replaceVar_new = new ReplaceVar();
    replaceVar_new.setSubstitutionsVariableLeft(replaceVar
        .getSubstitutionsVariableLeft());
    replaceVar_new.setSubstitutionsVariableRight(replaceVar
        .getSubstitutionsVariableRight());

    replaceVar.removePrecedingOperator(projection);

    // Enhance projection variables by left tuple variables of ReplaceVar
    final LinkedList<Variable> vars = replaceVar
        .getSubstitutionsVariableLeft();
    for (int i = 0; i < vars.size(); i++) {
      if (!projection.getProjectedVariables().contains(vars.get(i))) {
        projection.addProjectionElement(vars.get(i));
      }
    }

    final LinkedList<BasicOperator> pres = (LinkedList<BasicOperator>) projection
        .getPrecedingOperators();
    final LinkedList<OperatorIDTuple> succs = (LinkedList<OperatorIDTuple>) replaceVar
        .getSucceedingOperators();

    BasicOperator pre;
    for (int i = 0; i < pres.size(); i++) {
      pre = pres.get(i);
      pre.addSucceedingOperator(new OperatorIDTuple(replaceVar_new, 0));
      pre.removeSucceedingOperator(projection);
    }

    replaceVar_new.setPrecedingOperators(pres);
    replaceVar_new
        .setSucceedingOperator(new OperatorIDTuple(projection, 0));

    projection.setPrecedingOperator(replaceVar_new);
    projection.setSucceedingOperators(succs);

    for (int i = 0; i < succs.size(); i++) {
      succs.get(i).getOperator().addPrecedingOperator(projection);
    }
View Full Code Here
162
163
164
165
166
167
168
169
170
171
172
173
174
    if (substVar > 0) {
      order.add(replaceVar);
      added.add(replaceVar);
    } else {
      final Projection p = new Projection();
      p.setIntersectionVariables(new HashSet<Variable>());
      p.setUnionVariables(p.getUnionVariables());
      order.add(p);
      added.add(p);
    }
    if (addBindingsVar.size() > 0) {
      final Iterator<Literal> lit_it = addBindingsLit.iterator();
View Full Code Here
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
    return replaceAfterPre;
  }

  private Projection getProjectionAfterReplace(final ReplaceVar replacePre,
      final BasicOperator pre) {
    final Projection projectionPre = new Projection();

    final Object[] unionVars = pre.getUnionVariables().toArray();
    final LinkedList<Variable> replaceVarsLeft = replacePre
        .getSubstitutionsVariableLeft();
    final LinkedList<Variable> replaceVarsRight = replacePre
        .getSubstitutionsVariableRight();

    // Let the tupel from the new ReplaceVar through
    for (int i = 0; i < replaceVarsLeft.size(); i++) {
      projectionPre.addProjectionElement(replaceVarsLeft.get(i));
    }

    // Let all UNION-Variable through, but not the ones which the new
    // ReplaceVar has replaced (right side)
    final LinkedList<Variable> projVars = new LinkedList<Variable>();
    for (int i = 0; i < unionVars.length; i++) {
      final Variable var = (Variable) unionVars[i];
      if (!replaceVarsRight.contains(var)) {
        projVars.add(var);
      }
    }

    // Add the calculated variables to the new projection
    for (int i = 0; i < projVars.size(); i++) {
      projectionPre.addProjectionElement(projVars.get(i));
    }

    return projectionPre;
  }
View Full Code Here
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
      pre = pres.get(i);
      indices.add(pre.getOperatorIDTuple(join).getId());
    }

    ReplaceVar rep;
    Projection projectionPre;
    for (int i = 0; i < pres.size(); i++) {
      pre = pres.get(i);

      // Calculate the new ReplaceVar which will be replaced between the
      // i-th precessor and the join
      rep = getReplaceAfterPre(replaceVar, originalClone, pre, join);

      // Calculate projection after precessor and new ReplaceVar
      projectionPre = getProjectionAfterReplace(rep, pre);

      added.add(rep);
      added.add(projectionPre);

      pre.setSucceedingOperator(new OperatorIDTuple(rep, 0));
      rep.setPrecedingOperator(pre);
      rep.setSucceedingOperator(new OperatorIDTuple(projectionPre, 0));

      projectionPre.setPrecedingOperator(rep);
      projectionPre.setSucceedingOperator(new OperatorIDTuple(join,
          indices.get(i)));
      join.setPrecedingOperator(projectionPre);
    }

    rootOperator.deleteParents();
View Full Code Here
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
      final Union union = new Union();

      final BasicOperator leftSide = this.zeroPath(node, graphConstraint, subject, object, subjectNode, objectNode);
      leftSide.addSucceedingOperator(new OperatorIDTuple(union,0));

      final Projection projection = new Projection();
      projection.addProjectionElement(subject);
      projection.addProjectionElement(object);
      if(graphConstraint!=null && graphConstraint.isVariable() && !graphConstraint.equals(getItem(subjectNode)) && !graphConstraint.equals(getItem(objectNode))) {
        projection.addProjectionElement((Variable)graphConstraint);
      }

      startingOperator.addSucceedingOperator(new OperatorIDTuple(union,1));

      union.addSucceedingOperator(new OperatorIDTuple(projection,0));
View Full Code Here
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
      // alternative way to evaluate (...)* without using the Closure and PathLengthZero operators!

      // Plus Operator
      final BasicOperator startingOperator = node.jjtGetChild(0).accept(this, connection, graphConstraint, subject, object, subjectNode, objectNode);

      final Projection projection = new Projection();
      projection.addProjectionElement(subject);
      projection.addProjectionElement(object);
      if(graphConstraint!=null && graphConstraint.isVariable() && !graphConstraint.equals(getItem(subjectNode)) && !graphConstraint.equals(getItem(objectNode))) {
        projection.addProjectionElement((Variable)graphConstraint);
      }

      final Union union = new Union();
      final InMemoryDistinct memoryDistinct = new InMemoryDistinct();
      try {
View Full Code Here
TOP

Related Classes of lupos.engine.operators.singleinput.Projection

  • lupos.datastructures.bindings.Bindings
  • lupos.datastructures.items.Variable
  • lupos.engine.operators.messages.BoundVariablesMessage
  • lupos.optimizations.logical.rules.findsubgraph.FindSubGraph
  • lupos.optimizations.logical.rules.rdfs.RuleDeleteUseLessProjection
  • lupos.optimizations.logical.rules.rdfs.RuleGenerateAddOverProjection
  • lupos.optimizations.logical.rules.rdfs.RuleMergeTwoProjection
  • lupos.optimizations.logical.rules.rdfs.RuleOptimizeReplaceByPat
  • lupos.optimizations.logical.rules.rdfs.RuleReplaceGenPat
  • lupos.optimizations.logical.rules.rdfs.RuleReplaceLitOverProjection
    • Copyright © 2018 www.massapicom. All rights reserved.
    All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.