Package plan_runner.operators

Examples of plan_runner.operators.ProjectOperator

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
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
    final List<Integer> hashPart = Arrays.asList(0);

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

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

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

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

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

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

    // -------------------------------------------------------------------------------------
    final EquiJoinComponent P_Ljoin = new EquiJoinComponent(relationPart, relationLineitem,
        _queryPlan).setHashIndexes(Arrays.asList(0, 2));
    // -------------------------------------------------------------------------------------

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

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

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

    // -------------------------------------------------------------------------------------
    final EquiJoinComponent P_L_PSjoin = new EquiJoinComponent(P_Ljoin, relationPartsupp,
        _queryPlan).setHashIndexes(Arrays.asList(0)).addOperator(
        new ProjectOperator(new int[] { 1, 2, 3, 4, 5, 6 }));
    // -------------------------------------------------------------------------------------

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

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

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

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

    final EquiJoinComponent P_L_PS_Ojoin = new EquiJoinComponent(P_L_PSjoin, relationOrders,
        _queryPlan).setHashIndexes(Arrays.asList(0)).addOperator(
        new ProjectOperator(new int[] { 1, 2, 3, 4, 5, 6 }));
    // -------------------------------------------------------------------------------------

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

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

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

    // -------------------------------------------------------------------------------------
    final EquiJoinComponent P_L_PS_O_Sjoin = new EquiJoinComponent(P_L_PS_Ojoin,
        relationSupplier, _queryPlan).setHashIndexes(Arrays.asList(5)).addOperator(
        new ProjectOperator(new int[] { 1, 2, 3, 4, 5, 6 }));
    // -------------------------------------------------------------------------------------
    final List<Integer> hashNation = Arrays.asList(0);

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

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

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

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

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

    new EquiJoinComponent(P_L_PS_O_Sjoin, relationNation, _queryPlan).addOperator(
        new ProjectOperator(new int[] { 0, 1, 2, 3, 4, 6 })).addOperator(agg);

  }
View Full Code Here
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
    final List<Integer> hashRegion = Arrays.asList(0);

    final SelectOperator selectionRegion = new SelectOperator(new ComparisonPredicate(
        new ColumnReference(_sc, 1), new ValueSpecification(_sc, REGION_NAME)));

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

    final DataSourceComponent relationRegion = new DataSourceComponent("REGION", dataPath
        + "region" + extension, _queryPlan).setHashIndexes(hashRegion)
        .addOperator(selectionRegion).addOperator(projectionRegion);

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

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

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

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

    final ProjectOperator projectionRN = new ProjectOperator(new int[] { 1, 2 });

    final EquiJoinComponent R_Njoin = new EquiJoinComponent(relationRegion, relationNation,
        _queryPlan).setHashIndexes(hashRN).addOperator(projectionRN);

    // -------------------------------------------------------------------------------------
    final List<Integer> hashSupplier = 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 List<Integer> hashRNS = Arrays.asList(2);

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

    final EquiJoinComponent R_N_Sjoin = new EquiJoinComponent(R_Njoin, relationSupplier,
        _queryPlan).setHashIndexes(hashRNS).addOperator(projectionRNS);

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

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

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

    // -------------------------------------------------------------------------------------
    final List<Integer> hashRNSL = Arrays.asList(0, 2);

    final ProjectOperator projectionRNSL = new ProjectOperator(new int[] { 0, 1, 3, 4, 5 });

    final EquiJoinComponent R_N_S_Ljoin = new EquiJoinComponent(R_N_Sjoin, relationLineitem,
        _queryPlan).setHashIndexes(hashRNSL).addOperator(projectionRNSL);

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

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

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

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

    final SelectOperator selectionOrders = new SelectOperator(new BetweenPredicate(
        new ColumnReference(_dc, 4), true, new ValueSpecification(_dc, _date1), false,
        new ValueSpecification(_dc, _date2)));

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

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

    // -------------------------------------------------------------------------------------
    final List<Integer> hashCO = Arrays.asList(0, 1);

    final ProjectOperator projectionCO = new ProjectOperator(new int[] { 1, 2 });

    final EquiJoinComponent C_Ojoin = new EquiJoinComponent(relationCustomer, relationOrders,
        _queryPlan).setHashIndexes(hashCO).addOperator(projectionCO);

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

    final ProjectOperator projectionRNSLCO = new ProjectOperator(new int[] { 1, 3, 4 });

    final EquiJoinComponent R_N_S_L_C_Ojoin = new EquiJoinComponent(R_N_S_Ljoin, C_Ojoin,
        _queryPlan).setHashIndexes(hashRNSLCO).addOperator(projectionRNSLCO);

    // -------------------------------------------------------------------------------------
