@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)))); }
public static BlockStatement toFunctionBlock(Node body) { return toFunctionBlock(body, true); }
private static List<Expression> simpleList(BlockStatement statement) { Expression simple = Blocks.simple(statement); if (simple instanceof NewExpression) { NewExpression newExpression = (NewExpression) simple; return newExpression.arguments; } else { return Collections.singletonList(simple); } }
public static BlockStatement toBlock(Node body) { return toFunctionBlock(body, false); }
private static List<Expression> simpleList(BlockStatement statement) { Expression simple = Blocks.simple(statement); if (simple instanceof NewExpression) { NewExpression newExpression = (NewExpression) simple; return newExpression.arguments; } else { return Collections.singletonList(simple); } }
@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)); }
/** * Creates an Expression where the delegate type {@code F} is * known at compile time. */ public static <F extends Function<?>> FunctionExpression<F> lambda( Expression body, Iterable<? extends ParameterExpression> parameters) { return lambda(Blocks.toFunctionBlock(body), parameters); }
private static List<Expression> simpleList(BlockStatement statement) { Expression simple = Blocks.simple(statement); if (simple instanceof NewExpression) { NewExpression newExpression = (NewExpression) simple; return newExpression.arguments; } else { return Collections.singletonList(simple); } }
@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)); }
/** * Creates a LambdaExpression by first constructing a delegate * type. * * <p>It can be used when the delegate type is not known at compile time. */ public static <T, F extends Function<? extends T>> FunctionExpression<F> lambda( Class<F> type, Expression body, Iterable<? extends ParameterExpression> parameters) { return lambda(type, Blocks.toFunctionBlock(body), toList(parameters)); }
public RexNode toRex(BlockStatement statement) { return toRex(Blocks.simple(statement)); }
@Override void accept(ExpressionWriter writer, int lprec, int rprec) { for (int i = 0; i < expressionList.size(); i += 2) { writer.append(i > 0 ? " else if (" : "if (") .append(expressionList.get(i)) .append(") ") .append(Blocks.toBlock(expressionList.get(i + 1))); } if (expressionList.size() % 2 == 1) { writer.append(" else ") .append( Blocks.toBlock(expressionList.get(expressionList.size() - 1))); } }
/** * Creates an Expression where the delegate type {@code F} is * known at compile time, using varargs. */ public static <F extends Function<?>> FunctionExpression<F> lambda( Expression body, ParameterExpression... parameters) { return lambda(Blocks.toFunctionBlock(body), toList(parameters)); }
public RexNode toRex(BlockStatement statement) { return toRex(Blocks.simple(statement)); }
@Override void accept0(ExpressionWriter writer) { writer.append("try ").append(Blocks.toBlock(body)); for (CatchBlock catchBlock : catchBlocks) { writer.backUp(); writer.append(" catch (").append(catchBlock.parameter.declString()) .append(") ").append(Blocks.toBlock(catchBlock.body)); } if (fynally != null) { writer.backUp(); writer.append(" finally ").append(Blocks.toBlock(fynally)); } }
/** * Creates a LambdaExpression by first constructing a delegate * type, using varargs. * * <p>It can be used when the delegate type is not known at compile time. */ public static <T, F extends Function<? extends T>> FunctionExpression<F> lambda( Class<F> type, Expression body, ParameterExpression... parameters) { return lambda(type, Blocks.toFunctionBlock(body), toList(parameters)); }
public RexNode toRex(BlockStatement statement) { return toRex(Blocks.simple(statement)); }
@Override void accept0(ExpressionWriter writer) { for (int i = 0; i < expressionList.size() - 1; i += 2) { if (i > 0) { writer.backUp(); writer.append(" else "); } writer.append("if (") .append(expressionList.get(i)) .append(") ") .append(Blocks.toBlock(expressionList.get(i + 1))); } if (expressionList.size() % 2 == 1) { writer.backUp(); writer.append(" else ") .append(Blocks.toBlock(last(expressionList))); } }
BuiltInMethod.TYPED_GET_ELEMENT_TYPE.method.getName(), ImmutableList.of(), Blocks.toFunctionBlock( Expressions.return_(null, Expressions.constant(result.physType.getJavaRowType())))));
private List<RexNode> toRex( RelNode child, FunctionExpression expression) { RexBuilder rexBuilder = cluster.getRexBuilder(); List<RexNode> list = Collections.singletonList( rexBuilder.makeRangeReference(child)); CalcitePrepareImpl.ScalarTranslator translator = CalcitePrepareImpl.EmptyScalarTranslator .empty(rexBuilder) .bind(expression.parameterList, list); final List<RexNode> rexList = new ArrayList<>(); final Expression simple = Blocks.simple(expression.body); for (Expression expression1 : fieldExpressions(simple)) { rexList.add(translator.toRex(expression1)); } return rexList; }