Package plan_runner.components

Examples of plan_runner.components.Component


         * 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


      final String firstCompName = sourceNames.get(i);
      final List<String> joinedWith = _pq.getJte().getJoinedWithSingleDir(firstCompName);
      if (joinedWith != null)
        for (final String secondCompName : joinedWith) {
          final NameCompGen ncg = factory.create();
          final Component first = ncg.generateDataSource(firstCompName);
          final Component second = ncg.generateDataSource(secondCompName);
          addEquiJoinNotSuboptimal(first, second, ncg, ncgListFirst);
        }
    }
    if (numSources == 2)
      optimal = chooseBest(ncgListFirst);

    // **************creating multi-way joins********************
    for (int level = 2; level < numSources; level++) {
      final List<NameCompGen> ncgListSecond = new ArrayList<NameCompGen>();
      for (int i = 0; i < ncgListFirst.size(); i++) {
        final NameCompGen ncg = ncgListFirst.get(i);
        Component firstComp = ncg.getQueryPlan().getLastComponent();
        final List<String> ancestors = ParserUtil.getSourceNameList(firstComp);
        final List<String> joinedWith = _pq.getJte().getJoinedWith(ancestors);
        for (final String compName : joinedWith) {
          NameCompGen newNcg = ncg;
          if (joinedWith.size() > 1) {
            // doing deepCopy only if there are multiple tables to
            // be joined with
            newNcg = ncg.deepCopy();
            firstComp = newNcg.getQueryPlan().getLastComponent();
          }

          final Component secondComp = newNcg.generateDataSource(compName);
          addEquiJoinNotSuboptimal(firstComp, secondComp, newNcg, ncgListSecond);
        }
      }

      if (level == numSources - 1)
View Full Code Here

  // TODO: should compare them by parallelism as well, and not only by
  // totalLatency
  // we could also do some pruning
  private double getTotalLatency(NameCompGen ncg) {
    final Map<String, CostParams> allParams = ncg.getCompCost();
    final Component lastComponent = ncg.getQueryPlan().getLastComponent();
    final CostParams lastParams = allParams.get(lastComponent.getName());
    return lastParams.getTotalAvgLatency(); // it's computed as query plan
    // is built on
  }
View Full Code Here

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

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

TOP

Related Classes of plan_runner.components.Component

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.