View Full Code Here
67
68
69
70
71
72
73
74
75
76
77
    SelectOperator selectionOrders = new SelectOperator(new BetweenPredicate(
        new ColumnReference(_dc, 4), true, new ValueSpecification(_dc, _date1), false,
        new ValueSpecification(_dc, _date2)));

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

    DataSourceComponent relationOrders = new DataSourceComponent("ORDERS", dataPath + "orders"
        + extension, _queryPlan).setHashIndexes(hashOrders).addOperator(selectionOrders)
        .addOperator(projectionOrders);
View Full Code Here
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
    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 List<Integer> hashCustomer = 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 EquiJoinComponent N_Cjoin = new EquiJoinComponent(relationNation2, relationCustomer,
        _queryPlan).addOperator(new ProjectOperator(new int[] { 0, 2 })).setHashIndexes(
        Arrays.asList(1));

    // -------------------------------------------------------------------------------------
    final List<Integer> hashOrders = 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 EquiJoinComponent N_C_Ojoin = new EquiJoinComponent(N_Cjoin, relationOrders,
        _queryPlan).addOperator(new ProjectOperator(new int[] { 0, 2 })).setHashIndexes(
        Arrays.asList(1));

    // -------------------------------------------------------------------------------------
    final List<Integer> hashSupplier = 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 List<Integer> hashNation1 = 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 EquiJoinComponent S_Njoin = new EquiJoinComponent(relationSupplier, relationNation1,
        _queryPlan).addOperator(new ProjectOperator(new int[] { 0, 2 })).setHashIndexes(
        Arrays.asList(0));

    // -------------------------------------------------------------------------------------
    final List<Integer> hashLineitem = 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 EquiJoinComponent L_S_Njoin = new EquiJoinComponent(relationLineitem, S_Njoin,
        _queryPlan).addOperator(new ProjectOperator(new int[] { 4, 0, 1, 3 }))
        .setHashIndexes(Arrays.asList(3));

    // -------------------------------------------------------------------------------------
    // set up aggregation function on the same StormComponent(Bolt) where
    // the last join is
View Full Code Here
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
    final List<Integer> hashCustomer = Arrays.asList(0);

    final SelectOperator selectionCustomer = new SelectOperator(new ComparisonPredicate(
        new ColumnReference(_sc, 6), new ValueSpecification(_sc, _customerMktSegment)));

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

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

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

    final SelectOperator selectionOrders = new SelectOperator(new ComparisonPredicate(
        ComparisonPredicate.LESS_OP, new ColumnReference(_dateConv, 4),
        new ValueSpecification(_dateConv, _date)));

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

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

    // -------------------------------------------------------------------------------------
    final EquiJoinComponent C_Ojoin = new EquiJoinComponent(relationCustomer, relationOrders,
        _queryPlan).addOperator(new ProjectOperator(new int[] { 1, 2, 3 })).setHashIndexes(
        Arrays.asList(0));

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

    final SelectOperator selectionLineitem = new SelectOperator(new ComparisonPredicate(
        ComparisonPredicate.GREATER_OP, new ColumnReference(_dateConv, 10),
        new ValueSpecification(_dateConv, _date)));

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

    final DataSourceComponent relationLineitem = new DataSourceComponent("LINEITEM", dataPath
        + "lineitem" + extension, _queryPlan).setHashIndexes(hashLineitem)
        .addOperator(selectionLineitem).addOperator(projectionLineitem);
