Package plan_runner.expressions

Examples of plan_runner.expressions.ColumnReference


  public static List<Integer> extractColumnIndexes(List<ValueExpression> veList) {
    final List<Integer> indexes = new ArrayList<Integer>();
    for (final ValueExpression ve : veList)
      if (ve instanceof ColumnReference) {
        final ColumnReference cr = (ColumnReference) ve;
        indexes.add(cr.getColumnIndex());
        // }else if(ve instanceof IntegerYearFromDate){
        // //SUPPORT FOR EXTRACT_YEAR
        // IntegerYearFromDate iyfd = (IntegerYearFromDate) ve;
        // ColumnReference<Date> veDate = (ColumnReference<Date>)
        // iyfd.getInnerExpressions().get(0);
View Full Code Here


    // but only for GroupByProjections as the top level method.
    // That is, we can safely assume StringConversion method.
    // Permanent fix is to create StringConversion over overallAggregation.
    final TypeConversion tc = _sc;

    final ValueExpression ve = new ColumnReference(tc, position,
        ParserUtil.getStringExpr(column));
    pushToExprStack(ve);
  }
View Full Code Here

    final TypeConversion tc = _schema.getType(ParserUtil.getFullSchemaColumnName(column, _tan));

    // extract the position (index) of the required column
    final int position = _it.getColumnIndex(column, _affectedComponent);

    final ValueExpression ve = new ColumnReference(tc, position);
    _exprStack.push(ve);
  }
View Full Code Here

  private static AggregateOperator createOverallAgg(AggregateOperator lastAgg, Map map) {
    final TypeConversion wrapper = lastAgg.getType();
    AggregateOperator overallAgg;

    ColumnReference cr;
    if (lastAgg.hasGroupBy())
      cr = new ColumnReference(wrapper, 1);
    else
      cr = new ColumnReference(wrapper, 0);

    if (lastAgg instanceof AggregateAvgOperator)
      overallAgg = new AggregateAvgOperator(cr, map);
    else
      overallAgg = new AggregateSumOperator(cr, map);
View Full Code Here

        List<AggregateOperator> aggOps = selectVisitor.getAggOps();
        List<ValueExpression> groupByVEs = selectVisitor.getGroupByVEs();
       
        //expected
        AggregateOperator agg = new AggregateSumOperator(
                new ColumnReference(_dblConv, 3, "LINEITEM.EXTENDEDPRICE * (1.0 - LINEITEM.DISCOUNT)"),
                _map);
        List<AggregateOperator> expAggOps = Arrays.asList(agg);
        List<ColumnReference> expGroupByVEs = Arrays.asList(new ColumnReference(_sc, 0, "N1.NAME"),
                                                        new ColumnReference(_sc, 1, "N2.NAME"),
                                                        new ColumnReference(_ic, 2, "EXTRACT_YEAR(LINEITEM.SHIPDATE)"));
       
        //compare
        assertEquals(expAggOps.toString(), aggOps.toString());
        assertEquals(expGroupByVEs.toString(), groupByVEs.toString());
    }
View Full Code Here

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

    new DataSourceComponent("LINEITEM", dataPath + "lineitem" + extension, _queryPlan)
View Full Code Here

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

    new DataSourceComponent("ORDERS", dataPath + "orders" + extension, _queryPlan)
View Full Code Here

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

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

    // -------------------------------------------------------------------------------------
    // set up aggregation function on a separate StormComponent(Bolt)

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

    final AggregateOperator aggOp = new AggregateAvgOperator(product, conf)
        .setGroupByColumns(Arrays.asList(0));
    new OperatorComponent(R_N_S_L_C_Ojoin, "FINAL_RESULT", _queryPlan).addOperator(aggOp);
View Full Code Here

    final EquiJoinComponent CUSTOMER_ORDERSjoin = new EquiJoinComponent(relationCustomer,
        relationOrders, _queryPlan).addOperator(postAgg).setHashIndexes(hashIndexes)
        .setBatchOutputMillis(1000);

    // -------------------------------------------------------------------------------------
    final AggregateSumOperator agg = new AggregateSumOperator(new ColumnReference(_ic, 1), conf)
        .setGroupByColumns(Arrays.asList(0));

    new OperatorComponent(CUSTOMER_ORDERSjoin, "COUNTAGG", _queryPlan).addOperator(agg)
        .setFullHashList(
            Arrays.asList("FURNITURE", "BUILDING", "MACHINERY", "HOUSEHOLD",
View Full Code Here

TOP

Related Classes of plan_runner.expressions.ColumnReference

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.