Package plan_runner.expressions

Examples of plan_runner.expressions.ColumnReference


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

    //StringConcatenate colR_N_S_L= new StringConcatenate(colR_N_S_L1, colR_N_S_L2);
    //StringConcatenate colC_O= new StringConcatenate(colC_O1, colC_O2);
    //ComparisonPredicate R_N_S_L_C_O_comp = new ComparisonPredicate(ComparisonPredicate.EQUAL_OP, colR_N_S_L, colC_O);

    ComparisonPredicate pred1 = new ComparisonPredicate(ComparisonPredicate.EQUAL_OP,
        colR_N_S_L1, colC_O1);
    ComparisonPredicate pred2 = new ComparisonPredicate(ComparisonPredicate.EQUAL_OP,
        colR_N_S_L2, colC_O2);
    AndPredicate R_N_S_L_C_O_comp = new AndPredicate(pred1, pred2);

    Component R_N_S_L_C_Ojoin = ThetaJoinComponentFactory
        .createThetaJoinOperator(Theta_JoinType, R_N_S_Ljoin, C_Ojoin, _queryPlan)
        .setHashIndexes(hashRNSLCO).addOperator(projectionRNSLCO)
        .setJoinPredicate(R_N_S_L_C_O_comp);

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

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

    AggregateOperator aggOp = new AggregateSumOperator(product, conf).setGroupByColumns(Arrays
        .asList(0));
    OperatorComponent finalComponent = new OperatorComponent(R_N_S_L_C_Ojoin, "FINAL_RESULT",
View Full Code Here


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

View Full Code Here

    final DataSourceComponent relationT = new DataSourceComponent("T", dataPath + "t"
        + extension, _queryPlan).setHashIndexes(hashT);

    // -------------------------------------------------------------------------------------
    final ValueExpression<Double> aggVe = new Multiplication(new ColumnReference(_dc, 0),
        new ColumnReference(_dc, 3));

    final AggregateSumOperator sp = new AggregateSumOperator(aggVe, conf);

    new EquiJoinComponent(R_Sjoin, relationT, _queryPlan).addOperator(
        new SelectOperator(new ComparisonPredicate(new ColumnReference(_ic, 1),
            new ValueSpecification(_ic, 10)))).addOperator(sp);

  }
View Full Code Here

  public ThetaTPCH9Plan(String dataPath, String extension, Map conf) {
    int Theta_JoinType = ThetaQueryPlansParameters.getThetaJoinType(conf);
    //-------------------------------------------------------------------------------------
    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)
