Java RexToLixTranslator类代码示例

import org.apache.calcite.adapter.enumerable.RexToLixTranslator; //导入依赖的package包/类
private static CallImplementor createImplementor(final Method method) {
  return RexImpTable.createImplementor(
      new ReflectiveCallNotNullImplementor(method) {
        public Expression implement(RexToLixTranslator translator,
            RexCall call, List<Expression> translatedOperands) {
          Expression expr = super.implement(translator, call,
              translatedOperands);
          final Class<?> returnType = method.getReturnType();
          if (QueryableTable.class.isAssignableFrom(returnType)) {
            Expression queryable = Expressions.call(
                Expressions.convert_(expr, QueryableTable.class),
                BuiltInMethod.QUERYABLE_TABLE_AS_QUERYABLE.method,
                Expressions.call(DataContext.ROOT,
                    BuiltInMethod.DATA_CONTEXT_GET_QUERY_PROVIDER.method),
                Expressions.constant(null, SchemaPlus.class),
                Expressions.constant(call.getOperator().getName(), String.class));
            expr = Expressions.call(queryable,
                BuiltInMethod.QUERYABLE_AS_ENUMERABLE.method);
          } else {
            expr = Expressions.call(expr,
                BuiltInMethod.SCANNABLE_TABLE_SCAN.method, DataContext.ROOT);
          }
          return expr;
        }
      }, NullPolicy.ANY, false);
}
 

import org.apache.calcite.adapter.enumerable.RexToLixTranslator; //导入依赖的package包/类
public Expression field(BlockBuilder list, int index, Type storageType) {
  MethodCallExpression recFromCtx = Expressions.call(
      DataContext.ROOT,
      BuiltInMethod.DATA_CONTEXT_GET.method,
      Expressions.constant("inputRecord"));
  Expression recFromCtxCasted =
      RexToLixTranslator.convert(recFromCtx, Object[].class);
  IndexExpression recordAccess = Expressions.arrayIndex(recFromCtxCasted,
      Expressions.constant(index));
  if (storageType == null) {
    final RelDataType fieldType =
        rowType.getFieldList().get(index).getType();
    storageType = ((JavaTypeFactory) typeFactory).getJavaClass(fieldType);
  }
  return RexToLixTranslator.convert(recordAccess, storageType);
}
 

import org.apache.calcite.adapter.enumerable.RexToLixTranslator; //导入依赖的package包/类
/**
 * Create quasi-Java expression from given {@link RexNode}
 *
 * @param node Expression in the form of {@link RexNode}
 * @param inputRowType Input Data type to expression in the form of {@link RelDataType}
 * @param outputRowType Output data type of expression in the form of {@link RelDataType}
 *
 * @return Returns quasi-Java expression
 */
public String getExpression(RexNode node, RelDataType inputRowType, RelDataType outputRowType)
{
  final RexProgramBuilder programBuilder = new RexProgramBuilder(inputRowType, rexBuilder);
  programBuilder.addProject(node, null);
  final RexProgram program = programBuilder.getProgram();

  final BlockBuilder builder = new BlockBuilder();
  final JavaTypeFactory javaTypeFactory = (JavaTypeFactory)rexBuilder.getTypeFactory();

  final RexToLixTranslator.InputGetter inputGetter = new RexToLixTranslator.InputGetterImpl(ImmutableList
      .of(Pair.<Expression, PhysType>of(Expressions.variable(Object[].class, "inputValues"),
      PhysTypeImpl.of(javaTypeFactory, inputRowType, JavaRowFormat.ARRAY, false))));
  final Function1<String, RexToLixTranslator.InputGetter> correlates =
      new Function1<String, RexToLixTranslator.InputGetter>()
    {
      public RexToLixTranslator.InputGetter apply(String a0)
      {
        throw new UnsupportedOperationException();
      }
    };

  final List<Expression> list = RexToLixTranslator.translateProjects(program, javaTypeFactory, builder,
      PhysTypeImpl.of(javaTypeFactory, outputRowType, JavaRowFormat.ARRAY, false), null, inputGetter, correlates);

  for (int i = 0; i < list.size(); i++) {
    Statement statement = Expressions.statement(list.get(i));
    builder.add(statement);
  }

  return finalizeExpression(builder.toBlock(), inputRowType);
}
 

