/** * Defines a method. */ StormBuiltInMethod(Class clazz, String methodName, Class... argumentTypes) { this(Types.lookupMethod(clazz, methodName, argumentTypes), null, null); }
/** * Defines a constructor. */ StormBuiltInMethod(Class clazz, Class... argumentTypes) { this(null, Types.lookupConstructor(clazz, argumentTypes), null); }
/** * Defines a field. */ StormBuiltInMethod(Class clazz, String fieldName, boolean dummy) { this(null, null, Types.lookupField(clazz, fieldName)); assert dummy : "dummy value for method overloading must be true"; } }
Expressions.methodDecl(Modifier.PUBLIC, void.class, StormBuiltInMethod.EXPR_EXECUTE2.method.getName(), ImmutableList.of(context, outputValues), block)); final BlockBuilder builder = new BlockBuilder(); final Expression values_ = builder.append("values", Expressions.newArrayBounds(Object.class, 1, Expressions.constant(1))); builder.add( Expressions.statement( Expressions.call( Expressions.parameter(ExecutableExpression.class, "this"), StormBuiltInMethod.EXPR_EXECUTE2.method, context, values_))); builder.add( Expressions.return_(null, Expressions.arrayIndex(values_, Expressions.constant(0)))); declarations.add( Expressions.methodDecl(Modifier.PUBLIC, Object.class, StormBuiltInMethod.EXPR_EXECUTE1.method.getName(), ImmutableList.of(context), builder.toBlock())); Expressions.classDecl(Modifier.PUBLIC, className, null, ImmutableList.<Type>of(ExecutableExpression.class), declarations); return Expressions.toString(Lists.newArrayList(classDeclaration), "\n", false);
@Override public Result implement(EnumerableRelImplementor implementor, Prefer pref) { PhysType physType = PhysTypeImpl.of(implementor.getTypeFactory(), getRowType(), pref.preferArray()); return implementor.result(physType, Blocks.toBlock( Expressions.call(table.getExpression(FlowFileTable.class), "project", Expressions.constant(fields)))); }
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()); ImmutableList.of( Pair.<Expression, PhysType>of( Expressions.field(context, BuiltInMethod.CONTEXT_VALUES.field), PhysTypeImpl.of(javaTypeFactory, inputRowType, 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))));
@Override public Result implement(EnumerableRelImplementor implementor, Prefer pref) { final BlockBuilder builder = new BlockBuilder(); Expression unionExp = null; for (Ord<RelNode> ord : Ord.zip(inputs)) { EnumerableRel input = (EnumerableRel) ord.e; final Result result = implementor.visitChild(this, ord.i, input, pref); Expression childExp = builder.append( "child" + ord.i, result.block); if (unionExp == null) { unionExp = childExp; } else { unionExp = createUnionExpression(unionExp, childExp, result.format == JavaRowFormat.ARRAY); } } builder.add(unionExp); final PhysType physType = PhysTypeImpl.of( implementor.getTypeFactory(), getRowType(), pref.prefer(JavaRowFormat.CUSTOM)); return implementor.result(physType, builder.toBlock()); } }
public BlockStatement compileToBlock(final RexProgram program) { final ParameterExpression context_ = Expressions.parameter(Context.class, "context"); final ParameterExpression outputValues_ = Expressions.parameter(Object[].class, "outputValues"); return compileToBlock(program, context_, outputValues_).toBlock(); }
private Expression createUnionExpression(Expression left, Expression right, boolean arrayInput) { if (all) { return Expressions.call(left, BuiltInMethod.CONCAT.method, right); } return arrayInput ? Expressions.call(left, unionArray, right, Expressions.call(arrayComparer)) : Expressions.call(left, BuiltInMethod.UNION.method, right); }
@Override public RelWriter explainTerms(final RelWriter pw) { return super.explainTerms(pw).item("fields", Primitive.asList(fields)); }
@Override public ForStatement accept(Shuttle shuttle) { shuttle = shuttle.preVisit(this); List<DeclarationStatement> decls1 = Expressions.acceptDeclarations(declarations, shuttle); final Expression condition1 = condition == null ? null : condition.accept(shuttle); final Expression post1 = post == null ? null : post.accept(shuttle); final Statement body1 = body.accept(shuttle); return shuttle.visit(this, decls1, condition1, post1, body1); }
/** * Creates a LambdaExpression by first constructing a delegate * type. */ public static <F extends Function<?>> FunctionExpression<F> lambda( BlockStatement body, Iterable<? extends ParameterExpression> parameters) { final List<ParameterExpression> parameterList = toList(parameters); @SuppressWarnings("unchecked") Class<F> type = deduceType(parameterList, body.getType()); return new FunctionExpression<>(type, body, parameterList); }
@Override public Result implement(EnumerableRelImplementor implementor, Prefer pref) { context.setReturnTupleInfo(rowType, columnRowType); String execFunction = genExecFunc(); PhysType physType = PhysTypeImpl.of(implementor.getTypeFactory(), getRowType(), JavaRowFormat.ARRAY); MethodCallExpression exprCall = Expressions.call(table.getExpression(OLAPTable.class), execFunction, implementor.getRootExpression(), Expressions.constant(context.id)); return implementor.result(physType, Blocks.toBlock(exprCall)); }
public String compile(final RexProgram program, String className) { final ParameterExpression context_ = Expressions.parameter(Context.class, "context"); final ParameterExpression outputValues_ = Expressions.parameter(Object[].class, "outputValues"); BlockBuilder builder = compileToBlock(program, context_, outputValues_); return baz(context_, outputValues_, builder.toBlock(), className); }
public KylinEnumerableUnion(RelOptCluster cluster, RelTraitSet traitSet, List<RelNode> inputs, boolean all) { super(cluster, traitSet, inputs, all); unionArray = Types.lookupMethod(ExtendedEnumerable.class, "union", Enumerable.class, EqualityComparer.class); arrayComparer = Types.lookupMethod(Functions.class, "arrayComparer"); }
@Override public RelWriter explainTerms(RelWriter pw) { return super.explainTerms(pw) .item("ctx", context == null ? "" : String.valueOf(context.id) + "@" + context.realization) .item("fields", Primitive.asList(fields)); }
@Override public Result implement(EnumerableRelImplementor implementor, Prefer pref) { context.setReturnTupleInfo(rowType, columnRowType); PhysType physType = PhysTypeImpl.of(implementor.getTypeFactory(), getRowType(), pref.preferArray()); RelOptTable factTable = context.firstTableScan.getTable(); MethodCallExpression exprCall = Expressions.call(factTable.getExpression(OLAPTable.class), "executeOLAPQuery", implementor.getRootExpression(), Expressions.constant(context.id)); return implementor.result(physType, Blocks.toBlock(exprCall)); }