View Full Code Here

    // -------------------------------------------------------------------------------------
    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 EquiJoinComponent C_Ojoin = new EquiJoinComponent(relationCustomer, relationOrders,
        _queryPlan).setHashIndexes(Arrays.asList(3));
    // -------------------------------------------------------------------------------------
    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);
    // -------------------------------------------------------------------------------------

    final EquiJoinComponent C_O_Njoin = new EquiJoinComponent(C_Ojoin, relationNation,
        _queryPlan).addOperator(new ProjectOperator(new int[] { 0, 1, 2, 4, 5, 6, 7, 8 }))
        .setHashIndexes(Arrays.asList(6));
    // -------------------------------------------------------------------------------------

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

    final SelectOperator selectionLineitem = new SelectOperator(new ComparisonPredicate(
        new ColumnReference(_sc, 8), new ValueSpecification(_sc, "R")));

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

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

    new EquiJoinComponent(C_O_Njoin, relationLineitem, _queryPlan).addOperator(
View Full Code Here

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

    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);
    ColumnReference colO = new ColumnReference(_ic, 0);
    ComparisonPredicate P_L_O_comp = new ComparisonPredicate(ComparisonPredicate.EQUAL_OP,
        colP_L, colO);

    Component P_L_Ojoin = ThetaJoinComponentFactory
        .createThetaJoinOperator(Theta_JoinType, P_Ljoin, relationOrders, _queryPlan)
        .addOperator(new ProjectOperator(new int[] { 1, 2, 4, 5 }))
        .setHashIndexes(Arrays.asList(0)).setJoinPredicate(P_L_O_comp);

    //-------------------------------------------------------------------------------------
    ColumnReference colS_N = new ColumnReference(_ic, 0);
    ColumnReference colP_L_O = new ColumnReference(_ic, 0);
    ComparisonPredicate S_N_P_L_O_comp = new ComparisonPredicate(ComparisonPredicate.EQUAL_OP,
        colS_N, colP_L_O);

    Component S_N_P_L_Ojoin = ThetaJoinComponentFactory
        .createThetaJoinOperator(Theta_JoinType, S_Njoin, P_L_Ojoin, _queryPlan)
        .addOperator(new ProjectOperator(new int[] { 1, 3, 4, 5 }))
        .setHashIndexes(Arrays.asList(2)).setJoinPredicate(S_N_P_L_O_comp);

    //-------------------------------------------------------------------------------------
    AggregateOperator agg = new AggregateSumOperator(new ColumnReference(_doubleConv, 2), conf)
        .setGroupByColumns(Arrays.asList(1, 4));

    ColumnReference colR_N_C = new ColumnReference(_ic, 0);
    ColumnReference colS_N_P_L_O = new ColumnReference(_ic, 2);
    ComparisonPredicate R_N_C_S_N_P_L_O_comp = new ComparisonPredicate(
        ComparisonPredicate.EQUAL_OP, colR_N_C, colS_N_P_L_O);

    Component R_N_C_S_N_P_L_Ojoin = ThetaJoinComponentFactory
        .createThetaJoinOperator(Theta_JoinType, R_N_Cjoin, S_N_P_L_Ojoin, _queryPlan)
View Full Code Here

        + "partsupp" + extension, _queryPlan).setHashIndexes(hashPartsSupp).addOperator(
        projectionPartsSupp);

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

    final ColumnReference colRefLineItem = new ColumnReference(_intConv, 0);
    final ColumnReference colRefOrders = new ColumnReference(_intConv, 0);
    final ComparisonPredicate predL_O1 = new ComparisonPredicate(ComparisonPredicate.EQUAL_OP,
        colRefLineItem, colRefOrders);

    final ColumnReference colRefLineItemExtPrice = new ColumnReference(_doubleConv, 3);
    final ColumnReference colRefOrdersTotalPrice = new ColumnReference(_doubleConv, 1);
    final ValueSpecification val10 = new ValueSpecification(_doubleConv, 10.0);
    final Multiplication mult = new Multiplication(val10, colRefLineItemExtPrice);
    final ComparisonPredicate predL_O2 = new ComparisonPredicate(ComparisonPredicate.LESS_OP,
        mult, colRefOrdersTotalPrice);

    final AndPredicate predL_O = new AndPredicate(predL_O1, predL_O2);

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

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

    final SelectOperator selectionPartSupp = new SelectOperator(new ComparisonPredicate(
        ComparisonPredicate.GREATER_OP, new ColumnReference(_intConv, 2),
        new ValueSpecification(_intConv, 9990)));

    final ColumnReference colRefSupplier = new ColumnReference(_intConv, 0);
    final ColumnReference colRefPartSupp = new ColumnReference(_intConv, 1);
    final ComparisonPredicate predS_P = new ComparisonPredicate(ComparisonPredicate.EQUAL_OP,
        colRefSupplier, colRefPartSupp);

    Component SUPPLIER_PARTSUPPjoin = ThetaJoinComponentFactory
        .createThetaJoinOperator(Theta_JoinType, relationSupplier, relationPartsupp,
            _queryPlan).setJoinPredicate(predS_P)
        .addOperator(new ProjectOperator(new int[] { 0, 1, 3 }))
        .addOperator(selectionPartSupp);

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

    // 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, 3));
    // extendedPrice*(1-discount)
    final ValueExpression<Double> product = new Multiplication(new ColumnReference(_doubleConv,
        2), substract);
    final AggregateOperator agg = new AggregateSumOperator(product, conf);

    final ColumnReference colRefL_OPartKey = new ColumnReference(_intConv, 0);
    final ColumnReference colRefS_PPartKey = new ColumnReference(_intConv, 1);
    final ColumnReference colRefL_OSupKey = new ColumnReference(_intConv, 1);
    final ColumnReference colRefS_PSupKey = new ColumnReference(_intConv, 0);
    final ComparisonPredicate predL_P1 = new ComparisonPredicate(ComparisonPredicate.EQUAL_OP,
        colRefL_OPartKey, colRefS_PPartKey);
    final ComparisonPredicate predL_P2 = new ComparisonPredicate(ComparisonPredicate.EQUAL_OP,
        colRefL_OSupKey, colRefS_PSupKey);
    final AndPredicate predL_P = new AndPredicate(predL_P1, predL_P2);