import org.apache.calcite.adapter.enumerable.RexToLixTranslator; //导入依赖的package包/类
private BlockBuilder compileToBlock(final RexProgram program, ParameterExpression context_,
                                      ParameterExpression outputValues_) {
  RelDataType inputRowType = program.getInputRowType();
  final BlockBuilder builder = new BlockBuilder();
  final JavaTypeFactoryImpl javaTypeFactory =
          new JavaTypeFactoryImpl(rexBuilder.getTypeFactory().getTypeSystem());

  final RexToLixTranslator.InputGetter inputGetter =
          new RexToLixTranslator.InputGetterImpl(
                  ImmutableList.of(
                          Pair.<Expression, PhysType>of(
                                  Expressions.field(context_,
                                          BuiltInMethod.CONTEXT_VALUES.field),
                                  PhysTypeImpl.of(javaTypeFactory, inputRowType,
                                          JavaRowFormat.ARRAY, false))));
  final Function1<String, RexToLixTranslator.InputGetter> correlates =
          new Function1<String, RexToLixTranslator.InputGetter>() {
            public RexToLixTranslator.InputGetter apply(String a0) {
              throw new UnsupportedOperationException();
            }
          };
  final Expression root =
          Expressions.field(context_, BuiltInMethod.CONTEXT_ROOT.field);
  final List<Expression> list =
          RexToLixTranslator.translateProjects(program, javaTypeFactory, builder,
                  null, root, inputGetter, correlates);
  for (int i = 0; i < list.size(); i++) {
    builder.add(
            Expressions.statement(
                    Expressions.assign(
                            Expressions.arrayIndex(outputValues_,
                                    Expressions.constant(i)),
                            list.get(i))));
  }

  return builder;
}
 

import org.apache.calcite.adapter.enumerable.RexToLixTranslator; //导入依赖的package包/类
@Override public String visitLiteral(RexLiteral literal) {
  if (literal.getValue() == null) {
    return "null";
  }
  return "{$literal: "
      + RexToLixTranslator.translateLiteral(literal, literal.getType(),
          typeFactory, RexImpTable.NullAs.NOT_POSSIBLE)
      + "}";
}
 

import org.apache.calcite.adapter.enumerable.RexToLixTranslator; //导入依赖的package包/类
@Override public String visitLiteral(RexLiteral literal) {
  if (literal.getValue() == null) {
    return "null";
  }
  return "\"literal\":\""
    + RexToLixTranslator.translateLiteral(literal, literal.getType(),
      typeFactory, RexImpTable.NullAs.NOT_POSSIBLE)
    + "\"";
}
 

import org.apache.calcite.adapter.enumerable.RexToLixTranslator; //导入依赖的package包/类
private String compile(RexBuilder rexBuilder, List<RexNode> constExps,
    RexToLixTranslator.InputGetter getter, RelDataType rowType) {
  final RexProgramBuilder programBuilder =
      new RexProgramBuilder(rowType, rexBuilder);
  for (RexNode node : constExps) {
    programBuilder.addProject(
        node, "c" + programBuilder.getProjectList().size());
  }
  final JavaTypeFactoryImpl javaTypeFactory =
      new JavaTypeFactoryImpl(rexBuilder.getTypeFactory().getTypeSystem());
  final BlockBuilder blockBuilder = new BlockBuilder();
  final ParameterExpression root0_ =
      Expressions.parameter(Object.class, "root0");
  final ParameterExpression root_ = DataContext.ROOT;
  blockBuilder.add(
      Expressions.declare(
          Modifier.FINAL, root_,
          Expressions.convert_(root0_, DataContext.class)));
  final List<Expression> expressions =
      RexToLixTranslator.translateProjects(programBuilder.getProgram(),
      javaTypeFactory, blockBuilder, null, root_, getter, null);
  blockBuilder.add(
      Expressions.return_(null,
          Expressions.newArrayInit(Object[].class, expressions)));
  final MethodDeclaration methodDecl =
      Expressions.methodDecl(Modifier.PUBLIC, Object[].class,
          BuiltInMethod.FUNCTION1_APPLY.method.getName(),
          ImmutableList.of(root0_), blockBuilder.toBlock());
  String code = Expressions.toString(methodDecl);
  if (CalcitePrepareImpl.DEBUG) {
    Util.debugCode(System.out, code);
  }
  return code;
}
 

