final Expression values_ = builder.append("values", Expressions.newArrayBounds(Object.class, 1, Expressions.constant(1))); builder.add( Expressions.statement( builder.add( Expressions.return_(null, Expressions.arrayIndex(values_, Expressions.constant(0)))); declarations.add( Expressions.methodDecl(Modifier.PUBLIC, Object.class,
@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)))); }
Expressions.assign( Expressions.arrayIndex(outputValues, Expressions.constant(i)), list.get(i))));
@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)); }
@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)); }
@Override protected Expression computeNewRank(Expression acc, WinAggAddContext add) { return Expressions.add(acc, Expressions.constant(1)); } }
/** Normalizes a TIME value into 00:00:00..23:59:39. */ private Expression normalize(SqlTypeName typeName, Expression e) { switch (typeName) { case TIME: return Expressions.call(BuiltInMethod.FLOOR_MOD.method, e, Expressions.constant(DateTimeUtils.MILLIS_PER_DAY)); default: return e; } } }
/** Normalizes a TIME value into 00:00:00..23:59:39. */ private Expression normalize(SqlTypeName typeName, Expression e) { switch (typeName) { case TIME: return Expressions.call(BuiltInMethod.FLOOR_MOD.method, e, Expressions.constant(DateTimeUtils.MILLIS_PER_DAY)); default: return e; } } }
@Override protected Expression implementNotNullResult( WinAggContext info, WinAggResultContext result) { // Rank is 1-based return Expressions.add(super.implementNotNullResult(info, result), Expressions.constant(1)); } }
@Override protected Expression implementNotNullResult( WinAggContext info, WinAggResultContext result) { // Rank is 1-based return Expressions.add(super.implementNotNullResult(info, result), Expressions.constant(1)); } }
/** 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); }
@Override protected void implementNotNullReset(AggContext info, AggResetContext reset) { Expression start = info.returnType() == BigDecimal.class ? Expressions.constant(BigDecimal.ZERO) : Expressions.constant(0); reset.currentBlock().add( Expressions.statement( Expressions.assign(reset.accumulator().get(0), start))); }
private Expression call(Expression operand, Type type, TimeUnit timeUnit) { return Expressions.call(SqlFunctions.class, methodName, Types.castIfNecessary(type, operand), Types.castIfNecessary(type, Expressions.constant(timeUnit.multiplier))); } }
private UnaryExpression getTimeZoneExpression( EnumerableRelImplementor implementor) { return Expressions.convert_( Expressions.call( implementor.getRootExpression(), "get", Expressions.constant("timeZone")), TimeZone.class); }
public Expression field(Expression expression, int field, Type fromType, Type fieldType) { final MethodCallExpression e = Expressions.call(expression, BuiltInMethod.LIST_GET.method, Expressions.constant(field)); if (fromType == null) { fromType = e.getType(); } return RexToLixTranslator.convert(e, fromType, fieldType); } },
@Override public void implementAdd(AggContext info, AggAddContext add) { final SqlJsonObjectAggAggFunction function = (SqlJsonObjectAggAggFunction) info.aggregation(); add.currentBlock().add( Expressions.statement( Expressions.call(m, Iterables.concat( Collections.singletonList(add.accumulator().get(0)), add.arguments(), Collections.singletonList( Expressions.constant(function.getNullClause())))))); }
@Override protected Expression implementNotNullResult( WinAggContext info, WinAggResultContext result) { // Window cannot be empty since ROWS/RANGE is not possible for ROW_NUMBER return Expressions.add( Expressions.subtract(result.index(), result.startIndex()), Expressions.constant(1)); } }
/** Translates a parameter. */ private Expression translateParameter(RexDynamicParam expr, RexImpTable.NullAs nullAs, Type storageType) { if (storageType == null) { storageType = typeFactory.getJavaClass(expr.getType()); } return nullAs.handle( convert( Expressions.call(root, BuiltInMethod.DATA_CONTEXT_GET.method, Expressions.constant("?" + expr.getIndex())), storageType)); }
public Expression implementResult(AggContext info, AggResultContext result) { WinAggResultContext winResult = (WinAggResultContext) result; return Expressions.condition(winResult.hasRows(), winResult.rowTranslator( winResult.computeIndex(Expressions.constant(0), seekType)) .translate(winResult.rexArguments().get(0), info.returnType()), getDefaultValue(info.returnType())); } }
@Override protected void implementNotNullReset(AggContext info, AggResetContext reset) { Expression acc = reset.accumulator().get(0); Primitive p = Primitive.of(acc.getType()); boolean isMin = MIN == info.aggregation(); Object inf = p == null ? null : (isMin ? p.max : p.min); reset.currentBlock().add( Expressions.statement( Expressions.assign(acc, Expressions.constant(inf, acc.getType())))); }