Examples of ComparisonPredicate

Examples of plan_runner.predicates.ComparisonPredicate

269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
  public Predicate comparisonPredAnalyse(Predicate toAnalyse) {
    if (!(toAnalyse instanceof ComparisonPredicate))
      return toAnalyse;

    // Check if is Double or Integer
    ComparisonPredicate compToAnalyse = (ComparisonPredicate) toAnalyse;
    List<ValueExpression> followUps = compToAnalyse.getExpressions();

    // if one of the previous change to Double
    toAnalyse = getSameForDouble(toAnalyse);

    compToAnalyse = (ComparisonPredicate) toAnalyse;
    followUps = compToAnalyse.getExpressions();

    ValueExpression leftPart = null;
    try {
      leftPart = combine(null, 0, followUps.get(0));
    } catch (final Exception e) {
      return toAnalyse;
    }

    ValueExpression rightPart = null;
    try {
      rightPart = combine(null, 0, followUps.get(1));
    } catch (final Exception e) {
      return toAnalyse;
    }

    boolean temp = false;
    getInfo(leftPart, temp, 0);
    temp = false;
    getInfo(rightPart, temp, 1);

    if (Parameter[0] == null)
      Parameter[0] = new ValueSpecification<Double>(numConv, 1.0);
    if (Parameter[1] == null)
      Parameter[1] = new ValueSpecification<Double>(numConv, 1.0);

    Parameter[0].inverseNumber();
    ValueExpression fullClean = null;
    if (CleanPart[0] != null) {
      if (CleanPart[1] != null)
        fullClean = new Subtraction<Double>(CleanPart[1], CleanPart[0]);
      else if (CleanPart[1] == null) {
        final ValueExpression temp1 = new ValueSpecification<Double>(numConv, 0.0);
        fullClean = new Subtraction<Double>(temp1, CleanPart[0]);
      }
    } else if (CleanPart[0] == null)
      if (CleanPart[1] != null)
        fullClean = CleanPart[1];
      else
        fullClean = new ValueSpecification(numConv, 0.0);

    fullClean = combine(null, 0, fullClean);
    ValueExpression finalA = new Multiplication<Double>(Parameter[0], Parameter[1]);
    finalA = combine(null, 0, finalA);
    ValueExpression finalB = new Multiplication<Double>(Parameter[0], fullClean);
    finalB = combine(null, 0, finalB);

    final ValueExpression withVariable = new Multiplication<Double>(finalA, Variable[1]);
    final ValueExpression finalRightPart = new Addition<Double>(withVariable, finalB);

    Predicate finalPred;
    if (Parameter[0].isNegative())
      finalPred = new ComparisonPredicate(compToAnalyse.getOperator(true), Variable[0],
          finalRightPart);
    else
      finalPred = new ComparisonPredicate(compToAnalyse.getOperator(false), Variable[0],
          finalRightPart);
    return finalPred;
  }
View Full Code Here

Examples of plan_runner.predicates.ComparisonPredicate

356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
      param = false;
    }
  }

  Predicate getSameForDouble(Predicate pred) {
    final ComparisonPredicate compPred = (ComparisonPredicate) pred;

    final List<ValueExpression> followUps = compPred.getExpressions();

    final ValueExpression left = changeToDouble(followUps.get(0));
    final ValueExpression right = changeToDouble(followUps.get(1));

    final Predicate finalPred = new ComparisonPredicate<Double>(compPred.getOperator(false),
        left, right);
    return finalPred;
  }
View Full Code Here

Examples of plan_runner.predicates.ComparisonPredicate

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
64
65
66
67
68
69
70
71
72
73
74
75
  public TPCH3L23Plan(String dataPath, String extension, Map conf) {

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

    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 });
View Full Code Here

Examples of plan_runner.predicates.ComparisonPredicate

36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
  public TPCH3L1Plan(String dataPath, String extension, Map conf) {

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

    new DataSourceComponent("CUSTOMER", dataPath + "customer" + extension, _queryPlan)
        .setHashIndexes(hashCustomer).addOperator(selectionCustomer)
        .addOperator(projectionCustomer).setPrintOut(false);

    // -------------------------------------------------------------------------------------
    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 });
View Full Code Here

Examples of plan_runner.predicates.ComparisonPredicate

37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
  public TPCH3L2Plan(String dataPath, String extension, Map conf) {

    // -------------------------------------------------------------------------------------
    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 });
View Full Code Here

Examples of plan_runner.predicates.ComparisonPredicate

64
65
66
67
68
69
70
71
72
73
74
    computeDates();

    // -------------------------------------------------------------------------------------
    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
View Full Code Here

Examples of plan_runner.predicates.ComparisonPredicate

65
66
67
68
69
70
71
72
73
74
75
    computeDates();

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

    final SelectOperator selectionLineitem = new SelectOperator(new ComparisonPredicate(
        ComparisonPredicate.LESS_OP, new ColumnReference(_dc, 11), new ColumnReference(_dc,
            12)));

    final ProjectOperator projectionLineitem = new ProjectOperator(new int[] { 0 });
View Full Code Here

Examples of plan_runner.predicates.ComparisonPredicate

63
64
65
66
67
68
69
70
71
72
73
    computeDates();

    // -------------------------------------------------------------------------------------
    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
View Full Code Here

Examples of plan_runner.predicates.ComparisonPredicate

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
        .addOperator(projectionOrders);

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

    SelectOperator selectionLineitem = new SelectOperator(new ComparisonPredicate(
        ComparisonPredicate.LESS_OP, new ColumnReference(_dc, 11), new ColumnReference(_dc,
            12)));

    DistinctOperator distinctLineitem = new DistinctOperator(conf, new int[] { 0 });

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

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

    ColumnReference colO = new ColumnReference(_ic, 0);
    ColumnReference colL = new ColumnReference(_ic, 0);
    ComparisonPredicate O_L_comp = new ComparisonPredicate(ComparisonPredicate.EQUAL_OP, colO,
        colL);

    Component O_Ljoin = ThetaJoinComponentFactory
        .createThetaJoinOperator(Theta_JoinType, relationOrders, relationLineitem,
            _queryPlan).setHashIndexes(Arrays.asList(1)).setJoinPredicate(O_L_comp);
View Full Code Here

Examples of plan_runner.predicates.ComparisonPredicate

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
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
    // -------------------------------------------------------------------------------------
    final List<Integer> hashNation2 = Arrays.asList(1);

    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
    final SelectOperator so = new SelectOperator(new OrPredicate(new AndPredicate(
        new ComparisonPredicate(new ColumnReference(_sc, 0), new ValueSpecification(_sc,
            _firstCountryName)), new ComparisonPredicate(new ColumnReference(_sc, 2),
            new ValueSpecification(_sc, _secondCountryName))), new AndPredicate(
        new ComparisonPredicate(new ColumnReference(_sc, 0), new ValueSpecification(_sc,
            _secondCountryName)), new ComparisonPredicate(new ColumnReference(_sc, 2),
            new ValueSpecification(_sc, _firstCountryName)))));

    final AggregateOperator agg = new AggregateSumOperator(new ColumnReference(_doubleConv, 4),
        conf).setGroupByColumns(Arrays.asList(2, 0, 3));

View Full Code Here
TOP
Copyright © 2018 www.massapi.com. 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.