import org.apache.calcite.adapter.enumerable.RexToLixTranslator; //导入依赖的package包/类
/**
 * Do constant reduction using generated code.
 */
public void reduce(RexBuilder rexBuilder, List<RexNode> constExps,
    List<RexNode> reducedValues) {
  final String code = compile(rexBuilder, constExps,
      new RexToLixTranslator.InputGetter() {
        public Expression field(BlockBuilder list, int index,
            Type storageType) {
          throw new UnsupportedOperationException();
        }
      });

  final RexExecutable executable = new RexExecutable(code, constExps);
  executable.setDataContext(dataContext);
  executable.reduce(rexBuilder, constExps, reducedValues);
}
 

import org.apache.calcite.adapter.enumerable.RexToLixTranslator; //导入依赖的package包/类
@Override public CallImplementor getImplementor() {
  return new CallImplementor() {
    public Expression implement(RexToLixTranslator translator, RexCall call, NullAs nullAs) {
      Method lookupMethod =
          Types.lookupMethod(Smalls.AllTypesFunction.class,
              "arrayAppendFun", List.class, Integer.class);
      return Expressions.call(lookupMethod,
          translator.translateList(call.getOperands(), nullAs));
    }
  };
}
 

import org.apache.calcite.adapter.enumerable.RexToLixTranslator; //导入依赖的package包/类
public RexNode toRex(Expression expression) {
  switch (expression.getNodeType()) {
  case MemberAccess:
    // Case-sensitive name match because name was previously resolved.
    return rexBuilder.makeFieldAccess(
        toRex(
            ((MemberExpression) expression).expression),
        ((MemberExpression) expression).field.getName(),
        true);
  case GreaterThan:
    return binary(expression, SqlStdOperatorTable.GREATER_THAN);
  case LessThan:
    return binary(expression, SqlStdOperatorTable.LESS_THAN);
  case Parameter:
    return parameter((ParameterExpression) expression);
  case Call:
    MethodCallExpression call = (MethodCallExpression) expression;
    SqlOperator operator =
        RexToLixTranslator.JAVA_TO_SQL_METHOD_MAP.get(call.method);
    if (operator != null) {
      return rexBuilder.makeCall(
          type(call),
          operator,
          toRex(
              Expressions.<Expression>list()
                  .appendIfNotNull(call.targetExpression)
                  .appendAll(call.expressions)));
    }
    throw new RuntimeException(
        "Could translate call to method " + call.method);
  case Constant:
    final ConstantExpression constant =
        (ConstantExpression) expression;
    Object value = constant.value;
    if (value instanceof Number) {
      Number number = (Number) value;
      if (value instanceof Double || value instanceof Float) {
        return rexBuilder.makeApproxLiteral(
            BigDecimal.valueOf(number.doubleValue()));
      } else if (value instanceof BigDecimal) {
        return rexBuilder.makeExactLiteral((BigDecimal) value);
      } else {
        return rexBuilder.makeExactLiteral(
            BigDecimal.valueOf(number.longValue()));
      }
    } else if (value instanceof Boolean) {
      return rexBuilder.makeLiteral((Boolean) value);
    } else {
      return rexBuilder.makeLiteral(constant.toString());
    }
  default:
    throw new UnsupportedOperationException(
        "unknown expression type " + expression.getNodeType() + " "
        + expression);
  }
}
 

