Package plan_runner.components

Examples of plan_runner.components.DataSourceComponent

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
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
    SelectOperator selectionRegion = new SelectOperator(new ComparisonPredicate(
        new ColumnReference(_sc, 1), new ValueSpecification(_sc, _region)));

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

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

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

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

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

    //-------------------------------------------------------------------------------------
    ColumnReference colR = new ColumnReference(_ic, 0);
    ColumnReference colN = new ColumnReference(_ic, 1);
    ComparisonPredicate R_N_comp = new ComparisonPredicate(ComparisonPredicate.EQUAL_OP, colR,
        colN);

    Component R_Njoin = ThetaJoinComponentFactory
        .createThetaJoinOperator(Theta_JoinType, relationRegion, relationNation1,
            _queryPlan).addOperator(new ProjectOperator(new int[] { 1 }))
        .setHashIndexes(Arrays.asList(0)).setJoinPredicate(R_N_comp);

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

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

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

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

    ColumnReference colR_N = new ColumnReference(_ic, 0);
    ColumnReference colC = new ColumnReference(_ic, 0);
    ComparisonPredicate R_N_C_comp = new ComparisonPredicate(ComparisonPredicate.EQUAL_OP,
        colR_N, colC);
    Component R_N_Cjoin = ThetaJoinComponentFactory
        .createThetaJoinOperator(Theta_JoinType, R_Njoin, relationCustomer, _queryPlan)
        .addOperator(new ProjectOperator(new int[] { 2 })).setHashIndexes(Arrays.asList(0))
        .setJoinPredicate(R_N_C_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> hashNation2 = Arrays.asList(0);

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

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

    //-------------------------------------------------------------------------------------
    ColumnReference colS = new ColumnReference(_ic, 1);
    ColumnReference colN2 = new ColumnReference(_ic, 0);
    ComparisonPredicate S_N2_comp = new ComparisonPredicate(ComparisonPredicate.EQUAL_OP, colS,
        colN2);

    Component S_Njoin = ThetaJoinComponentFactory
        .createThetaJoinOperator(Theta_JoinType, relationSupplier, relationNation2,
            _queryPlan).addOperator(new ProjectOperator(new int[] { 0, 3 }))
        .setHashIndexes(Arrays.asList(0)).setJoinPredicate(S_N2_comp);

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

    SelectOperator selectionPart = new SelectOperator(new ComparisonPredicate(
        new ColumnReference(_sc, 4), new ValueSpecification(_sc, _type)));

    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);

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

    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)
        .addOperator(new ProjectOperator(new int[] { 1, 3, 4 }))
        .setHashIndexes(Arrays.asList(0)).setJoinPredicate(P_L_comp)
    //                             .addOperator(agg)
    ;

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

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

    //first field in projection
    ValueExpression OrdersOrderKey = new ColumnReference(_sc, 0);
    //second field in projection
    ValueExpression OrdersCustKey = new ColumnReference(_sc, 1);
    //third field in projection
    ValueExpression OrdersExtractYear = new IntegerYearFromDate(new ColumnReference<Date>(
        _dateConv, 4));
    ProjectOperator projectionOrders = new ProjectOperator(OrdersOrderKey, OrdersCustKey,
        OrdersExtractYear);

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

    //-------------------------------------------------------------------------------------
    ColumnReference colP_L = new ColumnReference(_ic, 0);
View Full Code Here
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
    // -------------------------------------------------------------------------------------
    final List<Integer> hashLineitem = Arrays.asList(0);

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

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

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

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

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

    // -------------------------------------------------------------------------------------
    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).setHashIndexes(hashSupplier).addOperator(
        projectionSupplier);

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

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

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

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

    // -------------------------------------------------------------------------------------
