Expressions.methodDecl(Modifier.PUBLIC, void.class, StormBuiltInMethod.EXPR_EXECUTE2.method.getName(), ImmutableList.of(context, outputValues), block)); 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);
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, 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) { 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)))); }
RelFieldCollation collation = collations.get(0); ParameterExpression parameter = Expressions.parameter(javaRowClass, "v"); selector = Expressions.lambda( Function1.class, fieldReference(parameter, collation.getFieldIndex()), parameter); return Pair.of(selector, Expressions.call( BuiltInMethod.NULLS_COMPARATOR.method, Expressions.constant( collation.nullDirection == RelFieldCollation.NullDirection.FIRST), Expressions.constant( collation.getDirection() == RelFieldCollation.Direction.DESCENDING))); Expressions.call(BuiltInMethod.IDENTITY_SELECTOR.method); Expressions.parameter(javaRowClass, "v0"); final ParameterExpression parameterV1 = Expressions.parameter(javaRowClass, "v1"); final ParameterExpression parameterC = Expressions.parameter(int.class, "c"); final int mod = collations.size() == 1 ? Modifier.FINAL : 0; body.add(Expressions.declare(mod, parameterC, null)); for (RelFieldCollation collation : collations) { final int index = collation.getFieldIndex();
Expressions.parameter(int.class, builder.newName("prevStart")); ParameterExpression prevEnd = Expressions.parameter(int.class, builder.newName("prevEnd")); builder.add(Expressions.declare(0, prevStart, null)); builder.add(Expressions.declare(0, prevEnd, null)); builder.append( "list", Expressions.new_( ArrayList.class, Expressions.call( collectionExpr, BuiltInMethod.COLLECTION_SIZE.method)), false); builder3.append( "rows", Expressions.convert_( Expressions.call( iterator_, BuiltInMethod.ITERATOR_NEXT.method), Object[].class), Expressions.statement( Expressions.assign(prevStart, Expressions.constant(-1)))); builder3.add( Expressions.statement( Expressions.assign(prevEnd, Expressions.constant(Integer.MAX_VALUE))));
private ClassDeclaration classDecl( JavaTypeFactoryImpl.SyntheticRecordType type) { ClassDeclaration classDeclaration = Expressions.classDecl( Modifier.PUBLIC | Modifier.STATIC, type.getName(), Expressions.fieldDecl( field.getModifiers(), Expressions.parameter( field.getType(), field.getName()), null)); final List<ParameterExpression> parameters = new ArrayList<>(); final ParameterExpression thisParameter = Expressions.parameter(type, "this"); Expressions.constructorDecl( Modifier.PUBLIC, type, Expressions.parameter(type, "that"); final ParameterExpression oParameter = Expressions.parameter(Object.class, "o"); blockBuilder2.add( Expressions.ifThen( Expressions.equal(thisParameter, oParameter), Expressions.return_(null, Expressions.constant(true)))); blockBuilder2.add( Expressions.ifThen(
builder0.append("sql", Expressions.constant(sql)); final int fieldCount = getRowType().getFieldCount(); BlockBuilder builder = new BlockBuilder(); final ParameterExpression resultSet_ = Expressions.parameter(Modifier.FINAL, ResultSet.class, builder.newName("resultSet")); final SqlDialect.CalendarPolicy calendarPolicy = calendar_ = builder0.append("calendar", Expressions.call(Calendar.class, "getInstance", getTimeZoneExpression(implementor))); break; Expressions.parameter(Object.class, builder.newName("value")); builder.add(Expressions.declare(Modifier.FINAL, value_, null)); generateGet(implementor, physType, builder, resultSet_, 0, value_, calendar_, calendarPolicy); builder.add(Expressions.return_(null, value_)); } else { final Expression values_ = builder.append("values", Expressions.newArrayBounds(Object.class, 1, Expressions.constant(fieldCount))); for (int i = 0; i < fieldCount; i++) { generateGet(implementor, physType, builder, resultSet_, i, Expressions.arrayIndex(values_, Expressions.constant(i)), calendar_, calendarPolicy);
Expressions.return_(null, Expressions.call(null, BuiltInMethod.SLICE0.method, e))); Expressions.parameter(Modifier.FINAL, DataContext.class, "root0"); input -> Expressions.declare(Modifier.FINAL, input, Expressions.convert_( Expressions.call(DataContext.ROOT, BuiltInMethod.DATA_CONTEXT_GET.method, Expressions.constant(input.name)), input.type))); final BlockStatement block = Expressions.block( Iterables.concat( ImmutableList.of( Expressions.statement( Expressions.assign(DataContext.ROOT, root0_))), stashed, result.block.statements)); memberDeclarations.add( Expressions.fieldDecl(0, DataContext.ROOT, null)); Expressions.methodDecl( Modifier.PUBLIC, Enumerable.class, BuiltInMethod.BINDABLE_BIND.method.getName(), Expressions.list(root0_), block)); memberDeclarations.add(
.that(CalciteAssert.Config.REGULAR).connect(); QueryProvider queryProvider = connection.unwrap(QueryProvider.class); ParameterExpression e = Expressions.parameter(Employee.class, "e"); Expressions.call( Expressions.call( Types.of(Enumerable.class, Employee.class), null, LINQ4J_AS_ENUMERABLE_METHOD, Expressions.constant( new JdbcTest.HrSchema().emps)), "asQueryable"), Employee.class) .where( Expressions.lambda( Expressions.lessThan( Expressions.field( e, "empid"), Expressions.constant(160)), e)) .where( Expressions.lambda( Expressions.greaterThan( Expressions.field( e, "empid"), Expressions.constant(140)), e)) .select( Expressions.<Function1<Employee, Object[]>>lambda(
Type inputJavaType = result.physType.getJavaRowType(); ParameterExpression inputEnumerator = Expressions.parameter( Types.of( Enumerator.class, inputJavaType), Expression input = RexToLixTranslator.convert( Expressions.call( inputEnumerator, BuiltInMethod.ENUMERATOR_CURRENT.method), moveNextBody = Blocks.toFunctionBlock( Expressions.call( inputEnumerator, BuiltInMethod.ENUMERATOR_MOVE_NEXT.method)); implementor.allCorrelateVariables, implementor.getConformance()); builder2.add( Expressions.ifThen( condition, Expressions.return_( null, Expressions.constant(true)))); moveNextBody = Expressions.block( Expressions.while_( Expressions.call( inputEnumerator,
Expressions.return_(null, Expressions.call(null, BuiltInMethod.SLICE0.method, e))); input -> Expressions.declare(Modifier.FINAL, input, Expressions.convert_( Expressions.call(DataContext.ROOT, BuiltInMethod.DATA_CONTEXT_GET.method, Expressions.constant(input.name)), input.type))); final BlockStatement block = Expressions.block( Iterables.concat( stashed, result.block.statements)); memberDeclarations.add( Expressions.methodDecl( Modifier.PUBLIC, Enumerable.class, BuiltInMethod.BINDABLE_BIND.method.getName(), Expressions.list(DataContext.ROOT), block)); memberDeclarations.add( Expressions.methodDecl(Modifier.PUBLIC, Class.class, BuiltInMethod.TYPED_GET_ELEMENT_TYPE.method.getName(), ImmutableList.of(), Blocks.toFunctionBlock( Expressions.return_(null, Expressions.constant(result.physType.getJavaRowType()))))); return Expressions.classDecl(Modifier.PUBLIC,
@Test public void testQueryProviderSingleColumn() throws Exception { Connection connection = CalciteAssert .that(CalciteAssert.Config.REGULAR).connect(); QueryProvider queryProvider = connection.unwrap(QueryProvider.class); ParameterExpression e = Expressions.parameter(Employee.class, "e"); // "Enumerable<T> asEnumerable(final T[] ts)" List<Integer> list = queryProvider.createQuery( Expressions.call( Expressions.call( Types.of(Enumerable.class, Employee.class), null, LINQ4J_AS_ENUMERABLE_METHOD, Expressions.constant(new JdbcTest.HrSchema().emps)), "asQueryable"), Employee.class) .select( Expressions.<Function1<Employee, Integer>>lambda( Expressions.field(e, "empid"), e)) .toList(); assertEquals(Arrays.asList(100, 200, 150, 110), list); }
final ParameterExpression executionContext = Expressions.parameter(SamzaSqlExecutionContext.class, "context"); final ParameterExpression root = DataContext.ROOT; final ParameterExpression inputValues = Expressions.parameter(Object[].class, "inputValues"); final ParameterExpression outputValues = Expressions.parameter(Object[].class, "outputValues"); final JavaTypeFactoryImpl javaTypeFactory = new SamzaSqlJavaTypeFactoryImpl(rexBuilder.getTypeFactory().getTypeSystem()); Expressions.variable(Object[].class, "inputValues"), PhysTypeImpl.of(javaTypeFactory, inputRowType, JavaRowFormat.ARRAY, false)))); null); 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 CallImplementor getImplementor() { return RexImpTable.createImplementor((translator, call, translatedOperands) -> { final Expression context = Expressions.parameter(SamzaSqlExecutionContext.class, "context"); final Expression getUdfInstance = Expressions.call(ScalarUdf.class, context, getUdfMethod, Expressions.constant(udfMethod.getDeclaringClass().getName()), Expressions.constant(udfName)); final Expression callExpression = Expressions.convert_(Expressions.call(Expressions.convert_(getUdfInstance, udfMethod.getDeclaringClass()), udfMethod, translatedOperands), Object.class); // The Janino compiler which is used to compile the expressions doesn't seem to understand the Type of the ScalarUdf.execute // because it is a generic. To work around that we are explicitly casting it to the return type. return Expressions.convert_(callExpression, udfMethod.getReturnType()); }, NullPolicy.NONE, false); }
public Expression implementResult(AggContext info, AggResultContext result) { WinAggResultContext winResult = (WinAggResultContext) result; List<RexNode> rexArgs = winResult.rexArguments(); ParameterExpression res = Expressions.parameter(0, info.returnType(), result.currentBlock().newName("nth")); RexToLixTranslator currentRowTranslator = winResult.rowTranslator( winResult.computeIndex(Expressions.constant(0), SeekType.START)); Expression dstIndex = winResult.computeIndex( Expressions.subtract( currentRowTranslator.translate(rexArgs.get(1), int.class), Expressions.constant(1)), SeekType.START); Expression rowInRange = winResult.rowInPartition(dstIndex); BlockBuilder thenBlock = result.nestBlock(); Expression nthValue = winResult.rowTranslator(dstIndex) .translate(rexArgs.get(0), res.type); thenBlock.add(Expressions.statement(Expressions.assign(res, nthValue))); result.exitBlock(); BlockStatement thenBranch = thenBlock.toBlock(); Expression defaultValue = getDefaultValue(res.type); result.currentBlock().add(Expressions.declare(0, res, null)); result.currentBlock().add( Expressions.ifThenElse(rowInRange, thenBranch, Expressions.statement(Expressions.assign(res, defaultValue)))); return res; } }
@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))); }
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 SqlConformance conformance = SqlConformanceEnum.DEFAULT; final RexProgram program = programBuilder.getProgram(); conformance, 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);
@Test public void testTableWhere() throws SQLException, ClassNotFoundException { final Connection connection = CalciteAssert.that(CalciteAssert.Config.JDBC_FOODMART).connect(); final CalciteConnection calciteConnection = connection.unwrap(CalciteConnection.class); final SchemaPlus rootSchema = calciteConnection.getRootSchema(); ParameterExpression c = Expressions.parameter(JdbcTest.Customer.class, "c"); String s = Schemas.queryable(Schemas.createDataContext(connection, rootSchema), rootSchema.getSubSchema("foodmart"), JdbcTest.Customer.class, "customer") .where( Expressions.lambda( Expressions.lessThan( Expressions.field(c, "customer_id"), Expressions.constant(5)), c)) .toList() .toString(); Util.discard(s); } }
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); } }
/** 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); }