View Full Code Here

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

    // -------------------------------------------------------------------------------------
    final ProjectOperator projFirstOut = new ProjectOperator(new ColumnReference(_sc, 1),
        new ValueSpecification(_sc, "1"));
    final ProjectOperator projSecondOut = new ProjectOperator(new int[] { 1, 2 });
    final AggregationStorage secondJoinStorage = new AggregationStorage(
        new AggregateCountOperator(conf).setGroupByColumns(Arrays.asList(0)), _lc, conf,
        false);

    final List<Integer> hashIndexes = Arrays.asList(0);
    final EquiJoinComponent CUSTOMER_ORDERSjoin = new EquiJoinComponent(relationCustomer,
        relationOrders, _queryPlan).setFirstPreAggProj(projFirstOut)
        .setSecondPreAggProj(projSecondOut).setSecondPreAggStorage(secondJoinStorage)
        .setHashIndexes(hashIndexes);

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

    new OperatorComponent(CUSTOMER_ORDERSjoin, "COUNTAGG", _queryPlan).addOperator(agg);

    // -------------------------------------------------------------------------------------
View Full Code Here

  public TPCH8Plan(String dataPath, String extension, Map conf) {
    // -------------------------------------------------------------------------------------
    final List<Integer> hashRegion = Arrays.asList(0);

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

    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> hashNation1 = Arrays.asList(1);

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

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

    // -------------------------------------------------------------------------------------
    final EquiJoinComponent R_Njoin = new EquiJoinComponent(relationRegion, relationNation1,
        _queryPlan).addOperator(new ProjectOperator(new int[] { 1 })).setHashIndexes(
        Arrays.asList(0));

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

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

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

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

    // -------------------------------------------------------------------------------------
    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> hashNation2 = Arrays.asList(0);

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

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

    // -------------------------------------------------------------------------------------
    final EquiJoinComponent S_Njoin = new EquiJoinComponent(relationSupplier, relationNation2,
        _queryPlan).addOperator(new ProjectOperator(new int[] { 0, 2 })).setHashIndexes(
        Arrays.asList(0));

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

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

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

    // first field in projection
    final ColumnReference orderKey = new ColumnReference(_sc, 0);
    // second field in projection
    final ColumnReference partKey = new ColumnReference(_sc, 1);
    // third field in projection
    final ColumnReference suppKey = new ColumnReference(_sc, 2);
    // forth field in projection
    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);
    final ProjectOperator projectionLineitem = new ProjectOperator(orderKey, partKey, suppKey,
        product);

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

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

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

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

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

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

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

    // -------------------------------------------------------------------------------------
    final EquiJoinComponent S_N_P_L_Ojoin = new EquiJoinComponent(S_Njoin, P_L_Ojoin,
        _queryPlan).addOperator(new ProjectOperator(new int[] { 1, 2, 3, 4 }))
        .setHashIndexes(Arrays.asList(2));

    // -------------------------------------------------------------------------------------
    final AggregateOperator agg = new AggregateSumOperator(new ColumnReference(_doubleConv, 2),
        conf).setGroupByColumns(Arrays.asList(1, 3));

    new EquiJoinComponent(R_N_Cjoin, S_N_P_L_Ojoin, _queryPlan).addOperator(agg);

    // -------------------------------------------------------------------------------------
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.