View Full Code Here
52
53
54
55
56
57
58
59
60
61
62
63
    @Test
    public void testHyracksManual() {
        String parserConfPath = CONF_PATH + "0_1G_hyracks_ncl";
        NameCompGen ncg = createCG(parserConfPath);
       
        DataSourceComponent customerSource = ncg.generateDataSource("CUSTOMER");
        DataSourceComponent ordersSource = ncg.generateDataSource("ORDERS");
        ncg.generateEquiJoin(customerSource, ordersSource);

        String planStr = ParserUtil.toString(ncg.getQueryPlan());
        //LOG.info(planStr);
       
View Full Code Here
78
79
80
81
82
83
84
85
86
87
88
89
90
91
    @Test
    public void testTPCH3Manual() {
        String parserConfPath = CONF_PATH + "0_1G_tpch3_ncl";
        NameCompGen ncg = createCG(parserConfPath);
       
        DataSourceComponent customerSource = ncg.generateDataSource("CUSTOMER");
        DataSourceComponent ordersSource = ncg.generateDataSource("ORDERS");
        Component C_Ojoin = ncg.generateEquiJoin(customerSource, ordersSource);
        DataSourceComponent lineitemSource = ncg.generateDataSource("LINEITEM");
        ncg.generateEquiJoin(C_Ojoin, lineitemSource);
       
        String planStr = ParserUtil.toString(ncg.getQueryPlan());
        //LOG.info(planStr);
       
View Full Code Here
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
         * R-N-S-L-O-C (this) : 33sec local mode, 51 nodes
         * R-N-S-C-O-L        : 48sec local mode, 83 nodes
         * R-N-S-L-C-O        : never finish, timeout problem, 3783 nodes
         * rule bushy plan    : 51sec local mode, even less total parallelism used
         */
        DataSourceComponent regionSource = ncg.generateDataSource("REGION");
        DataSourceComponent nationSource = ncg.generateDataSource("NATION");
        Component R_Njoin = ncg.generateEquiJoin(regionSource, nationSource);
        DataSourceComponent supplierSource = ncg.generateDataSource("SUPPLIER");
        Component R_N_Sjoin = ncg.generateEquiJoin(R_Njoin, supplierSource);
        DataSourceComponent lineitemSource = ncg.generateDataSource("LINEITEM");
        Component R_N_S_Ljoin = ncg.generateEquiJoin(R_N_Sjoin, lineitemSource);
        DataSourceComponent ordersSource = ncg.generateDataSource("ORDERS");
        Component R_N_S_L_Ojoin = ncg.generateEquiJoin(R_N_S_Ljoin, ordersSource);
        DataSourceComponent customerSource = ncg.generateDataSource("CUSTOMER");
        ncg.generateEquiJoin(R_N_S_L_Ojoin, customerSource);
       
        String planStr = ParserUtil.toString(ncg.getQueryPlan());
        //LOG.info(planStr);
       
View Full Code Here
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
  public HyracksPreAggPlan(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);

    // -------------------------------------------------------------------------------------
    final ProjectOperator projFirstOut = new ProjectOperator(new ColumnReference(_sc, 1),
View Full Code Here
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
         * some numbers are not accurate anymore (PushingOr time is accurate)
         * S-N1-L-O-C-N2   : 35sec, 42nodes; PushingOr, 24sec, 24nodes
         * N2-C-O-L-S-N1   : 38sec, 68nodes
         * Rule lefty plan : 35sec
         */
        DataSourceComponent supplierSource = ncg.generateDataSource("SUPPLIER");
        DataSourceComponent n1Source = ncg.generateDataSource("N1");
        Component S_N1join = ncg.generateEquiJoin(supplierSource, n1Source);
        DataSourceComponent lineitemSource = ncg.generateDataSource("LINEITEM");
        Component S_N1_Ljoin = ncg.generateEquiJoin(S_N1join, lineitemSource);
        DataSourceComponent ordersSource = ncg.generateDataSource("ORDERS");
        Component S_N1_L_Ojoin = ncg.generateEquiJoin(S_N1_Ljoin, ordersSource);
        DataSourceComponent customerSource = ncg.generateDataSource("CUSTOMER");
        Component S_N1_L_O_Cjoin = ncg.generateEquiJoin(S_N1_L_Ojoin, customerSource);
        DataSourceComponent n2Source = ncg.generateDataSource("N2");
        ncg.generateEquiJoin(S_N1_L_O_Cjoin, n2Source);
       
        String planStr = ParserUtil.toString(ncg.getQueryPlan());
        //LOG.info(planStr);
       
View Full Code Here
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
         * R-N1-C-O-L-S-P-N2: 54nodes, 33sec
         * R-N1-C-O-L-S-N2-P: 62nodes, 34sec
         * P-L-S-N2-O-C-N1-R: cannot have parallelism more than one on the last level because of Regionkey
         * Manual bushy plan: 50sec
         */
        DataSourceComponent regionSource = ncg.generateDataSource("REGION");
        DataSourceComponent n1Source = ncg.generateDataSource("N1");
        Component R_N1join = ncg.generateEquiJoin(regionSource, n1Source);
        DataSourceComponent customerSource = ncg.generateDataSource("CUSTOMER");
        Component R_N1_Cjoin = ncg.generateEquiJoin(R_N1join, customerSource);
        DataSourceComponent ordersSource = ncg.generateDataSource("ORDERS");
        Component R_N1_C_Ojoin = ncg.generateEquiJoin(R_N1_Cjoin, ordersSource);
        DataSourceComponent lineitemSource = ncg.generateDataSource("LINEITEM");
        Component R_N1_C_O_Ljoin = ncg.generateEquiJoin(R_N1_C_Ojoin, lineitemSource);
        DataSourceComponent partSouce = ncg.generateDataSource("PART");
        Component R_N1_C_O_L_Pjoin = ncg.generateEquiJoin(R_N1_C_O_Ljoin, partSouce);
        DataSourceComponent supplierSource = ncg.generateDataSource("SUPPLIER");
        Component R_N1_C_O_L_P_Sjoin = ncg.generateEquiJoin(R_N1_C_O_L_Pjoin, supplierSource);
        DataSourceComponent n2Source = ncg.generateDataSource("N2");
        ncg.generateEquiJoin(R_N1_C_O_L_P_Sjoin, n2Source);
       
        String planStr = ParserUtil.toString(ncg.getQueryPlan());
        //LOG.info(planStr);
       
View Full Code Here
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
         * P-L-S-N-O-PS     : 61nodes, 41sec
         * P-L-S-N-PS-O     : 61nodes, 43sec
         * L-S-N-PS-P-0     : 107nodes, more than 200sec
         * Manual lefty plan: 37sec (parallelism everywhere 1)
         */
        DataSourceComponent partSource = ncg.generateDataSource("PART");
        DataSourceComponent lineitemSource = ncg.generateDataSource("LINEITEM");
        Component P_Ljoin = ncg.generateEquiJoin(partSource, lineitemSource);
        DataSourceComponent partSuppSource = ncg.generateDataSource("PARTSUPP");
        Component P_L_SPjoin = ncg.generateEquiJoin(P_Ljoin, partSuppSource);
        DataSourceComponent ordersSource = ncg.generateDataSource("ORDERS");
        Component P_L_SP_Ojoin = ncg.generateEquiJoin(P_L_SPjoin, ordersSource);
        DataSourceComponent supplierSource = ncg.generateDataSource("SUPPLIER");
        Component P_L_SP_O_Sjoin = ncg.generateEquiJoin(P_L_SP_Ojoin, supplierSource);
        DataSourceComponent nationSource = ncg.generateDataSource("NATION");
        ncg.generateEquiJoin(P_L_SP_O_Sjoin, nationSource);
       
        String planStr = ParserUtil.toString(ncg.getQueryPlan());
        //LOG.info(planStr);
       
View Full Code Here
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
         * L-O-C-N          : 34nodes, 23sec
         * C-O-N-L          : 35nodes, 23sec. might not work unless schema synonims are set
         * C-N-O-L          : 37nodes, 22sec , might not work unless schema synonims are set
         * Manual lefty plan: 22sec 
         */
        DataSourceComponent lineitemSource = ncg.generateDataSource("LINEITEM");
        DataSourceComponent ordersSource = ncg.generateDataSource("ORDERS");
        Component L_Ojoin = ncg.generateEquiJoin(lineitemSource, ordersSource);
        DataSourceComponent customerSource = ncg.generateDataSource("CUSTOMER");
        Component L_O_Cjoin = ncg.generateEquiJoin(L_Ojoin, customerSource);
        DataSourceComponent nationSource = ncg.generateDataSource("NATION");
        ncg.generateEquiJoin(L_O_Cjoin, nationSource);
       
        String planStr = ParserUtil.toString(ncg.getQueryPlan());
        //LOG.info(planStr);
       
View Full Code Here
TOP

Related Classes of plan_runner.components.DataSourceComponent

  • optimizers.cost.CostOptimizerTest
  • optimizers.cost.ProjSchemaCreatorTest
  • 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
  • plan_runner.query_plans.HyracksPlan
    • 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.