diff --git data/files/kv8.txt data/files/kv8.txt new file mode 100644 index 0000000..4e4dc74 --- /dev/null +++ data/files/kv8.txt @@ -0,0 +1,73 @@ +1234567890123456789012345678901234567 +1.234567890123456789012345678901234567 +12.34567890123456789012345678901234567 +123.4567890123456789012345678901234567 +1234.567890123456789012345678901234567 +123456789012345678901234567890123456 +0.12345678901234567890123456789012345 +1.23456789012345678901234567890123456 +12.3456789012345678901234567890123456 +123.456789012345678901234567890123456 +1234.56789012345678901234567890123456 +12345.6789012345678901234567890123456 +123456.789012345678901234567890123456 +1234567.89012345678901234567890123456 +12345678.9012345678901234567890123456 +123456789.012345678901234567890123456 +1234567890.12345678901234567890123456 +12345678901.2345678901234567890123456 +123456789012.345678901234567890123456 +1234567890123.45678901234567890123456 +12345678901234.5678901234567890123456 +123456789012345.678901234567890123456 +1234567890123456.78901234567890123456 +12345678901234567.8901234567890123456 +123456789012345678.901234567890123456 +1234567890123456789.01234567890123456 +12345678901234567890.1234567890123456 +123456789012345678901.234567890123456 +1234567890123456789012.34567890123456 +12345678901234567890123.4567890123456 +123456789012345678901234.567890123456 +1234567890123456789012345.67890123456 +12345678901234567890123456.7890123456 +123456789012345678901234567.890123456 +1234567890123456789012345678.90123456 +12345678901234567890123456789.0123456 +123456789012345678901234567890.123456 +1234567890123456789012345678901.23456 +12345678901234567890123456789012.3456 +123456789012345678901234567890123.456 +1234567890123456789012345678901234.56 +12345678901234567890123456789012345.6 +123456789012345678901234567890123456.0 +123456789012345678901234567890123456.00 +123456789012345678901234567890123456.000 +000123456789012345678901234567890123456.000 +999999999999999999999999999999999999 +9999999999999999999999999999999999 +999999999999999999999999999999999 +-999999999999999999999999999999999999 +-9999999999999999999999999999999999 +-999999999999999999999999999999999 +0000000000000000000000000000000000000000000 +0.00000000000000000000000000000000001 +-0.00000000000000000000000000000000001 +0.000000000000000000000000000000000001 +-0.000000000000000000000000000000000001 +0.123456789012345 +1.234567890123456 +12.34567890123456 +123.4567890123456 +1234.567890123456 +12345.67890123456 +123456.7890123456 +1234567.890123456 +12345678.90123456 +123456789.0123456 +1234567890.123456 +12345678901.23456 +123456789012.3456 +1234567890123.456 +12345678901234.56 +123456789012345.6 diff --git ql/src/java/org/apache/hadoop/hive/ql/udf/UDFAbs.java ql/src/java/org/apache/hadoop/hive/ql/udf/UDFAbs.java index bfce482..f277ed3 100644 --- ql/src/java/org/apache/hadoop/hive/ql/udf/UDFAbs.java +++ ql/src/java/org/apache/hadoop/hive/ql/udf/UDFAbs.java @@ -24,6 +24,7 @@ import org.apache.hadoop.hive.serde2.io.DoubleWritable; import org.apache.hadoop.io.IntWritable; import org.apache.hadoop.io.LongWritable; +import java.io.IOException; /** * UDFAbs. @@ -76,7 +77,11 @@ public BigDecimalWritable evaluate(BigDecimalWritable n) { return null; } - resultBigDecimal.set(n.getBigDecimal().abs()); + try { + resultBigDecimal.set(n.getBigDecimal().abs()); + } catch (IOException e) { + return null; + } return resultBigDecimal; } } diff --git ql/src/java/org/apache/hadoop/hive/ql/udf/UDFCeil.java ql/src/java/org/apache/hadoop/hive/ql/udf/UDFCeil.java index 927c8b7..6789c5a 100644 --- ql/src/java/org/apache/hadoop/hive/ql/udf/UDFCeil.java +++ ql/src/java/org/apache/hadoop/hive/ql/udf/UDFCeil.java @@ -18,9 +18,8 @@ package org.apache.hadoop.hive.ql.udf; +import java.io.IOException; import java.math.BigDecimal; -import java.math.MathContext; -import java.math.RoundingMode; import org.apache.hadoop.hive.ql.exec.Description; import org.apache.hadoop.hive.ql.exec.UDF; @@ -60,7 +59,11 @@ public BigDecimalWritable evaluate(BigDecimalWritable i) { } else { BigDecimal bd = i.getBigDecimal(); int origScale = bd.scale(); - bigDecimalWritable.set(bd.setScale(0, BigDecimal.ROUND_CEILING).setScale(origScale)); + try { + bigDecimalWritable.set(bd.setScale(0, BigDecimal.ROUND_CEILING).setScale(origScale)); + } catch (IOException e) { + return null; + } return bigDecimalWritable; } } diff --git ql/src/java/org/apache/hadoop/hive/ql/udf/UDFFloor.java ql/src/java/org/apache/hadoop/hive/ql/udf/UDFFloor.java index fc07137..3717b9c 100644 --- ql/src/java/org/apache/hadoop/hive/ql/udf/UDFFloor.java +++ ql/src/java/org/apache/hadoop/hive/ql/udf/UDFFloor.java @@ -18,9 +18,8 @@ package org.apache.hadoop.hive.ql.udf; +import java.io.IOException; import java.math.BigDecimal; -import java.math.MathContext; -import java.math.RoundingMode; import org.apache.hadoop.hive.ql.exec.Description; import org.apache.hadoop.hive.ql.exec.UDF; @@ -60,7 +59,11 @@ public BigDecimalWritable evaluate(BigDecimalWritable i) { } else { BigDecimal bd = i.getBigDecimal(); int origScale = bd.scale(); - bdResult.set(bd.setScale(0, BigDecimal.ROUND_FLOOR).setScale(origScale)); + try { + bdResult.set(bd.setScale(0, BigDecimal.ROUND_FLOOR).setScale(origScale)); + } catch(IOException e) { + return null; + } return bdResult; } } diff --git ql/src/java/org/apache/hadoop/hive/ql/udf/UDFOPDivide.java ql/src/java/org/apache/hadoop/hive/ql/udf/UDFOPDivide.java index a8488d4..969a6b9 100755 --- ql/src/java/org/apache/hadoop/hive/ql/udf/UDFOPDivide.java +++ ql/src/java/org/apache/hadoop/hive/ql/udf/UDFOPDivide.java @@ -18,6 +18,7 @@ package org.apache.hadoop.hive.ql.udf; +import java.io.IOException; import java.math.BigDecimal; import java.math.RoundingMode; @@ -41,8 +42,6 @@ private final DoubleWritable doubleWritable = new DoubleWritable(); private final BigDecimalWritable bigDecimalWritable = new BigDecimalWritable(); - private final int MAX_SCALE = 65; // max compatible with MySQL - public DoubleWritable evaluate(DoubleWritable a, DoubleWritable b) { // LOG.info("Get input " + a.getClass() + ":" + a + " " + b.getClass() + ":" // + b); @@ -61,8 +60,12 @@ public BigDecimalWritable evaluate(BigDecimalWritable a, BigDecimalWritable b) { if (b.getBigDecimal().compareTo(BigDecimal.ZERO) == 0) { return null; } else { + try { bigDecimalWritable.set(a.getBigDecimal().divide( - b.getBigDecimal(), MAX_SCALE, RoundingMode.HALF_UP)); + b.getBigDecimal(), BigDecimalWritable.MAX_PRECISION, RoundingMode.HALF_UP), true); + } catch(IOException e) { + return null; + } } return bigDecimalWritable; diff --git ql/src/java/org/apache/hadoop/hive/ql/udf/UDFOPMinus.java ql/src/java/org/apache/hadoop/hive/ql/udf/UDFOPMinus.java index f884b9a..caa57bb 100755 --- ql/src/java/org/apache/hadoop/hive/ql/udf/UDFOPMinus.java +++ ql/src/java/org/apache/hadoop/hive/ql/udf/UDFOPMinus.java @@ -26,6 +26,7 @@ import org.apache.hadoop.io.FloatWritable; import org.apache.hadoop.io.IntWritable; import org.apache.hadoop.io.LongWritable; +import java.io.IOException; /** * UDFOPMinus. @@ -116,7 +117,11 @@ public BigDecimalWritable evaluate(BigDecimalWritable a, BigDecimalWritable b) { return null; } - bigDecimalWritable.set(a.getBigDecimal().subtract(b.getBigDecimal())); + try { + bigDecimalWritable.set(a.getBigDecimal().subtract(b.getBigDecimal())); + } catch (IOException e) { + return null; + } return bigDecimalWritable; } } diff --git ql/src/java/org/apache/hadoop/hive/ql/udf/UDFOPMod.java ql/src/java/org/apache/hadoop/hive/ql/udf/UDFOPMod.java index 9948c1f..56aa172 100755 --- ql/src/java/org/apache/hadoop/hive/ql/udf/UDFOPMod.java +++ ql/src/java/org/apache/hadoop/hive/ql/udf/UDFOPMod.java @@ -18,6 +18,7 @@ package org.apache.hadoop.hive.ql.udf; +import java.io.IOException; import java.math.BigDecimal; import org.apache.hadoop.hive.ql.exec.Description; @@ -124,7 +125,11 @@ public BigDecimalWritable evaluate(BigDecimalWritable a, BigDecimalWritable b) { return null; } - bigDecimalWritable.set(av.remainder(bv)); + try { + bigDecimalWritable.set(av.remainder(bv)); + } catch (IOException e) { + return null; + } return bigDecimalWritable; } } diff --git ql/src/java/org/apache/hadoop/hive/ql/udf/UDFOPMultiply.java ql/src/java/org/apache/hadoop/hive/ql/udf/UDFOPMultiply.java index 9058651..747d1a2 100755 --- ql/src/java/org/apache/hadoop/hive/ql/udf/UDFOPMultiply.java +++ ql/src/java/org/apache/hadoop/hive/ql/udf/UDFOPMultiply.java @@ -26,6 +26,7 @@ import org.apache.hadoop.io.FloatWritable; import org.apache.hadoop.io.IntWritable; import org.apache.hadoop.io.LongWritable; +import java.io.IOException; /** * UDFOPMultiply. @@ -115,7 +116,11 @@ public BigDecimalWritable evaluate(BigDecimalWritable a, BigDecimalWritable b) { return null; } - bigDecimalWritable.set(a.getBigDecimal().multiply(b.getBigDecimal())); + try { + bigDecimalWritable.set(a.getBigDecimal().multiply(b.getBigDecimal())); + } catch (IOException e) { + return null; + } return bigDecimalWritable; } } diff --git ql/src/java/org/apache/hadoop/hive/ql/udf/UDFOPNegative.java ql/src/java/org/apache/hadoop/hive/ql/udf/UDFOPNegative.java index 3c14fef..717658e 100644 --- ql/src/java/org/apache/hadoop/hive/ql/udf/UDFOPNegative.java +++ ql/src/java/org/apache/hadoop/hive/ql/udf/UDFOPNegative.java @@ -26,6 +26,7 @@ import org.apache.hadoop.io.FloatWritable; import org.apache.hadoop.io.IntWritable; import org.apache.hadoop.io.LongWritable; +import java.io.IOException; /** * UDFOPNegative. @@ -96,7 +97,11 @@ public BigDecimalWritable evaluate(BigDecimalWritable a) { if (a == null) { return null; } - bigDecimalWritable.set(a.getBigDecimal().negate()); + try { + bigDecimalWritable.set(a.getBigDecimal().negate()); + } catch (IOException e) { + return null; + } return bigDecimalWritable; } diff --git ql/src/java/org/apache/hadoop/hive/ql/udf/UDFOPPlus.java ql/src/java/org/apache/hadoop/hive/ql/udf/UDFOPPlus.java index 5722d8b..79995ec 100755 --- ql/src/java/org/apache/hadoop/hive/ql/udf/UDFOPPlus.java +++ ql/src/java/org/apache/hadoop/hive/ql/udf/UDFOPPlus.java @@ -26,6 +26,7 @@ import org.apache.hadoop.io.FloatWritable; import org.apache.hadoop.io.IntWritable; import org.apache.hadoop.io.LongWritable; +import java.io.IOException; /** * The reason that we list evaluate methods with all numeric types is for both @@ -120,7 +121,11 @@ public BigDecimalWritable evaluate(BigDecimalWritable a, BigDecimalWritable b) { return null; } - bigDecimalWritable.set(a.getBigDecimal().add(b.getBigDecimal())); + try { + bigDecimalWritable.set(a.getBigDecimal().add(b.getBigDecimal())); + } catch (IOException e) { + return null; + } return bigDecimalWritable; } diff --git ql/src/java/org/apache/hadoop/hive/ql/udf/UDFPosMod.java ql/src/java/org/apache/hadoop/hive/ql/udf/UDFPosMod.java index 85531a6..4164aa1 100644 --- ql/src/java/org/apache/hadoop/hive/ql/udf/UDFPosMod.java +++ ql/src/java/org/apache/hadoop/hive/ql/udf/UDFPosMod.java @@ -28,6 +28,7 @@ import org.apache.hadoop.io.FloatWritable; import org.apache.hadoop.io.IntWritable; import org.apache.hadoop.io.LongWritable; +import java.io.IOException; /** * class for computing positive modulo. Used for positive_mod command in Cli See @@ -125,7 +126,11 @@ public BigDecimalWritable evaluate(BigDecimalWritable a, BigDecimalWritable b) { return null; } - bigDecimalWritable.set(av.remainder(bv).add(bv).remainder(bv)); + try { + bigDecimalWritable.set(av.remainder(bv).add(bv).remainder(bv)); + } catch(IOException e) { + return null; + } return bigDecimalWritable; } } diff --git ql/src/java/org/apache/hadoop/hive/ql/udf/UDFPower.java ql/src/java/org/apache/hadoop/hive/ql/udf/UDFPower.java index 6795668..b17f1fd 100644 --- ql/src/java/org/apache/hadoop/hive/ql/udf/UDFPower.java +++ ql/src/java/org/apache/hadoop/hive/ql/udf/UDFPower.java @@ -23,6 +23,7 @@ import org.apache.hadoop.hive.serde2.io.BigDecimalWritable; import org.apache.hadoop.hive.serde2.io.DoubleWritable; import org.apache.hadoop.io.IntWritable; +import java.io.IOException; /** * UDFPower. @@ -70,9 +71,12 @@ public BigDecimalWritable evaluate(BigDecimalWritable a, IntWritable b) { if (a == null || b == null) { return null; } else { - resultBigDecimal.set(a.getBigDecimal().pow(b.get())); - return resultBigDecimal; + try { + resultBigDecimal.set(a.getBigDecimal().pow(b.get())); + return resultBigDecimal; + } catch (IOException e) { + return null; + } } } - } diff --git ql/src/java/org/apache/hadoop/hive/ql/udf/UDFRound.java ql/src/java/org/apache/hadoop/hive/ql/udf/UDFRound.java index 1c807ef..0c809be 100644 --- ql/src/java/org/apache/hadoop/hive/ql/udf/UDFRound.java +++ ql/src/java/org/apache/hadoop/hive/ql/udf/UDFRound.java @@ -18,6 +18,7 @@ package org.apache.hadoop.hive.ql.udf; +import java.io.IOException; import java.math.BigDecimal; import java.math.RoundingMode; @@ -73,7 +74,11 @@ private BigDecimalWritable evaluate(BigDecimalWritable n, int i) { } BigDecimal bd = n.getBigDecimal(); bd = n.getBigDecimal().setScale(i, RoundingMode.HALF_UP); - bigDecimalWritable.set(bd); + try { + bigDecimalWritable.set(bd); + } catch(IOException e) { + return null; + } return bigDecimalWritable; } diff --git ql/src/java/org/apache/hadoop/hive/ql/udf/generic/GenericUDAFSum.java ql/src/java/org/apache/hadoop/hive/ql/udf/generic/GenericUDAFSum.java index 8ef27c1..c17fece 100644 --- ql/src/java/org/apache/hadoop/hive/ql/udf/generic/GenericUDAFSum.java +++ ql/src/java/org/apache/hadoop/hive/ql/udf/generic/GenericUDAFSum.java @@ -17,6 +17,7 @@ */ package org.apache.hadoop.hive.ql.udf.generic; +import java.io.IOException; import java.math.BigDecimal; import org.apache.commons.logging.Log; @@ -91,7 +92,6 @@ public GenericUDAFEvaluator getEvaluator(TypeInfo[] parameters) public ObjectInspector init(Mode m, ObjectInspector[] parameters) throws HiveException { assert (parameters.length == 1); super.init(m, parameters); - result = new BigDecimalWritable(BigDecimal.ZERO); inputOI = (PrimitiveObjectInspector) parameters[0]; return PrimitiveObjectInspectorFactory.writableBigDecimalObjectInspector; } @@ -156,7 +156,11 @@ public Object terminate(AggregationBuffer agg) throws HiveException { if (myagg.empty) { return null; } - result.set(myagg.sum); + try { + result = new BigDecimalWritable(myagg.sum); + } catch(IOException e) { + return null; + } return result; } diff --git ql/src/java/org/apache/hadoop/hive/ql/udf/generic/GenericUDFReflect2.java ql/src/java/org/apache/hadoop/hive/ql/udf/generic/GenericUDFReflect2.java index ce468ec..5c10463 100644 --- ql/src/java/org/apache/hadoop/hive/ql/udf/generic/GenericUDFReflect2.java +++ ql/src/java/org/apache/hadoop/hive/ql/udf/generic/GenericUDFReflect2.java @@ -18,6 +18,7 @@ package org.apache.hadoop.hive.ql.udf.generic; +import java.io.IOException; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.math.BigDecimal; @@ -166,7 +167,11 @@ public Object evaluate(DeferredObject[] arguments) throws HiveException { ((BytesWritable)returnObj).set((byte[])result, 0, ((byte[]) result).length); return returnObj; case DECIMAL: - ((BigDecimalWritable)returnObj).set((BigDecimal)result); + try { + ((BigDecimalWritable)returnObj).set((BigDecimal)result); + } catch(IOException e) { + return null; + } return returnObj; } throw new HiveException("Invalid type " + returnOI.getPrimitiveCategory()); diff --git ql/src/test/queries/clientpositive/decimal_precision.q ql/src/test/queries/clientpositive/decimal_precision.q new file mode 100644 index 0000000..d7f4f34 --- /dev/null +++ ql/src/test/queries/clientpositive/decimal_precision.q @@ -0,0 +1,18 @@ +DROP TABLE IF EXISTS DECIMAL_PRECISION; + +CREATE TABLE DECIMAL_PRECISION(dec decimal) +ROW FORMAT DELIMITED + FIELDS TERMINATED BY ' ' +STORED AS TEXTFILE; + +LOAD DATA LOCAL INPATH '../data/files/kv8.txt' INTO TABLE DECIMAL_PRECISION; + +SELECT * FROM DECIMAL_PRECISION ORDER BY dec; + +SELECT dec, dec + 1, dec - 1 FROM DECIMAL_PRECISION ORDER BY dec; +SELECT dec, dec * 2, dec / 3 FROM DECIMAL_PRECISION ORDER BY dec; +SELECT dec, dec / 9 FROM DECIMAL_PRECISION ORDER BY dec; +SELECT dec, dec / 27 FROM DECIMAL_PRECISION ORDER BY dec; +SELECT dec, dec * dec FROM DECIMAL_PRECISION ORDER BY dec; + +DROP TABLE DECIMAL_PRECISION; diff --git ql/src/test/results/clientpositive/decimal_3.q.out ql/src/test/results/clientpositive/decimal_3.q.out index 440ce9e..e691346 100644 --- ql/src/test/results/clientpositive/decimal_3.q.out +++ ql/src/test/results/clientpositive/decimal_3.q.out @@ -27,6 +27,8 @@ POSTHOOK: query: SELECT * FROM DECIMAL_3 ORDER BY key, value POSTHOOK: type: QUERY POSTHOOK: Input: default@decimal_3 #### A masked pattern was here #### +NULL 0 +NULL 0 -1234567890.123456789 -1234567890 -4.4E+3 4400 -1255.49 -1255 @@ -38,7 +40,6 @@ POSTHOOK: Input: default@decimal_3 -0.3 0 0 0 0 0 -1E-99 0 0.01 0 0.02 0 0.1 0 @@ -64,7 +65,6 @@ POSTHOOK: Input: default@decimal_3 125.2 125 2E+2 200 1234567890.12345678 1234567890 -1E+99 0 PREHOOK: query: SELECT * FROM DECIMAL_3 ORDER BY key DESC, value DESC PREHOOK: type: QUERY PREHOOK: Input: default@decimal_3 @@ -73,7 +73,6 @@ POSTHOOK: query: SELECT * FROM DECIMAL_3 ORDER BY key DESC, value DESC POSTHOOK: type: QUERY POSTHOOK: Input: default@decimal_3 #### A masked pattern was here #### -1E+99 0 1234567890.12345678 1234567890 2E+2 200 125.2 125 @@ -99,7 +98,6 @@ POSTHOOK: Input: default@decimal_3 0.1 0 0.02 0 0.01 0 -1E-99 0 0 0 0 0 -0.3 0 @@ -111,6 +109,8 @@ POSTHOOK: Input: default@decimal_3 -1255.49 -1255 -4.4E+3 4400 -1234567890.123456789 -1234567890 +NULL 0 +NULL 0 PREHOOK: query: SELECT * FROM DECIMAL_3 ORDER BY key, value PREHOOK: type: QUERY PREHOOK: Input: default@decimal_3 @@ -119,6 +119,8 @@ POSTHOOK: query: SELECT * FROM DECIMAL_3 ORDER BY key, value POSTHOOK: type: QUERY POSTHOOK: Input: default@decimal_3 #### A masked pattern was here #### +NULL 0 +NULL 0 -1234567890.123456789 -1234567890 -4.4E+3 4400 -1255.49 -1255 @@ -130,7 +132,6 @@ POSTHOOK: Input: default@decimal_3 -0.3 0 0 0 0 0 -1E-99 0 0.01 0 0.02 0 0.1 0 @@ -156,7 +157,6 @@ POSTHOOK: Input: default@decimal_3 125.2 125 2E+2 200 1234567890.12345678 1234567890 -1E+99 0 PREHOOK: query: SELECT DISTINCT key FROM DECIMAL_3 ORDER BY key PREHOOK: type: QUERY PREHOOK: Input: default@decimal_3 @@ -165,6 +165,7 @@ POSTHOOK: query: SELECT DISTINCT key FROM DECIMAL_3 ORDER BY key POSTHOOK: type: QUERY POSTHOOK: Input: default@decimal_3 #### A masked pattern was here #### +NULL -1234567890.123456789 -4.4E+3 -1255.49 @@ -174,7 +175,6 @@ POSTHOOK: Input: default@decimal_3 -0.33 -0.3 0 -1E-99 0.01 0.02 0.1 @@ -195,7 +195,6 @@ POSTHOOK: Input: default@decimal_3 125.2 2E+2 1234567890.12345678 -1E+99 PREHOOK: query: SELECT key, sum(value) FROM DECIMAL_3 GROUP BY key ORDER BY key PREHOOK: type: QUERY PREHOOK: Input: default@decimal_3 @@ -204,6 +203,7 @@ POSTHOOK: query: SELECT key, sum(value) FROM DECIMAL_3 GROUP BY key ORDER BY key POSTHOOK: type: QUERY POSTHOOK: Input: default@decimal_3 #### A masked pattern was here #### +NULL 0 -1234567890.123456789 -1234567890 -4.4E+3 4400 -1255.49 -1255 @@ -213,7 +213,6 @@ POSTHOOK: Input: default@decimal_3 -0.33 0 -0.3 0 0 0 -1E-99 0 0.01 0 0.02 0 0.1 0 @@ -234,7 +233,6 @@ POSTHOOK: Input: default@decimal_3 125.2 125 2E+2 200 1234567890.12345678 1234567890 -1E+99 0 PREHOOK: query: SELECT value, sum(key) FROM DECIMAL_3 GROUP BY value ORDER BY value PREHOOK: type: QUERY PREHOOK: Input: default@decimal_3 @@ -247,18 +245,18 @@ POSTHOOK: Input: default@decimal_3 -1255 -1255.49 -11 -1.122 -1 -2.24 -0 1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.330000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001 +0 0.33 1 5.2419999999999999999999999 2 4 3 9.42 4 3.14 -10 1E+1 -20 2E+1 -100 1E+2 +10 10 +20 20 +100 100 124 124 125 125.2 -200 2E+2 -4400 -4.4E+3 +200 200 +4400 -4400 1234567890 1234567890.12345678 PREHOOK: query: SELECT * FROM DECIMAL_3 a JOIN DECIMAL_3 b ON (a.key = b.key) ORDER BY a.key, a.value, b.value PREHOOK: type: QUERY @@ -283,7 +281,6 @@ POSTHOOK: Input: default@decimal_3 0 0 0 0 0 0 0 0 0 0 0 0 -1E-99 0 1E-99 0 0.01 0 0.01 0 0.02 0 0.02 0 0.1 0 0.1 0 @@ -325,7 +322,6 @@ POSTHOOK: Input: default@decimal_3 125.2 125 125.2 125 2E+2 200 2E+2 200 1234567890.12345678 1234567890 1234567890.12345678 1234567890 -1E+99 0 1E+99 0 PREHOOK: query: SELECT * FROM DECIMAL_3 WHERE key=3.14 ORDER BY key, value PREHOOK: type: QUERY PREHOOK: Input: default@decimal_3 diff --git ql/src/test/results/clientpositive/decimal_precision.q.out ql/src/test/results/clientpositive/decimal_precision.q.out new file mode 100644 index 0000000..b5126f3 --- /dev/null +++ ql/src/test/results/clientpositive/decimal_precision.q.out @@ -0,0 +1,515 @@ +PREHOOK: query: DROP TABLE IF EXISTS DECIMAL_PRECISION +PREHOOK: type: DROPTABLE +POSTHOOK: query: DROP TABLE IF EXISTS DECIMAL_PRECISION +POSTHOOK: type: DROPTABLE +PREHOOK: query: CREATE TABLE DECIMAL_PRECISION(dec decimal) +ROW FORMAT DELIMITED + FIELDS TERMINATED BY ' ' +STORED AS TEXTFILE +PREHOOK: type: CREATETABLE +POSTHOOK: query: CREATE TABLE DECIMAL_PRECISION(dec decimal) +ROW FORMAT DELIMITED + FIELDS TERMINATED BY ' ' +STORED AS TEXTFILE +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: default@DECIMAL_PRECISION +PREHOOK: query: LOAD DATA LOCAL INPATH '../data/files/kv8.txt' INTO TABLE DECIMAL_PRECISION +PREHOOK: type: LOAD +PREHOOK: Output: default@decimal_precision +POSTHOOK: query: LOAD DATA LOCAL INPATH '../data/files/kv8.txt' INTO TABLE DECIMAL_PRECISION +POSTHOOK: type: LOAD +POSTHOOK: Output: default@decimal_precision +PREHOOK: query: SELECT * FROM DECIMAL_PRECISION ORDER BY dec +PREHOOK: type: QUERY +PREHOOK: Input: default@decimal_precision +#### A masked pattern was here #### +POSTHOOK: query: SELECT * FROM DECIMAL_PRECISION ORDER BY dec +POSTHOOK: type: QUERY +POSTHOOK: Input: default@decimal_precision +#### A masked pattern was here #### +NULL +NULL +NULL +NULL +NULL +NULL +NULL +-999999999999999999999999999999999999 +-9999999999999999999999999999999999 +-999999999999999999999999999999999 +-1E-35 +0 +1E-35 +0.123456789012345 +0.12345678901234567890123456789012345 +1.234567890123456 +1.23456789012345678901234567890123456 +12.34567890123456 +12.3456789012345678901234567890123456 +123.4567890123456 +123.456789012345678901234567890123456 +1234.567890123456 +1234.56789012345678901234567890123456 +12345.67890123456 +12345.6789012345678901234567890123456 +123456.7890123456 +123456.789012345678901234567890123456 +1234567.890123456 +1234567.89012345678901234567890123456 +12345678.90123456 +12345678.9012345678901234567890123456 +123456789.0123456 +123456789.012345678901234567890123456 +1234567890.123456 +1234567890.12345678901234567890123456 +12345678901.23456 +12345678901.2345678901234567890123456 +123456789012.3456 +123456789012.345678901234567890123456 +1234567890123.456 +1234567890123.45678901234567890123456 +12345678901234.56 +12345678901234.5678901234567890123456 +123456789012345.6 +123456789012345.678901234567890123456 +1234567890123456.78901234567890123456 +12345678901234567.8901234567890123456 +123456789012345678.901234567890123456 +1234567890123456789.01234567890123456 +12345678901234567890.1234567890123456 +123456789012345678901.234567890123456 +1234567890123456789012.34567890123456 +12345678901234567890123.4567890123456 +123456789012345678901234.567890123456 +1234567890123456789012345.67890123456 +12345678901234567890123456.7890123456 +123456789012345678901234567.890123456 +1234567890123456789012345678.90123456 +12345678901234567890123456789.0123456 +123456789012345678901234567890.123456 +1234567890123456789012345678901.23456 +12345678901234567890123456789012.3456 +123456789012345678901234567890123.456 +999999999999999999999999999999999 +1234567890123456789012345678901234.56 +9999999999999999999999999999999999 +12345678901234567890123456789012345.6 +123456789012345678901234567890123456 +123456789012345678901234567890123456 +123456789012345678901234567890123456 +123456789012345678901234567890123456 +123456789012345678901234567890123456 +999999999999999999999999999999999999 +PREHOOK: query: SELECT dec, dec + 1, dec - 1 FROM DECIMAL_PRECISION ORDER BY dec +PREHOOK: type: QUERY +PREHOOK: Input: default@decimal_precision +#### A masked pattern was here #### +POSTHOOK: query: SELECT dec, dec + 1, dec - 1 FROM DECIMAL_PRECISION ORDER BY dec +POSTHOOK: type: QUERY +POSTHOOK: Input: default@decimal_precision +#### A masked pattern was here #### +NULL NULL NULL +NULL NULL NULL +NULL NULL NULL +NULL NULL NULL +NULL NULL NULL +NULL NULL NULL +NULL NULL NULL +-999999999999999999999999999999999999 -999999999999999999999999999999999998 NULL +-9999999999999999999999999999999999 -9999999999999999999999999999999998 -1E+34 +-999999999999999999999999999999999 -999999999999999999999999999999998 -1E+33 +-1E-35 0.99999999999999999999999999999999999 -1.00000000000000000000000000000000001 +0 1 -1 +1E-35 1.00000000000000000000000000000000001 -0.99999999999999999999999999999999999 +0.123456789012345 1.123456789012345 -0.876543210987655 +0.12345678901234567890123456789012345 1.12345678901234567890123456789012345 -0.87654321098765432109876543210987655 +1.234567890123456 2.234567890123456 0.234567890123456 +1.23456789012345678901234567890123456 2.23456789012345678901234567890123456 0.23456789012345678901234567890123456 +12.34567890123456 13.34567890123456 11.34567890123456 +12.3456789012345678901234567890123456 13.3456789012345678901234567890123456 11.3456789012345678901234567890123456 +123.4567890123456 124.4567890123456 122.4567890123456 +123.456789012345678901234567890123456 124.456789012345678901234567890123456 122.456789012345678901234567890123456 +1234.567890123456 1235.567890123456 1233.567890123456 +1234.56789012345678901234567890123456 1235.56789012345678901234567890123456 1233.56789012345678901234567890123456 +12345.67890123456 12346.67890123456 12344.67890123456 +12345.6789012345678901234567890123456 12346.6789012345678901234567890123456 12344.6789012345678901234567890123456 +123456.7890123456 123457.7890123456 123455.7890123456 +123456.789012345678901234567890123456 123457.789012345678901234567890123456 123455.789012345678901234567890123456 +1234567.890123456 1234568.890123456 1234566.890123456 +1234567.89012345678901234567890123456 1234568.89012345678901234567890123456 1234566.89012345678901234567890123456 +12345678.90123456 12345679.90123456 12345677.90123456 +12345678.9012345678901234567890123456 12345679.9012345678901234567890123456 12345677.9012345678901234567890123456 +123456789.0123456 123456790.0123456 123456788.0123456 +123456789.012345678901234567890123456 123456790.012345678901234567890123456 123456788.012345678901234567890123456 +1234567890.123456 1234567891.123456 1234567889.123456 +1234567890.12345678901234567890123456 1234567891.12345678901234567890123456 1234567889.12345678901234567890123456 +12345678901.23456 12345678902.23456 12345678900.23456 +12345678901.2345678901234567890123456 12345678902.2345678901234567890123456 12345678900.2345678901234567890123456 +123456789012.3456 123456789013.3456 123456789011.3456 +123456789012.345678901234567890123456 123456789013.345678901234567890123456 123456789011.345678901234567890123456 +1234567890123.456 1234567890124.456 1234567890122.456 +1234567890123.45678901234567890123456 1234567890124.45678901234567890123456 1234567890122.45678901234567890123456 +12345678901234.56 12345678901235.56 12345678901233.56 +12345678901234.5678901234567890123456 12345678901235.5678901234567890123456 12345678901233.5678901234567890123456 +123456789012345.6 123456789012346.6 123456789012344.6 +123456789012345.678901234567890123456 123456789012346.678901234567890123456 123456789012344.678901234567890123456 +1234567890123456.78901234567890123456 1234567890123457.78901234567890123456 1234567890123455.78901234567890123456 +12345678901234567.8901234567890123456 12345678901234568.8901234567890123456 12345678901234566.8901234567890123456 +123456789012345678.901234567890123456 123456789012345679.901234567890123456 123456789012345677.901234567890123456 +1234567890123456789.01234567890123456 1234567890123456790.01234567890123456 1234567890123456788.01234567890123456 +12345678901234567890.1234567890123456 12345678901234567891.1234567890123456 12345678901234567889.1234567890123456 +123456789012345678901.234567890123456 123456789012345678902.234567890123456 123456789012345678900.234567890123456 +1234567890123456789012.34567890123456 1234567890123456789013.34567890123456 1234567890123456789011.34567890123456 +12345678901234567890123.4567890123456 12345678901234567890124.4567890123456 12345678901234567890122.4567890123456 +123456789012345678901234.567890123456 123456789012345678901235.567890123456 123456789012345678901233.567890123456 +1234567890123456789012345.67890123456 1234567890123456789012346.67890123456 1234567890123456789012344.67890123456 +12345678901234567890123456.7890123456 12345678901234567890123457.7890123456 12345678901234567890123455.7890123456 +123456789012345678901234567.890123456 123456789012345678901234568.890123456 123456789012345678901234566.890123456 +1234567890123456789012345678.90123456 1234567890123456789012345679.90123456 1234567890123456789012345677.90123456 +12345678901234567890123456789.0123456 12345678901234567890123456790.0123456 12345678901234567890123456788.0123456 +123456789012345678901234567890.123456 123456789012345678901234567891.123456 123456789012345678901234567889.123456 +1234567890123456789012345678901.23456 1234567890123456789012345678902.23456 1234567890123456789012345678900.23456 +12345678901234567890123456789012.3456 12345678901234567890123456789013.3456 12345678901234567890123456789011.3456 +123456789012345678901234567890123.456 123456789012345678901234567890124.456 123456789012345678901234567890122.456 +999999999999999999999999999999999 1E+33 999999999999999999999999999999998 +1234567890123456789012345678901234.56 1234567890123456789012345678901235.56 1234567890123456789012345678901233.56 +9999999999999999999999999999999999 1E+34 9999999999999999999999999999999998 +12345678901234567890123456789012345.6 12345678901234567890123456789012346.6 12345678901234567890123456789012344.6 +123456789012345678901234567890123456 123456789012345678901234567890123457 123456789012345678901234567890123455 +123456789012345678901234567890123456 123456789012345678901234567890123457 123456789012345678901234567890123455 +123456789012345678901234567890123456 123456789012345678901234567890123457 123456789012345678901234567890123455 +123456789012345678901234567890123456 123456789012345678901234567890123457 123456789012345678901234567890123455 +123456789012345678901234567890123456 123456789012345678901234567890123457 123456789012345678901234567890123455 +999999999999999999999999999999999999 NULL 999999999999999999999999999999999998 +PREHOOK: query: SELECT dec, dec * 2, dec / 3 FROM DECIMAL_PRECISION ORDER BY dec +PREHOOK: type: QUERY +PREHOOK: Input: default@decimal_precision +#### A masked pattern was here #### +POSTHOOK: query: SELECT dec, dec * 2, dec / 3 FROM DECIMAL_PRECISION ORDER BY dec +POSTHOOK: type: QUERY +POSTHOOK: Input: default@decimal_precision +#### A masked pattern was here #### +NULL NULL NULL +NULL NULL NULL +NULL NULL NULL +NULL NULL NULL +NULL NULL NULL +NULL NULL NULL +NULL NULL NULL +-999999999999999999999999999999999999 NULL -333333333333333333333333333333333333 +-9999999999999999999999999999999999 -19999999999999999999999999999999998 -3333333333333333333333333333333333 +-999999999999999999999999999999999 -1999999999999999999999999999999998 -333333333333333333333333333333333 +-1E-35 -2E-35 0 +0 0 0 +1E-35 2E-35 0 +0.123456789012345 0.24691357802469 0.041152263004115 +0.12345678901234567890123456789012345 0.2469135780246913578024691357802469 0.04115226300411522630041152263004115 +1.234567890123456 2.469135780246912 0.411522630041152 +1.23456789012345678901234567890123456 2.46913578024691357802469135780246912 0.41152263004115226300411522630041152 +12.34567890123456 24.69135780246912 4.11522630041152 +12.3456789012345678901234567890123456 24.6913578024691357802469135780246912 4.1152263004115226300411522630041152 +123.4567890123456 246.9135780246912 41.1522630041152 +123.456789012345678901234567890123456 246.913578024691357802469135780246912 41.152263004115226300411522630041152 +1234.567890123456 2469.135780246912 411.522630041152 +1234.56789012345678901234567890123456 2469.13578024691357802469135780246912 411.52263004115226300411522630041152 +12345.67890123456 24691.35780246912 4115.22630041152 +12345.6789012345678901234567890123456 24691.3578024691357802469135780246912 4115.2263004115226300411522630041152 +123456.7890123456 246913.5780246912 41152.2630041152 +123456.789012345678901234567890123456 246913.578024691357802469135780246912 41152.263004115226300411522630041152 +1234567.890123456 2469135.780246912 411522.630041152 +1234567.89012345678901234567890123456 2469135.78024691357802469135780246912 411522.63004115226300411522630041152 +12345678.90123456 24691357.80246912 4115226.30041152 +12345678.9012345678901234567890123456 24691357.8024691357802469135780246912 4115226.3004115226300411522630041152 +123456789.0123456 246913578.0246912 41152263.0041152 +123456789.012345678901234567890123456 246913578.024691357802469135780246912 41152263.004115226300411522630041152 +1234567890.123456 2469135780.246912 411522630.041152 +1234567890.12345678901234567890123456 2469135780.24691357802469135780246912 411522630.04115226300411522630041152 +12345678901.23456 24691357802.46912 4115226300.41152 +12345678901.2345678901234567890123456 24691357802.4691357802469135780246912 4115226300.4115226300411522630041152 +123456789012.3456 246913578024.6912 41152263004.1152 +123456789012.345678901234567890123456 246913578024.691357802469135780246912 41152263004.115226300411522630041152 +1234567890123.456 2469135780246.912 411522630041.152 +1234567890123.45678901234567890123456 2469135780246.91357802469135780246912 411522630041.15226300411522630041152 +12345678901234.56 24691357802469.12 4115226300411.52 +12345678901234.5678901234567890123456 24691357802469.1357802469135780246912 4115226300411.5226300411522630041152 +123456789012345.6 246913578024691.2 41152263004115.2 +123456789012345.678901234567890123456 246913578024691.357802469135780246912 41152263004115.226300411522630041152 +1234567890123456.78901234567890123456 2469135780246913.57802469135780246912 411522630041152.26300411522630041152 +12345678901234567.8901234567890123456 24691357802469135.7802469135780246912 4115226300411522.6300411522630041152 +123456789012345678.901234567890123456 246913578024691357.802469135780246912 41152263004115226.300411522630041152 +1234567890123456789.01234567890123456 2469135780246913578.02469135780246912 411522630041152263.00411522630041152 +12345678901234567890.1234567890123456 24691357802469135780.2469135780246912 4115226300411522630.0411522630041152 +123456789012345678901.234567890123456 246913578024691357802.469135780246912 41152263004115226300.411522630041152 +1234567890123456789012.34567890123456 2469135780246913578024.69135780246912 411522630041152263004.11522630041152 +12345678901234567890123.4567890123456 24691357802469135780246.9135780246912 4115226300411522630041.1522630041152 +123456789012345678901234.567890123456 246913578024691357802469.135780246912 41152263004115226300411.522630041152 +1234567890123456789012345.67890123456 2469135780246913578024691.35780246912 411522630041152263004115.22630041152 +12345678901234567890123456.7890123456 24691357802469135780246913.5780246912 4115226300411522630041152.2630041152 +123456789012345678901234567.890123456 246913578024691357802469135.780246912 41152263004115226300411522.630041152 +1234567890123456789012345678.90123456 2469135780246913578024691357.80246912 411522630041152263004115226.30041152 +12345678901234567890123456789.0123456 24691357802469135780246913578.0246912 4115226300411522630041152263.0041152 +123456789012345678901234567890.123456 246913578024691357802469135780.246912 41152263004115226300411522630.041152 +1234567890123456789012345678901.23456 2469135780246913578024691357802.46912 411522630041152263004115226300.41152 +12345678901234567890123456789012.3456 24691357802469135780246913578024.6912 4115226300411522630041152263004.1152 +123456789012345678901234567890123.456 246913578024691357802469135780246.912 41152263004115226300411522630041.152 +999999999999999999999999999999999 1999999999999999999999999999999998 333333333333333333333333333333333 +1234567890123456789012345678901234.56 2469135780246913578024691357802469.12 411522630041152263004115226300411.52 +9999999999999999999999999999999999 19999999999999999999999999999999998 3333333333333333333333333333333333 +12345678901234567890123456789012345.6 24691357802469135780246913578024691.2 4115226300411522630041152263004115.2 +123456789012345678901234567890123456 246913578024691357802469135780246912 41152263004115226300411522630041152 +123456789012345678901234567890123456 246913578024691357802469135780246912 41152263004115226300411522630041152 +123456789012345678901234567890123456 246913578024691357802469135780246912 41152263004115226300411522630041152 +123456789012345678901234567890123456 246913578024691357802469135780246912 41152263004115226300411522630041152 +123456789012345678901234567890123456 246913578024691357802469135780246912 41152263004115226300411522630041152 +999999999999999999999999999999999999 NULL 333333333333333333333333333333333333 +PREHOOK: query: SELECT dec, dec / 9 FROM DECIMAL_PRECISION ORDER BY dec +PREHOOK: type: QUERY +PREHOOK: Input: default@decimal_precision +#### A masked pattern was here #### +POSTHOOK: query: SELECT dec, dec / 9 FROM DECIMAL_PRECISION ORDER BY dec +POSTHOOK: type: QUERY +POSTHOOK: Input: default@decimal_precision +#### A masked pattern was here #### +NULL NULL +NULL NULL +NULL NULL +NULL NULL +NULL NULL +NULL NULL +NULL NULL +-999999999999999999999999999999999999 -111111111111111111111111111111111111 +-9999999999999999999999999999999999 -1111111111111111111111111111111111 +-999999999999999999999999999999999 -111111111111111111111111111111111 +-1E-35 0 +0 0 +1E-35 0 +0.123456789012345 0.01371742100137166666666666666666667 +0.12345678901234567890123456789012345 0.01371742100137174210013717421001372 +1.234567890123456 0.13717421001371733333333333333333333 +1.23456789012345678901234567890123456 0.13717421001371742100137174210013717 +12.34567890123456 1.37174210013717333333333333333333333 +12.3456789012345678901234567890123456 1.37174210013717421001371742100137173 +123.4567890123456 13.7174210013717333333333333333333333 +123.456789012345678901234567890123456 13.7174210013717421001371742100137173 +1234.567890123456 137.174210013717333333333333333333333 +1234.56789012345678901234567890123456 137.174210013717421001371742100137173 +12345.67890123456 1371.74210013717333333333333333333333 +12345.6789012345678901234567890123456 1371.74210013717421001371742100137173 +123456.7890123456 13717.4210013717333333333333333333333 +123456.789012345678901234567890123456 13717.4210013717421001371742100137173 +1234567.890123456 137174.210013717333333333333333333333 +1234567.89012345678901234567890123456 137174.210013717421001371742100137173 +12345678.90123456 1371742.10013717333333333333333333333 +12345678.9012345678901234567890123456 1371742.10013717421001371742100137173 +123456789.0123456 13717421.0013717333333333333333333333 +123456789.012345678901234567890123456 13717421.0013717421001371742100137173 +1234567890.123456 137174210.013717333333333333333333333 +1234567890.12345678901234567890123456 137174210.013717421001371742100137173 +12345678901.23456 1371742100.13717333333333333333333333 +12345678901.2345678901234567890123456 1371742100.13717421001371742100137173 +123456789012.3456 13717421001.3717333333333333333333333 +123456789012.345678901234567890123456 13717421001.3717421001371742100137173 +1234567890123.456 137174210013.717333333333333333333333 +1234567890123.45678901234567890123456 137174210013.717421001371742100137173 +12345678901234.56 1371742100137.17333333333333333333333 +12345678901234.5678901234567890123456 1371742100137.17421001371742100137173 +123456789012345.6 13717421001371.7333333333333333333333 +123456789012345.678901234567890123456 13717421001371.7421001371742100137173 +1234567890123456.78901234567890123456 137174210013717.421001371742100137173 +12345678901234567.8901234567890123456 1371742100137174.21001371742100137173 +123456789012345678.901234567890123456 13717421001371742.1001371742100137173 +1234567890123456789.01234567890123456 137174210013717421.001371742100137173 +12345678901234567890.1234567890123456 1371742100137174210.01371742100137173 +123456789012345678901.234567890123456 13717421001371742100.1371742100137173 +1234567890123456789012.34567890123456 137174210013717421001.371742100137173 +12345678901234567890123.4567890123456 1371742100137174210013.71742100137173 +123456789012345678901234.567890123456 13717421001371742100137.1742100137173 +1234567890123456789012345.67890123456 137174210013717421001371.742100137173 +12345678901234567890123456.7890123456 1371742100137174210013717.42100137173 +123456789012345678901234567.890123456 13717421001371742100137174.2100137173 +1234567890123456789012345678.90123456 137174210013717421001371742.100137173 +12345678901234567890123456789.0123456 1371742100137174210013717421.00137173 +123456789012345678901234567890.123456 13717421001371742100137174210.0137173 +1234567890123456789012345678901.23456 137174210013717421001371742100.137173 +12345678901234567890123456789012.3456 1371742100137174210013717421001.37173 +123456789012345678901234567890123.456 13717421001371742100137174210013.7173 +999999999999999999999999999999999 111111111111111111111111111111111 +1234567890123456789012345678901234.56 137174210013717421001371742100137.173 +9999999999999999999999999999999999 1111111111111111111111111111111111 +12345678901234567890123456789012345.6 1371742100137174210013717421001371.73 +123456789012345678901234567890123456 13717421001371742100137174210013717.3 +123456789012345678901234567890123456 13717421001371742100137174210013717.3 +123456789012345678901234567890123456 13717421001371742100137174210013717.3 +123456789012345678901234567890123456 13717421001371742100137174210013717.3 +123456789012345678901234567890123456 13717421001371742100137174210013717.3 +999999999999999999999999999999999999 111111111111111111111111111111111111 +PREHOOK: query: SELECT dec, dec / 27 FROM DECIMAL_PRECISION ORDER BY dec +PREHOOK: type: QUERY +PREHOOK: Input: default@decimal_precision +#### A masked pattern was here #### +POSTHOOK: query: SELECT dec, dec / 27 FROM DECIMAL_PRECISION ORDER BY dec +POSTHOOK: type: QUERY +POSTHOOK: Input: default@decimal_precision +#### A masked pattern was here #### +NULL NULL +NULL NULL +NULL NULL +NULL NULL +NULL NULL +NULL NULL +NULL NULL +-999999999999999999999999999999999999 -37037037037037037037037037037037037 +-9999999999999999999999999999999999 -370370370370370370370370370370370.333 +-999999999999999999999999999999999 -37037037037037037037037037037037 +-1E-35 0 +0 0 +1E-35 0 +0.123456789012345 0.00457247366712388888888888888888889 +0.12345678901234567890123456789012345 0.00457247366712391403337905807000457 +1.234567890123456 0.04572473667123911111111111111111111 +1.23456789012345678901234567890123456 0.04572473667123914033379058070004572 +12.34567890123456 0.45724736671239111111111111111111111 +12.3456789012345678901234567890123456 0.45724736671239140333790580700045724 +123.4567890123456 4.57247366712391111111111111111111111 +123.456789012345678901234567890123456 4.57247366712391403337905807000457244 +1234.567890123456 45.7247366712391111111111111111111111 +1234.56789012345678901234567890123456 45.7247366712391403337905807000457244 +12345.67890123456 457.247366712391111111111111111111111 +12345.6789012345678901234567890123456 457.247366712391403337905807000457244 +123456.7890123456 4572.47366712391111111111111111111111 +123456.789012345678901234567890123456 4572.47366712391403337905807000457244 +1234567.890123456 45724.7366712391111111111111111111111 +1234567.89012345678901234567890123456 45724.7366712391403337905807000457244 +12345678.90123456 457247.366712391111111111111111111111 +12345678.9012345678901234567890123456 457247.366712391403337905807000457244 +123456789.0123456 4572473.66712391111111111111111111111 +123456789.012345678901234567890123456 4572473.66712391403337905807000457244 +1234567890.123456 45724736.6712391111111111111111111111 +1234567890.12345678901234567890123456 45724736.6712391403337905807000457244 +12345678901.23456 457247366.712391111111111111111111111 +12345678901.2345678901234567890123456 457247366.712391403337905807000457244 +123456789012.3456 4572473667.12391111111111111111111111 +123456789012.345678901234567890123456 4572473667.12391403337905807000457244 +1234567890123.456 45724736671.2391111111111111111111111 +1234567890123.45678901234567890123456 45724736671.2391403337905807000457244 +12345678901234.56 457247366712.391111111111111111111111 +12345678901234.5678901234567890123456 457247366712.391403337905807000457244 +123456789012345.6 4572473667123.91111111111111111111111 +123456789012345.678901234567890123456 4572473667123.91403337905807000457244 +1234567890123456.78901234567890123456 45724736671239.1403337905807000457244 +12345678901234567.8901234567890123456 457247366712391.403337905807000457244 +123456789012345678.901234567890123456 4572473667123914.03337905807000457244 +1234567890123456789.01234567890123456 45724736671239140.3337905807000457244 +12345678901234567890.1234567890123456 457247366712391403.337905807000457244 +123456789012345678901.234567890123456 4572473667123914033.37905807000457244 +1234567890123456789012.34567890123456 45724736671239140333.7905807000457244 +12345678901234567890123.4567890123456 457247366712391403337.905807000457244 +123456789012345678901234.567890123456 4572473667123914033379.05807000457244 +1234567890123456789012345.67890123456 45724736671239140333790.5807000457244 +12345678901234567890123456.7890123456 457247366712391403337905.807000457244 +123456789012345678901234567.890123456 4572473667123914033379058.07000457244 +1234567890123456789012345678.90123456 45724736671239140333790580.7000457244 +12345678901234567890123456789.0123456 457247366712391403337905807.000457244 +123456789012345678901234567890.123456 4572473667123914033379058070.00457244 +1234567890123456789012345678901.23456 45724736671239140333790580700.0457244 +12345678901234567890123456789012.3456 457247366712391403337905807000.457244 +123456789012345678901234567890123.456 4572473667123914033379058070004.57244 +999999999999999999999999999999999 37037037037037037037037037037037 +1234567890123456789012345678901234.56 45724736671239140333790580700045.7244 +9999999999999999999999999999999999 370370370370370370370370370370370.333 +12345678901234567890123456789012345.6 457247366712391403337905807000457.244 +123456789012345678901234567890123456 4572473667123914033379058070004572.44 +123456789012345678901234567890123456 4572473667123914033379058070004572.44 +123456789012345678901234567890123456 4572473667123914033379058070004572.44 +123456789012345678901234567890123456 4572473667123914033379058070004572.44 +123456789012345678901234567890123456 4572473667123914033379058070004572.44 +999999999999999999999999999999999999 37037037037037037037037037037037037 +PREHOOK: query: SELECT dec, dec * dec FROM DECIMAL_PRECISION ORDER BY dec +PREHOOK: type: QUERY +PREHOOK: Input: default@decimal_precision +#### A masked pattern was here #### +POSTHOOK: query: SELECT dec, dec * dec FROM DECIMAL_PRECISION ORDER BY dec +POSTHOOK: type: QUERY +POSTHOOK: Input: default@decimal_precision +#### A masked pattern was here #### +NULL NULL +NULL NULL +NULL NULL +NULL NULL +NULL NULL +NULL NULL +NULL NULL +-999999999999999999999999999999999999 NULL +-9999999999999999999999999999999999 NULL +-999999999999999999999999999999999 NULL +-1E-35 NULL +0 0 +1E-35 NULL +0.123456789012345 0.015241578753238669120562399025 +0.12345678901234567890123456789012345 NULL +1.234567890123456 1.524157875323881726870921383936 +1.23456789012345678901234567890123456 NULL +12.34567890123456 152.4157875323881726870921383936 +12.3456789012345678901234567890123456 NULL +123.4567890123456 15241.57875323881726870921383936 +123.456789012345678901234567890123456 NULL +1234.567890123456 1524157.875323881726870921383936 +1234.56789012345678901234567890123456 NULL +12345.67890123456 152415787.5323881726870921383936 +12345.6789012345678901234567890123456 NULL +123456.7890123456 15241578753.23881726870921383936 +123456.789012345678901234567890123456 NULL +1234567.890123456 1524157875323.881726870921383936 +1234567.89012345678901234567890123456 NULL +12345678.90123456 152415787532388.1726870921383936 +12345678.9012345678901234567890123456 NULL +123456789.0123456 15241578753238817.26870921383936 +123456789.012345678901234567890123456 NULL +1234567890.123456 1524157875323881726.870921383936 +1234567890.12345678901234567890123456 NULL +12345678901.23456 152415787532388172687.0921383936 +12345678901.2345678901234567890123456 NULL +123456789012.3456 15241578753238817268709.21383936 +123456789012.345678901234567890123456 NULL +1234567890123.456 1524157875323881726870921.383936 +1234567890123.45678901234567890123456 NULL +12345678901234.56 152415787532388172687092138.3936 +12345678901234.5678901234567890123456 NULL +123456789012345.6 15241578753238817268709213839.36 +123456789012345.678901234567890123456 NULL +1234567890123456.78901234567890123456 NULL +12345678901234567.8901234567890123456 NULL +123456789012345678.901234567890123456 NULL +1234567890123456789.01234567890123456 NULL +12345678901234567890.1234567890123456 NULL +123456789012345678901.234567890123456 NULL +1234567890123456789012.34567890123456 NULL +12345678901234567890123.4567890123456 NULL +123456789012345678901234.567890123456 NULL +1234567890123456789012345.67890123456 NULL +12345678901234567890123456.7890123456 NULL +123456789012345678901234567.890123456 NULL +1234567890123456789012345678.90123456 NULL +12345678901234567890123456789.0123456 NULL +123456789012345678901234567890.123456 NULL +1234567890123456789012345678901.23456 NULL +12345678901234567890123456789012.3456 NULL +123456789012345678901234567890123.456 NULL +999999999999999999999999999999999 NULL +1234567890123456789012345678901234.56 NULL +9999999999999999999999999999999999 NULL +12345678901234567890123456789012345.6 NULL +123456789012345678901234567890123456 NULL +123456789012345678901234567890123456 NULL +123456789012345678901234567890123456 NULL +123456789012345678901234567890123456 NULL +123456789012345678901234567890123456 NULL +999999999999999999999999999999999999 NULL +PREHOOK: query: DROP TABLE DECIMAL_PRECISION +PREHOOK: type: DROPTABLE +PREHOOK: Input: default@decimal_precision +PREHOOK: Output: default@decimal_precision +POSTHOOK: query: DROP TABLE DECIMAL_PRECISION +POSTHOOK: type: DROPTABLE +POSTHOOK: Input: default@decimal_precision +POSTHOOK: Output: default@decimal_precision diff --git ql/src/test/results/clientpositive/decimal_serde.q.out ql/src/test/results/clientpositive/decimal_serde.q.out index a90be8c..0d50e26 100644 --- ql/src/test/results/clientpositive/decimal_serde.q.out +++ ql/src/test/results/clientpositive/decimal_serde.q.out @@ -39,6 +39,8 @@ POSTHOOK: query: SELECT * FROM DECIMAL_TEXT ORDER BY key, value POSTHOOK: type: QUERY POSTHOOK: Input: default@decimal_text #### A masked pattern was here #### +NULL 0 +NULL 0 -1234567890.123456789 -1234567890 -4.4E+3 4400 -1255.49 -1255 @@ -50,7 +52,6 @@ POSTHOOK: Input: default@decimal_text -0.3 0 0 0 0 0 -1E-99 0 0.01 0 0.02 0 0.1 0 @@ -76,7 +77,6 @@ POSTHOOK: Input: default@decimal_text 125.2 125 2E+2 200 1234567890.12345678 1234567890 -1E+99 0 PREHOOK: query: CREATE TABLE DECIMAL_RC STORED AS RCFile AS SELECT * FROM DECIMAL_TEXT @@ -128,6 +128,8 @@ POSTHOOK: query: SELECT * FROM DECIMAL_SEQUENCE ORDER BY key, value POSTHOOK: type: QUERY POSTHOOK: Input: default@decimal_sequence #### A masked pattern was here #### +NULL 0 +NULL 0 -1234567890.123456789 -1234567890 -4.4E+3 4400 -1255.49 -1255 @@ -139,7 +141,6 @@ POSTHOOK: Input: default@decimal_sequence -0.3 0 0 0 0 0 -1E-99 0 0.01 0 0.02 0 0.1 0 @@ -165,7 +166,6 @@ POSTHOOK: Input: default@decimal_sequence 125.2 125 2E+2 200 1234567890.12345678 1234567890 -1E+99 0 PREHOOK: query: DROP TABLE IF EXISTS DECIMAL_TEXT PREHOOK: type: DROPTABLE PREHOOK: Input: default@decimal_text diff --git ql/src/test/results/clientpositive/decimal_udf.q.out ql/src/test/results/clientpositive/decimal_udf.q.out index e55ad9d..fc18525 100644 --- ql/src/test/results/clientpositive/decimal_udf.q.out +++ ql/src/test/results/clientpositive/decimal_udf.q.out @@ -64,17 +64,17 @@ POSTHOOK: query: SELECT key + key FROM DECIMAL_UDF POSTHOOK: type: QUERY POSTHOOK: Input: default@decimal_udf #### A masked pattern was here #### --8.8E+3 -2E+99 -2E-99 +-8800 +NULL +NULL 0 -2E+2 -2E+1 +200 +20 2 0.2 0.02 -4E+2 -4E+1 +400 +40 4 0 0.4 @@ -146,16 +146,16 @@ POSTHOOK: type: QUERY POSTHOOK: Input: default@decimal_udf #### A masked pattern was here #### 0 -1E+99 -1E-99 +NULL +NULL 0 -2E+2 -2E+1 +200 +20 2 0.1 0.01 -4E+2 -4E+1 +400 +40 4 0 0.2 @@ -226,17 +226,17 @@ POSTHOOK: query: SELECT key + (value/2) FROM DECIMAL_UDF POSTHOOK: type: QUERY POSTHOOK: Input: default@decimal_udf #### A masked pattern was here #### --2.2E+3 -1E+99 -1E-99 +-2200 +NULL +NULL 0 -1.5E+2 +150 15 1.5 0.1 0.01 -3E+2 -3E+1 +300 +30 3 0 0.2 @@ -308,8 +308,8 @@ POSTHOOK: type: QUERY POSTHOOK: Input: default@decimal_udf #### A masked pattern was here #### -4399 -1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001 -1.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001 +NULL +NULL 1 101 11 @@ -391,8 +391,8 @@ POSTHOOK: type: QUERY POSTHOOK: Input: default@decimal_udf #### A masked pattern was here #### 0 -0 -0 +NULL +NULL 0 0 0 @@ -471,9 +471,9 @@ POSTHOOK: query: SELECT key - value FROM DECIMAL_UDF POSTHOOK: type: QUERY POSTHOOK: Input: default@decimal_udf #### A masked pattern was here #### --8.8E+3 -1E+99 -1E-99 +-8800 +NULL +NULL 0 0 0 @@ -552,17 +552,17 @@ POSTHOOK: query: SELECT key - (value/2) FROM DECIMAL_UDF POSTHOOK: type: QUERY POSTHOOK: Input: default@decimal_udf #### A masked pattern was here #### --6.6E+3 -1E+99 -1E-99 +-6600 +NULL +NULL 0 -5E+1 +50 5 0.5 0.1 0.01 -1E+2 -1E+1 +100 +10 1 0 0.2 @@ -634,8 +634,8 @@ POSTHOOK: type: QUERY POSTHOOK: Input: default@decimal_udf #### A masked pattern was here #### -4401 -999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999 --0.999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999 +NULL +NULL -1 99 9 @@ -716,17 +716,17 @@ POSTHOOK: query: SELECT key * key FROM DECIMAL_UDF POSTHOOK: type: QUERY POSTHOOK: Input: default@decimal_udf #### A masked pattern was here #### -1.936E+7 -1E+198 -1E-198 +19360000 +NULL +NULL 0 -1E+4 -1E+2 +10000 +100 1 0.01 0.0001 -4E+4 -4E+2 +40000 +400 4 0 0.04 @@ -751,8 +751,8 @@ POSTHOOK: Input: default@decimal_udf 9.8596 9.8596 9.8596 -0.99999999999999999999999980000000000000000000000001 -1524157875323883675.019051998750190521 +NULL +NULL 1524157875323883652.7968299765279684 PREHOOK: query: EXPLAIN SELECT key * value FROM DECIMAL_UDF PREHOOK: type: QUERY @@ -798,8 +798,8 @@ POSTHOOK: type: QUERY POSTHOOK: Input: default@decimal_udf #### A masked pattern was here #### -1.936E+7 -0 -0 +NULL +NULL 0 1E+4 1E+2 @@ -827,7 +827,7 @@ POSTHOOK: Input: default@decimal_udf 1.12 1.122 15376 -1.565E+4 +15650 1575639.95 9.42 9.42 @@ -879,11 +879,11 @@ POSTHOOK: type: QUERY POSTHOOK: Input: default@decimal_udf #### A masked pattern was here #### -9.68E+6 -0 -0 +NULL +NULL 0 5E+3 -5E+1 +50 0.5 0 0 @@ -959,17 +959,17 @@ POSTHOOK: query: SELECT key * '2.0' FROM DECIMAL_UDF POSTHOOK: type: QUERY POSTHOOK: Input: default@decimal_udf #### A masked pattern was here #### --8.8E+3 -2E+99 -2E-99 +-8800 +NULL +NULL 0 -2E+2 -2E+1 +200 +20 2 0.2 0.02 -4E+2 -4E+1 +400 +40 4 0 0.4 @@ -1170,8 +1170,6 @@ POSTHOOK: Input: default@decimal_udf 1 1 1 -1 -1 PREHOOK: query: EXPLAIN SELECT key / value FROM DECIMAL_UDF WHERE value is not null and value <> 0 PREHOOK: type: QUERY POSTHOOK: query: EXPLAIN SELECT key / value FROM DECIMAL_UDF WHERE value is not null and value <> 0 @@ -1228,7 +1226,7 @@ POSTHOOK: Input: default@decimal_udf 1 1 1 -1.04666666666666666666666666666666666666666666666666666666666666667 +1.04666666666666666666666666666666667 1.12 1.12 0.102 @@ -1236,13 +1234,13 @@ POSTHOOK: Input: default@decimal_udf 1.122 1 1.0016 -1.00039043824701195219123505976095617529880478087649402390438247012 -1.04666666666666666666666666666666666666666666666666666666666666667 -1.04666666666666666666666666666666666666666666666666666666666666667 +1.00039043824701195219123505976095618 +1.04666666666666666666666666666666667 +1.04666666666666666666666666666666667 0.785 0.9999999999999999999999999 1.0000000001 -1.00000000009999999270999993366099939631509450646736000885297608056 +1.0000000000999999927099999336609994 PREHOOK: query: EXPLAIN SELECT key / (value/2) FROM DECIMAL_UDF WHERE value is not null and value <> 0 PREHOOK: type: QUERY POSTHOOK: query: EXPLAIN SELECT key / (value/2) FROM DECIMAL_UDF WHERE value is not null and value <> 0 @@ -1299,7 +1297,7 @@ POSTHOOK: Input: default@decimal_udf 2 2 2 -2.09333333333333333333333333333333333333333333333333333333333333333 +2.09333333333333333333333333333333333 2.24 2.24 0.204 @@ -1307,13 +1305,13 @@ POSTHOOK: Input: default@decimal_udf 2.244 2 2.0032 -2.00078087649402390438247011952191235059760956175298804780876494024 -2.09333333333333333333333333333333333333333333333333333333333333333 -2.09333333333333333333333333333333333333333333333333333333333333333 +2.00078087649402390438247011952191235 +2.09333333333333333333333333333333333 +2.09333333333333333333333333333333333 1.57 1.9999999999999999999999998 2.0000000002 -2.00000000019999998541999986732199879263018901293472001770595216112 +2.00000000019999998541999986732199879 PREHOOK: query: EXPLAIN SELECT key / '2.0' FROM DECIMAL_UDF PREHOOK: type: QUERY POSTHOOK: query: EXPLAIN SELECT key / '2.0' FROM DECIMAL_UDF @@ -1357,17 +1355,17 @@ POSTHOOK: query: SELECT key / '2.0' FROM DECIMAL_UDF POSTHOOK: type: QUERY POSTHOOK: Input: default@decimal_udf #### A masked pattern was here #### --2.2E+3 -5E+98 -0 +-2200 +NULL +NULL 0 -5E+1 +50 5 0.5 0.05 0.005 -1E+2 -1E+1 +100 +10 1 0 0.1 @@ -1440,17 +1438,17 @@ POSTHOOK: query: SELECT abs(key) FROM DECIMAL_UDF POSTHOOK: type: QUERY POSTHOOK: Input: default@decimal_udf #### A masked pattern was here #### -4.4E+3 -1E+99 -1E-99 +4400 +NULL +NULL 0 -1E+2 -1E+1 +100 +10 1 0.1 0.01 -2E+2 -2E+1 +200 +20 2 0 0.2 @@ -1523,17 +1521,17 @@ POSTHOOK: query: SELECT -key FROM DECIMAL_UDF POSTHOOK: type: QUERY POSTHOOK: Input: default@decimal_udf #### A masked pattern was here #### -4.4E+3 --1E+99 --1E-99 +4400 +NULL +NULL 0 --1E+2 --1E+1 +-100 +-10 -1 -0.1 -0.01 --2E+2 --2E+1 +-200 +-20 -2 0 -0.2 @@ -1606,17 +1604,17 @@ POSTHOOK: query: SELECT +key FROM DECIMAL_UDF POSTHOOK: type: QUERY POSTHOOK: Input: default@decimal_udf #### A masked pattern was here #### --4.4E+3 -1E+99 -1E-99 +-4400 +NULL +NULL 0 -1E+2 -1E+1 +100 +10 1 0.1 0.01 -2E+2 -2E+1 +200 +20 2 0 0.2 @@ -1689,17 +1687,17 @@ POSTHOOK: query: SELECT CEIL(key) FROM DECIMAL_UDF POSTHOOK: type: QUERY POSTHOOK: Input: default@decimal_udf #### A masked pattern was here #### --4.4E+3 -1E+99 -1 +-4400 +NULL +NULL 0 -1E+2 -1E+1 +100 +10 1 1 1 -2E+2 -2E+1 +200 +20 2 0 1 @@ -1725,7 +1723,7 @@ POSTHOOK: Input: default@decimal_udf 4 4 1 --1.23456789E+9 +-1234567890 1234567891 PREHOOK: query: -- floor EXPLAIN SELECT FLOOR(key) FROM DECIMAL_UDF @@ -1772,17 +1770,17 @@ POSTHOOK: query: SELECT FLOOR(key) FROM DECIMAL_UDF POSTHOOK: type: QUERY POSTHOOK: Input: default@decimal_udf #### A masked pattern was here #### --4.4E+3 -1E+99 -0 +-4400 +NULL +NULL 0 -1E+2 -1E+1 +100 +10 1 0 0 -2E+2 -2E+1 +200 +20 2 0 0 @@ -1809,7 +1807,7 @@ POSTHOOK: Input: default@decimal_udf 3 0 -1234567891 -1.23456789E+9 +1234567890 PREHOOK: query: -- round EXPLAIN SELECT ROUND(key, 2) FROM DECIMAL_UDF PREHOOK: type: QUERY @@ -1855,17 +1853,17 @@ POSTHOOK: query: SELECT ROUND(key, 2) FROM DECIMAL_UDF POSTHOOK: type: QUERY POSTHOOK: Input: default@decimal_udf #### A masked pattern was here #### --4.4E+3 -1E+99 -0 +-4400 +NULL +NULL 0 -1E+2 -1E+1 +100 +10 1 0.1 0.01 -2E+2 -2E+1 +200 +20 2 0 0.2 @@ -1938,17 +1936,17 @@ POSTHOOK: query: SELECT POWER(key, 2) FROM DECIMAL_UDF POSTHOOK: type: QUERY POSTHOOK: Input: default@decimal_udf #### A masked pattern was here #### -1.936E+7 -1E+198 -1E-198 +19360000 +NULL +NULL 0 -1E+4 -1E+2 +10000 +100 1 0.01 0.0001 -4E+4 -4E+2 +40000 +400 4 0 0.04 @@ -1973,8 +1971,8 @@ POSTHOOK: Input: default@decimal_udf 9.8596 9.8596 9.8596 -0.99999999999999999999999980000000000000000000000001 -1524157875323883675.019051998750190521 +NULL +NULL 1524157875323883652.7968299765279684 PREHOOK: query: -- modulo EXPLAIN SELECT (key + 1) % (key / 2) FROM DECIMAL_UDF @@ -2022,7 +2020,7 @@ POSTHOOK: type: QUERY POSTHOOK: Input: default@decimal_udf #### A masked pattern was here #### -2199 -1 +NULL NULL NULL 1 @@ -2154,7 +2152,7 @@ POSTHOOK: Input: default@decimal_udf -1255 0.0 0.0 -11 0.0 0.0 -1 0.0 0.0 -0 2.5753937681885636E98 6.632653061224489E196 +0 0.23469892060538614 0.055083583333333345 1 0.05928102563215321 0.0035142400000000066 2 0.0 0.0 3 0.0 0.0 @@ -2262,7 +2260,7 @@ POSTHOOK: Input: default@decimal_udf -1255 0.0 0.0 -11 0.0 0.0 -1 0.0 0.0 -0 2.6726124191242437E98 7.142857142857142E196 +0 0.24513502772590828 0.06009118181818183 1 0.06627820154470102 0.004392800000000008 2 0.0 0.0 3 0.0 0.0 @@ -2344,7 +2342,7 @@ POSTHOOK: query: SELECT histogram_numeric(key, 3) FROM DECIMAL_UDF POSTHOOK: type: QUERY POSTHOOK: Input: default@decimal_udf #### A masked pattern was here #### -[{"x":-3.429369299009602E7,"y":36.0},{"x":1.2345678901234567E9,"y":1.0},{"x":1.0E99,"y":1.0}] +[{"x":-1.2345678901234567E9,"y":1.0},{"x":-148.75058823529412,"y":34.0},{"x":1.2345678901234567E9,"y":1.0}] PREHOOK: query: DROP TABLE IF EXISTS DECIMAL_UDF PREHOOK: type: DROPTABLE PREHOOK: Input: default@decimal_udf diff --git serde/src/java/org/apache/hadoop/hive/serde2/io/BigDecimalWritable.java serde/src/java/org/apache/hadoop/hive/serde2/io/BigDecimalWritable.java index db009c4..d9a7e39 100644 --- serde/src/java/org/apache/hadoop/hive/serde2/io/BigDecimalWritable.java +++ serde/src/java/org/apache/hadoop/hive/serde2/io/BigDecimalWritable.java @@ -22,6 +22,7 @@ import java.io.IOException; import java.math.BigDecimal; import java.math.BigInteger; +import java.math.RoundingMode; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; @@ -35,73 +36,134 @@ static final private Log LOG = LogFactory.getLog(BigDecimalWritable.class); - private byte[] internalStorage = new byte[0]; - private int scale; + static final private byte[] EMPTY_STORAGE = new byte[0]; - private final VInt vInt = new VInt(); // reusable integer + private byte[] internalStorage = EMPTY_STORAGE; + private int internalScale; - public BigDecimalWritable() { + private int precision; + + public int getPrecision() { + return precision; + } + + public void setPrecision(int precision) { + this.precision = precision; } - public BigDecimalWritable(byte[] bytes, int scale) { - set(bytes, scale); + private final VInt vInt = new VInt(); // reusable integer + + public static final int MAX_PRECISION = 36; // multiple of 9 for compact representation + + public BigDecimalWritable() { + precision = MAX_PRECISION; } public BigDecimalWritable(BigDecimalWritable writable) { - set(writable.getBigDecimal()); + internalStorage = new byte[writable.internalStorage.length]; + System.arraycopy(writable.internalStorage, 0, internalStorage, 0, internalStorage.length); + internalScale = writable.internalScale; + precision = writable.precision; } - public BigDecimalWritable(BigDecimal value) { + public BigDecimalWritable(BigDecimal value) throws IOException { + precision = MAX_PRECISION; set(value); } - public void set(BigDecimal value) { - value = value.stripTrailingZeros(); - if (value.compareTo(BigDecimal.ZERO) == 0) { + public BigDecimalWritable(byte[] bs, int scale) throws IOException { + precision = MAX_PRECISION; + set(bs, scale); + } + + public void set(BigDecimal value) throws IOException { + set(value, false); + } + + public BigDecimal normalize(BigDecimal d) { + + if (d.compareTo(BigDecimal.ZERO) == 0) { // Special case for 0, because java doesn't strip zeros correctly on that number. - value = BigDecimal.ZERO; + return BigDecimal.ZERO; + } else { + BigDecimal b = d.stripTrailingZeros(); + if (d.scale() < 0) { + b = b.setScale(0); + } + return b; + } + } + + public void set(BigDecimal value, boolean allowRounding) throws IOException { + + value = normalize(value); + + int valuePrecision = value.precision() + + Math.max(0, 1 + value.scale() - value.precision()); + + if (valuePrecision > precision) { + if (allowRounding) { + int adjustedScale = value.scale() - (valuePrecision-precision); + if (adjustedScale >= 0) { + value = value.setScale(adjustedScale, RoundingMode.HALF_UP); + value = normalize(value); + } else { + setInternal(EMPTY_STORAGE, 0); + throw new IOException("Assignment would result in truncation"); + } + } else { + setInternal(EMPTY_STORAGE, 0); + throw new IOException("Assignment would result in truncation."); + } } - set(value.unscaledValue().toByteArray(), value.scale()); + + setInternal(value.unscaledValue().toByteArray(), value.scale()); } public void set(BigDecimalWritable writable) { - set(writable.getBigDecimal()); + this.internalScale = writable.internalScale; + this.internalStorage = writable.internalStorage; + this.precision = writable.precision; } - public void set(byte[] bytes, int scale) { + public void set(byte[] bytes, int scale) throws IOException { + set(new BigDecimal(new BigInteger(bytes), scale)); + } + + private void setInternal(byte[] bytes, int scale) { this.internalStorage = bytes; - this.scale = scale; + this.internalScale = scale; } - public void setFromBytes(byte[] bytes, int offset, int length) { + public void setFromBytes(byte[] bytes, int offset, int length) throws IOException { LazyBinaryUtils.readVInt(bytes, offset, vInt); - scale = vInt.value; + int scale = vInt.value; offset += vInt.length; LazyBinaryUtils.readVInt(bytes, offset, vInt); offset += vInt.length; - if (internalStorage.length != vInt.value) { - internalStorage = new byte[vInt.value]; - } - System.arraycopy(bytes, offset, internalStorage, 0, vInt.value); + byte[] bs = new byte[vInt.value]; + System.arraycopy(bytes, offset, bs, 0, vInt.value); + set(bs, scale); } public BigDecimal getBigDecimal() { - return new BigDecimal(new BigInteger(internalStorage), scale); + return new BigDecimal(new BigInteger(internalStorage), internalScale); } @Override public void readFields(DataInput in) throws IOException { - scale = WritableUtils.readVInt(in); + internalScale = WritableUtils.readVInt(in); int byteArrayLen = WritableUtils.readVInt(in); if (internalStorage.length != byteArrayLen) { internalStorage = new byte[byteArrayLen]; } in.readFully(internalStorage); + set(internalStorage, internalScale); } @Override public void write(DataOutput out) throws IOException { - WritableUtils.writeVInt(out, scale); + WritableUtils.writeVInt(out, internalScale); WritableUtils.writeVInt(out, internalStorage.length); out.write(internalStorage); } @@ -112,14 +174,14 @@ public int compareTo(BigDecimalWritable that) { } public void writeToByteStream(Output byteStream) { - LazyBinaryUtils.writeVInt(byteStream, scale); + LazyBinaryUtils.writeVInt(byteStream, internalScale); LazyBinaryUtils.writeVInt(byteStream, internalStorage.length); byteStream.write(internalStorage, 0, internalStorage.length); } @Override public String toString() { - return getBigDecimal().toString(); + return getBigDecimal().toPlainString(); } @Override diff --git serde/src/java/org/apache/hadoop/hive/serde2/lazy/LazyBigDecimal.java serde/src/java/org/apache/hadoop/hive/serde2/lazy/LazyBigDecimal.java index 719e78c..ca08c4b 100644 --- serde/src/java/org/apache/hadoop/hive/serde2/lazy/LazyBigDecimal.java +++ serde/src/java/org/apache/hadoop/hive/serde2/lazy/LazyBigDecimal.java @@ -17,8 +17,8 @@ */ package org.apache.hadoop.hive.serde2.lazy; +import java.io.IOException; import java.math.BigDecimal; -import java.nio.charset.CharacterCodingException; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; @@ -54,13 +54,10 @@ public void init(ByteArrayRef bytes, int start, int length) { byteData = Text.decode(bytes.getData(), start, length); data.set(new BigDecimal(byteData)); isNull = false; - } catch (NumberFormatException e) { + } catch (IOException e) { isNull = true; LOG.debug("Data not in the BigDecimal data type range so converted to null. Given data is :" + byteData, e); - } catch (CharacterCodingException e) { - isNull = true; - LOG.debug("Data not in the BigDecimal data type range so converted to null.", e); } } diff --git serde/src/java/org/apache/hadoop/hive/serde2/lazybinary/LazyBinaryBigDecimal.java serde/src/java/org/apache/hadoop/hive/serde2/lazybinary/LazyBinaryBigDecimal.java index 5d8a6a1..304e255 100644 --- serde/src/java/org/apache/hadoop/hive/serde2/lazybinary/LazyBinaryBigDecimal.java +++ serde/src/java/org/apache/hadoop/hive/serde2/lazybinary/LazyBinaryBigDecimal.java @@ -17,6 +17,7 @@ */ package org.apache.hadoop.hive.serde2.lazybinary; +import java.io.IOException; import org.apache.hadoop.hive.serde2.io.BigDecimalWritable; import org.apache.hadoop.hive.serde2.lazy.ByteArrayRef; import org.apache.hadoop.hive.serde2.objectinspector.primitive.WritableBigDecimalObjectInspector; @@ -26,7 +27,6 @@ LazyBinaryBigDecimal(WritableBigDecimalObjectInspector oi) { super(oi); - data = new BigDecimalWritable(); } LazyBinaryBigDecimal(LazyBinaryBigDecimal copy) { @@ -36,7 +36,12 @@ @Override public void init(ByteArrayRef bytes, int start, int length) { - data.setFromBytes(bytes.getData(), start, length); + try { + data = new BigDecimalWritable(); + data.setFromBytes(bytes.getData(), start, length); + } catch (IOException e) { + data = null; + } } } diff --git serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/JavaBigDecimalObjectInspector.java serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/JavaBigDecimalObjectInspector.java index 5070a0a..44f2b86 100644 --- serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/JavaBigDecimalObjectInspector.java +++ serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/JavaBigDecimalObjectInspector.java @@ -17,6 +17,7 @@ */ package org.apache.hadoop.hive.serde2.objectinspector.primitive; +import java.io.IOException; import java.math.BigDecimal; import java.math.BigInteger; @@ -39,7 +40,11 @@ public BigDecimalWritable getPrimitiveWritableObject(Object o) { if (o instanceof String) { o = new BigDecimal((String)o); } - return new BigDecimalWritable((BigDecimal) o); + try { + return new BigDecimalWritable((BigDecimal) o); + } catch (IOException io) { + return null; + } } @Override diff --git serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableBigDecimalObjectInspector.java serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableBigDecimalObjectInspector.java index 88184cf..b742282 100644 --- serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableBigDecimalObjectInspector.java +++ serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableBigDecimalObjectInspector.java @@ -17,6 +17,7 @@ */ package org.apache.hadoop.hive.serde2.objectinspector.primitive; +import java.io.IOException; import java.math.BigDecimal; import org.apache.hadoop.hive.serde2.io.BigDecimalWritable; @@ -46,13 +47,21 @@ public Object copyObject(Object o) { @Override public Object set(Object o, byte[] bytes, int scale) { - ((BigDecimalWritable) o).set(bytes, scale); + try { + ((BigDecimalWritable) o).set(bytes, scale); + } catch (IOException e) { + return null; + } return o; } @Override public Object set(Object o, BigDecimal t) { - ((BigDecimalWritable) o).set(t); + try { + ((BigDecimalWritable) o).set(t); + } catch (IOException e) { + return null; + } return o; } @@ -64,12 +73,19 @@ public Object set(Object o, BigDecimalWritable t) { @Override public Object create(byte[] bytes, int scale) { - return new BigDecimalWritable(bytes, scale); + try { + return new BigDecimalWritable(bytes, scale); + } catch (IOException e) { + return null; + } } @Override public Object create(BigDecimal t) { - return new BigDecimalWritable(t); + try { + return new BigDecimalWritable(t); + } catch (IOException e) { + return null; + } } - }