@Override protected void func(DecimalColumnVector outV, LongColumnVector inV, int i) { outV.set(i, HiveDecimal.create(inV.vector[i])); } }
public static HiveDecimal getHiveDecimal(Timestamp timestamp) { // The BigDecimal class recommends not converting directly from double to BigDecimal, // so we convert through a string... Double timestampDouble = TimestampUtils.getDouble(timestamp); HiveDecimal result = HiveDecimal.create(timestampDouble.toString()); return result; }
@Override public HiveDecimalWritable div(HiveDecimalWritable sum, long numRows) { if (sum == null || numRows == 0) return null; HiveDecimalWritable result = new HiveDecimalWritable(sum); result.mutateDivide(HiveDecimal.create(numRows)); return result; }
public static ExprNodeConstantDesc createDecimal(String strVal, boolean notNull) { HiveDecimal hd = HiveDecimal.create(strVal); if (notNull && hd == null) { return null; } return new ExprNodeConstantDesc(adjustType(hd), hd); }
protected static HiveDecimal getDecimal( boolean isDictionaryEncoding, int index) { int decimalVal = index % 100; String decimalStr = (decimalVal < 10) ? "0" + String.valueOf(decimalVal) : String .valueOf(decimalVal); int intVal = (isDictionaryEncoding) ? index % UNIQUE_NUM : index / 100; String d = String.valueOf(intVal) + "." + decimalStr; return HiveDecimal.create(d); }
private static HiveDecimal getHiveDecimal(DecimalType decimalType, Block block, int position) { BigInteger unscaledValue; if (decimalType.isShort()) { unscaledValue = BigInteger.valueOf(decimalType.getLong(block, position)); } else { unscaledValue = Decimals.decodeUnscaledValue(decimalType.getSlice(block, position)); } return HiveDecimal.create(unscaledValue, decimalType.getScale()); }
@Override protected Object doTerminate(AverageAggregationBuffer<HiveDecimal> aggregation) { if(aggregation.count == 0 || aggregation.sum == null) { return null; } else { HiveDecimalWritable result = new HiveDecimalWritable(HiveDecimal.ZERO); result.set(aggregation.sum.divide(HiveDecimal.create(aggregation.count))); result.mutateEnforcePrecisionScale(resultPrecision, resultScale); return result; } }
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 static HCatRecord getHCat13TypesRecord() { List<Object> rec_hcat13types = new ArrayList<Object>(5); rec_hcat13types.add(HiveDecimal.create(new BigDecimal("123.45")));//prec 5, scale 2 rec_hcat13types.add(new HiveChar("hive_char", 10)); rec_hcat13types.add(new HiveVarchar("hive_varchar", 20)); rec_hcat13types.add(Date.valueOf("2014-01-06")); rec_hcat13types.add(Timestamp.ofEpochMilli(System.currentTimeMillis())); return new DefaultHCatRecord(rec_hcat13types); } private static HCatRecord getHCat13TypesComplexRecord() {
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; }
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; }
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; }
@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())); }
@Test public void testCastLongToDecimal() throws HiveException { VectorizedRowBatch b = getBatchLongDecimal(); VectorExpression expr = new CastLongToDecimal(0, 1); expr.evaluate(b); DecimalColumnVector r = (DecimalColumnVector) b.cols[1]; assertTrue(r.vector[0].getHiveDecimal().equals(HiveDecimal.create("0"))); assertTrue(r.vector[1].getHiveDecimal().equals(HiveDecimal.create("-1"))); assertTrue(r.vector[2].getHiveDecimal().equals(HiveDecimal.create("99999999999999"))); }
private void runDecimal(double v, IntWritable scale, Double expV, GenericUDF udf) throws HiveException { HiveDecimal hd = HiveDecimal.create(BigDecimal.valueOf(v)); DeferredObject valueObj0 = new DeferredJavaObject(new HiveDecimalWritable(hd)); DeferredObject valueObj1 = new DeferredJavaObject(scale); DeferredObject[] args = { valueObj0, valueObj1 }; HiveDecimalWritable output = (HiveDecimalWritable) udf.evaluate(args); Assert.assertEquals("bround() test ", expV.doubleValue(), output.getHiveDecimal().doubleValue(), 0.00001); } }