Java Expressions.FluentList方法代码示例

import org.apache.calcite.linq4j.tree.Expressions; //导入方法依赖的package包/类
/**
 * Once you have a Result of implementing a child relational expression,
 * call this method to create a Builder to implement the current relational
 * expression by adding additional clauses to the SQL query.
 * <p/>
 * <p>You need to declare which clauses you intend to add. If the clauses
 * are "later", you can add to the same query. For example, "GROUP BY" comes
 * after "WHERE". But if they are the same or earlier, this method will
 * start a new SELECT that wraps the previous result.</p>
 * <p/>
 * <p>When you have called
 * {@link Builder#setSelect(org.apache.calcite.sql.SqlNodeList)},
 * {@link Builder#setWhere(org.apache.calcite.sql.SqlNode)} etc. call
 * {@link Builder#result(org.apache.calcite.sql.SqlNode, java.util.Collection, org.apache.calcite.rel.RelNode)}
 * to fix the new query.</p>
 *
 * @param rel       Relational expression being implemented
 * @param clauseArr Clauses that will be generated to implement current
 *                  relational expression
 * @return A builder
 */
public Builder builder(JdbcRel rel, Clause... clauseArr) {
    final Clause maxClause = maxClause();
    boolean needNew = false;
    for (Clause clause : clauseArr) {
        if (maxClause.ordinal() >= clause.ordinal()) {
            needNew = true;
        }
    }
    SqlSelect select;
    Expressions.FluentList<Clause> clauseList = Expressions.list();
    if (needNew) {
        select = subSelect();
    } else {
        select = asSelect();
        clauseList.addAll(this.clauses);
    }
    clauseList.appendAll(clauseArr);
    Context newContext;
    final SqlNodeList selectList = select.getSelectList();
    if (selectList != null) {
        newContext = new Context(selectList.size()) {
            @Override
            public SqlNode field(int ordinal) {
                final SqlNode selectItem = selectList.get(ordinal);
                switch (selectItem.getKind()) {
                case AS:
                    return ((SqlCall) selectItem).operand(0);
                default:
                }
                return selectItem;
            }
        };
    } else {
        newContext = aliasContext(aliases, aliases.size() > 1);
    }
    return new Builder(rel, clauseList, select, newContext);
}
 

import org.apache.calcite.linq4j.tree.Expressions; //导入方法依赖的package包/类
/**
 * Once you have a Result of implementing a child relational expression,
 * call this method to create a Builder to implement the current relational
 * expression by adding additional clauses to the SQL query.
 * <p></p>
 * <p>You need to declare which clauses you intend to add. If the clauses
 * are "later", you can add to the same query. For example, "GROUP BY" comes
 * after "WHERE". But if they are the same or earlier, this method will
 * start a new SELECT that wraps the previous result.</p>
 * <p>When you have called
 * {@link Builder#setSelect(org.apache.calcite.sql.SqlNodeList)},
 * {@link Builder#setWhere(org.apache.calcite.sql.SqlNode)} etc. call
 * {@link Builder#result(org.apache.calcite.sql.SqlNode, java.util.Collection, org.apache.calcite.rel.RelNode)}
 * to fix the new query.</p>
 *
 * @param rel     Relational expression being implemented
 * @param clauses Clauses that will be generated to implement current
 *                relational expression
 * @return A builder
 */
public Builder builder(RelNode rel, Clause... clauses) {
  final Clause maxClause = maxClause();
  boolean needNew = false;
  for (Clause clause : clauses) {
    if (maxClause.ordinal() >= clause.ordinal()) {
      needNew = true;
    }
  }
  SqlSelect select;
  Expressions.FluentList<Clause> clauseList = Expressions.list();
  if (needNew) {
    select = subSelect();
  } else {
    select = asSelect();
    clauseList.addAll(this.clauses);
  }
  clauseList.appendAll(clauses);
  Context newContext;
  final SqlNodeList selectList = select.getSelectList();
  if (selectList != null) {
    newContext = new Context(selectList.size()) {

      @Override
      public SqlNode field(int ordinal) {
        return field(ordinal, false);
      }

      @Override
      public SqlNode field(int ordinal, boolean useAlias) {
        final SqlNode selectItem = selectList.get(ordinal);
        switch (selectItem.getKind()) {
          case AS:
            if (useAlias) {
              return ((SqlCall) selectItem).operand(1);
            } else {
              return ((SqlCall) selectItem).operand(0);
            }
        }
        return selectItem;
      }
    };
  } else {
    newContext = new AliasContext(aliases, aliases.size() > 1);
  }
  return new Builder(rel, clauseList, select, newContext);
}
 