import org.apache.calcite.adapter.enumerable.RexToLixTranslator; //导入依赖的package包/类
public Result implementSpark(Implementor implementor) {
/*
            return Linq4j.asSpark(
                new Object[][] {
                    new Object[] {1, 2},
                    new Object[] {3, 4}
                });
*/
      final JavaTypeFactory typeFactory =
          (JavaTypeFactory) getCluster().getTypeFactory();
      final BlockBuilder builder = new BlockBuilder();
      final PhysType physType =
          PhysTypeImpl.of(implementor.getTypeFactory(),
              getRowType(),
              JavaRowFormat.CUSTOM);
      final Type rowClass = physType.getJavaRowType();

      final List<Expression> expressions = new ArrayList<Expression>();
      final List<RelDataTypeField> fields = rowType.getFieldList();
      for (List<RexLiteral> tuple : tuples) {
        final List<Expression> literals = new ArrayList<Expression>();
        for (Pair<RelDataTypeField, RexLiteral> pair
            : Pair.zip(fields, tuple)) {
          literals.add(
              RexToLixTranslator.translateLiteral(
                  pair.right,
                  pair.left.getType(),
                  typeFactory,
                  RexImpTable.NullAs.NULL));
        }
        expressions.add(physType.record(literals));
      }
      builder.add(
          Expressions.return_(null,
              Expressions.call(SparkMethod.ARRAY_TO_RDD.method,
                  Expressions.call(SparkMethod.GET_SPARK_CONTEXT.method,
                      implementor.getRootExpression()),
                  Expressions.newArrayInit(Primitive.box(rowClass),
                      expressions))));
      return implementor.result(physType, builder.toBlock());
    }
 

import org.apache.calcite.adapter.enumerable.RexToLixTranslator; //导入依赖的package包/类
public final RexToLixTranslator rowTranslator() {
  return rowTranslator(
      computeIndex(Expressions.constant(0),
          WinAggImplementor.SeekType.AGG_INDEX));
}
 

import org.apache.calcite.adapter.enumerable.RexToLixTranslator; //导入依赖的package包/类
public RexToLixTranslator rowTranslator(Expression rowIndex) {
  return getFrame().rowTranslator(rowIndex)
      .setNullable(currentNullables());
}
 

import org.apache.calcite.adapter.enumerable.RexToLixTranslator; //导入依赖的package包/类
public Expression implement(RexToLixTranslator translator,
    RexCall call, List<Expression> operands) {
  return Expressions.call(GET_COMPLETION_HINTS,
      Iterables.concat(Collections.singleton(ADVISOR), operands));
}
 

import org.apache.calcite.adapter.enumerable.RexToLixTranslator; //导入依赖的package包/类
public Scalar compile(List<RexNode> nodes, RelDataType inputRowType) {
  final RexProgramBuilder programBuilder =
      new RexProgramBuilder(inputRowType, rexBuilder);
  for (RexNode node : nodes) {
    programBuilder.addProject(node, null);
  }
  final RexProgram program = programBuilder.getProgram();

  final BlockBuilder builder = new BlockBuilder();
  final ParameterExpression context_ =
      Expressions.parameter(Context.class, "context");
  final ParameterExpression outputValues_ =
      Expressions.parameter(Object[].class, "outputValues");
  final JavaTypeFactoryImpl javaTypeFactory =
      new JavaTypeFactoryImpl(rexBuilder.getTypeFactory().getTypeSystem());

  // public void execute(Context, Object[] outputValues)
  final RexToLixTranslator.InputGetter inputGetter =
      new RexToLixTranslator.InputGetterImpl(
          ImmutableList.of(
              Pair.<Expression, PhysType>of(
                  Expressions.field(context_,
                      BuiltInMethod.CONTEXT_VALUES.field),
                  PhysTypeImpl.of(javaTypeFactory, inputRowType,
                      JavaRowFormat.ARRAY, false))));
  final Function1<String, RexToLixTranslator.InputGetter> correlates =
      new Function1<String, RexToLixTranslator.InputGetter>() {
        public RexToLixTranslator.InputGetter apply(String a0) {
          throw new UnsupportedOperationException();
        }
      };
  final Expression root =
      Expressions.field(context_, BuiltInMethod.CONTEXT_ROOT.field);
  final List<Expression> list =
      RexToLixTranslator.translateProjects(program, javaTypeFactory, builder,
          null, root, inputGetter, correlates);
  for (int i = 0; i < list.size(); i++) {
    builder.add(
        Expressions.statement(
            Expressions.assign(
                Expressions.arrayIndex(outputValues_,
                    Expressions.constant(i)),
                list.get(i))));
  }
  return baz(context_, outputValues_, builder.toBlock());
}