vvysotskyi closed pull request #1453: DRILL-6710: Disallow negative scale for
decimal data type
URL: https://github.com/apache/drill/pull/1453
This is a PR merged from a forked repository.
As GitHub hides the original diff on merge, it is displayed below for
the sake of provenance:
As this is a foreign pull request (from a fork), the diff is supplied
below (as it won't show otherwise due to GitHub magic):
diff --git a/contrib/native/client/src/protobuf/UserBitShared.pb.cc
b/contrib/native/client/src/protobuf/UserBitShared.pb.cc
index 574406d7ce7..d0e4aa593e4 100644
--- a/contrib/native/client/src/protobuf/UserBitShared.pb.cc
+++ b/contrib/native/client/src/protobuf/UserBitShared.pb.cc
@@ -750,7 +750,7 @@ void protobuf_AddDesc_UserBitShared_2eproto() {
"TATEMENT\020\005*\207\001\n\rFragmentState\022\013\n\007SENDING\020"
"\000\022\027\n\023AWAITING_ALLOCATION\020\001\022\013\n\007RUNNING\020\002\022"
"\014\n\010FINISHED\020\003\022\r\n\tCANCELLED\020\004\022\n\n\006FAILED\020\005"
- "\022\032\n\026CANCELLATION_REQUESTED\020\006*\343\010\n\020CoreOpe"
+ "\022\032\n\026CANCELLATION_REQUESTED\020\006*\367\010\n\020CoreOpe"
"ratorType\022\021\n\rSINGLE_SENDER\020\000\022\024\n\020BROADCAS"
"T_SENDER\020\001\022\n\n\006FILTER\020\002\022\022\n\016HASH_AGGREGATE"
"\020\003\022\r\n\tHASH_JOIN\020\004\022\016\n\nMERGE_JOIN\020\005\022\031\n\025HAS"
@@ -778,12 +778,12 @@ void protobuf_AddDesc_UserBitShared_2eproto() {
"ER\0200\022\026\n\022OPEN_TSDB_SUB_SCAN\0201\022\017\n\013JSON_WRI"
"TER\0202\022\026\n\022HTPPD_LOG_SUB_SCAN\0203\022\022\n\016IMAGE_S"
"UB_SCAN\0204\022\025\n\021SEQUENCE_SUB_SCAN\0205\022\023\n\017PART"
- "ITION_LIMIT\0206\022\023\n\017PCAPNG_SUB_SCAN\0207*g\n\nSa"
- "ITION_LIMIT\0206\022\022\n\016RUNTIME_FILTER\0207*g\n\nSas"
- "slStatus\022\020\n\014SASL_UNKNOWN\020\000\022\016\n\nSASL_START"
- "\020\001\022\024\n\020SASL_IN_PROGRESS\020\002\022\020\n\014SASL_SUCCESS"
- "\020\003\022\017\n\013SASL_FAILED\020\004B.\n\033org.apache.drill."
- "exec.protoB\rUserBitSharedH\001", 5427);
+ "ITION_LIMIT\0206\022\023\n\017PCAPNG_SUB_SCAN\0207\022\022\n\016RU"
+ "NTIME_FILTER\0208*g\n\nSaslStatus\022\020\n\014SASL_UNK"
+ "NOWN\020\000\022\016\n\nSASL_START\020\001\022\024\n\020SASL_IN_PROGRE"
+
"SS\020\002\022\020\n\014SASL_SUCCESS\020\003\022\017\n\013SASL_FAILED\020\004B"
+ ".\n\033org.apache.drill.exec.protoB\rUserBitS"
+ "haredH\001", 5447);
::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
"UserBitShared.proto", &protobuf_RegisterTypes);
UserCredentials::default_instance_ = new UserCredentials();
@@ -960,6 +960,7 @@ bool CoreOperatorType_IsValid(int value) {
case 53:
case 54:
case 55:
+ case 56:
return true;
default:
return false;
diff --git a/contrib/native/client/src/protobuf/UserBitShared.pb.h
b/contrib/native/client/src/protobuf/UserBitShared.pb.h
index 07ec0af0ac9..849485788b8 100644
--- a/contrib/native/client/src/protobuf/UserBitShared.pb.h
+++ b/contrib/native/client/src/protobuf/UserBitShared.pb.h
@@ -260,7 +260,7 @@ enum CoreOperatorType {
SEQUENCE_SUB_SCAN = 53,
PARTITION_LIMIT = 54,
PCAPNG_SUB_SCAN = 55,
- RUNTIME_FILTER = 56
+ RUNTIME_FILTER = 56
};
bool CoreOperatorType_IsValid(int value);
const CoreOperatorType CoreOperatorType_MIN = SINGLE_SENDER;
diff --git
a/exec/java-exec/src/main/codegen/templates/Decimal/DecimalAggrTypeFunctions1.java
b/exec/java-exec/src/main/codegen/templates/Decimal/DecimalAggrTypeFunctions1.java
index 7f4ca154cd0..083a3cdd3e9 100644
---
a/exec/java-exec/src/main/codegen/templates/Decimal/DecimalAggrTypeFunctions1.java
+++
b/exec/java-exec/src/main/codegen/templates/Decimal/DecimalAggrTypeFunctions1.java
@@ -92,6 +92,8 @@ public void add() {
if (outputScale.value == Integer.MIN_VALUE) {
outputScale.value = in.scale;
}
+
org.apache.drill.exec.util.DecimalUtility.checkValueOverflow((java.math.BigDecimal)
value.obj,
+
org.apache.drill.exec.planner.types.DrillRelDataTypeSystem.DRILL_REL_DATATYPE_SYSTEM.getMaxNumericPrecision(),
outputScale.value);
<#if type.inputType?starts_with("Nullable")>
} // end of sout block
</#if>
@@ -102,8 +104,7 @@ public void output() {
if (nonNullCount.value > 0) {
out.isSet = 1;
out.start = 0;
- out.scale = Math.min(outputScale.value,
-
org.apache.drill.exec.planner.types.DrillRelDataTypeSystem.DRILL_REL_DATATYPE_SYSTEM.getMaxNumericScale());
+ out.scale = outputScale.value;
out.precision =
org.apache.drill.exec.planner.types.DrillRelDataTypeSystem.DRILL_REL_DATATYPE_SYSTEM.getMaxNumericPrecision();
value.obj = ((java.math.BigDecimal) value.obj).setScale(out.scale,
java.math.BigDecimal.ROUND_HALF_UP);
diff --git
a/exec/java-exec/src/main/codegen/templates/Decimal/DecimalAggrTypeFunctions3.java
b/exec/java-exec/src/main/codegen/templates/Decimal/DecimalAggrTypeFunctions3.java
index 3058381d9fc..211bab9bab4 100644
---
a/exec/java-exec/src/main/codegen/templates/Decimal/DecimalAggrTypeFunctions3.java
+++
b/exec/java-exec/src/main/codegen/templates/Decimal/DecimalAggrTypeFunctions3.java
@@ -155,6 +155,7 @@ public void output() {
result = result.setScale(out.scale, java.math.RoundingMode.HALF_UP);
out.start = 0;
out.precision =
org.apache.drill.exec.planner.types.DrillRelDataTypeSystem.DRILL_REL_DATATYPE_SYSTEM.getMaxNumericPrecision();
+ org.apache.drill.exec.util.DecimalUtility.checkValueOverflow(result,
out.precision, out.scale);
byte[] bytes = result.unscaledValue().toByteArray();
int len = bytes.length;
out.buffer = buffer.reallocIfNeeded(len);
diff --git
a/exec/java-exec/src/main/codegen/templates/Decimal/DecimalFunctions.java
b/exec/java-exec/src/main/codegen/templates/Decimal/DecimalFunctions.java
index da18cb11fde..9b055f1be37 100644
--- a/exec/java-exec/src/main/codegen/templates/Decimal/DecimalFunctions.java
+++ b/exec/java-exec/src/main/codegen/templates/Decimal/DecimalFunctions.java
@@ -183,6 +183,8 @@ public void eval() {
new java.math.MathContext(result.precision,
java.math.RoundingMode.HALF_UP))
.setScale(result.scale, java.math.BigDecimal.ROUND_HALF_UP);
+ org.apache.drill.exec.util.DecimalUtility.checkValueOverflow(opResult,
result.precision, result.scale);
+
byte[] bytes = opResult.unscaledValue().toByteArray();
int len = bytes.length;
result.buffer = buffer.reallocIfNeeded(len);
@@ -285,7 +287,7 @@ public void setup() {
public void eval() {
result.start = 0;
- result.scale = right.value;
+ result.scale = Math.max(right.value, 0);
result.precision = left.precision;
java.math.BigDecimal opResult =
org.apache.drill.exec.util.DecimalUtility
@@ -313,7 +315,7 @@ public void setup() {
}
public void eval() {
- result.scale = right.value;
+ result.scale = Math.max(right.value, 0);
result.precision = left.precision;
result.start = 0;
java.math.BigDecimal bd =
diff --git
a/exec/java-exec/src/main/java/org/apache/drill/exec/expr/fn/output/DecimalReturnTypeInference.java
b/exec/java-exec/src/main/java/org/apache/drill/exec/expr/fn/output/DecimalReturnTypeInference.java
index 442514f792e..b30703d7ba2 100644
---
a/exec/java-exec/src/main/java/org/apache/drill/exec/expr/fn/output/DecimalReturnTypeInference.java
+++
b/exec/java-exec/src/main/java/org/apache/drill/exec/expr/fn/output/DecimalReturnTypeInference.java
@@ -277,7 +277,7 @@
return TypeProtos.MajorType.newBuilder()
.setMinorType(attributes.getReturnValue().getType().getMinorType())
- .setScale(scale)
+ .setScale(Math.max(scale, 0))
.setPrecision(precision)
.setMode(mode)
.build();
diff --git
a/exec/java-exec/src/main/java/org/apache/drill/exec/planner/types/decimal/DecimalScalePrecisionAddFunction.java
b/exec/java-exec/src/main/java/org/apache/drill/exec/planner/types/decimal/DecimalScalePrecisionAddFunction.java
index 138f97f6387..db00c51a9d7 100644
---
a/exec/java-exec/src/main/java/org/apache/drill/exec/planner/types/decimal/DecimalScalePrecisionAddFunction.java
+++
b/exec/java-exec/src/main/java/org/apache/drill/exec/planner/types/decimal/DecimalScalePrecisionAddFunction.java
@@ -31,6 +31,6 @@ public void computeScalePrecision(int leftPrecision, int
leftScale, int rightPre
outputPrecision = (outputScale + maxResultIntegerDigits);
- checkPrecisionRange();
+ adjustScaleAndPrecision();
}
}
diff --git
a/exec/java-exec/src/main/java/org/apache/drill/exec/planner/types/decimal/DecimalScalePrecisionDivideFunction.java
b/exec/java-exec/src/main/java/org/apache/drill/exec/planner/types/decimal/DecimalScalePrecisionDivideFunction.java
index eb79d44ae0a..af04f2bc8cf 100644
---
a/exec/java-exec/src/main/java/org/apache/drill/exec/planner/types/decimal/DecimalScalePrecisionDivideFunction.java
+++
b/exec/java-exec/src/main/java/org/apache/drill/exec/planner/types/decimal/DecimalScalePrecisionDivideFunction.java
@@ -34,5 +34,6 @@ public void computeScalePrecision(int leftPrecision, int
leftScale, int rightPre
outputScale = Math.min(outputScale, MAX_NUMERIC_PRECISION -
maxResultIntegerDigits);
outputScale = Math.min(outputScale,
DRILL_REL_DATATYPE_SYSTEM.getMaxNumericScale());
outputPrecision = maxResultIntegerDigits + outputScale;
+ adjustScaleAndPrecision();
}
}
diff --git
a/exec/java-exec/src/main/java/org/apache/drill/exec/planner/types/decimal/DecimalScalePrecisionModFunction.java
b/exec/java-exec/src/main/java/org/apache/drill/exec/planner/types/decimal/DecimalScalePrecisionModFunction.java
index 6901580eb26..9508f3d4e1b 100644
---
a/exec/java-exec/src/main/java/org/apache/drill/exec/planner/types/decimal/DecimalScalePrecisionModFunction.java
+++
b/exec/java-exec/src/main/java/org/apache/drill/exec/planner/types/decimal/DecimalScalePrecisionModFunction.java
@@ -38,7 +38,7 @@ public void computeScalePrecision(int leftPrecision, int
leftScale, int rightPre
outputScale = outputPrecision - leftIntegerDigits;
}
- // Output precision should atleast be greater or equal to the input
precision
- outputPrecision = Math.max(outputPrecision, Math.max(leftPrecision,
rightPrecision));
+ // Output precision should at least be greater or equal to the input
precision
+ outputPrecision = Math.min(outputPrecision, Math.max(leftPrecision,
rightPrecision));
}
}
diff --git
a/exec/java-exec/src/main/java/org/apache/drill/exec/planner/types/decimal/DecimalScalePrecisionMulFunction.java
b/exec/java-exec/src/main/java/org/apache/drill/exec/planner/types/decimal/DecimalScalePrecisionMulFunction.java
index 2a8b22b9d39..6cc55370778 100644
---
a/exec/java-exec/src/main/java/org/apache/drill/exec/planner/types/decimal/DecimalScalePrecisionMulFunction.java
+++
b/exec/java-exec/src/main/java/org/apache/drill/exec/planner/types/decimal/DecimalScalePrecisionMulFunction.java
@@ -32,10 +32,9 @@ public DecimalScalePrecisionMulFunction(int leftPrecision,
int leftScale, int ri
public void computeScalePrecision(int leftPrecision, int leftScale, int
rightPrecision, int rightScale) {
// compute the output scale and precision here
outputScale = leftScale + rightScale;
-
outputPrecision = leftPrecision + rightPrecision;
- checkPrecisionRange();
+ adjustScaleAndPrecision();
}
}
diff --git
a/exec/java-exec/src/main/java/org/apache/drill/exec/planner/types/decimal/DrillBaseComputeScalePrecision.java
b/exec/java-exec/src/main/java/org/apache/drill/exec/planner/types/decimal/DrillBaseComputeScalePrecision.java
index 1c3c186670b..af671e01b09 100644
---
a/exec/java-exec/src/main/java/org/apache/drill/exec/planner/types/decimal/DrillBaseComputeScalePrecision.java
+++
b/exec/java-exec/src/main/java/org/apache/drill/exec/planner/types/decimal/DrillBaseComputeScalePrecision.java
@@ -17,9 +17,14 @@
*/
package org.apache.drill.exec.planner.types.decimal;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
import static
org.apache.drill.exec.planner.types.DrillRelDataTypeSystem.DRILL_REL_DATATYPE_SYSTEM;
public abstract class DrillBaseComputeScalePrecision {
+ private static final Logger logger =
LoggerFactory.getLogger(DrillBaseComputeScalePrecision.class);
+
protected final static int MAX_NUMERIC_PRECISION =
DRILL_REL_DATATYPE_SYSTEM.getMaxNumericPrecision();
protected int outputScale = 0;
@@ -43,10 +48,16 @@ public int getOutputPrecision() {
* Cuts down the fractional part if the current precision
* exceeds the maximum precision range.
*/
- protected void checkPrecisionRange() {
+ protected void adjustScaleAndPrecision() {
if (outputPrecision > MAX_NUMERIC_PRECISION) {
outputScale = outputScale - (outputPrecision - MAX_NUMERIC_PRECISION);
outputPrecision = MAX_NUMERIC_PRECISION;
}
+ if (outputScale < 0) {
+ logger.warn("Resulting precision: {} may overflow max allowed precision:
{}.\n" +
+ "Forced setting max allowed precision and 0 scale.",
+ MAX_NUMERIC_PRECISION - outputScale, MAX_NUMERIC_PRECISION);
+ outputScale = 0;
+ }
}
}
diff --git
a/exec/java-exec/src/test/java/org/apache/drill/TestFunctionsQuery.java
b/exec/java-exec/src/test/java/org/apache/drill/TestFunctionsQuery.java
index 390a6bf8f33..719df6ff53e 100644
--- a/exec/java-exec/src/test/java/org/apache/drill/TestFunctionsQuery.java
+++ b/exec/java-exec/src/test/java/org/apache/drill/TestFunctionsQuery.java
@@ -26,13 +26,17 @@
import java.time.ZoneOffset;
import org.apache.drill.categories.SqlFunctionTest;
+import org.apache.drill.common.exceptions.UserRemoteException;
import org.apache.drill.exec.planner.physical.PlannerSettings;
import org.apache.drill.test.BaseTestQuery;
+import org.hamcrest.CoreMatchers;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Ignore;
+import org.junit.Rule;
import org.junit.Test;
import org.junit.experimental.categories.Category;
+import org.junit.rules.ExpectedException;
@Category(SqlFunctionTest.class)
public class TestFunctionsQuery extends BaseTestQuery {
@@ -48,6 +52,9 @@ public static void disableDecimalDataType() {
resetSessionOption(PlannerSettings.ENABLE_DECIMAL_DATA_TYPE_KEY);
}
+ @Rule
+ public ExpectedException expectedException = ExpectedException.none();
+
@Test
public void testAbsDecimalFunction() throws Exception{
String query = "SELECT " +
@@ -58,16 +65,18 @@ public void testAbsDecimalFunction() throws Exception{
"abs(cast('12345678912345678912.4567' as decimal(28, 5))) DEC28_ABS_1,
" +
"abs(cast('-12345678912345678912.4567' as decimal(28, 5)))
DEC28_ABS_2, " +
"abs(cast('1234567891234567891234567891234567891.4' as decimal(38,
1))) DEC38_ABS_1, " +
- "abs(cast('-1234567891234567891234567891234567891.4' as decimal(38,
1))) DEC38_ABS_2 " +
- "FROM cp.`tpch/region.parquet` limit 1";
+ "abs(cast('-1234567891234567891234567891234567891.4' as decimal(38,
1))) DEC38_ABS_2";
testBuilder()
.sqlQuery(query)
.unOrdered()
- .baselineColumns("DEC9_ABS_1", "DEC9_ABS_2", "DEC18_ABS_1",
"DEC18_ABS_2", "DEC28_ABS_1", "DEC28_ABS_2", "DEC38_ABS_1", "DEC38_ABS_2")
- .baselineValues(new BigDecimal("1234.45670"), new
BigDecimal("1234.45670"), new BigDecimal("99999912399.45670"), new
BigDecimal("99999912399.45670"),
- new BigDecimal("12345678912345678912.45670"), new
BigDecimal("12345678912345678912.45670"), new
BigDecimal("1234567891234567891234567891234567891.4"),
- new BigDecimal("1234567891234567891234567891234567891.4"))
+ .baselineColumns("DEC9_ABS_1", "DEC9_ABS_2", "DEC18_ABS_1",
"DEC18_ABS_2", "DEC28_ABS_1", "DEC28_ABS_2",
+ "DEC38_ABS_1", "DEC38_ABS_2")
+ .baselineValues(new BigDecimal("1234.45670"), new
BigDecimal("1234.45670"),
+ new BigDecimal("99999912399.45670"), new
BigDecimal("99999912399.45670"),
+ new BigDecimal("12345678912345678912.45670"), new
BigDecimal("12345678912345678912.45670"),
+ new BigDecimal("1234567891234567891234567891234567891.4"),
+ new BigDecimal("1234567891234567891234567891234567891.4"))
.go();
}
@@ -92,20 +101,23 @@ public void testCeilDecimalFunction() throws Exception {
"ceil(cast('999999999999999999999999999999999999.4' as decimal(38,
1))) DEC38_2, " +
"ceil(cast('1234567891234567891234567891234567891.0' as decimal(38,
1))) DEC38_3, " +
"ceil(cast('-1234567891234567891234567891234567891.4' as decimal(38,
1))) DEC38_4, " +
- "ceil(cast('-1234567891234567891234567891234567891.0' as decimal(38,
1))) DEC38_5 " +
- "FROM cp.`tpch/region.parquet` limit 1";
+ "ceil(cast('-1234567891234567891234567891234567891.0' as decimal(38,
1))) DEC38_5";
testBuilder()
.sqlQuery(query)
.unOrdered()
.baselineColumns("DEC9_1", "DEC9_2", "DEC9_3", "DEC9_4", "DEC18_1",
"DEC18_2", "DEC18_3", "DEC18_4", "DEC28_1",
"DEC28_2", "DEC28_3", "DEC28_4", "DEC28_5", "DEC38_1", "DEC38_2",
"DEC38_3", "DEC38_4", "DEC38_5")
- .baselineValues(new BigDecimal("1235"), new BigDecimal("1234"), new
BigDecimal("-1234"), new BigDecimal("-1234"),
- new BigDecimal("99999912400"), new BigDecimal("99999912399"), new
BigDecimal("-99999912399"), new BigDecimal("-99999912399"),
- new BigDecimal("12345678912345678913"), new
BigDecimal("1000000000000000000"), new BigDecimal("12345678912345678912"), new
BigDecimal("-12345678912345678912"),
- new BigDecimal("-12345678912345678912"), new
BigDecimal("1234567891234567891234567891234567892"), new
BigDecimal("1000000000000000000000000000000000000"),
- new BigDecimal("1234567891234567891234567891234567891"), new
BigDecimal("-1234567891234567891234567891234567891"),
- new BigDecimal("-1234567891234567891234567891234567891"))
+ .baselineValues(new BigDecimal("1235"), new BigDecimal("1234"), new
BigDecimal("-1234"),
+ new BigDecimal("-1234"), new BigDecimal("99999912400"), new
BigDecimal("99999912399"),
+ new BigDecimal("-99999912399"), new BigDecimal("-99999912399"),
+ new BigDecimal("12345678912345678913"), new
BigDecimal("1000000000000000000"),
+ new BigDecimal("12345678912345678912"), new
BigDecimal("-12345678912345678912"),
+ new BigDecimal("-12345678912345678912"), new
BigDecimal("1234567891234567891234567891234567892"),
+ new BigDecimal("1000000000000000000000000000000000000"),
+ new BigDecimal("1234567891234567891234567891234567891"),
+ new BigDecimal("-1234567891234567891234567891234567891"),
+ new BigDecimal("-1234567891234567891234567891234567891"))
.go();
}
@@ -129,20 +141,23 @@ public void testFloorDecimalFunction() throws Exception {
"floor(cast('999999999999999999999999999999999999.4' as decimal(38,
1))) DEC38_2, " +
"floor(cast('1234567891234567891234567891234567891.0' as decimal(38,
1))) DEC38_3, " +
"floor(cast('-1234567891234567891234567891234567891.4' as decimal(38,
1))) DEC38_4, " +
- "floor(cast('-999999999999999999999999999999999999.4' as decimal(38,
1))) DEC38_5 " +
- "FROM cp.`tpch/region.parquet` limit 1";
+ "floor(cast('-999999999999999999999999999999999999.4' as decimal(38,
1))) DEC38_5";
testBuilder()
.sqlQuery(query)
.unOrdered()
.baselineColumns("DEC9_1", "DEC9_2", "DEC9_3", "DEC9_4", "DEC18_1",
"DEC18_2", "DEC18_3", "DEC18_4", "DEC28_1",
"DEC28_2", "DEC28_3", "DEC28_4", "DEC28_5", "DEC38_1", "DEC38_2",
"DEC38_3", "DEC38_4", "DEC38_5")
- .baselineValues(new BigDecimal("1234"), new BigDecimal("1234"), new
BigDecimal("-1235"), new BigDecimal("-1234"),
- new BigDecimal("99999912399"), new BigDecimal("99999912399"), new
BigDecimal("-99999912400"), new BigDecimal("-99999912399"),
- new BigDecimal("12345678912345678912"), new
BigDecimal("999999999999999999"), new BigDecimal("12345678912345678912"),
- new BigDecimal("-12345678912345678913"), new
BigDecimal("-12345678912345678912"), new
BigDecimal("1234567891234567891234567891234567891"),
- new BigDecimal("999999999999999999999999999999999999"), new
BigDecimal("1234567891234567891234567891234567891"),
- new BigDecimal("-1234567891234567891234567891234567892"), new
BigDecimal("-1000000000000000000000000000000000000"))
+ .baselineValues(new BigDecimal("1234"), new BigDecimal("1234"), new
BigDecimal("-1235"),
+ new BigDecimal("-1234"), new BigDecimal("99999912399"), new
BigDecimal("99999912399"),
+ new BigDecimal("-99999912400"), new BigDecimal("-99999912399"),
+ new BigDecimal("12345678912345678912"), new
BigDecimal("999999999999999999"),
+ new BigDecimal("12345678912345678912"), new
BigDecimal("-12345678912345678913"),
+ new BigDecimal("-12345678912345678912"), new
BigDecimal("1234567891234567891234567891234567891"),
+ new BigDecimal("999999999999999999999999999999999999"),
+ new BigDecimal("1234567891234567891234567891234567891"),
+ new BigDecimal("-1234567891234567891234567891234567892"),
+ new BigDecimal("-1000000000000000000000000000000000000"))
.go();
}
@@ -166,21 +181,23 @@ public void testTruncateDecimalFunction() throws
Exception {
"trunc(cast('999999999999999999999999999999999999.4' as decimal(38,
1))) DEC38_2, " +
"trunc(cast('1234567891234567891234567891234567891.0' as decimal(38,
1))) DEC38_3, " +
"trunc(cast('-1234567891234567891234567891234567891.4' as decimal(38,
1))) DEC38_4, " +
- "trunc(cast('-999999999999999999999999999999999999.4' as decimal(38,
1))) DEC38_5 " +
- "FROM cp.`tpch/region.parquet` limit 1";
+ "trunc(cast('-999999999999999999999999999999999999.4' as decimal(38,
1))) DEC38_5";
testBuilder()
.sqlQuery(query)
.unOrdered()
.baselineColumns("DEC9_1", "DEC9_2", "DEC9_3", "DEC9_4", "DEC18_1",
"DEC18_2", "DEC18_3", "DEC18_4", "DEC28_1",
"DEC28_2", "DEC28_3", "DEC28_4", "DEC28_5", "DEC38_1", "DEC38_2",
"DEC38_3", "DEC38_4", "DEC38_5")
- .baselineValues(new BigDecimal("1234"), new BigDecimal("1234"), new
BigDecimal("-1234"), new BigDecimal("0"),
- new BigDecimal("99999912399"), new BigDecimal("99999912399"), new
BigDecimal("-99999912399"),
- new BigDecimal("-99999912399"), new
BigDecimal("12345678912345678912"), new BigDecimal("999999999999999999"),
- new BigDecimal("12345678912345678912"), new
BigDecimal("-12345678912345678912"), new BigDecimal("-12345678912345678912"),
- new BigDecimal("1234567891234567891234567891234567891"), new
BigDecimal("999999999999999999999999999999999999"),
- new BigDecimal("1234567891234567891234567891234567891"), new
BigDecimal("-1234567891234567891234567891234567891"),
- new BigDecimal("-999999999999999999999999999999999999"))
+ .baselineValues(new BigDecimal("1234"), new BigDecimal("1234"), new
BigDecimal("-1234"),
+ new BigDecimal("0"), new BigDecimal("99999912399"), new
BigDecimal("99999912399"),
+ new BigDecimal("-99999912399"), new BigDecimal("-99999912399"),
+ new BigDecimal("12345678912345678912"), new
BigDecimal("999999999999999999"),
+ new BigDecimal("12345678912345678912"), new
BigDecimal("-12345678912345678912"),
+ new BigDecimal("-12345678912345678912"), new
BigDecimal("1234567891234567891234567891234567891"),
+ new BigDecimal("999999999999999999999999999999999999"),
+ new BigDecimal("1234567891234567891234567891234567891"),
+ new BigDecimal("-1234567891234567891234567891234567891"),
+ new BigDecimal("-999999999999999999999999999999999999"))
.go();
}
@@ -204,20 +221,22 @@ public void testTruncateWithParamDecimalFunction() throws
Exception {
"trunc(cast('999999999.4' as decimal(38, 1)), 8) DEC38_2, " +
"trunc(cast('999999999.1234' as decimal(38, 4)), 12) DEC38_3, " +
"trunc(cast('-123456789123456789.4' as decimal(38, 1)), 10) DEC38_4, "
+
- "trunc(cast('-999999999999999999999999999999999999.4' as decimal(38,
1)), 1) DEC38_5 " +
- "FROM cp.`tpch/region.parquet` limit 1";
+ "trunc(cast('-999999999999999999999999999999999999.4' as decimal(38,
1)), 1) DEC38_5";
testBuilder()
.sqlQuery(query)
.unOrdered()
.baselineColumns("DEC9_1", "DEC9_2", "DEC9_3", "DEC9_4", "DEC18_1",
"DEC18_2", "DEC18_3", "DEC18_4", "DEC28_1",
"DEC28_2", "DEC28_3", "DEC28_4", "DEC28_5", "DEC38_1", "DEC38_2",
"DEC38_3", "DEC38_4", "DEC38_5")
- .baselineValues(new BigDecimal("1234.45"), new
BigDecimal("1234.4500"), new BigDecimal("-1234"), new BigDecimal("0.11"),
- new BigDecimal("99999912399.45"), new
BigDecimal("99999912399.00"), new BigDecimal("-99999912399.450000"),
- new BigDecimal("-99999912399.0000"), new
BigDecimal("12345678912345678912.4"), new
BigDecimal("999999999999999999.456000"),
- new BigDecimal("12345678912345678912.00"), new
BigDecimal("-12345678912345678912"), new BigDecimal("-12345678912345678912.0"),
- new BigDecimal("999999999.1234567"), new
BigDecimal("999999999.40000000"), new BigDecimal("999999999.123400000000"),
- new BigDecimal("-123456789123456789.4000000000"), new
BigDecimal("-999999999999999999999999999999999999.4"))
+ .baselineValues(new BigDecimal("1234.45"), new
BigDecimal("1234.4500"), new BigDecimal("-1234"),
+ new BigDecimal("0.11"), new BigDecimal("99999912399.45"), new
BigDecimal("99999912399.00"),
+ new BigDecimal("-99999912399.450000"), new
BigDecimal("-99999912399.0000"),
+ new BigDecimal("12345678912345678912.4"), new
BigDecimal("999999999999999999.456000"),
+ new BigDecimal("12345678912345678912.00"), new
BigDecimal("-12345678912345678912"),
+ new BigDecimal("-12345678912345678912.0"), new
BigDecimal("999999999.1234567"),
+ new BigDecimal("999999999.40000000"), new
BigDecimal("999999999.123400000000"),
+ new BigDecimal("-123456789123456789.4000000000"),
+ new BigDecimal("-999999999999999999999999999999999999.4"))
.go();
}
@@ -242,20 +261,23 @@ public void testRoundDecimalFunction() throws Exception {
"round(cast('999999999999999999999999999999999999.5' as decimal(38,
1))) DEC38_3, " +
"round(cast('1234567891234567891234567891234567891.2' as decimal(38,
1))) DEC38_4, " +
"round(cast('-1234567891234567891234567891234567891.4' as decimal(38,
1))) DEC38_5, " +
- "round(cast('-999999999999999999999999999999999999.9' as decimal(38,
1))) DEC38_6 " +
- "FROM cp.`tpch/region.parquet` limit 1";
+ "round(cast('-999999999999999999999999999999999999.9' as decimal(38,
1))) DEC38_6";
testBuilder()
.sqlQuery(query)
.unOrdered()
.baselineColumns("DEC9_1", "DEC9_2", "DEC9_3", "DEC9_4", "DEC18_1",
"DEC18_2", "DEC18_3", "DEC18_4", "DEC28_1",
"DEC28_2", "DEC28_3", "DEC28_4", "DEC28_5", "DEC38_1", "DEC38_2",
"DEC38_3", "DEC38_4", "DEC38_5", "DEC38_6")
- .baselineValues(new BigDecimal("1235"), new BigDecimal("1234"), new
BigDecimal("-1235"), new BigDecimal("-1234"),
- new BigDecimal("99999912400"), new BigDecimal("99999912399"), new
BigDecimal("-99999912400"), new BigDecimal("-99999912399"),
- new BigDecimal("12345678912345678913"), new
BigDecimal("1000000000000000000"), new BigDecimal("12345678912345678912"),
- new BigDecimal("-12345678912345678913"), new
BigDecimal("-12345678912345678912"), new
BigDecimal("1000000000000000000000000000"),
- new BigDecimal("100000000"), new
BigDecimal("1000000000000000000000000000000000000"), new
BigDecimal("1234567891234567891234567891234567891"),
- new BigDecimal("-1234567891234567891234567891234567891"), new
BigDecimal("-1000000000000000000000000000000000000"))
+ .baselineValues(new BigDecimal("1235"), new BigDecimal("1234"), new
BigDecimal("-1235"),
+ new BigDecimal("-1234"), new BigDecimal("99999912400"), new
BigDecimal("99999912399"),
+ new BigDecimal("-99999912400"), new BigDecimal("-99999912399"),
+ new BigDecimal("12345678912345678913"), new
BigDecimal("1000000000000000000"),
+ new BigDecimal("12345678912345678912"), new
BigDecimal("-12345678912345678913"),
+ new BigDecimal("-12345678912345678912"), new
BigDecimal("1000000000000000000000000000"),
+ new BigDecimal("100000000"), new
BigDecimal("1000000000000000000000000000000000000"),
+ new BigDecimal("1234567891234567891234567891234567891"),
+ new BigDecimal("-1234567891234567891234567891234567891"),
+ new BigDecimal("-1000000000000000000000000000000000000"))
.go();
}
@@ -283,20 +305,24 @@ public void testRoundWithScaleDecimalFunction() throws
Exception {
"round(cast('999999999.9999999995678' as decimal(38, 18)), 11)
DEC38_4, " +
"round(cast('999999999.9999999995678' as decimal(38, 18)), 21)
DEC38_5, " +
"round(cast('-1234567891234567891234567891234567891.4' as decimal(38,
1)), 1) DEC38_6, " +
- "round(cast('-999999999999999999999999999999999999.9' as decimal(38,
1)), 0) DEC38_7 " +
- "FROM cp.`tpch/region.parquet` limit 1";
+ "round(cast('-999999999999999999999999999999999999.9' as decimal(38,
1)), 0) DEC38_7";
testBuilder()
.sqlQuery(query)
.unOrdered()
- .baselineColumns("DEC9_1", "DEC9_2", "DEC9_3", "DEC9_4", "DEC9_5",
"DEC18_1", "DEC18_2", "DEC18_3", "DEC18_4", "DEC28_1",
- "DEC28_2", "DEC28_3", "DEC28_4", "DEC28_5", "DEC38_1", "DEC38_2",
"DEC38_3", "DEC38_4", "DEC38_5", "DEC38_6", "DEC38_7")
- .baselineValues(new BigDecimal("1234.557"), new BigDecimal("1234.10"),
new BigDecimal("-1234.5567"), new BigDecimal("-1234.123"),
- new BigDecimal("-1234.1200"), new BigDecimal("99999912399.957"),
new BigDecimal("99999912399.00"), new BigDecimal("-99999912399.56"),
- new BigDecimal("-99999912399"), new
BigDecimal("12345678912345678912.56"), new BigDecimal("999999999999999999.6"),
- new BigDecimal("12345678912345678912.00000000"), new
BigDecimal("-12345678912345678912.557"), new
BigDecimal("-12345678912345678912"),
- new BigDecimal("999999999999999999999999999.5"), new
BigDecimal("99999999.512345679"), new BigDecimal("1000000000.000000000"),
- new BigDecimal("999999999.99999999957"), new
BigDecimal("999999999.999999999567800000000"), new
BigDecimal("-1234567891234567891234567891234567891.4"),
- new BigDecimal("-1000000000000000000000000000000000000"))
+ .baselineColumns("DEC9_1", "DEC9_2", "DEC9_3", "DEC9_4", "DEC9_5",
"DEC18_1", "DEC18_2", "DEC18_3", "DEC18_4",
+ "DEC28_1", "DEC28_2", "DEC28_3", "DEC28_4", "DEC28_5", "DEC38_1",
"DEC38_2", "DEC38_3", "DEC38_4", "DEC38_5",
+ "DEC38_6", "DEC38_7")
+ .baselineValues(new BigDecimal("1234.557"), new BigDecimal("1234.10"),
new BigDecimal("-1234.5567"),
+ new BigDecimal("-1234.123"), new BigDecimal("-1234.1200"), new
BigDecimal("99999912399.957"),
+ new BigDecimal("99999912399.00"), new BigDecimal("-99999912399.56"),
+ new BigDecimal("-99999912399"), new
BigDecimal("12345678912345678912.56"),
+ new BigDecimal("999999999999999999.6"), new
BigDecimal("12345678912345678912.00000000"),
+ new BigDecimal("-12345678912345678912.557"), new
BigDecimal("-12345678912345678912"),
+ new BigDecimal("999999999999999999999999999.5"), new
BigDecimal("99999999.512345679"),
+ new BigDecimal("1000000000.000000000"), new
BigDecimal("999999999.99999999957"),
+ new BigDecimal("999999999.999999999567800000000"),
+ new BigDecimal("-1234567891234567891234567891234567891.4"),
+ new BigDecimal("-1000000000000000000000000000000000000"))
.go();
}
@@ -305,8 +331,7 @@ public void testRoundWithScaleDecimalFunction() throws
Exception {
public void testCastDecimalDivide() throws Exception {
String query = "select (cast('9' as decimal(9, 1)) / cast('2' as
decimal(4, 1))) as DEC9_DIV, " +
"cast('999999999' as decimal(9,0)) /
cast('0.000000000000000000000000001' as decimal(28,28)) as DEC38_DIV, " +
- "cast('123456789.123456789' as decimal(18, 9)) *
cast('123456789.123456789' as decimal(18, 9)) as DEC18_MUL " +
- "from cp.`employee.json` where employee_id = 1";
+ "cast('123456789.123456789' as decimal(18, 9)) *
cast('123456789.123456789' as decimal(18, 9)) as DEC18_MUL";
testBuilder()
.sqlQuery(query)
@@ -327,44 +352,40 @@ public void testCastDecimalDivide() throws Exception {
@Test
public void testLiteralCastToFLOATYieldsFLOAT() throws Exception {
testBuilder()
- .sqlQuery( "SELECT CAST( 1.5 AS FLOAT ) AS ShouldBeFLOAT "
- + "FROM cp.`employee.json` LIMIT 1" )
+ .sqlQuery( "SELECT CAST( 1.5 AS FLOAT ) AS ShouldBeFLOAT")
.unOrdered()
.baselineColumns("ShouldBeFLOAT")
- .baselineValues(Float.valueOf(1.5f))
+ .baselineValues(1.5f)
.go();
}
@Test
public void testLiteralCastToDOUBLEYieldsDOUBLE() throws Exception {
testBuilder()
- .sqlQuery( "SELECT CAST( 1.25 AS DOUBLE PRECISION ) AS ShouldBeDOUBLE "
- + "FROM cp.`employee.json` LIMIT 1" )
+ .sqlQuery( "SELECT CAST( 1.25 AS DOUBLE PRECISION ) AS ShouldBeDOUBLE")
.unOrdered()
.baselineColumns("ShouldBeDOUBLE")
- .baselineValues(Double.valueOf(1.25))
+ .baselineValues(1.25)
.go();
}
@Test
public void testLiteralCastToBIGINTYieldsBIGINT() throws Exception {
testBuilder()
- .sqlQuery( "SELECT CAST( 64 AS BIGINT ) AS ShouldBeBIGINT "
- + "FROM cp.`employee.json` LIMIT 1" )
+ .sqlQuery( "SELECT CAST( 64 AS BIGINT ) AS ShouldBeBIGINT")
.unOrdered()
.baselineColumns("ShouldBeBIGINT")
- .baselineValues(Long.valueOf(64))
+ .baselineValues(64L)
.go();
}
@Test
public void testLiteralCastToINTEGERYieldsINTEGER() throws Exception {
testBuilder()
- .sqlQuery( "SELECT CAST( 32 AS INTEGER ) AS ShouldBeINTEGER "
- + "FROM cp.`employee.json` LIMIT 1" )
+ .sqlQuery( "SELECT CAST( 32 AS INTEGER ) AS ShouldBeINTEGER")
.unOrdered()
.baselineColumns("ShouldBeINTEGER")
- .baselineValues(Integer.valueOf(32))
+ .baselineValues(32)
.go();
}
@@ -372,11 +393,10 @@ public void testLiteralCastToINTEGERYieldsINTEGER()
throws Exception {
@Test
public void testLiteralCastToSMALLINTYieldsSMALLINT() throws Exception {
testBuilder()
- .sqlQuery( "SELECT CAST( 16 AS SMALLINT ) AS ShouldBeSMALLINT "
- + "FROM cp.`employee.json` LIMIT 1" )
+ .sqlQuery( "SELECT CAST( 16 AS SMALLINT ) AS ShouldBeSMALLINT")
.unOrdered()
.baselineColumns("ShouldBeSMALLINT")
- .baselineValues(Short.valueOf((short) 16))
+ .baselineValues((short) 16)
.go();
}
@@ -384,14 +404,21 @@ public void testLiteralCastToSMALLINTYieldsSMALLINT()
throws Exception {
@Test
public void testLiteralCastToTINYINTYieldsTINYINT() throws Exception {
testBuilder()
- .sqlQuery( "SELECT CAST( 8 AS TINYINT ) AS ShouldBeTINYINT "
- + "FROM cp.`employee.json` LIMIT 1" )
+ .sqlQuery( "SELECT CAST( 8 AS TINYINT ) AS ShouldBeTINYINT")
.unOrdered()
.baselineColumns("ShouldBeTINYINT")
- .baselineValues(Byte.valueOf((byte) 8))
+ .baselineValues((byte) 8)
.go();
}
+ @Test
+ public void testDecimalMultiplicationOverflowNegativeScale() throws
Exception {
+ String query = "select cast('1000000000000000001.000000000000000000' as
decimal(38, 18)) * " +
+ "cast('99999999999999999999.999999999999999999' as decimal(38, 18)) as
DEC38_1";
+ expectedException.expect(UserRemoteException.class);
+ expectedException.expectMessage(CoreMatchers.containsString("VALIDATION
ERROR: Value 100000000000000000100000000000000000000 overflows specified
precision 38 with scale 0."));
+ test(query);
+ }
@Test
public void testDecimalMultiplicationOverflowHandling() throws Exception {
@@ -404,7 +431,7 @@ public void testDecimalMultiplicationOverflowHandling()
throws Exception {
.sqlQuery(query)
.unOrdered()
.baselineColumns("DEC38_1", "DEC38_2", "DEC38_3")
- .baselineValues(new BigDecimal("1000000000000000000000000000.00000"),
new BigDecimal("1.0000000000000000E+18"), new
BigDecimal("1000000000.000000000000000000"))
+ .baselineValues(new BigDecimal("1000000000000000000000000000.00000"),
new BigDecimal("1000000000000000000"), new
BigDecimal("1000000000.000000000000000000"))
.go();
}
@@ -414,15 +441,16 @@ public void testDecimalRoundUp() throws Exception {
"cast('999999999999999999.9999999999999999994' as decimal(38, 18)) as
DEC38_2, " +
"cast('999999999999999999.1234567895' as decimal(38, 9)) as DEC38_3, "
+
"cast('99999.12345' as decimal(18, 4)) as DEC18_1, " +
- "cast('99999.99995' as decimal(18, 4)) as DEC18_2 " +
- "from cp.`employee.json` where employee_id = 1";
+ "cast('99999.99995' as decimal(18, 4)) as DEC18_2";
testBuilder()
.sqlQuery(query)
.unOrdered()
.baselineColumns("DEC38_1", "DEC38_2", "DEC38_3", "DEC18_1", "DEC18_2")
- .baselineValues(new
BigDecimal("1000000000000000000.000000000000000000"), new
BigDecimal("999999999999999999.999999999999999999"),
- new BigDecimal("999999999999999999.123456790"), new
BigDecimal("99999.1235"), new BigDecimal("100000.0000"))
+ .baselineValues(new
BigDecimal("1000000000000000000.000000000000000000"),
+ new BigDecimal("999999999999999999.999999999999999999"),
+ new BigDecimal("999999999999999999.123456790"), new
BigDecimal("99999.1235"),
+ new BigDecimal("100000.0000"))
.go();
}
@@ -434,14 +462,15 @@ public void testDecimalDownwardCast() throws Exception {
"cast((cast('99999999.6789' as decimal(38, 4))) as decimal(9, 0)) as
DEC38_DEC19_1, " +
"cast((cast('-999999999999999.6789' as decimal(38, 4))) as decimal(18,
2)) as DEC38_DEC18_1, " +
"cast((cast('-999999999999999.6789' as decimal(38, 4))) as decimal(18,
0)) as DEC38_DEC18_2, " +
- "cast((cast('100000000999999999.6789' as decimal(38, 4))) as
decimal(28, 0)) as DEC38_DEC28_1 " +
- "from cp.`employee.json` where employee_id = 1";
+ "cast((cast('100000000999999999.6789' as decimal(38, 4))) as
decimal(28, 0)) as DEC38_DEC28_1";
testBuilder()
.sqlQuery(query)
.unOrdered()
- .baselineColumns("DEC18_DEC9_1", "DEC18_DEC9_2", "DEC18_DEC9_3",
"DEC38_DEC19_1", "DEC38_DEC18_1", "DEC38_DEC18_2", "DEC38_DEC28_1")
- .baselineValues(new BigDecimal("12345.6789"), new
BigDecimal("12345.68"), new BigDecimal("-12346"), new BigDecimal("100000000"),
- new BigDecimal("-999999999999999.68"), new
BigDecimal("-1000000000000000"), new BigDecimal("100000001000000000"))
+ .baselineColumns("DEC18_DEC9_1", "DEC18_DEC9_2", "DEC18_DEC9_3",
"DEC38_DEC19_1", "DEC38_DEC18_1",
+ "DEC38_DEC18_2", "DEC38_DEC28_1")
+ .baselineValues(new BigDecimal("12345.6789"), new
BigDecimal("12345.68"), new BigDecimal("-12346"),
+ new BigDecimal("100000000"), new BigDecimal("-999999999999999.68"),
+ new BigDecimal("-1000000000000000"), new
BigDecimal("100000001000000000"))
.go();
}
@@ -458,15 +487,15 @@ public void testTruncateWithParamFunction() throws
Exception {
"trunc(cast('1234' as double), -4) as T_7,\n" +
"trunc(cast('-1234' as double), -4) as T_8,\n" +
"trunc(cast('8124674407369523212' as double), 0) as T_9,\n" +
- "trunc(cast('81246744073695.395' as double), 1) as T_10\n" +
- "FROM cp.`tpch/region.parquet` limit 1";
+ "trunc(cast('81246744073695.395' as double), 1) as T_10\n";
testBuilder()
.sqlQuery(query)
.unOrdered()
.baselineColumns("T_1", "T_2", "T_3", "T_4", "T_5", "T_6", "T_7",
"T_8", "T_9", "T_10")
- .baselineValues(Double.valueOf("1234.45"), Double.valueOf("-1234.45"),
Double.valueOf("1200.0"), Double.valueOf("-1200.0"), Double.valueOf("1234.0"),
- Double.valueOf("-1234.0"), Double.valueOf("0.0"),
Double.valueOf("0.0"), Double.valueOf("8.1246744073695232E18"),
Double.valueOf("8.12467440736953E13"))
+ .baselineValues(Double.valueOf("1234.45"), Double.valueOf("-1234.45"),
Double.valueOf("1200.0"),
+ Double.valueOf("-1200.0"), Double.valueOf("1234.0"),
Double.valueOf("-1234.0"), Double.valueOf("0.0"),
+ Double.valueOf("0.0"), Double.valueOf("8.1246744073695232E18"),
Double.valueOf("8.12467440736953E13"))
.go();
}
@@ -483,15 +512,14 @@ public void testRoundWithParamFunction() throws Exception
{
"round(cast('1234' as double), -4) as T_7,\n" +
"round(cast('-1234' as double), -4) as T_8,\n" +
"round(cast('8124674407369523212' as double), -4) as T_9,\n" +
- "round(cast('81246744073695.395' as double), 1) as T_10\n" +
- "FROM cp.`tpch/region.parquet` limit 1";
-
+ "round(cast('81246744073695.395' as double), 1) as T_10\n";
testBuilder()
.sqlQuery(query)
.unOrdered()
.baselineColumns("T_1", "T_2", "T_3", "T_4", "T_5", "T_6", "T_7",
"T_8", "T_9", "T_10")
- .baselineValues(Double.valueOf("1234.46"), Double.valueOf("-1234.46"),
Double.valueOf("1200.0"), Double.valueOf("-1200.0"), Double.valueOf("1234.0"),
- Double.valueOf("-1234.0"), Double.valueOf("0.0"),
Double.valueOf("0.0"), Double.valueOf("8.1246744073695201E18"),
Double.valueOf("8.12467440736954E13"))
+ .baselineValues(Double.valueOf("1234.46"), Double.valueOf("-1234.46"),
Double.valueOf("1200.0"),
+ Double.valueOf("-1200.0"), Double.valueOf("1234.0"),
Double.valueOf("-1234.0"), Double.valueOf("0.0"),
+ Double.valueOf("0.0"), Double.valueOf("8.1246744073695201E18"),
Double.valueOf("8.12467440736954E13"))
.go();
}
@@ -505,8 +533,8 @@ public void testRoundWithOneParam() throws Exception {
"round(cast('23.45' as float)) round_float_1,\n" +
"round(cast('23.55' as float)) round_float_2,\n" +
"round(cast('8124674407369.2345' as double)) round_double_1,\n" +
- "round(cast('8124674407369.589' as double)) round_double_2\n" +
- "from cp.`tpch/region.parquet` limit 1";
+ "round(cast('8124674407369.589' as double)) round_double_2\n";
+
testBuilder()
.sqlQuery(query)
.unOrdered()
@@ -523,14 +551,14 @@ public void testToCharFunction() throws Exception {
"to_char(cast('1234.5567' as decimal(9, 5)), '#,###.##') as DEC9_1, " +
"to_char(cast('99999912399.9567' as decimal(18, 5)), '#.#####')
DEC18_1, " +
"to_char(cast('12345678912345678912.5567' as decimal(28, 5)),
'#,###.#####') DEC28_1, " +
- "to_char(cast('999999999999999999999999999.5' as decimal(38, 1)),
'#.#') DEC38_1 " +
- "FROM cp.`tpch/region.parquet` limit 1";
+ "to_char(cast('999999999999999999999999999.5' as decimal(38, 1)),
'#.#') DEC38_1";
testBuilder()
.sqlQuery(query)
.unOrdered()
.baselineColumns("FLOAT8_1", "FLOAT8_2", "DEC9_1", "DEC18_1",
"DEC28_1", "DEC38_1")
- .baselineValues("1,234.56", "$1,234.50", "1,234.56",
"99999912399.9567", "12,345,678,912,345,678,912.5567",
"999999999999999999999999999.5")
+ .baselineValues("1,234.56", "$1,234.50", "1,234.56",
"99999912399.9567", "12,345,678,912,345,678,912.5567",
+ "999999999999999999999999999.5")
.go();
}
@@ -551,8 +579,7 @@ public void testConcatFunction() throws Exception {
@Test
public void testTimeStampConstant() throws Exception {
String query = "SELECT " +
- "timestamp '2008-2-23 12:23:23' as TS " +
- "FROM cp.`tpch/region.parquet` limit 1";
+ "timestamp '2008-2-23 12:23:23' as TS";
LocalDateTime date = LocalDateTime.parse("2008-02-23 12:23:23.0",
formatTimeStamp);
testBuilder()
@@ -568,8 +595,7 @@ public void testNullConstantsTimeTimeStampAndDate() throws
Exception {
String query = "SELECT " +
"CAST(NULL AS TIME) AS t, " +
"CAST(NULL AS TIMESTAMP) AS ts, " +
- "CAST(NULL AS DATE) AS d " +
- "FROM cp.`region.json` LIMIT 1";
+ "CAST(NULL AS DATE) AS d";
testBuilder()
.sqlQuery(query)
.unOrdered()
@@ -623,8 +649,8 @@ public void testDecimalAddIntConstant() throws Exception {
@Test
public void testSignFunction() throws Exception {
- String query = "select sign(cast('1.23' as float)) as SIGN_FLOAT,
sign(-1234.4567) as SIGN_DOUBLE, sign(23) as SIGN_INT " +
- "from cp.`employee.json` where employee_id < 2";
+ String query = "select sign(cast('1.23' as float)) as SIGN_FLOAT,
sign(-1234.4567) as SIGN_DOUBLE, " +
+ "sign(23) as SIGN_INT";
testBuilder()
.sqlQuery(query)
.unOrdered()
@@ -636,9 +662,9 @@ public void testSignFunction() throws Exception {
@Test
public void testPadFunctions() throws Exception {
- String query = "select rpad(first_name, 10) as RPAD_DEF, rpad(first_name,
10, '*') as RPAD_STAR, lpad(first_name, 10) as LPAD_DEF, lpad(first_name, 10,
'*') as LPAD_STAR, " +
- "lpad(first_name, 2) as LPAD_TRUNC, rpad(first_name, 2) as RPAD_TRUNC
" +
- "from cp.`employee.json` where employee_id = 1";
+ String query = "select rpad(first_name, 10) as RPAD_DEF, rpad(first_name,
10, '*') as RPAD_STAR, " +
+ "lpad(first_name, 10) as LPAD_DEF, lpad(first_name, 10, '*') as
LPAD_STAR, lpad(first_name, 2) as LPAD_TRUNC, " +
+ "rpad(first_name, 2) as RPAD_TRUNC from cp.`employee.json` where
employee_id = 1";
testBuilder()
.sqlQuery(query)
@@ -651,9 +677,9 @@ public void testPadFunctions() throws Exception {
@Test
public void testExtractSecond() throws Exception {
- String query = "select extract(second from date '2008-2-23') as DATE_EXT,
extract(second from timestamp '2008-2-23 10:00:20.123') as TS_EXT, " +
- "extract(second from time '10:20:30.303') as TM_EXT " +
- "from cp.`employee.json` where employee_id = 1";
+ String query = "select extract(second from date '2008-2-23') as DATE_EXT,
" +
+ "extract(second from timestamp '2008-2-23 10:00:20.123') as TS_EXT, " +
+ "extract(second from time '10:20:30.303') as TM_EXT";
testBuilder()
.sqlQuery(query)
@@ -665,8 +691,7 @@ public void testExtractSecond() throws Exception {
@Test
public void testCastDecimalDouble() throws Exception {
- String query = "select cast((cast('1.0001' as decimal(18, 9))) as double)
DECIMAL_DOUBLE_CAST " +
- "from cp.`employee.json` where employee_id = 1";
+ String query = "select cast((cast('1.0001' as decimal(18, 9))) as double)
DECIMAL_DOUBLE_CAST";
testBuilder()
.sqlQuery(query)
@@ -678,8 +703,7 @@ public void testCastDecimalDouble() throws Exception {
@Test
public void testExtractSecondFromInterval() throws Exception {
- String query = "select extract (second from interval '1 2:30:45.100' day
to second) as EXT_INTDAY " +
- "from cp.`employee.json` where employee_id = 1";
+ String query = "select extract (second from interval '1 2:30:45.100' day
to second) as EXT_INTDAY";
testBuilder()
.sqlQuery(query)
@@ -693,8 +717,7 @@ public void testExtractSecondFromInterval() throws
Exception {
public void testFunctionCaseInsensitiveNames() throws Exception {
String query = "SELECT to_date('2003/07/09', 'yyyy/MM/dd') as col1, " +
"TO_DATE('2003/07/09', 'yyyy/MM/dd') as col2, " +
- "To_DaTe('2003/07/09', 'yyyy/MM/dd') as col3 " +
- "from cp.`employee.json` LIMIT 1";
+ "To_DaTe('2003/07/09', 'yyyy/MM/dd') as col3";
LocalDate date = LocalDate.parse("2003-07-09");
@@ -708,8 +731,8 @@ public void testFunctionCaseInsensitiveNames() throws
Exception {
@Test
public void testDecimal18Decimal38Comparison() throws Exception {
- String query = "select cast('-999999999.999999999' as decimal(18, 9)) =
cast('-999999999.999999999' as decimal(38, 18)) as CMP " +
- "from cp.`employee.json` where employee_id = 1";
+ String query = "select cast('-999999999.999999999' as decimal(18, 9)) =
cast('-999999999.999999999' as " +
+ "decimal(38, 18)) as CMP";
testBuilder()
.sqlQuery(query)
@@ -721,8 +744,7 @@ public void testDecimal18Decimal38Comparison() throws
Exception {
@Test
public void testOptiqDecimalCapping() throws Exception {
- String query = "select cast('12345.678900000' as decimal(18,
9))=cast('12345.678900000' as decimal(38, 9)) as CMP " +
- "from cp.`employee.json` where employee_id = 1";
+ String query = "select cast('12345.678900000' as decimal(18,
9))=cast('12345.678900000' as decimal(38, 9)) as CMP";
testBuilder()
.sqlQuery(query)
@@ -734,8 +756,7 @@ public void testOptiqDecimalCapping() throws Exception {
@Test
public void testNegative() throws Exception {
- String query = "select negative(cast(2 as bigint)) as NEG\n" +
- "from cp.`employee.json` where employee_id = 1";
+ String query = "select negative(cast(2 as bigint)) as NEG\n";
testBuilder()
.sqlQuery(query)
@@ -760,8 +781,8 @@ public void testOptiqValidationFunctions() throws Exception
{
@Test
public void testToTimeStamp() throws Exception {
- String query = "select to_timestamp(cast('800120400.12312' as decimal(38,
5))) as DEC38_TS, to_timestamp(200120400) as INT_TS\n" +
- "from cp.`employee.json` where employee_id < 2";
+ String query = "select to_timestamp(cast('800120400.12312' as decimal(38,
5))) as DEC38_TS, " +
+ "to_timestamp(200120400) as INT_TS\n";
LocalDateTime result1 =
Instant.ofEpochMilli(800120400123L).atZone(ZoneOffset.systemDefault()).toLocalDateTime();
LocalDateTime result2 =
Instant.ofEpochMilli(200120400000L).atZone(ZoneOffset.systemDefault()).toLocalDateTime();
diff --git
a/exec/java-exec/src/test/java/org/apache/drill/exec/fn/impl/TestVarDecimalFunctions.java
b/exec/java-exec/src/test/java/org/apache/drill/exec/fn/impl/TestVarDecimalFunctions.java
index 4087e675931..68a1fb68d2d 100644
---
a/exec/java-exec/src/test/java/org/apache/drill/exec/fn/impl/TestVarDecimalFunctions.java
+++
b/exec/java-exec/src/test/java/org/apache/drill/exec/fn/impl/TestVarDecimalFunctions.java
@@ -18,12 +18,16 @@
package org.apache.drill.exec.fn.impl;
import org.apache.drill.categories.SqlFunctionTest;
+import org.apache.drill.common.exceptions.UserRemoteException;
import org.apache.drill.exec.planner.physical.PlannerSettings;
import org.apache.drill.test.BaseTestQuery;
+import org.hamcrest.CoreMatchers;
import org.junit.AfterClass;
import org.junit.BeforeClass;
+import org.junit.Rule;
import org.junit.Test;
import org.junit.experimental.categories.Category;
+import org.junit.rules.ExpectedException;
import java.math.BigDecimal;
import java.math.MathContext;
@@ -42,6 +46,9 @@ public static void disableDecimalDataType() {
resetSessionOption(PlannerSettings.ENABLE_DECIMAL_DATA_TYPE_KEY);
}
+ @Rule
+ public ExpectedException expectedException = ExpectedException.none();
+
// Tests for math functions
@Test
@@ -59,9 +66,9 @@ public void testDecimalAdd() throws Exception {
"cast('15.02' as DECIMAL(4, 2)) - cast('12.93' as DECIMAL(4, 2))
as s4,\n" +
"cast('11.02' as DECIMAL(4, 2)) - cast('12.93' as DECIMAL(4, 2))
as s5,\n" +
"cast('0' as DECIMAL(36, 2)) - cast('12.93' as DECIMAL(36, 2)) as
s6,\n" +
- // check trimming (negative scale)
- "cast('99999999999999999999999999992345678912' as DECIMAL(38,
0))\n" +
- "+ cast('32345678912345678912345678912345678912' as DECIMAL(38,
0)) as s7";
+ // check trimming (digits after decimal point will be trimmed from
result)
+ "cast('9999999999999999999999999999234567891.1' as DECIMAL(38,
1))\n" +
+ "+ cast('3234567891234567891234567891234567891.1' as DECIMAL(38,
1)) as s7";
testBuilder()
.sqlQuery(query)
.ordered()
@@ -73,10 +80,23 @@ public void testDecimalAdd() throws Exception {
new BigDecimal("1358024680358024680358024680358024.679"),
new BigDecimal("1234567891234567891234567891234567.890"),
new BigDecimal("2.09"), new BigDecimal("-1.91"), new
BigDecimal("-12.93"),
- new BigDecimal("1.3234567891234567891234567890469135782E+38"))
+ new BigDecimal("13234567891234567891234567890469135782"))
.go();
}
+ @Test
+ public void testDecimalAddOverflow() throws Exception {
+ String query =
+ "select\n" +
+ "cast('99999999999999999999999999992345678912' as DECIMAL(38, 0))\n"
+
+ "+ cast('32345678912345678912345678912345678912' as DECIMAL(38, 0))
as s7";
+ expectedException.expect(UserRemoteException.class);
+ expectedException.expectMessage(
+ CoreMatchers.containsString("VALIDATION ERROR: Value
132345678912345678912345678904691357820 " +
+ "overflows specified precision 38 with scale 0."));
+ test(query);
+ }
+
@Test
public void testDecimalMultiply() throws Exception {
String query =
@@ -101,13 +121,25 @@ public void testDecimalMultiply() throws Exception {
.go();
}
+ @Test
+ public void testDecimalMultiplyOverflow() throws Exception {
+ String query = "select\n" +
+ "cast('999999999999999999999999999.92345678912' as DECIMAL(38, 11))\n"
+
+ " * cast('323456789123.45678912345678912345678912' as DECIMAL(38, 26))
as s1";
+ expectedException.expect(UserRemoteException.class);
+ expectedException.expectMessage(
+ CoreMatchers.containsString("VALIDATION ERROR: Value
323456789123456789123456789098698367900 " +
+ "overflows specified precision 38 with scale 0."));
+ test(query);
+ }
+
@Test
public void testDecimalDivide() throws Exception {
String query =
"select\n" +
// checks trimming of scale
"cast('1.9999999999999999999999999999234567891' as DECIMAL(38,
37))\n" +
- "/ cast('0.00000000000000000000000000000000000001' as DECIMAL(38,
38)) as s1,\n" +
+ "/ cast('0.0000000000000000000000000000000000001' as DECIMAL(38,
37)) as s1,\n" +
// sanitary checks
"cast('1234567.89' as DECIMAL(9, 2))\n" +
"/ cast('-1.789' as DECIMAL(4, 3)) as s2,\n" +
@@ -118,12 +150,24 @@ public void testDecimalDivide() throws Exception {
.sqlQuery(query)
.ordered()
.baselineColumns("s1", "s2", "s3", "s4", "s5")
- .baselineValues(new
BigDecimal("199999999999999999999999999992345678910"),
+ .baselineValues(new
BigDecimal("19999999999999999999999999999234567891"),
new BigDecimal("-690088.2560089"),
new BigDecimal("1.0000000"), new BigDecimal("12.9312345678900"),
new BigDecimal("0.000000"))
.go();
}
+ @Test
+ public void testDecimalDivideOverflow() throws Exception {
+ String query = "select\n" +
+ "cast('1.9999999999999999999999999999234567891' as DECIMAL(38, 37))\n"
+
+ " / cast('0.00000000000000000000000000000000000001' as DECIMAL(38,
38)) as s1";
+ expectedException.expect(UserRemoteException.class);
+ expectedException.expectMessage(
+ CoreMatchers.containsString("VALIDATION ERROR: Value
199999999999999999999999999992345678910 " +
+ "overflows specified precision 38 with scale 0"));
+ test(query);
+ }
+
@Test
public void testDecimalMod() throws Exception {
String query =
----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
[email protected]
With regards,
Apache Git Services