View Full Code Here
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
  public ThetaOutputDominatedPlan(String dataPath, String extension, Map conf) {
    final int Theta_JoinType = ThetaQueryPlansParameters.getThetaJoinType(conf);
    // -------------------------------------------------------------------------------------
    final List<Integer> hashSupplier = Arrays.asList(0);

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

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

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

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

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

    final AggregateOperator agg = new AggregateSumOperator(new ColumnReference(_doubleConv, 0),
        conf);
    // Empty parameters = Cartesian Product

    Component lastJoiner = ThetaJoinComponentFactory
        .createThetaJoinOperator(Theta_JoinType, relationSupplier, relationNation,
            _queryPlan).addOperator(new ProjectOperator(new int[] { 0 }))
        .addOperator(agg);
    //lastJoiner.setPrintOut(false);

    // -------------------------------------------------------------------------------------
View Full Code Here
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
    int Theta_JoinType = ThetaQueryPlansParameters.getThetaJoinType(conf);

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

    ProjectOperator projectionCustomer = new ProjectOperator(new int[] { 0, 1, 2, 3, 4, 5, 7 });

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

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

    SelectOperator selectionOrders = new SelectOperator(new BetweenPredicate(
        new ColumnReference(_dc, 4), true, new ValueSpecification(_dc, _date1), false,
        new ValueSpecification(_dc, _date2)));

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

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

    //-------------------------------------------------------------------------------------
    ColumnReference colC = new ColumnReference(_ic, 0);
    ColumnReference colO = new ColumnReference(_ic, 1);
    ComparisonPredicate C_O_comp = new ComparisonPredicate(ComparisonPredicate.EQUAL_OP, colC,
        colO);

    Component C_Ojoin = ThetaJoinComponentFactory
        .createThetaJoinOperator(Theta_JoinType, relationCustomer, relationOrders,
            _queryPlan).setHashIndexes(Arrays.asList(3))
        .addOperator(new ProjectOperator(new int[] { 0, 1, 2, 3, 4, 5, 6, 7 }))
        .setJoinPredicate(C_O_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);
    //-------------------------------------------------------------------------------------

    ColumnReference colC_O = new ColumnReference(_ic, 3);
    ColumnReference colN = new ColumnReference(_ic, 0);
    ComparisonPredicate C_O_N_comp = new ComparisonPredicate(ComparisonPredicate.EQUAL_OP,
        colC_O, colN);

    Component C_O_Njoin = ThetaJoinComponentFactory
        .createThetaJoinOperator(Theta_JoinType, C_Ojoin, relationNation, _queryPlan)
        .addOperator(new ProjectOperator(new int[] { 0, 1, 2, 4, 5, 6, 7, 9 }))
        .setHashIndexes(Arrays.asList(6)).setJoinPredicate(C_O_N_comp);

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

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

    SelectOperator selectionLineitem = new SelectOperator(new ComparisonPredicate(
        new ColumnReference(_sc, 8), new ValueSpecification(_sc, MARK)));

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

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

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

    //1 - discount
    ValueExpression<Double> substract = new Subtraction(
        new ValueSpecification(_doubleConv, 1.0), new ColumnReference(_doubleConv, 8));
    //extendedPrice*(1-discount)
    ValueExpression<Double> product = new Multiplication(new ColumnReference(_doubleConv, 7),
        substract);
    AggregateOperator agg = new AggregateSumOperator(product, conf)
    //.setGroupByColumns(Arrays.asList(0, 1, 4, 6, 2, 3, 5));
        .setGroupByColumns(Arrays.asList(0, 1, 4, 6, 2, 3, 5));

    ColumnReference colC_O_N = new ColumnReference(_ic, 6);
    ColumnReference colL = new ColumnReference(_ic, 0);
    ComparisonPredicate C_O_N_L_comp = new ComparisonPredicate(ComparisonPredicate.EQUAL_OP,
        colC_O_N, colL);

    Component C_O_N_Ljoin = ThetaJoinComponentFactory
        .createThetaJoinOperator(Theta_JoinType, C_O_Njoin, relationLineitem, _queryPlan)
        .addOperator(new ProjectOperator(new int[] { 0, 1, 2, 3, 4, 5, 7, 9, 10 }))
        .addOperator(agg).setJoinPredicate(C_O_N_L_comp);

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

  }
View Full Code Here
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
  public ThetaHyracksPlan(String dataPath, String extension, Map conf) {
    final int Theta_JoinType = ThetaQueryPlansParameters.getThetaJoinType(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
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
        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));
        expOutputTupleSchema.add(new ColumnNameType("EXTRACT_YEAR(LINEITEM.SHIPDATE)", _ic));
        expOutputTupleSchema.add(new ColumnNameType("LINEITEM.EXTENDEDPRICE * (1.0 - LINEITEM.DISCOUNT)", _dblConv));
        expOutputTupleSchema.add(new ColumnNameType("LINEITEM.ORDERKEY", _lc));
        ProjectOperator expProjectOperator = new ProjectOperator(new ColumnReference(_sc, 1, "N1.NAME"),
                                                            new ColumnReference(_ic, 4, "EXTRACT_YEAR(LINEITEM.SHIPDATE)"),
                                                            new ColumnReference(_dblConv, 3, "LINEITEM.EXTENDEDPRICE * (1.0 - LINEITEM.DISCOUNT)"),
                                                            new ColumnReference(_ic, 2, "LINEITEM.ORDERKEY")
                                                                );
       
        //compare it
        assertEquals(expOutputTupleSchema, outputTupleSchema); //ColumnNameType has equals method
        assertEquals(expProjectOperator.toString(), projectOperator.toString());
    }
