org.apache.calcite.runtime.SqlFunctions Java Examples
The following examples show how to use
org.apache.calcite.runtime.SqlFunctions.
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.
Example #1
Source File: FlinkAggregateRemoveRule.java From flink with Apache License 2.0 | 6 votes |
@Override public boolean matches(RelOptRuleCall call) { final Aggregate aggregate = call.rel(0); final RelNode input = call.rel(1); if (aggregate.getGroupCount() == 0 || aggregate.indicator || aggregate.getGroupType() != Aggregate.Group.SIMPLE) { return false; } for (AggregateCall aggCall : aggregate.getAggCallList()) { SqlKind aggCallKind = aggCall.getAggregation().getKind(); // TODO supports more AggregateCalls boolean isAllowAggCall = aggCallKind == SqlKind.SUM || aggCallKind == SqlKind.MIN || aggCallKind == SqlKind.MAX || aggCall.getAggregation() instanceof SqlAuxiliaryGroupAggFunction; if (!isAllowAggCall || aggCall.filterArg >= 0 || aggCall.getArgList().size() != 1) { return false; } } final RelMetadataQuery mq = call.getMetadataQuery(); return SqlFunctions.isTrue(mq.areColumnsUnique(input, aggregate.getGroupSet())); }
Example #2
Source File: UtilTest.java From calcite with Apache License 2.0 | 6 votes |
@Test void testFlatListProduct() { final List<Enumerator<List<String>>> list = new ArrayList<>(); list.add(Linq4j.enumerator(l2(l1("a"), l1("b")))); list.add(Linq4j.enumerator(l3(l2("x", "p"), l2("y", "q"), l2("z", "r")))); final Enumerable<FlatLists.ComparableList<String>> product = SqlFunctions.product(list, 3, false); int n = 0; FlatLists.ComparableList<String> previous = FlatLists.of(); for (FlatLists.ComparableList<String> strings : product) { if (n++ == 1) { assertThat(strings.size(), is(3)); assertThat(strings.get(0), is("a")); assertThat(strings.get(1), is("y")); assertThat(strings.get(2), is("q")); } if (previous != null) { assertTrue(previous.compareTo(strings) < 0); } previous = strings; } assertThat(n, is(6)); }
Example #3
Source File: SqlFunctionsTest.java From calcite with Apache License 2.0 | 6 votes |
@Test void testNeWithAny() { // Non-numeric same type inequality check assertThat(SqlFunctions.neAny("hello", "world"), is(true)); // Numeric types inequality check assertThat(SqlFunctions.neAny(1, 2L), is(true)); assertThat(SqlFunctions.neAny(1, 2.0D), is(true)); assertThat(SqlFunctions.neAny(1L, 2.0D), is(true)); assertThat(SqlFunctions.neAny(new BigDecimal(2L), 1), is(true)); assertThat(SqlFunctions.neAny(new BigDecimal(2L), 1L), is(true)); assertThat(SqlFunctions.neAny(new BigDecimal(2L), 1.0D), is(true)); assertThat(SqlFunctions.neAny(new BigDecimal(2L), new BigDecimal(1.0D)), is(true)); // Non-numeric different type inequality check assertThat(SqlFunctions.neAny("2", 2), is(true)); }
Example #4
Source File: SqlFunctionsTest.java From calcite with Apache License 2.0 | 6 votes |
@Test void testEqWithAny() { // Non-numeric same type equality check assertThat(SqlFunctions.eqAny("hello", "hello"), is(true)); // Numeric types equality check assertThat(SqlFunctions.eqAny(1, 1L), is(true)); assertThat(SqlFunctions.eqAny(1, 1.0D), is(true)); assertThat(SqlFunctions.eqAny(1L, 1.0D), is(true)); assertThat(SqlFunctions.eqAny(new BigDecimal(1L), 1), is(true)); assertThat(SqlFunctions.eqAny(new BigDecimal(1L), 1L), is(true)); assertThat(SqlFunctions.eqAny(new BigDecimal(1L), 1.0D), is(true)); assertThat(SqlFunctions.eqAny(new BigDecimal(1L), new BigDecimal(1.0D)), is(true)); // Non-numeric different type equality check assertThat(SqlFunctions.eqAny("2", 2), is(false)); }
Example #5
Source File: SqlFunctionsTest.java From calcite with Apache License 2.0 | 6 votes |
@Test void testSRoundInt() { assertThat(SqlFunctions.sround(12345, -1), within(12350d, 0.001)); assertThat(SqlFunctions.sround(12345, -2), within(12300d, 0.001)); assertThat(SqlFunctions.sround(12345, -3), within(12000d, 0.001)); assertThat(SqlFunctions.sround(12000, -3), within(12000d, 0.001)); assertThat(SqlFunctions.sround(12001, -3), within(12000d, 0.001)); assertThat(SqlFunctions.sround(12000, -4), within(10000d, 0.001)); assertThat(SqlFunctions.sround(12000, -5), within(0d, 0.001)); assertThat(SqlFunctions.sround(11999, -3), within(12000d, 0.001)); assertThat(SqlFunctions.sround(-12345, -1), within(-12350d, 0.001)); assertThat(SqlFunctions.sround(-12345, -2), within(-12300d, 0.001)); assertThat(SqlFunctions.sround(-12345, -3), within(-12000d, 0.001)); assertThat(SqlFunctions.sround(-12000, -3), within(-12000d, 0.001)); assertThat(SqlFunctions.sround(-11999, -3), within(-12000d, 0.001)); assertThat(SqlFunctions.sround(-12000, -4), within(-10000d, 0.001)); assertThat(SqlFunctions.sround(-12000, -5), within(0d, 0.001)); }
Example #6
Source File: SqlFunctionsTest.java From calcite with Apache License 2.0 | 6 votes |
@Test void testLtWithAny() { // Non-numeric same type "less then" check assertThat(SqlFunctions.ltAny("apple", "banana"), is(true)); // Numeric types "less than" check assertThat(SqlFunctions.ltAny(1, 2L), is(true)); assertThat(SqlFunctions.ltAny(1, 2.0D), is(true)); assertThat(SqlFunctions.ltAny(1L, 2.0D), is(true)); assertThat(SqlFunctions.ltAny(new BigDecimal(1L), 2), is(true)); assertThat(SqlFunctions.ltAny(new BigDecimal(1L), 2L), is(true)); assertThat(SqlFunctions.ltAny(new BigDecimal(1L), 2.0D), is(true)); assertThat(SqlFunctions.ltAny(new BigDecimal(1L), new BigDecimal(2.0D)), is(true)); // Non-numeric different type but both implements Comparable // "less than" check try { assertThat(SqlFunctions.ltAny("1", 2L), is(false)); fail("'lt' on non-numeric different type is not possible"); } catch (CalciteException e) { assertThat(e.getMessage(), is("Invalid types for comparison: class java.lang.String < " + "class java.lang.Long")); } }
Example #7
Source File: SqlFunctionsTest.java From calcite with Apache License 2.0 | 6 votes |
@Test void testSRoundLong() { assertThat(SqlFunctions.sround(12345L, -1), within(12350d, 0.001)); assertThat(SqlFunctions.sround(12345L, -2), within(12300d, 0.001)); assertThat(SqlFunctions.sround(12345L, -3), within(12000d, 0.001)); assertThat(SqlFunctions.sround(12000L, -3), within(12000d, 0.001)); assertThat(SqlFunctions.sround(12001L, -3), within(12000d, 0.001)); assertThat(SqlFunctions.sround(12000L, -4), within(10000d, 0.001)); assertThat(SqlFunctions.sround(12000L, -5), within(0d, 0.001)); assertThat(SqlFunctions.sround(11999L, -3), within(12000d, 0.001)); assertThat(SqlFunctions.sround(-12345L, -1), within(-12350d, 0.001)); assertThat(SqlFunctions.sround(-12345L, -2), within(-12300d, 0.001)); assertThat(SqlFunctions.sround(-12345L, -3), within(-12000d, 0.001)); assertThat(SqlFunctions.sround(-12000L, -3), within(-12000d, 0.001)); assertThat(SqlFunctions.sround(-11999L, -3), within(-12000d, 0.001)); assertThat(SqlFunctions.sround(-12000L, -4), within(-10000d, 0.001)); assertThat(SqlFunctions.sround(-12000L, -5), within(0d, 0.001)); }
Example #8
Source File: SqlFunctionsTest.java From calcite with Apache License 2.0 | 6 votes |
@Test void testGtWithAny() { // Non-numeric same type "greater then" check assertThat(SqlFunctions.gtAny("banana", "apple"), is(true)); // Numeric types "greater than" check assertThat(SqlFunctions.gtAny(2, 1L), is(true)); assertThat(SqlFunctions.gtAny(2, 1.0D), is(true)); assertThat(SqlFunctions.gtAny(2L, 1.0D), is(true)); assertThat(SqlFunctions.gtAny(new BigDecimal(2L), 1), is(true)); assertThat(SqlFunctions.gtAny(new BigDecimal(2L), 1L), is(true)); assertThat(SqlFunctions.gtAny(new BigDecimal(2L), 1.0D), is(true)); assertThat(SqlFunctions.gtAny(new BigDecimal(2L), new BigDecimal(1.0D)), is(true)); // Non-numeric different type but both implements Comparable // "greater than" check try { assertThat(SqlFunctions.gtAny("2", 1L), is(false)); fail("'gt' on non-numeric different type is not possible"); } catch (CalciteException e) { assertThat(e.getMessage(), is("Invalid types for comparison: class java.lang.String > " + "class java.lang.Long")); } }
Example #9
Source File: DateRangeRules.java From calcite with Apache License 2.0 | 6 votes |
private Calendar timestampValue(RexLiteral timeLiteral) { switch (timeLiteral.getTypeName()) { case TIMESTAMP_WITH_LOCAL_TIME_ZONE: final TimeZone tz = TimeZone.getTimeZone(this.timeZone); return Util.calendar( SqlFunctions.timestampWithLocalTimeZoneToTimestamp( timeLiteral.getValueAs(Long.class), tz)); case TIMESTAMP: return Util.calendar(timeLiteral.getValueAs(Long.class)); case DATE: // Cast date to timestamp with local time zone final DateString d = timeLiteral.getValueAs(DateString.class); return Util.calendar(d.getMillisSinceEpoch()); default: throw Util.unexpected(timeLiteral.getTypeName()); } }
Example #10
Source File: FlinkAggregateRemoveRule.java From flink with Apache License 2.0 | 6 votes |
@Override public boolean matches(RelOptRuleCall call) { final Aggregate aggregate = call.rel(0); final RelNode input = call.rel(1); if (aggregate.getGroupCount() == 0 || aggregate.indicator || aggregate.getGroupType() != Aggregate.Group.SIMPLE) { return false; } for (AggregateCall aggCall : aggregate.getAggCallList()) { SqlKind aggCallKind = aggCall.getAggregation().getKind(); // TODO supports more AggregateCalls boolean isAllowAggCall = aggCallKind == SqlKind.SUM || aggCallKind == SqlKind.MIN || aggCallKind == SqlKind.MAX || aggCall.getAggregation() instanceof SqlAuxiliaryGroupAggFunction; if (!isAllowAggCall || aggCall.filterArg >= 0 || aggCall.getArgList().size() != 1) { return false; } } final RelMetadataQuery mq = call.getMetadataQuery(); return SqlFunctions.isTrue(mq.areColumnsUnique(input, aggregate.getGroupSet())); }
Example #11
Source File: SqlFunctionsTest.java From calcite with Apache License 2.0 | 6 votes |
@Test void testSTruncateDouble() { assertThat(SqlFunctions.struncate(12.345d, 3), within(12.345d, 0.001)); assertThat(SqlFunctions.struncate(12.345d, 2), within(12.340d, 0.001)); assertThat(SqlFunctions.struncate(12.345d, 1), within(12.300d, 0.001)); assertThat(SqlFunctions.struncate(12.999d, 0), within(12.000d, 0.001)); assertThat(SqlFunctions.struncate(-12.345d, 3), within(-12.345d, 0.001)); assertThat(SqlFunctions.struncate(-12.345d, 2), within(-12.340d, 0.001)); assertThat(SqlFunctions.struncate(-12.345d, 1), within(-12.300d, 0.001)); assertThat(SqlFunctions.struncate(-12.999d, 0), within(-12.000d, 0.001)); assertThat(SqlFunctions.struncate(12345d, -3), within(12000d, 0.001)); assertThat(SqlFunctions.struncate(12000d, -3), within(12000d, 0.001)); assertThat(SqlFunctions.struncate(12001d, -3), within(12000d, 0.001)); assertThat(SqlFunctions.struncate(12000d, -4), within(10000d, 0.001)); assertThat(SqlFunctions.struncate(12000d, -5), within(0d, 0.001)); assertThat(SqlFunctions.struncate(11999d, -3), within(11000d, 0.001)); assertThat(SqlFunctions.struncate(-12345d, -3), within(-12000d, 0.001)); assertThat(SqlFunctions.struncate(-12000d, -3), within(-12000d, 0.001)); assertThat(SqlFunctions.struncate(-11999d, -3), within(-11000d, 0.001)); assertThat(SqlFunctions.struncate(-12000d, -4), within(-10000d, 0.001)); assertThat(SqlFunctions.struncate(-12000d, -5), within(0d, 0.001)); }
Example #12
Source File: SqlFunctionsTest.java From calcite with Apache License 2.0 | 6 votes |
@Test void testTruncateInt() { assertThat(SqlFunctions.truncate(12345, 1000), is(12000)); assertThat(SqlFunctions.truncate(12000, 1000), is(12000)); assertThat(SqlFunctions.truncate(12001, 1000), is(12000)); assertThat(SqlFunctions.truncate(11999, 1000), is(11000)); assertThat(SqlFunctions.truncate(-12345, 1000), is(-13000)); assertThat(SqlFunctions.truncate(-12000, 1000), is(-12000)); assertThat(SqlFunctions.truncate(-12001, 1000), is(-13000)); assertThat(SqlFunctions.truncate(-11999, 1000), is(-12000)); assertThat(SqlFunctions.round(12345, 1000), is(12000)); assertThat(SqlFunctions.round(12845, 1000), is(13000)); assertThat(SqlFunctions.round(-12345, 1000), is(-12000)); assertThat(SqlFunctions.round(-12845, 1000), is(-13000)); }
Example #13
Source File: NlsString.java From calcite with Apache License 2.0 | 5 votes |
/** * Returns a string the same as this but with spaces trimmed from the * right. */ public NlsString rtrim() { String trimmed = SqlFunctions.rtrim(getValue()); if (!trimmed.equals(getValue())) { return new NlsString(trimmed, charsetName, collation); } return this; }
Example #14
Source File: SqlFunctionsTest.java From calcite with Apache License 2.0 | 5 votes |
@Test void testSTruncateLong() { assertThat(SqlFunctions.struncate(12345L, -3), within(12000d, 0.001)); assertThat(SqlFunctions.struncate(12000L, -3), within(12000d, 0.001)); assertThat(SqlFunctions.struncate(12001L, -3), within(12000d, 0.001)); assertThat(SqlFunctions.struncate(12000L, -4), within(10000d, 0.001)); assertThat(SqlFunctions.struncate(12000L, -5), within(0d, 0.001)); assertThat(SqlFunctions.struncate(11999L, -3), within(11000d, 0.001)); assertThat(SqlFunctions.struncate(-12345L, -3), within(-12000d, 0.001)); assertThat(SqlFunctions.struncate(-12000L, -3), within(-12000d, 0.001)); assertThat(SqlFunctions.struncate(-11999L, -3), within(-11000d, 0.001)); assertThat(SqlFunctions.struncate(-12000L, -4), within(-10000d, 0.001)); assertThat(SqlFunctions.struncate(-12000L, -5), within(0d, 0.001)); }
Example #15
Source File: SqlFunctionsTest.java From calcite with Apache License 2.0 | 5 votes |
@Test void testSTruncateInt() { assertThat(SqlFunctions.struncate(12345, -3), within(12000d, 0.001)); assertThat(SqlFunctions.struncate(12000, -3), within(12000d, 0.001)); assertThat(SqlFunctions.struncate(12001, -3), within(12000d, 0.001)); assertThat(SqlFunctions.struncate(12000, -4), within(10000d, 0.001)); assertThat(SqlFunctions.struncate(12000, -5), within(0d, 0.001)); assertThat(SqlFunctions.struncate(11999, -3), within(11000d, 0.001)); assertThat(SqlFunctions.struncate(-12345, -3), within(-12000d, 0.001)); assertThat(SqlFunctions.struncate(-12000, -3), within(-12000d, 0.001)); assertThat(SqlFunctions.struncate(-11999, -3), within(-11000d, 0.001)); assertThat(SqlFunctions.struncate(-12000, -4), within(-10000d, 0.001)); assertThat(SqlFunctions.struncate(-12000, -5), within(0d, 0.001)); }
Example #16
Source File: SqlFunctionsTest.java From calcite with Apache License 2.0 | 5 votes |
@Test void testSRoundDouble() { assertThat(SqlFunctions.sround(12.345d, 3), within(12.345d, 0.001)); assertThat(SqlFunctions.sround(12.345d, 2), within(12.350d, 0.001)); assertThat(SqlFunctions.sround(12.345d, 1), within(12.300d, 0.001)); assertThat(SqlFunctions.sround(12.999d, 2), within(13.000d, 0.001)); assertThat(SqlFunctions.sround(12.999d, 1), within(13.000d, 0.001)); assertThat(SqlFunctions.sround(12.999d, 0), within(13.000d, 0.001)); assertThat(SqlFunctions.sround(-12.345d, 3), within(-12.345d, 0.001)); assertThat(SqlFunctions.sround(-12.345d, 2), within(-12.350d, 0.001)); assertThat(SqlFunctions.sround(-12.345d, 1), within(-12.300d, 0.001)); assertThat(SqlFunctions.sround(-12.999d, 2), within(-13.000d, 0.001)); assertThat(SqlFunctions.sround(-12.999d, 1), within(-13.000d, 0.001)); assertThat(SqlFunctions.sround(-12.999d, 0), within(-13.000d, 0.001)); assertThat(SqlFunctions.sround(12345d, -1), within(12350d, 0.001)); assertThat(SqlFunctions.sround(12345d, -2), within(12300d, 0.001)); assertThat(SqlFunctions.sround(12345d, -3), within(12000d, 0.001)); assertThat(SqlFunctions.sround(12000d, -3), within(12000d, 0.001)); assertThat(SqlFunctions.sround(12001d, -3), within(12000d, 0.001)); assertThat(SqlFunctions.sround(12000d, -4), within(10000d, 0.001)); assertThat(SqlFunctions.sround(12000d, -5), within(0d, 0.001)); assertThat(SqlFunctions.sround(11999d, -3), within(12000d, 0.001)); assertThat(SqlFunctions.sround(-12345d, -1), within(-12350d, 0.001)); assertThat(SqlFunctions.sround(-12345d, -2), within(-12300d, 0.001)); assertThat(SqlFunctions.sround(-12345d, -3), within(-12000d, 0.001)); assertThat(SqlFunctions.sround(-12000d, -3), within(-12000d, 0.001)); assertThat(SqlFunctions.sround(-11999d, -3), within(-12000d, 0.001)); assertThat(SqlFunctions.sround(-12000d, -4), within(-10000d, 0.001)); assertThat(SqlFunctions.sround(-12000d, -5), within(0d, 0.001)); }
Example #17
Source File: RelMetadataTest.java From calcite with Apache License 2.0 | 5 votes |
/** Asserts that {@link RelMetadataQuery#getUniqueKeys(RelNode)} * and {@link RelMetadataQuery#areColumnsUnique(RelNode, ImmutableBitSet)} * return consistent results. */ private void assertUniqueConsistent(RelNode rel) { final RelMetadataQuery mq = rel.getCluster().getMetadataQuery(); final Set<ImmutableBitSet> uniqueKeys = mq.getUniqueKeys(rel); final ImmutableBitSet allCols = ImmutableBitSet.range(0, rel.getRowType().getFieldCount()); for (ImmutableBitSet key : allCols.powerSet()) { Boolean result2 = mq.areColumnsUnique(rel, key); assertEquals(isUnique(uniqueKeys, key), SqlFunctions.isTrue(result2), () -> "areColumnsUnique. key: " + key + ", uniqueKeys: " + uniqueKeys + ", rel: " + RelOptUtil.toString(rel)); } }
Example #18
Source File: SqlFunctionsTest.java From calcite with Apache License 2.0 | 5 votes |
@Test void testToString() { assertThat(SqlFunctions.toString(0f), is("0E0")); assertThat(SqlFunctions.toString(1f), is("1")); assertThat(SqlFunctions.toString(1.5f), is("1.5")); assertThat(SqlFunctions.toString(-1.5f), is("-1.5")); assertThat(SqlFunctions.toString(1.5e8f), is("1.5E8")); assertThat(SqlFunctions.toString(-0.0625f), is("-0.0625")); assertThat(SqlFunctions.toString(0.0625f), is("0.0625")); assertThat(SqlFunctions.toString(-5e-12f), is("-5E-12")); assertThat(SqlFunctions.toString(0d), is("0E0")); assertThat(SqlFunctions.toString(1d), is("1")); assertThat(SqlFunctions.toString(1.5d), is("1.5")); assertThat(SqlFunctions.toString(-1.5d), is("-1.5")); assertThat(SqlFunctions.toString(1.5e8d), is("1.5E8")); assertThat(SqlFunctions.toString(-0.0625d), is("-0.0625")); assertThat(SqlFunctions.toString(0.0625d), is("0.0625")); assertThat(SqlFunctions.toString(-5e-12d), is("-5E-12")); assertThat(SqlFunctions.toString(new BigDecimal("0")), is("0")); assertThat(SqlFunctions.toString(new BigDecimal("1")), is("1")); assertThat(SqlFunctions.toString(new BigDecimal("1.5")), is("1.5")); assertThat(SqlFunctions.toString(new BigDecimal("-1.5")), is("-1.5")); assertThat(SqlFunctions.toString(new BigDecimal("1.5e8")), is("1.5E+8")); assertThat(SqlFunctions.toString(new BigDecimal("-0.0625")), is("-.0625")); assertThat(SqlFunctions.toString(new BigDecimal("0.0625")), is(".0625")); assertThat(SqlFunctions.toString(new BigDecimal("-5e-12")), is("-5E-12")); }
Example #19
Source File: SqlFunctionsTest.java From calcite with Apache License 2.0 | 5 votes |
private void checkFloor(int x, int y, int result) { assertThat(SqlFunctions.floor(x, y), is(result)); assertThat(SqlFunctions.floor((long) x, (long) y), is((long) result)); assertThat(SqlFunctions.floor((short) x, (short) y), is((short) result)); assertThat(SqlFunctions.floor((byte) x, (byte) y), is((byte) result)); assertThat( SqlFunctions.floor(BigDecimal.valueOf(x), BigDecimal.valueOf(y)), is(BigDecimal.valueOf(result))); }
Example #20
Source File: SqlFunctionsTest.java From calcite with Apache License 2.0 | 5 votes |
private void checkCeil(int x, int y, int result) { assertThat(SqlFunctions.ceil(x, y), is(result)); assertThat(SqlFunctions.ceil((long) x, (long) y), is((long) result)); assertThat(SqlFunctions.ceil((short) x, (short) y), is((short) result)); assertThat(SqlFunctions.ceil((byte) x, (byte) y), is((byte) result)); assertThat( SqlFunctions.ceil(BigDecimal.valueOf(x), BigDecimal.valueOf(y)), is(BigDecimal.valueOf(result))); }
Example #21
Source File: SqlFunctionsTest.java From calcite with Apache License 2.0 | 5 votes |
@Test void testTruncateLong() { assertThat(SqlFunctions.truncate(12345L, 1000L), is(12000L)); assertThat(SqlFunctions.truncate(12000L, 1000L), is(12000L)); assertThat(SqlFunctions.truncate(12001L, 1000L), is(12000L)); assertThat(SqlFunctions.truncate(11999L, 1000L), is(11000L)); assertThat(SqlFunctions.truncate(-12345L, 1000L), is(-13000L)); assertThat(SqlFunctions.truncate(-12000L, 1000L), is(-12000L)); assertThat(SqlFunctions.truncate(-12001L, 1000L), is(-13000L)); assertThat(SqlFunctions.truncate(-11999L, 1000L), is(-12000L)); }
Example #22
Source File: EnumUtilsTest.java From calcite with Apache License 2.0 | 5 votes |
@Test void testMethodCallExpression() { // test for Object.class method parameter type final ConstantExpression arg0 = Expressions.constant(1, int.class); final ConstantExpression arg1 = Expressions.constant("x", String.class); final MethodCallExpression arrayMethodCall = EnumUtils.call(SqlFunctions.class, BuiltInMethod.ARRAY.getMethodName(), Arrays.asList(arg0, arg1)); assertThat(Expressions.toString(arrayMethodCall), is("org.apache.calcite.runtime.SqlFunctions.array(1, \"x\")")); // test for Object.class argument type final ConstantExpression nullLiteral = Expressions.constant(null); final MethodCallExpression xmlExtractMethodCall = EnumUtils.call( XmlFunctions.class, BuiltInMethod.EXTRACT_VALUE.getMethodName(), Arrays.asList(arg1, nullLiteral)); assertThat(Expressions.toString(xmlExtractMethodCall), is("org.apache.calcite.runtime.XmlFunctions.extractValue(\"x\", (String) null)")); // test "mod(decimal, long)" match to "mod(decimal, decimal)" final ConstantExpression arg2 = Expressions.constant(12.5, BigDecimal.class); final ConstantExpression arg3 = Expressions.constant(3, long.class); final MethodCallExpression modMethodCall = EnumUtils.call( SqlFunctions.class, "mod", Arrays.asList(arg2, arg3)); assertThat(Expressions.toString(modMethodCall), is("org.apache.calcite.runtime.SqlFunctions.mod(" + "java.math.BigDecimal.valueOf(125L, 1), " + "new java.math.BigDecimal(\n 3L))")); // test "ST_MakePoint(int, int)" match to "ST_MakePoint(decimal, decimal)" final ConstantExpression arg4 = Expressions.constant(1, int.class); final ConstantExpression arg5 = Expressions.constant(2, int.class); final MethodCallExpression geoMethodCall = EnumUtils.call( GeoFunctions.class, "ST_MakePoint", Arrays.asList(arg4, arg5)); assertThat(Expressions.toString(geoMethodCall), is("org.apache.calcite.runtime.GeoFunctions.ST_MakePoint(" + "new java.math.BigDecimal(\n 1), " + "new java.math.BigDecimal(\n 2))")); }
Example #23
Source File: RexImpTable.java From calcite with Apache License 2.0 | 5 votes |
private Expression callBackupMethodAnyType(RexToLixTranslator translator, RexCall call, List<Expression> expressions) { final String backupMethodNameForAnyType = backupMethodName + METHOD_POSTFIX_FOR_ANY_TYPE; // one or both of parameter(s) is(are) ANY type final Expression expression0 = maybeBox(expressions.get(0)); final Expression expression1 = maybeBox(expressions.get(1)); return Expressions.call(SqlFunctions.class, backupMethodNameForAnyType, expression0, expression1); }
Example #24
Source File: RexImpTable.java From calcite with Apache License 2.0 | 5 votes |
@Override Expression implementSafe(RexToLixTranslator translator, RexCall call, List<Expression> argValueList) { return EnumUtils.call( SqlFunctions.class, methodName, argValueList); }
Example #25
Source File: RexImpTable.java From calcite with Apache License 2.0 | 5 votes |
private Expression call(Expression operand, Type type, TimeUnit timeUnit) { return Expressions.call(SqlFunctions.class, methodName, EnumUtils.convert(operand, type), EnumUtils.convert( Expressions.constant(timeUnit.multiplier), type)); }
Example #26
Source File: SqlFunctionsTest.java From calcite with Apache License 2.0 | 5 votes |
@Test void testLeWithAny() { // Non-numeric same type "less or equal" check assertThat(SqlFunctions.leAny("apple", "banana"), is(true)); assertThat(SqlFunctions.leAny("apple", "apple"), is(true)); // Numeric types "less or equal" check assertThat(SqlFunctions.leAny(1, 2L), is(true)); assertThat(SqlFunctions.leAny(1, 1L), is(true)); assertThat(SqlFunctions.leAny(1, 2.0D), is(true)); assertThat(SqlFunctions.leAny(1, 1.0D), is(true)); assertThat(SqlFunctions.leAny(1L, 2.0D), is(true)); assertThat(SqlFunctions.leAny(1L, 1.0D), is(true)); assertThat(SqlFunctions.leAny(new BigDecimal(1L), 2), is(true)); assertThat(SqlFunctions.leAny(new BigDecimal(1L), 1), is(true)); assertThat(SqlFunctions.leAny(new BigDecimal(1L), 2L), is(true)); assertThat(SqlFunctions.leAny(new BigDecimal(1L), 1L), is(true)); assertThat(SqlFunctions.leAny(new BigDecimal(1L), 2.0D), is(true)); assertThat(SqlFunctions.leAny(new BigDecimal(1L), 1.0D), is(true)); assertThat(SqlFunctions.leAny(new BigDecimal(1L), new BigDecimal(2.0D)), is(true)); assertThat(SqlFunctions.leAny(new BigDecimal(1L), new BigDecimal(1.0D)), is(true)); // Non-numeric different type but both implements Comparable // "less or equal" check try { assertThat(SqlFunctions.leAny("2", 2L), is(false)); fail("'le' on non-numeric different type is not possible"); } catch (CalciteException e) { assertThat(e.getMessage(), is("Invalid types for comparison: class java.lang.String <= " + "class java.lang.Long")); } }
Example #27
Source File: TypeConvertUtil.java From marble with Apache License 2.0 | 5 votes |
public static Boolean toBoolean(Object value) { if (value == null) { return null; } else { return SqlFunctions.toBoolean(value); } }
Example #28
Source File: SqlFunctionsTest.java From calcite with Apache License 2.0 | 5 votes |
@Test void testGeWithAny() { // Non-numeric same type "greater or equal" check assertThat(SqlFunctions.geAny("banana", "apple"), is(true)); assertThat(SqlFunctions.geAny("apple", "apple"), is(true)); // Numeric types "greater or equal" check assertThat(SqlFunctions.geAny(2, 1L), is(true)); assertThat(SqlFunctions.geAny(1, 1L), is(true)); assertThat(SqlFunctions.geAny(2, 1.0D), is(true)); assertThat(SqlFunctions.geAny(1, 1.0D), is(true)); assertThat(SqlFunctions.geAny(2L, 1.0D), is(true)); assertThat(SqlFunctions.geAny(1L, 1.0D), is(true)); assertThat(SqlFunctions.geAny(new BigDecimal(2L), 1), is(true)); assertThat(SqlFunctions.geAny(new BigDecimal(1L), 1), is(true)); assertThat(SqlFunctions.geAny(new BigDecimal(2L), 1L), is(true)); assertThat(SqlFunctions.geAny(new BigDecimal(1L), 1L), is(true)); assertThat(SqlFunctions.geAny(new BigDecimal(2L), 1.0D), is(true)); assertThat(SqlFunctions.geAny(new BigDecimal(1L), 1.0D), is(true)); assertThat(SqlFunctions.geAny(new BigDecimal(2L), new BigDecimal(1.0D)), is(true)); assertThat(SqlFunctions.geAny(new BigDecimal(1L), new BigDecimal(1.0D)), is(true)); // Non-numeric different type but both implements Comparable // "greater or equal" check try { assertThat(SqlFunctions.geAny("2", 2L), is(false)); fail("'ge' on non-numeric different type is not possible"); } catch (CalciteException e) { assertThat(e.getMessage(), is("Invalid types for comparison: class java.lang.String >= " + "class java.lang.Long")); } }
Example #29
Source File: TypeConvertUtil.java From marble with Apache License 2.0 | 5 votes |
public static Integer toInteger(Object value) { if (value == null) { return null; } if (value instanceof Boolean) { return ((Boolean) value) ? 1 : 0; } return SqlFunctions.toInt(value); }
Example #30
Source File: SqlFunctionsTest.java From calcite with Apache License 2.0 | 5 votes |
@Test void testPlusAny() { // null parameters assertThat(SqlFunctions.plusAny(null, null), nullValue()); assertThat(SqlFunctions.plusAny(null, 1), nullValue()); assertThat(SqlFunctions.plusAny(1, null), nullValue()); // Numeric types assertThat(SqlFunctions.plusAny(2, 1L), is((Object) new BigDecimal(3))); assertThat(SqlFunctions.plusAny(2, 1.0D), is((Object) new BigDecimal(3))); assertThat(SqlFunctions.plusAny(2L, 1.0D), is((Object) new BigDecimal(3))); assertThat(SqlFunctions.plusAny(new BigDecimal(2L), 1), is((Object) new BigDecimal(3))); assertThat(SqlFunctions.plusAny(new BigDecimal(2L), 1L), is((Object) new BigDecimal(3))); assertThat(SqlFunctions.plusAny(new BigDecimal(2L), 1.0D), is((Object) new BigDecimal(3))); assertThat(SqlFunctions.plusAny(new BigDecimal(2L), new BigDecimal(1.0D)), is((Object) new BigDecimal(3))); // Non-numeric type try { SqlFunctions.plusAny("2", 2L); fail("'plus' on non-numeric type is not possible"); } catch (CalciteException e) { assertThat(e.getMessage(), is("Invalid types for arithmetic: class java.lang.String + " + "class java.lang.Long")); } }