Java Expressions.list方法代码示例

import org.apache.calcite.linq4j.tree.Expressions; //导入方法依赖的package包/类
/** @see #dispatch */
public Result visit(Sort e) {
  Result x = visitChild(0, e.getInput());
  Builder builder = x.builder(e, Clause.ORDER_BY);
  List<SqlNode> orderByList = Expressions.list();
  for (RelFieldCollation field : e.getCollation().getFieldCollations()) {
    builder.addOrderItem(orderByList, field);
  }
  if (!orderByList.isEmpty()) {
    builder.setOrderBy(new SqlNodeList(orderByList, POS));
    x = builder.result();
  }
  if (e.fetch != null) {
    builder = x.builder(e, Clause.FETCH);
    builder.setFetch(builder.context.toSql(null, e.fetch));
    x = builder.result();
  }
  if (e.offset != null) {
    builder = x.builder(e, Clause.OFFSET);
    builder.setOffset(builder.context.toSql(null, e.offset));
    x = builder.result();
  }
  return x;
}
 

import org.apache.calcite.linq4j.tree.Expressions; //导入方法依赖的package包/类
/**
 * Creates a result based on a join. (Each join could contain one or more
 * relational expressions.)
 */
public Result result(SqlNode join, Result leftResult, Result rightResult) {
    final List<Pair<String, RelDataType>> list = new ArrayList<>();
    list.addAll(leftResult.aliases);
    list.addAll(rightResult.aliases);
    return new Result(join, Expressions.list(Clause.FROM), null, list);
}
 

import org.apache.calcite.linq4j.tree.Expressions; //导入方法依赖的package包/类
/**
 * Converts a call to an aggregate function to an expression.
 */
final SqlNode toSql(AggregateCall aggCall) {
    SqlOperator op = aggCall.getAggregation();
    if (op instanceof SqlSumEmptyIsZeroAggFunction) {
        op = SqlStdOperatorTable.SUM;
    }
    final List<SqlNode> operands = Expressions.list();
    for (int arg : aggCall.getArgList()) {
        operands.add(field(arg));
    }
    return op.createCall(
            aggCall.isDistinct() ? SqlSelectKeyword.DISTINCT.symbol(POS) : null,
            POS, operands.toArray(new SqlNode[operands.size()]));
}
 

import org.apache.calcite.linq4j.tree.Expressions; //导入方法依赖的package包/类
private Result(SqlNode node, Collection<Clause> clauses, String neededAlias,
               List<Pair<String, RelDataType>> aliases) {
    this.node = node;
    this.neededAlias = neededAlias;
    this.aliases = aliases;
    this.clauses = Expressions.list(clauses);
}
 

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包/类
private static JdbcImplementor.Result setOpToSql(JdbcImplementor implementor,
                                                 SqlSetOperator operator, JdbcRel rel) {
    List<SqlNode> list = Expressions.list();
    for (Ord<RelNode> input : Ord.zip(rel.getInputs())) {
        final JdbcImplementor.Result result =
                implementor.visitChild(input.i, input.e);
        list.add(result.asSelect());
    }
    final SqlCall node = operator.createCall(new SqlNodeList(list, POS));
    final List<JdbcImplementor.Clause> clauses =
            Expressions.list(JdbcImplementor.Clause.SET_OP);
    return implementor.result(node, clauses, rel);
}
 

import org.apache.calcite.linq4j.tree.Expressions; //导入方法依赖的package包/类
public JdbcImplementor.Result implement(JdbcImplementor implementor) {
    // "select a, b, sum(x) from ( ... ) group by a, b"
    final JdbcImplementor.Result x = implementor.visitChild(0, getInput());
    final JdbcImplementor.Builder builder =
            x.builder(this, JdbcImplementor.Clause.GROUP_BY);
    List<SqlNode> groupByList = Expressions.list();
    final List<SqlNode> selectList = new ArrayList<>();
    for (int group : groupSet) {
        final SqlNode field = builder.getContext().field(group);
        addSelect(selectList, field, getRowType());
        groupByList.add(field);
    }
    for (AggregateCall aggCall : aggCalls) {
        SqlNode aggCallSqlNode = builder.getContext().toSql(aggCall);
        if (aggCall.getAggregation() instanceof SqlSingleValueAggFunction) {
            aggCallSqlNode =
                    rewriteSingleValueExpr(aggCallSqlNode, implementor.getDialect());
        }
        addSelect(selectList, aggCallSqlNode, getRowType());
    }
    builder.setSelect(new SqlNodeList(selectList, POS));
    if (!groupByList.isEmpty() || aggCalls.isEmpty()) {
        // Some databases don't support "GROUP BY ()". We can omit it as long
        // as there is at least one aggregate function.
        builder.setGroupBy(new SqlNodeList(groupByList, POS));
    }
    return builder.result();
}
 

import org.apache.calcite.linq4j.tree.Expressions; //导入方法依赖的package包/类
/**
 * Creates a result based on a join. (Each join could contain one or more
 * relational expressions.)
 */
public Result result(SqlNode join, Result leftResult, Result rightResult) {
  final List<Pair<String, RelDataType>> list =
      new ArrayList<Pair<String, RelDataType>>();
  list.addAll(leftResult.aliases);
  list.addAll(rightResult.aliases);
  return new Result(join, Expressions.list(Clause.FROM), null, list);
}
 

