public void testLambdaCallsBinaryOp() { // A parameter for the lambda expression. ParameterExpression paramExpr = Expressions.parameter(Integer.TYPE, "arg"); // This expression represents a lambda expression // that adds 1 to the parameter value. FunctionExpression lambdaExpr = Expressions.lambda( Expressions.add(paramExpr, Expressions.constant(2)), Arrays.asList(paramExpr)); // Print out the expression. String s = Expressions.toString(lambdaExpr); assertEquals( "new net.hydromatic.linq4j.function.Function1() {\n" + " public int apply(Integer arg) {\n" + " return arg + 2;\n" + " }\n" + " public Object apply(Object arg) {\n" + " return apply(\n" + " (Integer) arg);\n" + " }\n" + "}\n", s); // Compile and run the lambda expression. // The value of the parameter is 1. int n = (Integer) lambdaExpr.compile().dynamicInvoke(1); // This code example produces the following output: // // arg => (arg +2) // 3 assertEquals(3, n); }
/** * Gets the expression for an input and counts it. * * @param index Input ordinal * @return Expression to which an input should be translated */ private Expression getInput(int index) { Slot slot = inputSlots.get(index); if (list == null) { slot.count++; } else { if (slot.count > 1 && slot.parameterExpression == null) { slot.parameterExpression = Expressions.parameter(slot.expression.type, "current" + index); list.add(Expressions.declare(Modifier.FINAL, slot.parameterExpression, slot.expression)); } } return slot.parameterExpression != null ? slot.parameterExpression : slot.expression; }
public void testLambdaCallsTwoArgMethod() throws NoSuchMethodException { // A parameter for the lambda expression. ParameterExpression paramS = Expressions.parameter(String.class, "s"); ParameterExpression paramBegin = Expressions.parameter(Integer.TYPE, "begin"); ParameterExpression paramEnd = Expressions.parameter(Integer.TYPE, "end"); // This expression represents a lambda expression // that adds 1 to the parameter value. FunctionExpression lambdaExpr = Expressions.lambda( Expressions.call( paramS, String.class.getMethod("substring", Integer.TYPE, Integer.TYPE), paramBegin, paramEnd), paramS, paramBegin, paramEnd); // Compile and run the lambda expression. String s = (String) lambdaExpr.compile().dynamicInvoke("hello world", 3, 7); assertEquals("lo w", s); }
@Override protected PreparedExecution implement( RelDataType rowType, RelNode rootRel, SqlKind sqlKind, ClassDeclaration decl, Argument[] args) { RelDataType resultType = rootRel.getRowType(); boolean isDml = sqlKind.belongsTo(SqlKind.DML); javaCompiler = createCompiler(); EnumerableRelImplementor relImplementor = getRelImplementor(rootRel.getCluster().getRexBuilder()); BlockExpression expr = relImplementor.implementRoot((EnumerableRel) rootRel); ParameterExpression root0 = Expressions.parameter(DataContext.class, "root0"); String s = Expressions.toString( Blocks.create( Expressions.declare( Modifier.FINAL, (ParameterExpression) schema.getExpression(), root0), expr), false); final Executable executable; try { executable = (Executable) ExpressionEvaluator.createFastScriptEvaluator( s, Executable.class, new String[] {root0.name}); } catch (Exception e) { throw Helper.INSTANCE.wrap("Error while compiling generated Java code:\n" + s, e); } if (timingTracer != null) { timingTracer.traceTime("end codegen"); } if (timingTracer != null) { timingTracer.traceTime("end compilation"); } return new PreparedExecution( null, rootRel, resultType, isDml, mapTableModOp(isDml, sqlKind), null) { public Object execute() { return executable.execute(schema); } }; }
public void testCompile() throws NoSuchMethodException { // Creating a parameter for the expression tree. ParameterExpression param = Expressions.parameter(String.class); // Creating an expression for the method call and specifying its // parameter. MethodCallExpression methodCall = Expressions.call(Integer.class, "valueOf", Collections.<Expression>singletonList(param)); // The following statement first creates an expression tree, // then compiles it, and then runs it. int x = Expressions.<Function1<String, Integer>>lambda( methodCall, new ParameterExpression[] {param}) .getFunction() .apply("1234"); assertEquals(1234, x); }
private Expression translate(RexNode expr) { Slot slot = map.get(expr); if (slot == null) { Expression expression = translate0(expr); assert expression != null; final ParameterExpression parameter; if (!inlineRexSet.contains(expr) && !(expr instanceof RexLocalRef)) { parameter = Expressions.parameter(expression.getType(), "v" + map.size()); } else { parameter = null; } slot = new Slot(parameter, expression); if (parameter != null && list != null) { list.add(Expressions.declare(Modifier.FINAL, slot.parameterExpression, slot.expression)); } map.put(expr, slot); } slot.count++; return slot.parameterExpression != null ? slot.parameterExpression : slot.expression; }
public void testWrite() { assertEquals( "1 + 2.0F + 3L + Long.valueOf(4L)", Expressions.toString( Expressions.add( Expressions.add( Expressions.add(Expressions.constant(1), Expressions.constant(2F, Float.TYPE)), Expressions.constant(3L, Long.TYPE)), Expressions.constant(4L, Long.class)))); assertEquals( "new java.math.BigDecimal(31415926L, 7)", Expressions.toString(Expressions.constant(BigDecimal.valueOf(314159260, 8)))); // Parentheses needed, to override the left-associativity of +. assertEquals( "1 + (2 + 3)", Expressions.toString( Expressions.add( Expressions.constant(1), Expressions.add(Expressions.constant(2), Expressions.constant(3))))); // No parentheses needed; higher precedence of * achieves the desired // effect. assertEquals( "1 + 2 * 3", Expressions.toString( Expressions.add( Expressions.constant(1), Expressions.multiply(Expressions.constant(2), Expressions.constant(3))))); assertEquals( "1 * (2 + 3)", Expressions.toString( Expressions.multiply( Expressions.constant(1), Expressions.add(Expressions.constant(2), Expressions.constant(3))))); // Parentheses needed, to overcome right-associativity of =. assertEquals( "(1 = 2) = 3", Expressions.toString( Expressions.assign( Expressions.assign(Expressions.constant(1), Expressions.constant(2)), Expressions.constant(3)))); // Ternary operator. assertEquals( "1 < 2 ? (3 < 4 ? 5 : 6) : 7 < 8 ? 9 : 10", Expressions.toString( Expressions.condition( Expressions.lessThan(Expressions.constant(1), Expressions.constant(2)), Expressions.condition( Expressions.lessThan(Expressions.constant(3), Expressions.constant(4)), Expressions.constant(5), Expressions.constant(6)), Expressions.condition( Expressions.lessThan(Expressions.constant(7), Expressions.constant(8)), Expressions.constant(9), Expressions.constant(10))))); assertEquals( "0 + (double) (2 + 3)", Expressions.toString( Expressions.add( Expressions.constant(0), Expressions.convert_( Expressions.add(Expressions.constant(2), Expressions.constant(3)), Double.TYPE)))); assertEquals( "a.empno", Expressions.toString( Expressions.field(Expressions.parameter(Linq4jTest.Employee.class, "a"), "empno"))); assertEquals( "java.util.Collections.EMPTY_LIST", Expressions.toString(Expressions.field(null, Collections.class, "EMPTY_LIST"))); final ParameterExpression paramX = Expressions.parameter(String.class, "x"); assertEquals( "new net.hydromatic.linq4j.function.Function1() {\n" + " public int apply(String x) {\n" + " return x.length();\n" + " }\n" + " public Object apply(Object x) {\n" + " return apply(\n" + " (String) x);\n" + " }\n" + "}\n", Expressions.toString( Expressions.lambda( Function1.class, Expressions.call(paramX, "length", Collections.<Expression>emptyList()), Arrays.asList(paramX)))); assertEquals( "new String[] {\n" + " \"foo\",\n" + " null,\n" + " \"bar\\\"baz\"}", Expressions.toString( Expressions.newArrayInit( String.class, Arrays.<Expression>asList( Expressions.constant("foo"), Expressions.constant(null), Expressions.constant("bar\"baz"))))); assertEquals( "(int) ((String) (Object) \"foo\").length()", Expressions.toString( Expressions.convert_( Expressions.call( Expressions.convert_( Expressions.convert_(Expressions.constant("foo"), Object.class), String.class), "length", Collections.<Expression>emptyList()), Integer.TYPE))); // resolving a static method assertEquals( "Integer.valueOf(\"0123\")", Expressions.toString( Expressions.call( Integer.class, "valueOf", Collections.<Expression>singletonList(Expressions.constant("0123"))))); // precedence of not and instanceof assertEquals( "!(o instanceof String)", Expressions.toString( Expressions.not( Expressions.typeIs(Expressions.parameter(Object.class, "o"), String.class)))); // not not assertEquals( "!!(o instanceof String)", Expressions.toString( Expressions.not( Expressions.not( Expressions.typeIs(Expressions.parameter(Object.class, "o"), String.class))))); }
public void testWriteAnonymousClass() { // final List<String> baz = Arrays.asList("foo", "bar"); // new AbstractList<String>() { // public int size() { // return baz.size(); // } // public String get(int index) { // return ((String) baz.get(index)).toUpperCase(); // } // } final ParameterExpression bazParameter = Expressions.parameter(Types.of(List.class, String.class), "baz"); final ParameterExpression indexParameter = Expressions.parameter(Integer.TYPE, "index"); BlockExpression e = Expressions.block( Expressions.declare( Modifier.FINAL, bazParameter, Expressions.call( Arrays.class, "asList", Arrays.<Expression>asList( Expressions.constant("foo"), Expressions.constant("bar")))), Expressions.statement( Expressions.new_( Types.of(AbstractList.class, String.class), Collections.<Expression>emptyList(), Arrays.<MemberDeclaration>asList( Expressions.fieldDecl( Modifier.PUBLIC | Modifier.FINAL, Expressions.parameter(String.class, "qux"), Expressions.constant("xyzzy")), Expressions.methodDecl( Modifier.PUBLIC, Integer.TYPE, "size", Collections.<ParameterExpression>emptyList(), Blocks.toFunctionBlock( Expressions.call( bazParameter, "size", Collections.<Expression>emptyList()))), Expressions.methodDecl( Modifier.PUBLIC, String.class, "get", Arrays.asList(indexParameter), Blocks.toFunctionBlock( Expressions.call( Expressions.convert_( Expressions.call( bazParameter, "get", Arrays.<Expression>asList(indexParameter)), String.class), "toUpperCase", Collections.<Expression>emptyList()))))))); assertEquals( "{\n" + " final java.util.List<String> baz = java.util.Arrays.asList(\"foo\", \"bar\");\n" + " new java.util.AbstractList<String>(){\n" + " public final String qux = \"xyzzy\";\n" + " public int size() {\n" + " return baz.size();\n" + " }\n" + "\n" + " public String get(int index) {\n" + " return ((String) baz.get(index)).toUpperCase();\n" + " }\n" + "\n" + " };\n" + "}\n", Expressions.toString(e)); }