Package plan_runner.operators

Examples of plan_runner.operators.ProjectOperator

206
207
208
209
210
211
212
213
214
215
216
217
218
  }

  private void attachSelectClauseOnLastJoin(Component lastComponent,
      NameSelectItemsVisitor selectVisitor) {
    final List<AggregateOperator> aggOps = selectVisitor.getAggOps();
    ProjectOperator project = null;
    if (!(selectVisitor.getGroupByVEs() == null || selectVisitor.getGroupByVEs().isEmpty()))
      project = new ProjectOperator(selectVisitor.getGroupByVEs());

    if (aggOps.isEmpty()) {
      if (project != null)
        lastComponent.addOperator(project);
    } else if (aggOps.size() == 1) {
View Full Code Here
58
59
60
61
62
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
  }

  private void attachSelectClause(Component lastComponent, List<AggregateOperator> aggOps,
      List<ValueExpression> groupByVEs) {
    if (aggOps.isEmpty()) {
      final ProjectOperator project = new ProjectOperator(groupByVEs);
      lastComponent.addOperator(project);
    } else if (aggOps.size() == 1) {
      // all the others are group by
      final AggregateOperator firstAgg = aggOps.get(0);

      if (ParserUtil.isAllColumnRefs(groupByVEs)) {
        // plain fields in select
        final List<Integer> groupByColumns = ParserUtil.extractColumnIndexes(groupByVEs);
        firstAgg.setGroupByColumns(groupByColumns);

        // Setting new level of components is necessary for correctness
        // only for distinct in aggregates
        // but it's certainly pleasant to have the final result grouped
        // on nodes by group by columns.
        final boolean newLevel = !(_it.isHashedBy(lastComponent, groupByColumns));
        if (newLevel) {
          lastComponent.setHashIndexes(groupByColumns);
          new OperatorComponent(lastComponent, ParserUtil.generateUniqueName("OPERATOR"),
              _cg.getQueryPlan()).addOperator(firstAgg);

        } else
          lastComponent.addOperator(firstAgg);
      } else {
        // Sometimes groupByVEs contains other functions, so we have to
        // use projections instead of simple groupBy
        // always new level

        // WARNING: groupByVEs cannot be used on two places: that's why
        // we do deep copy
        final ProjectOperator groupByProj = new ProjectOperator(
            (List<ValueExpression>) DeepCopy.copy(groupByVEs));
        if (!(groupByProj.getExpressions() == null || groupByProj.getExpressions()
            .isEmpty()))
          firstAgg.setGroupByProjection(groupByProj);

        // current component
        lastComponent.setHashExpressions((List<ValueExpression>) DeepCopy.copy(groupByVEs));
View Full Code Here
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
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
  }

  private void attachSelectClause(List<AggregateOperator> aggOps,
      List<ValueExpression> groupByVEs, Component affectedComponent) {
    if (aggOps.isEmpty()) {
      final ProjectOperator project = new ProjectOperator(groupByVEs);
      affectedComponent.addOperator(project);
    } else if (aggOps.size() == 1) {
      // all the others are group by
      final AggregateOperator firstAgg = aggOps.get(0);

      if (ParserUtil.isAllColumnRefs(groupByVEs)) {
        // plain fields in select
        final List<Integer> groupByColumns = ParserUtil.extractColumnIndexes(groupByVEs);
        firstAgg.setGroupByColumns(groupByColumns);

        // Setting new level of components is necessary for correctness
        // only for distinct in aggregates
        // but it's certainly pleasant to have the final result grouped
        // on nodes by group by columns.
        final boolean newLevel = !(_it.isHashedBy(affectedComponent, groupByColumns));
        if (newLevel) {
          affectedComponent.setHashIndexes(groupByColumns);
          new OperatorComponent(affectedComponent,
              ParserUtil.generateUniqueName("OPERATOR"), _cg.getQueryPlan())
              .addOperator(firstAgg);

        } else
          affectedComponent.addOperator(firstAgg);
      } else {
        // Sometimes groupByVEs contains other functions, so we have to
        // use projections instead of simple groupBy
        // always new level

        if (affectedComponent.getHashExpressions() != null
            && !affectedComponent.getHashExpressions().isEmpty())
          throw new RuntimeException(
              "Too complex: cannot have hashExpression both for joinCondition and groupBy!");

        // WARNING: groupByVEs cannot be used on two places: that's why
        // we do deep copy
        final ProjectOperator groupByProj = new ProjectOperator(
            (List<ValueExpression>) DeepCopy.copy(groupByVEs));
        if (!(groupByProj.getExpressions() == null || groupByProj.getExpressions()
            .isEmpty()))
          firstAgg.setGroupByProjection(groupByProj);

        // current component
        affectedComponent.setHashExpressions((List<ValueExpression>) DeepCopy
View Full Code Here
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
        ProjSchemaCreator psc = new ProjSchemaCreator(_globalProject, new TupleSchema(inputTupleSchema), L_S_Njoin, _parsedQuery, _schema);
        psc.create();
       
        List<ColumnNameType> outputTupleSchema = psc.getOutputSchema().getSchema();
        ProjectOperator projectOperator = psc.getProjectOperator();
        
        //expected results
        List<ColumnNameType> expOutputTupleSchema = new ArrayList<ColumnNameType>();
        expOutputTupleSchema.add(new ColumnNameType("N1.NAME", _sc)); //1
        expOutputTupleSchema.add(new ColumnNameType("EXTRACT_YEAR(LINEITEM.SHIPDATE)", _ic)); //5
        expOutputTupleSchema.add(new ColumnNameType("LINEITEM.EXTENDEDPRICE * (1.0 - LINEITEM.DISCOUNT)", _dblConv)); //3, 4
        expOutputTupleSchema.add(new ColumnNameType("LINEITEM.ORDERKEY", _lc)); //2
        ProjectOperator expProjectOperator = new ProjectOperator(new ColumnReference(_sc, 1, "N1.NAME"),
                                                                new IntegerYearFromDate(new ColumnReference(_dateConv, 5, "LINEITEM.SHIPDATE")),
                                                                new Multiplication(
                                                                    new ColumnReference(_dblConv, 3, "LINEITEM.EXTENDEDPRICE"),
                                                                    new ColumnReference(_dblConv, 4, "1.0 - LINEITEM.DISCOUNT")
                                                                ),
                                                                new ColumnReference(_sc, 2, "LINEITEM.ORDERKEY"));
       
        //compare it
        assertEquals(expOutputTupleSchema, outputTupleSchema); //ColumnNameType has equals method
        assertEquals(expProjectOperator.toString(), projectOperator.toString());
    }
View Full Code Here
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
        ProjSchemaCreator psc = new ProjSchemaCreator(_globalProject, new TupleSchema(inputTupleSchema), L_S_Njoin, _parsedQuery, _schema);
        psc.create();
       
        List<ColumnNameType> outputTupleSchema = psc.getOutputSchema().getSchema();
        ProjectOperator projectOperator = psc.getProjectOperator();
        
        //expected results
        List<ColumnNameType> expOutputTupleSchema = new ArrayList<ColumnNameType>();
        expOutputTupleSchema.add(new ColumnNameType("N1.NAME", _sc)); //1
        expOutputTupleSchema.add(new ColumnNameType("EXTRACT_YEAR(LINEITEM.SHIPDATE)", _ic)); //5
        expOutputTupleSchema.add(new ColumnNameType("LINEITEM.EXTENDEDPRICE * (1.0 - LINEITEM.DISCOUNT)", _dblConv)); //3, 4
        expOutputTupleSchema.add(new ColumnNameType("LINEITEM.ORDERKEY", _lc)); //2
        ProjectOperator expProjectOperator = new ProjectOperator(new ColumnReference(_sc, 1, "N1.NAME"),
                                                                new IntegerYearFromDate(new ColumnReference(_dateConv, 5, "LINEITEM.SHIPDATE")),
                                                                new Multiplication(
                                                                    new ColumnReference(_dblConv, 3, "LINEITEM.EXTENDEDPRICE"),
                                                                    new Subtraction(
                                                                        new ValueSpecification(_dblConv, "1.0"),
                                                                        new ColumnReference(_dblConv, 4, "LINEITEM.DISCOUNT")
                                                                    )
                                                                ),
                                                                new ColumnReference(_sc, 2, "LINEITEM.ORDERKEY"));
       
        //compare it
        assertEquals(expOutputTupleSchema, outputTupleSchema); //ColumnNameType has equals method
        assertEquals(expProjectOperator.toString(), projectOperator.toString());
    }   
View Full Code Here
59
60
61
62
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
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
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
    final SelectOperator selectionNation2 = new SelectOperator(new OrPredicate(
        new ComparisonPredicate(new ColumnReference(_sc, 1), new ValueSpecification(_sc,
            _firstCountryName)), new ComparisonPredicate(new ColumnReference(_sc, 1),
            new ValueSpecification(_sc, _secondCountryName))));

    final ProjectOperator projectionNation2 = new ProjectOperator(new int[] { 1, 0 });

    final DataSourceComponent relationNation2 = new DataSourceComponent("NATION2", dataPath
        + "nation" + extension, _queryPlan).setHashIndexes(hashNation2)
        .addOperator(selectionNation2).addOperator(projectionNation2);

    // -------------------------------------------------------------------------------------
    final ArrayList<Integer> hashCustomer = new ArrayList<Integer>(Arrays.asList(1));

    final ProjectOperator projectionCustomer = new ProjectOperator(new int[] { 0, 3 });

    final DataSourceComponent relationCustomer = new DataSourceComponent("CUSTOMER", dataPath
        + "customer" + extension, _queryPlan).setHashIndexes(hashCustomer).addOperator(
        projectionCustomer);

    // -------------------------------------------------------------------------------------
    final ColumnReference colN = new ColumnReference(_ic, 1);
    final ColumnReference colC = new ColumnReference(_ic, 1);
    final ComparisonPredicate N_C_comp = new ComparisonPredicate(ComparisonPredicate.EQUAL_OP,
        colN, colC);

    Component N_Cjoin = ThetaJoinComponentFactory
        .createThetaJoinOperator(Theta_JoinType, relationNation2, relationCustomer,
            _queryPlan).addOperator(new ProjectOperator(new int[] { 0, 2 }))
        .setJoinPredicate(N_C_comp);

    // -------------------------------------------------------------------------------------
    final ArrayList<Integer> hashOrders = new ArrayList<Integer>(Arrays.asList(1));

    final ProjectOperator projectionOrders = new ProjectOperator(new int[] { 0, 1 });

    final DataSourceComponent relationOrders = new DataSourceComponent("ORDERS", dataPath
        + "orders" + extension, _queryPlan).setHashIndexes(hashOrders).addOperator(
        projectionOrders);

    // -------------------------------------------------------------------------------------

    final ColumnReference colN_C = new ColumnReference(_ic, 1);
    final ColumnReference colO = new ColumnReference(_ic, 1);
    final ComparisonPredicate N_C_O_comp = new ComparisonPredicate(
        ComparisonPredicate.EQUAL_OP, colN_C, colO);

    Component N_C_Ojoin = ThetaJoinComponentFactory
        .createThetaJoinOperator(Theta_JoinType, N_Cjoin, relationOrders, _queryPlan)
        .addOperator(new ProjectOperator(new int[] { 0, 2 })).setJoinPredicate(N_C_O_comp);

    // -------------------------------------------------------------------------------------
    final ArrayList<Integer> hashSupplier = new ArrayList<Integer>(Arrays.asList(1));

    final ProjectOperator projectionSupplier = new ProjectOperator(new int[] { 0, 3 });

    final DataSourceComponent relationSupplier = new DataSourceComponent("SUPPLIER", dataPath
        + "supplier" + extension, _queryPlan).setHashIndexes(hashSupplier).addOperator(
        projectionSupplier);

    // -------------------------------------------------------------------------------------
    final ArrayList<Integer> hashNation1 = new ArrayList<Integer>(Arrays.asList(1));

    final ProjectOperator projectionNation1 = new ProjectOperator(new int[] { 1, 0 });

    final DataSourceComponent relationNation1 = new DataSourceComponent("NATION1", dataPath
        + "nation" + extension, _queryPlan).setHashIndexes(hashNation1)
        .addOperator(selectionNation2).addOperator(projectionNation1);

    // -------------------------------------------------------------------------------------

    final ColumnReference colS = new ColumnReference(_ic, 1);
    final ColumnReference colN2 = new ColumnReference(_ic, 1);
    final ComparisonPredicate S_N_comp = new ComparisonPredicate(ComparisonPredicate.EQUAL_OP,
        colS, colN2);

    Component S_Njoin = ThetaJoinComponentFactory
        .createThetaJoinOperator(Theta_JoinType, relationSupplier, relationNation1,
            _queryPlan).addOperator(new ProjectOperator(new int[] { 0, 2 }))
        .setJoinPredicate(S_N_comp);

    // -------------------------------------------------------------------------------------
    final ArrayList<Integer> hashLineitem = new ArrayList<Integer>(Arrays.asList(2));

    final SelectOperator selectionLineitem = new SelectOperator(new BetweenPredicate(
        new ColumnReference(_dateConv, 10), true,
        new ValueSpecification(_dateConv, _date1), true, new ValueSpecification(_dateConv,
            _date2)));

    // first field in projection
    final ValueExpression extractYear = new IntegerYearFromDate(new ColumnReference<Date>(
        _dateConv, 10));
    // second field in projection
    // 1 - discount
    final ValueExpression<Double> substract = new Subtraction(new ValueSpecification(
        _doubleConv, 1.0), new ColumnReference(_doubleConv, 6));
    // extendedPrice*(1-discount)
    final ValueExpression<Double> product = new Multiplication(new ColumnReference(_doubleConv,
        5), substract);
    // third field in projection
    final ColumnReference supplierKey = new ColumnReference(_sc, 2);
    // forth field in projection
    final ColumnReference orderKey = new ColumnReference(_sc, 0);
    final ProjectOperator projectionLineitem = new ProjectOperator(extractYear, product,
        supplierKey, orderKey);

    final DataSourceComponent relationLineitem = new DataSourceComponent("LINEITEM", dataPath
        + "lineitem" + extension, _queryPlan).setHashIndexes(hashLineitem)
        .addOperator(selectionLineitem).addOperator(projectionLineitem);

    // -------------------------------------------------------------------------------------

    final ColumnReference colL = new ColumnReference(_ic, 2);
    final ColumnReference colS_N = new ColumnReference(_ic, 0);
    final ComparisonPredicate L_S_N_comp = new ComparisonPredicate(
        ComparisonPredicate.EQUAL_OP, colL, colS_N);

    Component L_S_Njoin = ThetaJoinComponentFactory
        .createThetaJoinOperator(Theta_JoinType, relationLineitem, S_Njoin, _queryPlan)
        .addOperator(new ProjectOperator(new int[] { 5, 0, 1, 3 }))
        .setJoinPredicate(L_S_N_comp);

    // -------------------------------------------------------------------------------------
    // set up aggregation function on the same StormComponent(Bolt) where
    // the last join is
View Full Code Here
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
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
  public ThetaInputDominatedPlan(String dataPath, String extension, Map conf) {
    final int Theta_JoinType = ThetaQueryPlansParameters.getThetaJoinType(conf);
    // -------------------------------------------------------------------------------------
    final List<Integer> hashLineitem = Arrays.asList(0);

    final ProjectOperator projectionLineitem = new ProjectOperator(new int[] { 0, 5, 6 });

    final DataSourceComponent relationLineitem = new DataSourceComponent("LINEITEM", dataPath
        + "lineitem" + extension, _queryPlan).setHashIndexes(hashLineitem).addOperator(
        projectionLineitem);

    // -------------------------------------------------------------------------------------
    final List<Integer> hashOrders = Arrays.asList(1);

    final ProjectOperator projectionOrders = new ProjectOperator(new int[] { 0, 3 });

    final DataSourceComponent relationOrders = new DataSourceComponent("ORDERS", dataPath
        + "orders" + extension, _queryPlan).setHashIndexes(hashOrders).addOperator(
        projectionOrders);

    // -------------------------------------------------------------------------------------

    // set up aggregation function on the StormComponent(Bolt) where join is
    // performed
    // 1 - discount
    final ValueExpression<Double> substract = new Subtraction(new ValueSpecification(
        _doubleConv, 1.0), new ColumnReference(_doubleConv, 1));
    // extendedPrice*(1-discount)
    final ValueExpression<Double> product = new Multiplication(new ColumnReference(_doubleConv,
        0), substract);
    final AggregateOperator agg = new AggregateSumOperator(product, conf);

    // /Join predicate
    final ColumnReference colLineItems = new ColumnReference(_ic, 0);
    final ColumnReference colOrders = new ColumnReference(_ic, 0);
    final ComparisonPredicate pred1 = new ComparisonPredicate(ComparisonPredicate.EQUAL_OP,
        colLineItems, colOrders);

    final ValueSpecification value10 = new ValueSpecification(_doubleConv, 10.0);
    final ColumnReference colLineItemsInequality = new ColumnReference(_doubleConv, 1);
    final Multiplication mult = new Multiplication(value10, colLineItemsInequality);
    final ColumnReference colOrdersInequality = new ColumnReference(_doubleConv, 1);
    final ComparisonPredicate pred2 = new ComparisonPredicate(ComparisonPredicate.LESS_OP,
        mult, colOrdersInequality);

    final AndPredicate overallPred = new AndPredicate(pred1, pred2);

    Component lastJoiner = ThetaJoinComponentFactory
        .createThetaJoinOperator(Theta_JoinType, relationLineitem, relationOrders,
            _queryPlan).setJoinPredicate(overallPred)
        .addOperator(new ProjectOperator(new int[] { 1, 2, 4 })).addOperator(agg);
    ;

    //lastJoiner.setPrintOut(false);
    // -------------------------------------------------------------------------------------

View Full Code Here
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
  private static final IntegerConversion _ic = new IntegerConversion();

  public HyracksPlan(String dataPath, String extension, Map conf) {
    // -------------------------------------------------------------------------------------
    // start of query plan filling
    final ProjectOperator projectionCustomer = new ProjectOperator(new int[] { 0, 6 });
    final List<Integer> hashCustomer = Arrays.asList(0);
    final DataSourceComponent relationCustomer = new DataSourceComponent("CUSTOMER", dataPath
        + "customer" + extension, _queryPlan).addOperator(projectionCustomer)
        .setHashIndexes(hashCustomer);

    // -------------------------------------------------------------------------------------
    final ProjectOperator projectionOrders = new ProjectOperator(new int[] { 1 });
    final List<Integer> hashOrders = Arrays.asList(0);
    final DataSourceComponent relationOrders = new DataSourceComponent("ORDERS", dataPath
        + "orders" + extension, _queryPlan).addOperator(projectionOrders).setHashIndexes(
        hashOrders);
View Full Code Here
203
204
205
206
207
208
209
  /*
   * will be used for a creation of a ProjectOperator
   */
  public ProjectOperator getProjectOperator() {
    return new ProjectOperator(_veList);
  }
View Full Code Here
52
53
54
55
56
57
58
59
60
61
62
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
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
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
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
    List<Integer> hashPart = Arrays.asList(0);

    SelectOperator selectionPart = new SelectOperator(new LikePredicate(new ColumnReference(
        _sc, 1), new ValueSpecification(_sc, COLOR)));

    ProjectOperator projectionPart = new ProjectOperator(new int[] { 0 });

    DataSourceComponent relationPart = new DataSourceComponent("PART", dataPath + "part"
        + extension, _queryPlan).setHashIndexes(hashPart).addOperator(selectionPart)
        .addOperator(projectionPart);

    //-------------------------------------------------------------------------------------
    List<Integer> hashLineitem = Arrays.asList(1);

    ProjectOperator projectionLineitem = new ProjectOperator(new int[] { 0, 1, 2, 4, 5, 6 });

    DataSourceComponent relationLineitem = new DataSourceComponent("LINEITEM", dataPath
        + "lineitem" + extension, _queryPlan).setHashIndexes(hashLineitem).addOperator(
        projectionLineitem);

    //-------------------------------------------------------------------------------------
    ColumnReference colP = new ColumnReference(_ic, 0);
    ColumnReference colL = new ColumnReference(_ic, 1);
    ComparisonPredicate P_L_comp = new ComparisonPredicate(ComparisonPredicate.EQUAL_OP, colP,
        colL);
    Component P_Ljoin = ThetaJoinComponentFactory
        .createThetaJoinOperator(Theta_JoinType, relationPart, relationLineitem, _queryPlan)
        .setHashIndexes(Arrays.asList(0, 2)).setJoinPredicate(P_L_comp)
        .addOperator(new ProjectOperator(new int[] { 0, 1, 3, 4, 5, 6 }));

    //-------------------------------------------------------------------------------------

    List<Integer> hashPartsupp = Arrays.asList(0, 1);

    ProjectOperator projectionPartsupp = new ProjectOperator(new int[] { 0, 1, 3 });

    DataSourceComponent relationPartsupp = new DataSourceComponent("PARTSUPP", dataPath
        + "partsupp" + extension, _queryPlan).setHashIndexes(hashPartsupp).addOperator(
        projectionPartsupp);

    //-------------------------------------------------------------------------------------
    ColumnReference colP_L1 = new ColumnReference(_ic, 0);
    ColumnReference colP_L2 = new ColumnReference(_ic, 2);
    ColumnReference colPS1 = new ColumnReference(_ic, 0);
    ColumnReference colPS2 = new ColumnReference(_ic, 1);
    ComparisonPredicate P_L_PS1_comp = new ComparisonPredicate(ComparisonPredicate.EQUAL_OP,
        colP_L1, colPS1);

    ComparisonPredicate P_L_PS2_comp = new ComparisonPredicate(ComparisonPredicate.EQUAL_OP,
        colP_L2, colPS2);
    AndPredicate P_L_PS = new AndPredicate(P_L_PS1_comp, P_L_PS2_comp);

    Component P_L_PSjoin = ThetaJoinComponentFactory
        .createThetaJoinOperator(Theta_JoinType, P_Ljoin, relationPartsupp, _queryPlan)
        .setHashIndexes(Arrays.asList(0))
        .addOperator(new ProjectOperator(new int[] { 1, 2, 3, 4, 5, 8 }))
        .setJoinPredicate(P_L_PS);

    //-------------------------------------------------------------------------------------

    List<Integer> hashOrders = Arrays.asList(0);

    ProjectOperator projectionOrders = new ProjectOperator(new ColumnReference(_sc, 0),
        new IntegerYearFromDate(new ColumnReference(_dateConv, 4)));

    DataSourceComponent relationOrders = new DataSourceComponent("ORDERS", dataPath + "orders"
        + extension, _queryPlan).setHashIndexes(hashOrders).addOperator(projectionOrders);

    //-------------------------------------------------------------------------------------
    ColumnReference colP_L_PS = new ColumnReference(_ic, 0);
    ColumnReference colO = new ColumnReference(_ic, 0);
    ComparisonPredicate P_L_PS_O_comp = new ComparisonPredicate(ComparisonPredicate.EQUAL_OP,
        colP_L_PS, colO);

    Component P_L_PS_Ojoin = ThetaJoinComponentFactory
        .createThetaJoinOperator(Theta_JoinType, P_L_PSjoin, relationOrders, _queryPlan)
        .addOperator(new ProjectOperator(new int[] { 1, 2, 3, 4, 5, 7 }))
        .setJoinPredicate(P_L_PS_O_comp);

    //-------------------------------------------------------------------------------------

    List<Integer> hashSupplier = Arrays.asList(0);

    ProjectOperator projectionSupplier = new ProjectOperator(new int[] { 0, 3 });

    DataSourceComponent relationSupplier = new DataSourceComponent("SUPPLIER", dataPath
        + "supplier" + extension, _queryPlan).setHashIndexes(hashSupplier).addOperator(
        projectionSupplier);

    //-------------------------------------------------------------------------------------

    ColumnReference P_L_PS_O = new ColumnReference(_ic, 0);
    ColumnReference colS = new ColumnReference(_ic, 0);
    ComparisonPredicate P_L_PS_O_S_comp = new ComparisonPredicate(ComparisonPredicate.EQUAL_OP,
        P_L_PS_O, colS);

    Component P_L_PS_O_Sjoin = ThetaJoinComponentFactory
        .createThetaJoinOperator(Theta_JoinType, P_L_PS_Ojoin, relationSupplier, _queryPlan)
        .setHashIndexes(Arrays.asList(5))
        .addOperator(new ProjectOperator(new int[] { 1, 2, 3, 4, 5, 7 }))
        .setJoinPredicate(P_L_PS_O_S_comp);

    //-------------------------------------------------------------------------------------
    List<Integer> hashNation = Arrays.asList(0);

    ProjectOperator projectionNation = new ProjectOperator(new int[] { 0, 1 });

    DataSourceComponent relationNation = new DataSourceComponent("NATION", dataPath + "nation"
        + extension, _queryPlan).setHashIndexes(hashNation).addOperator(projectionNation);

    //-------------------------------------------------------------------------------------
    // set up aggregation function on the StormComponent(Bolt) where join is performed

    //1 - discount
    ValueExpression<Double> substract1 = new Subtraction(new ValueSpecification(_doubleConv,
        1.0), new ColumnReference(_doubleConv, 2));
    //extendedPrice*(1-discount)
    ValueExpression<Double> product1 = new Multiplication(new ColumnReference(_doubleConv, 1),
        substract1);

    //ps_supplycost * l_quantity
    ValueExpression<Double> product2 = new Multiplication(new ColumnReference(_doubleConv, 3),
        new ColumnReference(_doubleConv, 0));

    //all together
    ValueExpression<Double> substract2 = new Subtraction(product1, product2);

    AggregateOperator agg = new AggregateSumOperator(substract2, conf).setGroupByColumns(Arrays
        .asList(5, 4));

    ColumnReference P_L_PS_O_S = new ColumnReference(_ic, 5);
    ColumnReference colN = new ColumnReference(_ic, 0);
    ComparisonPredicate P_L_PS_O_S_N_comp = new ComparisonPredicate(
        ComparisonPredicate.EQUAL_OP, P_L_PS_O_S, colN);

    Component P_L_PS_O_S_Njoin = ThetaJoinComponentFactory
        .createThetaJoinOperator(Theta_JoinType, P_L_PS_O_Sjoin, relationNation, _queryPlan)
        .addOperator(new ProjectOperator(new int[] { 0, 1, 2, 3, 4, 7 })).addOperator(agg)
        .setJoinPredicate(P_L_PS_O_S_N_comp);

    //-------------------------------------------------------------------------------------

  }
View Full Code Here
TOP

Related Classes of plan_runner.operators.ProjectOperator

  • optimizers.cost.ProjSchemaCreatorTest
  • plan_runner.conversion.StringConversion
  • plan_runner.expressions.ColumnReference
  • plan_runner.query_plans.debug.HyracksL1Plan
  • plan_runner.query_plans.debug.HyracksL3BatchPlan
  • plan_runner.query_plans.debug.HyracksL3Plan
  • plan_runner.query_plans.debug.TPCH3L1Plan
  • plan_runner.query_plans.debug.TPCH3L23Plan
  • plan_runner.query_plans.debug.TPCH3L2Plan
  • plan_runner.query_plans.debug.TPCH5PlanAvg
    • 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.