import org.apache.calcite.linq4j.tree.Expressions; //导入方法依赖的package包/类
/** Once you have a Result of implementing a child relational expression,
 * call this method to create a Builder to implement the current relational
 * expression by adding additional clauses to the SQL query.
 *
 * <p>You need to declare which clauses you intend to add. If the clauses
 * are "later", you can add to the same query. For example, "GROUP BY" comes
 * after "WHERE". But if they are the same or earlier, this method will
 * start a new SELECT that wraps the previous result.
 *
 * <p>When you have called
 * {@link Builder#setSelect(SqlNodeList)},
 * {@link Builder#setWhere(SqlNode)} etc. call
 * {@link Builder#result(SqlNode, Collection, RelNode, Map)}
 * to fix the new query.
 *
 * @param rel Relational expression being implemented
 * @param clauses Clauses that will be generated to implement current
 *                relational expression
 * @return A builder
 */
public Builder builder(RelNode rel, Clause... clauses) {
  final Clause maxClause = maxClause();
  boolean needNew = false;
  // If old and new clause are equal and belong to below set,
  // then new SELECT wrap is not required
  Set<Clause> nonWrapSet = ImmutableSet.of(Clause.SELECT);
  for (Clause clause : clauses) {
    if (maxClause.ordinal() > clause.ordinal()
        || (maxClause == clause && !nonWrapSet.contains(clause))) {
      needNew = true;
    }
  }
  if (rel instanceof LogicalAggregate
      && !dialect.supportsNestedAggregations()
      && hasNestedAggregations((LogicalAggregate) rel)) {
    needNew = true;
  }

  SqlSelect select;
  Expressions.FluentList<Clause> clauseList = Expressions.list();
  if (needNew) {
    select = subSelect();
  } else {
    select = asSelect();
    clauseList.addAll(this.clauses);
  }
  clauseList.appendAll(clauses);
  Context newContext;
  final SqlNodeList selectList = select.getSelectList();
  if (selectList != null) {
    newContext = new Context(selectList.size()) {
      public SqlNode field(int ordinal) {
        final SqlNode selectItem = selectList.get(ordinal);
        switch (selectItem.getKind()) {
        case AS:
          return ((SqlCall) selectItem).operand(0);
        }
        return selectItem;
      }
    };
  } else {
    boolean qualified =
        !dialect.hasImplicitTableAlias() || aliases.size() > 1;
    // basically, we did a subSelect() since needNew is set and neededAlias is not null
    // now, we need to make sure that we need to update the alias context.
    // if our aliases map has a single element:  <neededAlias, rowType>,
    // then we don't need to rewrite the alias but otherwise, it should be updated.
    if (needNew
            && neededAlias != null
            && (aliases.size() != 1 || !aliases.containsKey(neededAlias))) {
      final Map<String, RelDataType> newAliases =
          ImmutableMap.of(neededAlias, rel.getInput(0).getRowType());
      newContext = aliasContext(newAliases, qualified);
    } else {
      newContext = aliasContext(aliases, qualified);
    }
  }
  return new Builder(rel, clauseList, select, newContext,
      needNew ? null : aliases);
}
 

import org.apache.calcite.linq4j.tree.Expressions; //导入方法依赖的package包/类
/**
 * Converts traits using well-founded induction. We don't require that
 * each conversion preserves all traits that have previously been converted,
 * but if it changes "locked in" traits we'll try some other conversion.
 *
 * @param rel                         Relational expression
 * @param allowInfiniteCostConverters Whether to allow infinite converters
 * @param toTraits                    Target trait set
 * @param usedTraits                  Traits that have been locked in
 * @return Converted relational expression
 */
private RelNode completeConversion(
    RelNode rel,
    boolean allowInfiniteCostConverters,
    RelTraitSet toTraits,
    Expressions.FluentList<RelTraitDef> usedTraits) {
  if (true) {
    return rel;
  }
  for (RelTrait trait : rel.getTraitSet()) {
    if (toTraits.contains(trait)) {
      // We're already a match on this trait type.
      continue;
    }
    final RelTraitDef traitDef = trait.getTraitDef();
    RelNode rel2 =
        traitDef.convert(
            this,
            rel,
            toTraits.getTrait(traitDef),
            allowInfiniteCostConverters);

    // if any of the used traits have been knocked out, we could be
    // heading for a cycle.
    for (RelTraitDef usedTrait : usedTraits) {
      if (!rel2.getTraitSet().contains(usedTrait)) {
        continue;
      }
    }
    // recursive call, to convert one more trait
    rel =
        completeConversion(
            rel2,
            allowInfiniteCostConverters,
            toTraits,
            usedTraits.append(traitDef));
    if (rel != null) {
      return rel;
    }
  }
  assert rel.getTraitSet().equals(toTraits);
  return rel;
}