Java Expressions.convert_方法代码示例

import org.apache.calcite.linq4j.tree.Expressions; //导入方法依赖的package包/类
private UnaryExpression getTimeZoneExpression(
        EnumerableRelImplementor implementor) {
    return Expressions.convert_(
            Expressions.call(
                    implementor.getRootExpression(),
                    "get",
                    Expressions.constant("timeZone")),
            TimeZone.class);
}
 

import org.apache.calcite.linq4j.tree.Expressions; //导入方法依赖的package包/类
private UnaryExpression getTimeZoneExpression(
    EnumerableRelImplementor implementor) {
  return Expressions.convert_(
      Expressions.call(
          implementor.getRootExpression(),
          "get",
          Expressions.constant("timeZone")),
      TimeZone.class);
}
 

import org.apache.calcite.linq4j.tree.Expressions; //导入方法依赖的package包/类
private static Expression getExpression(RexNode offset) {
  if (offset instanceof RexDynamicParam) {
    final RexDynamicParam param = (RexDynamicParam) offset;
    return Expressions.convert_(
        Expressions.call(DataContext.ROOT,
            BuiltInMethod.DATA_CONTEXT_GET.method,
            Expressions.constant("?" + param.getIndex())),
        Integer.class);
  } else {
    return Expressions.constant(RexLiteral.intValue(offset));
  }
}
 

import org.apache.calcite.linq4j.tree.Expressions; //导入方法依赖的package包/类
/** Converts from internal representation to JDBC representation used by
 * arguments of user-defined functions. For example, converts date values from
 * {@code int} to {@link java.sql.Date}. */
static Expression fromInternal(Expression e, Class<?> targetType) {
  if (e == ConstantUntypedNull.INSTANCE) {
    return e;
  }
  if (!(e.getType() instanceof Class)) {
    return e;
  }
  if (targetType.isAssignableFrom((Class) e.getType())) {
    return e;
  }
  if (targetType == java.sql.Date.class) {
    return Expressions.call(BuiltInMethod.INTERNAL_TO_DATE.method, e);
  }
  if (targetType == java.sql.Time.class) {
    return Expressions.call(BuiltInMethod.INTERNAL_TO_TIME.method, e);
  }
  if (targetType == java.sql.Timestamp.class) {
    return Expressions.call(BuiltInMethod.INTERNAL_TO_TIMESTAMP.method, e);
  }
  if (Primitive.is(e.type)
      && Primitive.isBox(targetType)) {
    // E.g. e is "int", target is "Long", generate "(long) e".
    return Expressions.convert_(e,
        Primitive.ofBox(targetType).primitiveClass);
  }
  return e;
}
 

import org.apache.calcite.linq4j.tree.Expressions; //导入方法依赖的package包/类
/** Converts a schema expression to a given type by calling the
 * {@link SchemaPlus#unwrap(Class)} method. */
public static Expression unwrap(Expression call, Class type) {
  return Expressions.convert_(
      Expressions.call(call, BuiltInMethod.SCHEMA_PLUS_UNWRAP.method,
          Expressions.constant(type)),
      type);
}
 