View Full Code Here
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
195
196
197
198
199
200
201
202
    List<Integer> hashRegion = Arrays.asList(0);

    SelectOperator selectionRegion = new SelectOperator(new ComparisonPredicate(
        new ColumnReference(_sc, 1), new ValueSpecification(_sc, REGION_NAME)));

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

    DataSourceComponent relationRegion = new DataSourceComponent("REGION", dataPath + "region"
        + extension, _queryPlan).setHashIndexes(hashRegion).addOperator(selectionRegion)
        .addOperator(projectionRegion);

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

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

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

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

    ProjectOperator projectionRN = new ProjectOperator(new int[] { 1, 2 });

    ColumnReference colR = new ColumnReference(_ic, 0);
    ColumnReference colN = new ColumnReference(_ic, 2);
    ComparisonPredicate R_N_comp = new ComparisonPredicate(ComparisonPredicate.EQUAL_OP, colR,
        colN);

    Component R_Njoin = ThetaJoinComponentFactory
        .createThetaJoinOperator(Theta_JoinType, relationRegion, relationNation, _queryPlan)
        .setHashIndexes(hashRN).addOperator(projectionRN).setJoinPredicate(R_N_comp);

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

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

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

    //-------------------------------------------------------------------------------------
    List<Integer> hashRNS = Arrays.asList(2);

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

    ColumnReference colR_N = new ColumnReference(_ic, 0);
    ColumnReference colS = new ColumnReference(_ic, 1);
    ComparisonPredicate R_N_S_comp = new ComparisonPredicate(ComparisonPredicate.EQUAL_OP,
        colR_N, colS);

    Component R_N_Sjoin = ThetaJoinComponentFactory
        .createThetaJoinOperator(Theta_JoinType, R_Njoin, relationSupplier, _queryPlan)
        .setHashIndexes(hashRNS).addOperator(projectionRNS).setJoinPredicate(R_N_S_comp);

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

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

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

    //-------------------------------------------------------------------------------------
    List<Integer> hashRNSL = Arrays.asList(0, 2);

    ColumnReference colR_N_S = new ColumnReference(_ic, 2);
    ColumnReference colL = new ColumnReference(_ic, 1);
    ComparisonPredicate R_N_S_L_comp = new ComparisonPredicate(ComparisonPredicate.EQUAL_OP,
        colR_N_S, colL);

    ProjectOperator projectionRNSL = new ProjectOperator(new int[] { 0, 1, 3, 5, 6 });

    Component R_N_S_Ljoin = ThetaJoinComponentFactory
        .createThetaJoinOperator(Theta_JoinType, R_N_Sjoin, relationLineitem, _queryPlan)
        .setHashIndexes(hashRNSL).addOperator(projectionRNSL)
        .setJoinPredicate(R_N_S_L_comp);

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

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

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

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

    SelectOperator selectionOrders = new SelectOperator(new BetweenPredicate(
        new ColumnReference(_dc, 4), true, new ValueSpecification(_dc, _date1), false,
        new ValueSpecification(_dc, _date2)));

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

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

    //-------------------------------------------------------------------------------------
    List<Integer> hashCO = Arrays.asList(0, 1);

    ProjectOperator projectionCO = new ProjectOperator(new int[] { 1, 2 });

    ColumnReference colC = new ColumnReference(_ic, 0);
    ColumnReference colO = new ColumnReference(_ic, 1);
    ComparisonPredicate C_O_comp = new ComparisonPredicate(ComparisonPredicate.EQUAL_OP, colC,
        colO);

    Component C_Ojoin = ThetaJoinComponentFactory
        .createThetaJoinOperator(Theta_JoinType, relationCustomer, relationOrders,
            _queryPlan).setHashIndexes(hashCO).addOperator(projectionCO)
        .setJoinPredicate(C_O_comp);

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

    ProjectOperator projectionRNSLCO = new ProjectOperator(new int[] { 1, 3, 4 });

    ColumnReference colR_N_S_L1 = new ColumnReference(_ic, 0);
    ColumnReference colR_N_S_L2 = new ColumnReference(_ic, 2);
    ColumnReference colC_O1 = new ColumnReference(_ic, 0);
    ColumnReference colC_O2 = new ColumnReference(_ic, 1);
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.