private VectorizedRowBatch getBatchDoubleDecimal() { VectorizedRowBatch b = new VectorizedRowBatch(2); DoubleColumnVector dv; short scale = 2; b.cols[0] = dv = new DoubleColumnVector(); b.cols[1] = new DecimalColumnVector(18, scale); b.size = 3; dv.vector[0] = 0d; dv.vector[1] = -1d; dv.vector[2] = 99999999999999.0d; return b; }
private VectorizedRowBatch getBatchLongDecimal() { VectorizedRowBatch b = new VectorizedRowBatch(2); LongColumnVector lv; b.cols[0] = lv = new LongColumnVector(); b.cols[1] = new DecimalColumnVector(18, 2); lv.vector[0] = 0; lv.vector[1] = -1; lv.vector[2] = 99999999999999L; return b; }
/** * This batch has output decimal column precision 5 and scale 2. * The goal is to allow testing of input long values that, when * converted to decimal, will not fit in the given precision. * Then it will be possible to check that the results are NULL. */ private VectorizedRowBatch getBatchLongDecimalPrec5Scale2() { VectorizedRowBatch b = new VectorizedRowBatch(2); LongColumnVector lv; b.cols[0] = lv = new LongColumnVector(); b.cols[1] = new DecimalColumnVector(5, 2); lv.vector[0] = 0; lv.vector[1] = -1; lv.vector[2] = 99999999999999L; return b; }
private VectorizedRowBatch getBatchDecimalTimestamp(double[] doubleValues) { VectorizedRowBatch b = new VectorizedRowBatch(2); DecimalColumnVector dv; b.cols[0] = dv = new DecimalColumnVector(doubleValues.length, HiveDecimal.SYSTEM_DEFAULT_PRECISION, HiveDecimal.SYSTEM_DEFAULT_SCALE); b.cols[1] = new TimestampColumnVector(doubleValues.length); dv.noNulls = true; Random r = new Random(94830); for (int i = 0; i < doubleValues.length; i++) { long millis = RandomTypeUtil.randomMillis(r); Timestamp ts = new Timestamp(millis); int nanos = RandomTypeUtil.randomNanos(r); ts.setNanos(nanos); TimestampWritableV2 tsw = new TimestampWritableV2( org.apache.hadoop.hive.common.type.Timestamp.ofEpochMilli(ts.getTime(), ts.getNanos())); double asDouble = tsw.getDouble(); doubleValues[i] = asDouble; HiveDecimal hiveDecimal = HiveDecimal.create(new BigDecimal(asDouble)); dv.set(i, hiveDecimal); } b.size = doubleValues.length; return b; }
private VectorizedRowBatch getBatchDecimalDecimal() { VectorizedRowBatch b = new VectorizedRowBatch(2); DecimalColumnVector v0, v1; b.cols[0] = v0 = new DecimalColumnVector(18, 4); b.cols[1] = v1 = new DecimalColumnVector(5, 2); v0.vector[0].set(HiveDecimal.create("10.0001")); v0.vector[1].set(HiveDecimal.create("-9999999.9999")); v1.vector[0].set(HiveDecimal.create("100.01")); v1.vector[1].set(HiveDecimal.create("-200.02")); b.size = 2; return b; } }
private VectorizedRowBatch getVectorizedRowBatch3DecimalCols() { VectorizedRowBatch b = new VectorizedRowBatch(3); DecimalColumnVector v0, v1; b.cols[0] = v0 = new DecimalColumnVector(18, 2); b.cols[1] = v1 = new DecimalColumnVector(18, 2); b.cols[2] = new DecimalColumnVector(18, 2); v0.vector[0].set(HiveDecimal.create("1.20")); v0.vector[1].set(HiveDecimal.create("-3.30")); v0.vector[2].set(HiveDecimal.create("0")); v1.vector[0].set(HiveDecimal.create("1.00")); v1.vector[1].set(HiveDecimal.create("1.00")); v1.vector[2].set(HiveDecimal.create("1.00")); b.size = 3; return b; } }
@Test public void testAbs() { DecimalColumnVector dcv = new DecimalColumnVector(4 ,20, 13); HiveDecimal d1 = HiveDecimal.create("19.56778"); DecimalUtil.abs(0, d1, dcv); Assert.assertEquals(0, d1.compareTo(dcv.vector[0].getHiveDecimal())); HiveDecimal d2 = HiveDecimal.create("-25.34567"); HiveDecimal expected2 = HiveDecimal.create("25.34567"); DecimalUtil.abs(0, d2, dcv); Assert.assertEquals(0, expected2.compareTo(dcv.vector[0].getHiveDecimal())); }
private VectorizedRowBatch getVectorizedRowBatch1DecimalCol() { VectorizedRowBatch b = new VectorizedRowBatch(1); DecimalColumnVector v0; b.cols[0] = v0 = new DecimalColumnVector(18, 2); v0.vector[0].set(HiveDecimal.create("1.20")); v0.vector[1].set(HiveDecimal.create("-3.30")); v0.vector[2].set(HiveDecimal.create("0")); b.size = 3; return b; }
private VectorizedRowBatch getVectorizedRowBatch2DecimalCol() { VectorizedRowBatch b = new VectorizedRowBatch(2); DecimalColumnVector v0, v1; b.cols[0] = v0 = new DecimalColumnVector(18, 2); v0.vector[0].set(HiveDecimal.create("1.20")); v0.vector[1].set(HiveDecimal.create("-3.30")); v0.vector[2].set(HiveDecimal.create("0")); b.cols[1] = v1 = new DecimalColumnVector(18, 2); v1.vector[0].set(HiveDecimal.create("-1.00")); v1.vector[1].set(HiveDecimal.create("-3.30")); v1.vector[2].set(HiveDecimal.create("10.00")); b.size = 3; return b; } }
private VectorizedRowBatch getBatchDecimalLong2() { VectorizedRowBatch b = new VectorizedRowBatch(2); DecimalColumnVector dv; short scale = 9; b.cols[0] = dv = new DecimalColumnVector(18, scale); b.cols[1] = new LongColumnVector(); b.size = 3; dv.vector[0].set(HiveDecimal.create("1.111111111")); dv.vector[1].set(HiveDecimal.create("-2.222222222")); dv.vector[2].set(HiveDecimal.create("31536000.999999999")); return b; }
@Test public void testNegate() { DecimalColumnVector dcv = new DecimalColumnVector(4 ,20, 13); HiveDecimal d1 = HiveDecimal.create("19.56778"); HiveDecimal expected1 = HiveDecimal.create("-19.56778"); DecimalUtil.negate(0, d1, dcv); Assert.assertEquals(0, expected1.compareTo(dcv.vector[0].getHiveDecimal())); HiveDecimal d2 = HiveDecimal.create("-25.34567"); HiveDecimal expected2 = HiveDecimal.create("25.34567"); DecimalUtil.negate(0, d2, dcv); Assert.assertEquals(0, expected2.compareTo(dcv.vector[0].getHiveDecimal())); // As of HIVE-8745, these decimal values should be trimmed of trailing zeros. HiveDecimal d3 = HiveDecimal.create("0.00000"); Assert.assertEquals(0, d3.scale()); HiveDecimal expected3 = HiveDecimal.create("0"); DecimalUtil.negate(0, d3, dcv); Assert.assertEquals(0, expected3.compareTo(dcv.vector[0].getHiveDecimal())); }
private VectorizedRowBatch getBatchDecimalString() { VectorizedRowBatch b = new VectorizedRowBatch(2); DecimalColumnVector dv; short scale = 2; b.cols[0] = dv = new DecimalColumnVector(18, scale); b.cols[1] = new BytesColumnVector(); b.size = 3; dv.vector[0].set(HiveDecimal.create("1.1")); dv.vector[1].set(HiveDecimal.create("-2.2")); dv.vector[2].set(HiveDecimal.create("9999999999999999.00")); return b; }
private VectorizedRowBatch getBatchDecimalDouble() { VectorizedRowBatch b = new VectorizedRowBatch(2); DecimalColumnVector dv; short scale = 2; b.cols[0] = dv = new DecimalColumnVector(18, scale); b.cols[1] = new DoubleColumnVector(); b.size = 3; dv.vector[0].set(HiveDecimal.create("1.1")); dv.vector[1].set(HiveDecimal.create("-2.2")); dv.vector[2].set(HiveDecimal.create("9999999999999999.00")); return b; }
private VectorizedRowBatch getBatchDecimalLong() { VectorizedRowBatch b = new VectorizedRowBatch(2); DecimalColumnVector dv; short scale = 2; b.cols[0] = dv = new DecimalColumnVector(18, scale); b.cols[1] = new LongColumnVector(); b.size = 3; dv.vector[0].set(HiveDecimal.create("1.1")); dv.vector[1].set(HiveDecimal.create("-2.2")); dv.vector[2].set(HiveDecimal.create("9999999999999999.00")); return b; }
public static DecimalColumnVector generateDecimalColumnVector(DecimalTypeInfo typeInfo, boolean nulls, boolean repeating, int size, Random rand) { DecimalColumnVector dcv = new DecimalColumnVector(size, typeInfo.precision(), typeInfo.scale()); dcv.noNulls = !nulls; dcv.isRepeating = repeating; HiveDecimalWritable repeatingValue = new HiveDecimalWritable(); do{ repeatingValue.set(HiveDecimal.create(((Double) rand.nextDouble()).toString()).setScale((short)typeInfo.scale(), HiveDecimal.ROUND_HALF_UP)); }while(repeatingValue.getHiveDecimal().doubleValue() == 0); int nullFrequency = generateNullFrequency(rand); for(int i = 0; i < size; i++) { if(nulls && (repeating || i % nullFrequency == 0)) { dcv.isNull[i] = true; dcv.vector[i] = null; }else { dcv.isNull[i] = false; if (repeating) { dcv.vector[i].set(repeatingValue); } else { dcv.vector[i].set(HiveDecimal.create(((Double) rand.nextDouble()).toString()).setScale((short) typeInfo.scale(), HiveDecimal.ROUND_HALF_UP)); } if(dcv.vector[i].getHiveDecimal().doubleValue() == 0) { i--; } } } return dcv; }
private VectorizedRowBatch getBatchStringDecimal() { VectorizedRowBatch b = new VectorizedRowBatch(2); BytesColumnVector bv; b.cols[0] = bv = new BytesColumnVector(); b.cols[1] = new DecimalColumnVector(18, 2); bv.initBuffer(); byte[] x0 = toBytes("1.10"); byte[] x1 = toBytes("-2.20"); byte[] x2 = toBytes("99999999999999.0"); bv.setVal(0, x0, 0, x0.length); bv.setVal(1, x1, 0, x1.length); bv.setVal(2, x2, 0, x2.length); return b; }
@Test public void testFloor() { DecimalColumnVector dcv = new DecimalColumnVector(4 ,20, 13); HiveDecimal d1 = HiveDecimal.create("19.56778"); HiveDecimal expected1 = HiveDecimal.create("19");
@Test public void testCeiling() { DecimalColumnVector dcv = new DecimalColumnVector(4 ,20, 13); HiveDecimal d1 = HiveDecimal.create("19.56778"); HiveDecimal expected1 = HiveDecimal.create("20");
@Test public void testRoundWithDigits() { DecimalColumnVector dcv = new DecimalColumnVector(4 ,20, 3); HiveDecimal d1 = HiveDecimal.create("19.56778"); HiveDecimal expected1 = HiveDecimal.create("19.568");
@Test public void testRound() { DecimalColumnVector dcv = new DecimalColumnVector(4 ,20, 0); HiveDecimal d1 = HiveDecimal.create("19.56778"); HiveDecimal expected1 = HiveDecimal.create("20");