import org.apache.calcite.linq4j.tree.Expressions; //导入方法依赖的package包/类
private void generateGet(EnumerableRelImplementor implementor,
                         PhysType physType, BlockBuilder builder, ParameterExpression resultSet,
                         int i, Expression target, Expression calendar,
                         CalendarPolicy calendarPolicy) {
    final Primitive primitive = Primitive.ofBoxOr(physType.fieldClass(i));
    final RelDataType fieldType =
            physType.getRowType().getFieldList().get(i).getType();
    final List<Expression> dateTimeArgs = new ArrayList<Expression>();
    dateTimeArgs.add(Expressions.constant(i + 1));
    SqlTypeName sqlTypeName = fieldType.getSqlTypeName();
    boolean offset = false;
    switch (calendarPolicy) {
    case LOCAL:
        dateTimeArgs.add(calendar);
        break;
    case NULL:
        // We don't specify a calendar at all, so we don't add an argument and
        // instead use the version of the getXXX that doesn't take a Calendar
        break;
    case DIRECT:
        sqlTypeName = SqlTypeName.ANY;
        break;
    case SHIFT:
        switch (sqlTypeName) {
        case TIMESTAMP:
        case DATE:
            offset = true;
            break;
        default:
        }
        break;
    default:
    }
    final Expression source;
    switch (sqlTypeName) {
    case DATE:
    case TIME:
    case TIMESTAMP:
        source = Expressions.call(
                getMethod(sqlTypeName, fieldType.isNullable(), offset),
                Expressions.<Expression>list()
                        .append(
                                Expressions.call(resultSet,
                                        getMethod2(sqlTypeName), dateTimeArgs))
                        .appendIf(offset, getTimeZoneExpression(implementor)));
        break;
    case ARRAY:
        final Expression x = Expressions.convert_(
                Expressions.call(resultSet, jdbcGetMethod(primitive),
                        Expressions.constant(i + 1)),
                java.sql.Array.class);
        source = Expressions.call(BuiltInMethod.JDBC_ARRAY_TO_LIST.method, x);
        break;
    default:
        source = Expressions.call(
                resultSet, jdbcGetMethod(primitive), Expressions.constant(i + 1));
    }
    builder.add(
            Expressions.statement(
                    Expressions.assign(
                            target, source)));

    // [CALCITE-596] If primitive type columns contain null value, returns null
    // object
    if (primitive != null) {
        builder.add(
                Expressions.ifThen(
                        Expressions.call(resultSet, "wasNull"),
                        Expressions.statement(
                                Expressions.assign(target,
                                        Expressions.constant(null)))));
    }
}
 

import org.apache.calcite.linq4j.tree.Expressions; //导入方法依赖的package包/类
private void generateGet(EnumerableRelImplementor implementor,
    PhysType physType, BlockBuilder builder, ParameterExpression resultSet_,
    int i, Expression target, Expression calendar_,
    SqlDialect.CalendarPolicy calendarPolicy) {
  final Primitive primitive = Primitive.ofBoxOr(physType.fieldClass(i));
  final RelDataType fieldType =
      physType.getRowType().getFieldList().get(i).getType();
  final List<Expression> dateTimeArgs = new ArrayList<Expression>();
  dateTimeArgs.add(Expressions.constant(i + 1));
  SqlTypeName sqlTypeName = fieldType.getSqlTypeName();
  boolean offset = false;
  switch (calendarPolicy) {
  case LOCAL:
    dateTimeArgs.add(calendar_);
    break;
  case NULL:
    // We don't specify a calendar at all, so we don't add an argument and
    // instead use the version of the getXXX that doesn't take a Calendar
    break;
  case DIRECT:
    sqlTypeName = SqlTypeName.ANY;
    break;
  case SHIFT:
    switch (sqlTypeName) {
    case TIMESTAMP:
    case DATE:
      offset = true;
    }
    break;
  }
  final Expression source;
  switch (sqlTypeName) {
  case DATE:
  case TIME:
  case TIMESTAMP:
    source = Expressions.call(
        getMethod(sqlTypeName, fieldType.isNullable(), offset),
        Expressions.<Expression>list()
            .append(
                Expressions.call(resultSet_,
                    getMethod2(sqlTypeName), dateTimeArgs))
        .appendIf(offset, getTimeZoneExpression(implementor)));
    break;
  case ARRAY:
    final Expression x = Expressions.convert_(
        Expressions.call(resultSet_, jdbcGetMethod(primitive),
            Expressions.constant(i + 1)),
        java.sql.Array.class);
    source = Expressions.call(BuiltInMethod.JDBC_ARRAY_TO_LIST.method, x);
    break;
  default:
    source = Expressions.call(
        resultSet_, jdbcGetMethod(primitive), Expressions.constant(i + 1));
  }
  builder.add(
      Expressions.statement(
          Expressions.assign(
              target, source)));

  // [CALCITE-596] If primitive type columns contain null value, returns null
  // object
  if (primitive != null) {
    builder.add(
        Expressions.ifThen(
            Expressions.call(resultSet_, "wasNull"),
            Expressions.statement(
                Expressions.assign(target,
                    Expressions.constant(null)))));
  }
}