Examples with ParameterExpression org.apache.calcite.linq4j.tree.ParameterExpression used on opensource projects

Example 6 with ParameterExpression

use of org.apache.calcite.linq4j.tree.ParameterExpression in project calcite by apache.

the class ExpressionTest method testWrite.

@Test
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))));
    // "--5" would be a syntax error
    assertEquals("- - 5", Expressions.toString(Expressions.negate(Expressions.negate(Expressions.constant(5)))));
    assertEquals("a.empno", Expressions.toString(Expressions.field(Expressions.parameter(Linq4jTest.Employee.class, "a"), "empno")));
    assertEquals("a.length", Expressions.toString(Expressions.field(Expressions.parameter(Object[].class, "a"), "length")));
    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 org.apache.calcite.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))));
    // 1-dimensional array with initializer
    assertEquals("new String[] {\n" + "  \"foo\",\n" + "  null,\n" + "  \"bar\\\"baz\"}", Expressions.toString(Expressions.newArrayInit(String.class, Expressions.constant("foo"), Expressions.constant(null), Expressions.constant("bar\"baz"))));
    // 2-dimensional array with initializer
    assertEquals("new String[][] {\n" + "  new String[] {\n" + "    \"foo\",\n" + "    \"bar\"},\n" + "  null,\n" + "  new String[] {\n" + "    null}}", Expressions.toString(Expressions.newArrayInit(String.class, 2, Expressions.constant(new String[] { "foo", "bar" }), Expressions.constant(null), Expressions.constant(new String[] { null }))));
    // 1-dimensional array
    assertEquals("new String[x + 1]", Expressions.toString(Expressions.newArrayBounds(String.class, 1, Expressions.add(Expressions.parameter(0, int.class, "x"), Expressions.constant(1)))));
    // 3-dimensional array
    assertEquals("new String[x + 1][][]", Expressions.toString(Expressions.newArrayBounds(String.class, 3, Expressions.add(Expressions.parameter(0, int.class, "x"), Expressions.constant(1)))));
    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)))));
}

Example 7 with ParameterExpression

use of org.apache.calcite.linq4j.tree.ParameterExpression in project calcite by apache.

the class ExpressionTest method testLambdaCallsTwoArgMethod.

@Test
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);
}

Example 8 with ParameterExpression

use of org.apache.calcite.linq4j.tree.ParameterExpression in project calcite by apache.

the class ExpressionTest method testWriteAnonymousClass.

@Test
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");
    BlockStatement 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));
}

Example 9 with ParameterExpression

use of org.apache.calcite.linq4j.tree.ParameterExpression in project calcite by apache.

the class InlinerTest method testMultiPassOptimization.

@Test
public void testMultiPassOptimization() {
    // int t = u + v;
    // boolean b = t > 1 ? true : true; -- optimized out, thus t can be inlined
    // return b ? t : 2
    final BlockBuilder builder = new BlockBuilder(true);
    final ParameterExpression u = Expressions.parameter(int.class, "u");
    final ParameterExpression v = Expressions.parameter(int.class, "v");
    Expression t = builder.append("t", Expressions.add(u, v));
    Expression b = builder.append("b", Expressions.condition(Expressions.greaterThan(t, ONE), TRUE, TRUE));
    builder.add(Expressions.return_(null, Expressions.condition(b, t, TWO)));
    assertEquals("{\n" + "  return u + v;\n" + "}\n", Expressions.toString(builder.toBlock()));
}

Example 10 with ParameterExpression

use of org.apache.calcite.linq4j.tree.ParameterExpression in project calcite by apache.

the class InlinerTest method checkAssignInConditionOptimizedOut.

void checkAssignInConditionOptimizedOut(int modifiers, String s) {
    // int t;
    // return (t = 1) != a ? b : c
    final BlockBuilder builder = new BlockBuilder(true);
    final ParameterExpression t = Expressions.parameter(int.class, "t");
    builder.add(Expressions.declare(modifiers, t, null));
    Expression v = builder.append("v", Expressions.makeTernary(ExpressionType.Conditional, Expressions.makeBinary(ExpressionType.NotEqual, Expressions.assign(t, Expressions.constant(1)), Expressions.parameter(int.class, "a")), Expressions.parameter(int.class, "b"), Expressions.parameter(int.class, "c")));
    builder.add(Expressions.return_(null, v));
    assertThat(Expressions.toString(builder.toBlock()), CoreMatchers.equalTo(s));
}