Examples of plan_runner.components.Component

plan_runner.components.Component

    final ColumnReference colN = new ColumnReference(_ic, 1);
    final ColumnReference colC = new ColumnReference(_ic, 1);
    final ComparisonPredicate N_C_comp = new ComparisonPredicate(ComparisonPredicate.EQUAL_OP,
        colN, colC);


    Component N_Cjoin = ThetaJoinComponentFactory
        .createThetaJoinOperator(Theta_JoinType, relationNation2, relationCustomer,
            _queryPlan).addOperator(new ProjectOperator(new int[] { 0, 2 }))
        .setJoinPredicate(N_C_comp);


    // -------------------------------------------------------------------------------------
    final ArrayList<Integer> hashOrders = new ArrayList<Integer>(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 ColumnReference colN_C = new ColumnReference(_ic, 1);
    final ColumnReference colO = new ColumnReference(_ic, 1);
    final ComparisonPredicate N_C_O_comp = new ComparisonPredicate(
        ComparisonPredicate.EQUAL_OP, colN_C, colO);


    Component N_C_Ojoin = ThetaJoinComponentFactory
        .createThetaJoinOperator(Theta_JoinType, N_Cjoin, relationOrders, _queryPlan)
        .addOperator(new ProjectOperator(new int[] { 0, 2 })).setJoinPredicate(N_C_O_comp);


    // -------------------------------------------------------------------------------------
    final ArrayList<Integer> hashSupplier = new ArrayList<Integer>(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 ArrayList<Integer> hashNation1 = new ArrayList<Integer>(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 ColumnReference colS = new ColumnReference(_ic, 1);
    final ColumnReference colN2 = new ColumnReference(_ic, 1);
    final ComparisonPredicate S_N_comp = new ComparisonPredicate(ComparisonPredicate.EQUAL_OP,
        colS, colN2);


    Component S_Njoin = ThetaJoinComponentFactory
        .createThetaJoinOperator(Theta_JoinType, relationSupplier, relationNation1,
            _queryPlan).addOperator(new ProjectOperator(new int[] { 0, 2 }))
        .setJoinPredicate(S_N_comp);


    // -------------------------------------------------------------------------------------
    final ArrayList<Integer> hashLineitem = new ArrayList<Integer>(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 ColumnReference colL = new ColumnReference(_ic, 2);
    final ColumnReference colS_N = new ColumnReference(_ic, 0);
    final ComparisonPredicate L_S_N_comp = new ComparisonPredicate(
        ComparisonPredicate.EQUAL_OP, colL, colS_N);


    Component L_S_Njoin = ThetaJoinComponentFactory
        .createThetaJoinOperator(Theta_JoinType, relationLineitem, S_Njoin, _queryPlan)
        .addOperator(new ProjectOperator(new int[] { 5, 0, 1, 3 }))
        .setJoinPredicate(L_S_N_comp);


    // -------------------------------------------------------------------------------------
    // 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(new ArrayList<Integer>(Arrays.asList(2, 0, 3)));


    final ColumnReference colN_C_O = new ColumnReference(_ic, 1);
    final ColumnReference colL_S_N = new ColumnReference(_ic, 3);
    final ComparisonPredicate N_C_O_L_S_N_comp = new ComparisonPredicate(
        ComparisonPredicate.EQUAL_OP, colN_C_O, colL_S_N);


    Component lastJoiner = ThetaJoinComponentFactory
        .createThetaJoinOperator(Theta_JoinType, N_C_Ojoin, L_S_Njoin, _queryPlan)
        .addOperator(so).addOperator(agg).setJoinPredicate(N_C_O_L_S_N_comp);
    //lastJoiner.setPrintOut(false);
  }

View Full Code Here

    final int index = indexOf(tupleSchema, columnName);
    return index != ParserUtil.NOT_FOUND;
  }


  public int getChildIndex(int originalIndex, Component originator, Component requestor) {
    final Component child = originator.getChild();
    final Component[] parents = child.getParents();


    if (child.getChainOperator().getProjection() != null)
      throw new RuntimeException(
          "Cannot use getChildIndex method on the component with Projection! getOutputSize does not work anymore!");


    int index = originalIndex;


    if (parents.length < 2)
      // no changes, only one parent
      return index;


    // only right parent changes the index
    final Component leftParent = parents[0];
    final Component rightParent = parents[1];


    if (rightParent.equals(originator))
      if (!rightParent.getHashIndexes().contains(originalIndex)) {
        // requested column is *not* in joinColumns
        final int indexesBefore = ParserUtil.getNumElementsBefore(originalIndex,
            rightParent.getHashIndexes());
        index = ParserUtil.getPreOpsOutputSize(leftParent, _schema, _tan) - indexesBefore
            + originalIndex;
      } else {
        // requested column is in joinColumns
        // if in the keys have to find lhs index
        final int joinIndex = rightParent.getHashIndexes().indexOf(originalIndex);
        index = leftParent.getHashIndexes().get(joinIndex);
      }


    if (child.equals(requestor))
      return index;

View Full Code Here


    final int originalIndex = indexOf(columns, columnName);


    // finding originator by name in the list of ancestors
    final List<DataSourceComponent> sources = requestor.getAncestorDataSources();
    Component originator = null;
    for (final DataSourceComponent source : sources)
      if (source.getName().equals(tblCompName)) {
        originator = source;
        break;
      }

View Full Code Here

    final Component[] parents = component.getParents();
    if (parents != null) {
      // if both parents have only hashIndexes, they point to the same
      // indexes in the child
      // so we choose arbitrarily first parent
      final Component parent = parents[0];
      final List<Integer> parentHashes = parent.getHashIndexes();
      if (parent.getHashExpressions() == null) {
        final List<Integer> parentHashIndexes = new ArrayList<Integer>();
        for (final int parentHash : parentHashes)
          parentHashIndexes.add(getChildIndex(parentHash, parent, component));
        return isSuperset(parentHashIndexes, hashIndexes);
      }

View Full Code Here

    // third phase: joining Components until there is a single component
    subPlans = cg.getSubPlans();
    while (subPlans.size() > 1) {
      // this is joining of components having approximately the same
      // number of ancestors - the same level
      final Component firstComp = subPlans.get(0);
      final List<String> firstAncestors = ParserUtil.getSourceNameList(firstComp);
      for (int i = 1; i < subPlans.size(); i++) {
        final Component otherComp = subPlans.get(i);
        final List<String> otherAncestors = ParserUtil.getSourceNameList(otherComp);
        if (_pq.getJte().joinExistsBetween(firstAncestors, otherAncestors)) {
          cg.generateEquiJoin(firstComp, otherComp);
          break;
        }

View Full Code Here

    ParserUtil.addOrExprsToComps(collocatedOrs, orExprs);


    for (final Map.Entry<Set<String>, Expression> orEntry : collocatedOrs.entrySet()) {
      final List<String> compNames = new ArrayList<String>(orEntry.getKey());
      final List<Component> compList = ParserUtil.getComponents(compNames, _cg);
      final Component affectedComponent = HierarchyExtractor.getLCM(compList);


      final Expression orExpr = orEntry.getValue();
      ParserUtil.addAndExprToComp(collocatedExprs, orExpr, affectedComponent.getName());
    }


    return collocatedExprs;
  }

View Full Code Here

    for (final SelectItem elem : selectItems)
      elem.accept(selectVisitor);
    final List<AggregateOperator> aggOps = selectVisitor.getAggOps();
    final List<ValueExpression> groupByVEs = selectVisitor.getGroupByVEs();


    final Component affectedComponent = _cg.getQueryPlan().getLastComponent();
    attachSelectClause(affectedComponent, aggOps, groupByVEs);
    return (aggOps.isEmpty() ? IndexSelectItemsVisitor.NON_AGG : IndexSelectItemsVisitor.AGG);
  }

View Full Code Here

    // assinging JSQL expressions to Components
    final Map<String, Expression> whereCompExprPairs = getWhereForComponents(whereExpr);


    // Each component process its own part of JSQL whereExpression
    for (final Map.Entry<String, Expression> whereCompExprPair : whereCompExprPairs.entrySet()) {
      final Component affectedComponent = _cg.getQueryPlan().getComponent(
          whereCompExprPair.getKey());
      final Expression whereCompExpr = whereCompExprPair.getValue();
      processWhereForComponent(affectedComponent, whereCompExpr);
    }

View Full Code Here

   * square root of parallelism of its parent b) number of distinct groupBy
   * values c) the same as previous level We decided to -if groupBy is a
   * single column, take min(b, c) -otherwise take c
   */
  public void setParallelism(OperatorComponent opComp, Map<String, CostParams> compCost) {
    final Component parent = opComp.getParents()[0];
    final String parentName = parent.getName();
    final int parentPar = compCost.get(parentName).getParallelism();


    int parallelism = parentPar;
    //
    final List<Integer> hashIndexes = parent.getHashIndexes();
    if ((hashIndexes) != null && (hashIndexes.size() == 1)) {
      final int index = hashIndexes.get(0);
      final String aliasedColumnName = compCost.get(parentName).getSchema().getSchema()
          .get(index).getName();
      final String fullSchemaColumnName = ParserUtil.getFullSchemaColumnName(

View Full Code Here

    final int totalParallelism = SystemParameters.getInt(_map, "DIP_TOTAL_SRC_PAR");
    final NameCompGenFactory factory = new NameCompGenFactory(_map, _pq.getTan(),
        totalParallelism);
    final NameCompGen ncg = factory.create();


    Component first = ncg.generateDataSource(_compNames.get(0));
    for (int i = 1; i < _compNames.size(); i++) {
      final Component second = ncg.generateDataSource(_compNames.get(i));
      first = ncg.generateEquiJoin(first, second);
    }


    ParserUtil.parallelismToMap(ncg, _map);

View Full Code Here

0 1 2 3 4

TOP

Related Classes of plan_runner.components.Component

optimizers.cost.CostOptimizerTest

plan_runner.main.Main

plan_runner.query_plans.ThetaHyracksPlan

plan_runner.query_plans.ThetaInputDominatedPlan

plan_runner.query_plans.ThetaMultipleJoinPlan

plan_runner.query_plans.ThetaOutputDominatedPlan

plan_runner.query_plans.ThetaTPCH10Plan

plan_runner.query_plans.ThetaTPCH4Plan

plan_runner.query_plans.ThetaTPCH5Plan

plan_runner.query_plans.ThetaTPCH7Plan

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.