import org.apache.calcite.linq4j.tree.Expressions; //导入方法依赖的package包/类
public Result visitAggregate(Aggregate e) {
  // "select a, b, sum(x) from ( ... ) group by a, b"
  final Result x = visitChild(0, e.getInput());
  final Builder builder =
      x.builder(e, Clause.GROUP_BY);
  List<SqlNode> groupByList = Expressions.list();
  final List<SqlNode> selectList = new ArrayList<>();
  for (int group : e.getGroupSet()) {
    final SqlNode field = builder.context.field(group);
    addSelect(selectList, field, e.getRowType());
    groupByList.add(field);
  }
  for (AggregateCall aggCall : e.getAggCallList()) {
    SqlNode aggCallSqlNode = builder.context.toSql(aggCall);
    if (aggCall.getAggregation() instanceof SqlSingleValueAggFunction) {
      aggCallSqlNode =
          rewriteSingleValueExpr(aggCallSqlNode, dialect);
    }
    addSelect(selectList, aggCallSqlNode, e.getRowType());
  }
  builder.setSelect(new SqlNodeList(selectList, POS));
  if (!groupByList.isEmpty() || e.getAggCallList().isEmpty()) {
    // Some databases don't support "GROUP BY ()". We can omit it as long
    // as there is at least one aggregate function.
    builder.setGroupBy(new SqlNodeList(groupByList, POS));
  }
  return builder.result();
}
 

import org.apache.calcite.linq4j.tree.Expressions; //导入方法依赖的package包/类
private Result setOpToSql(SqlSetOperator operator, RelNode rel) {
  List<SqlNode> list = Expressions.list();
  for (Ord<RelNode> input : Ord.zip(rel.getInputs())) {
    final Result result = this.visitChild(input.i, input.e);
    list.add(result.asSelect());
  }
  final SqlCall node = operator.createCall(new SqlNodeList(list, POS));
  final List<Clause> clauses =
      Expressions.list(Clause.SET_OP);
  return result(node, clauses, rel);
}
 

import org.apache.calcite.linq4j.tree.Expressions; //导入方法依赖的package包/类
/**
 * Converts a call to an aggregate function to an expression.
 */
public SqlNode toSql(AggregateCall aggCall) {
  SqlOperator op = (SqlAggFunction) aggCall.getAggregation();
  if (op instanceof SqlSumEmptyIsZeroAggFunction) {
    op = SqlStdOperatorTable.SUM;
  }
  final List<SqlNode> operands = Expressions.list();
  for (int arg : aggCall.getArgList()) {
    operands.add(field(arg));
  }
  return op.createCall(
      aggCall.isDistinct() ? SqlSelectKeyword.DISTINCT.symbol(POS) : null,
      POS, operands.toArray(new SqlNode[operands.size()]));
}
 

import org.apache.calcite.linq4j.tree.Expressions; //导入方法依赖的package包/类
private Result(SqlNode node, Collection<Clause> clauses, String neededAlias,
               List<Pair<String, RelDataType>> aliases) {
  this.node = node;
  this.neededAlias = neededAlias;
  this.aliases = aliases;
  this.clauses = Expressions.list(clauses);
}
 

import org.apache.calcite.linq4j.tree.Expressions; //导入方法依赖的package包/类
public Result setOpToSql(SqlSetOperator operator, RelNode rel) {
  SqlNode node = null;
  for (Ord<RelNode> input : Ord.zip(rel.getInputs())) {
    final Result result = visitChild(input.i, input.e);
    if (node == null) {
      node = result.asSelect();
    } else {
      node = operator.createCall(POS, node, result.asSelect());
    }
  }
  final List<Clause> clauses =
      Expressions.list(Clause.SET_OP);
  return result(node, clauses, rel, null);
}
 

import org.apache.calcite.linq4j.tree.Expressions; //导入方法依赖的package包/类
/** Creates a result based on a join. (Each join could contain one or more
 * relational expressions.) */
public Result result(SqlNode join, Result leftResult, Result rightResult) {
  final ImmutableMap.Builder<String, RelDataType> builder =
      ImmutableMap.builder();
  collectAliases(builder, join,
      Iterables.concat(leftResult.aliases.values(),
          rightResult.aliases.values()).iterator());
  return new Result(join, Expressions.list(Clause.FROM), null, null,
      builder.build());
}
 

import org.apache.calcite.linq4j.tree.Expressions; //导入方法依赖的package包/类
/** Converts a call to an aggregate function to an expression. */
public SqlNode toSql(AggregateCall aggCall) {
  SqlOperator op = aggCall.getAggregation();
  if (op instanceof SqlSumEmptyIsZeroAggFunction) {
    op = SqlStdOperatorTable.SUM;
  }
  final List<SqlNode> operands = Expressions.list();
  for (int arg : aggCall.getArgList()) {
    operands.add(field(arg));
  }
  return op.createCall(
      aggCall.isDistinct() ? SqlSelectKeyword.DISTINCT.symbol(POS) : null,
      POS, operands.toArray(new SqlNode[operands.size()]));
}