[
https://issues.apache.org/jira/browse/FLINK-3859?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=15327547#comment-15327547
]
ASF GitHub Bot commented on FLINK-3859:
---------------------------------------
Github user fhueske commented on a diff in the pull request:
https://github.com/apache/flink/pull/2088#discussion_r66807225
--- Diff:
flink-libraries/flink-table/src/test/scala/org/apache/flink/api/scala/expression/DecimalTypeTest.scala
---
@@ -0,0 +1,262 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.flink.api.scala.expression
+
+import org.apache.flink.api.common.typeinfo.BasicTypeInfo._
+import org.apache.flink.api.common.typeinfo.TypeInformation
+import org.apache.flink.api.scala.expression.utils.ExpressionTestBase
+import org.apache.flink.api.scala.table._
+import org.apache.flink.api.table.Row
+import org.apache.flink.api.table.expressions.Literal
+import org.apache.flink.api.table.typeutils.RowTypeInfo
+import org.junit.Test
+
+class DecimalTypeTest extends ExpressionTestBase {
+
+ @Test
+ def testDecimalLiterals(): Unit = {
+ // implicit double
+ testAllApis(
+ 11.2,
+ "11.2",
+ "11.2",
+ "11.2")
+
+ // implicit double
+ testAllApis(
+ 0.7623533651719233,
+ "0.7623533651719233",
+ "0.7623533651719233",
+ "0.7623533651719233")
+
+ // explicit decimal (with precision of 19)
+ testAllApis(
+ BigDecimal("1234567891234567891"),
+ "1234567891234567891p",
+ "1234567891234567891",
+ "1234567891234567891")
+
+ // explicit decimal (high precision, not SQL compliant)
+ testTableApi(
+ BigDecimal("123456789123456789123456789"),
+ "123456789123456789123456789p",
+ "123456789123456789123456789")
+
+ // explicit decimal (high precision, not SQL compliant)
+ testTableApi(
+ BigDecimal("12.3456789123456789123456789"),
+ "12.3456789123456789123456789p",
+ "12.3456789123456789123456789")
+ }
+
+ @Test
+ def testDecimalBorders(): Unit = {
+ testAllApis(
+ Double.MaxValue,
+ Double.MaxValue.toString,
+ Double.MaxValue.toString,
+ Double.MaxValue.toString)
+
+ testAllApis(
+ Double.MinValue,
+ Double.MinValue.toString,
+ Double.MinValue.toString,
+ Double.MinValue.toString)
+
+ testAllApis(
+ Double.MinValue.cast(FLOAT_TYPE_INFO),
+ s"${Double.MinValue}.cast(FLOAT)",
+ s"CAST(${Double.MinValue} AS FLOAT)",
+ Float.NegativeInfinity.toString)
+
+ testAllApis(
+ Byte.MinValue.cast(BYTE_TYPE_INFO),
+ s"(${Byte.MinValue}).cast(BYTE)",
+ s"CAST(${Byte.MinValue} AS TINYINT)",
+ Byte.MinValue.toString)
+
+ testAllApis(
+ Byte.MinValue.cast(BYTE_TYPE_INFO) - 1.cast(BYTE_TYPE_INFO),
+ s"(${Byte.MinValue}).cast(BYTE) - (1).cast(BYTE)",
+ s"CAST(${Byte.MinValue} AS TINYINT) - CAST(1 AS TINYINT)",
+ Byte.MaxValue.toString)
+
+ testAllApis(
+ Short.MinValue.cast(SHORT_TYPE_INFO),
+ s"(${Short.MinValue}).cast(SHORT)",
+ s"CAST(${Short.MinValue} AS SMALLINT)",
+ Short.MinValue.toString)
+
+ testAllApis(
+ Int.MinValue.cast(INT_TYPE_INFO) - 1,
+ s"(${Int.MinValue}).cast(INT) - 1",
+ s"CAST(${Int.MinValue} AS INT) - 1",
+ Int.MaxValue.toString)
+
+ testAllApis(
+ Long.MinValue.cast(LONG_TYPE_INFO),
+ s"(${Long.MinValue}L).cast(LONG)",
+ s"CAST(${Long.MinValue} AS BIGINT)",
+ Long.MinValue.toString)
+ }
+
+ @Test
+ def testDecimalCasting(): Unit = {
+ // from String
+ testTableApi(
+ "123456789123456789123456789".cast(BIG_DEC_TYPE_INFO),
+ "'123456789123456789123456789'.cast(DECIMAL)",
+ "123456789123456789123456789")
+
+ // from double
+ testAllApis(
+ 'f3.cast(BIG_DEC_TYPE_INFO),
+ "f3.cast(DECIMAL)",
+ "CAST(f3 AS DECIMAL)",
+ "4.2")
+
+ // to double
+ testAllApis(
+ 'f0.cast(DOUBLE_TYPE_INFO),
+ "f0.cast(DOUBLE)",
+ "CAST(f0 AS DOUBLE)",
+ "1.2345678912345679E8")
+
+ // to int
+ testAllApis(
+ 'f4.cast(INT_TYPE_INFO),
+ "f4.cast(INT)",
+ "CAST(f4 AS INT)",
+ "123456789")
+
+ // to long
+ testAllApis(
+ 'f4.cast(LONG_TYPE_INFO),
+ "f4.cast(LONG)",
+ "CAST(f4 AS BIGINT)",
+ "123456789")
+
+ // to boolean (not SQL compliant)
+ testTableApi(
+ 'f1.cast(BOOLEAN_TYPE_INFO),
+ "f1.cast(BOOL)",
+ "true")
+
+ testTableApi(
+ 'f5.cast(BOOLEAN_TYPE_INFO),
+ "f5.cast(BOOL)",
+ "false")
+
+ testTableApi(
+ BigDecimal("123456789.123456789123456789").cast(DOUBLE_TYPE_INFO),
+ "(123456789.123456789123456789p).cast(DOUBLE)",
+ "1.2345678912345679E8")
+ }
+
+ @Test
+ def testDecimalArithmetic(): Unit = {
+ // implicit cast to decimal
+ testAllApis(
+ 'f1 + 12,
+ "f1 + 12",
+ "f1 + 12",
+ "123456789123456789123456801")
+
+ // implicit cast to decimal
+ testAllApis(
+ Literal(12) + 'f1,
+ "12 + f1",
+ "12 + f1",
+ "123456789123456789123456801")
+
+ // implicit cast to decimal
+ testAllApis(
+ 'f1 + 12.3,
+ "f1 + 12.3",
+ "f1 + 12.3",
+ "123456789123456789123456801.3")
+
+ // implicit cast to decimal
+ testAllApis(
+ Literal(12.3) + 'f1,
+ "12.3 + f1",
+ "12.3 + f1",
+ "123456789123456789123456801.3")
+
+ testAllApis(
+ 'f1 + 'f1,
+ "f1 + f1",
+ "f1 + f1",
+ "246913578246913578246913578")
+
+ testAllApis(
+ 'f1 - 'f1,
+ "f1 - f1",
+ "f1 - f1",
+ "0")
+
+ testAllApis(
+ 'f1 * 'f1,
+ "f1 * f1",
+ "f1 * f1",
+ "15241578780673678546105778281054720515622620750190521")
+
+ testAllApis(
+ 'f1 / 'f1,
+ "f1 / f1",
+ "f1 / f1",
+ "1")
+
+ testAllApis(
+ 'f1 % 'f1,
+ "f1 % f1",
+ "MOD(f1, f1)",
+ "0")
+
+ testAllApis(
+ -'f0,
+ "-f0",
+ "-f0",
+ "-123456789.123456789123456789")
+ }
+
--- End diff --
It would be good to add tests for comparison operators as well. For
instance,
```
testTableApi('f4 < 'f0, "f4 < f0", "true")
```
yields a
> org.apache.flink.api.table.ValidationException: Expression 'f4 < 'f0
failed on input check: Comparison is only supported for Strings and numeric
types, get BigDecimal and BigDecimal
while
```
testSqlApi("f4 < f0", "true")
```
completes successfully.
> Add BigDecimal/BigInteger support to Table API
> ----------------------------------------------
>
> Key: FLINK-3859
> URL: https://issues.apache.org/jira/browse/FLINK-3859
> Project: Flink
> Issue Type: New Feature
> Components: Table API
> Reporter: Timo Walther
> Assignee: Timo Walther
> Priority: Critical
>
> Since FLINK-3786 has been solved, we can now start integrating
> BigDecimal/BigInteger into the Table API.
--
This message was sent by Atlassian JIRA
(v6.3.4#6332)
