private static Object coercePrimitiveObject(final PrimitiveObjectInspector inspector, final Object object) { if (object instanceof HiveDecimalWritable) { // inspector on HiveDecimal rounds off to integer for some reason. return ((HiveDecimalWritable) object).getHiveDecimal().doubleValue(); } else if (object instanceof DateWritable) { return object.toString(); } else { return inspector.getPrimitiveJavaObject(object); } }
public VectorUDAFAvgDecimal() { super(); partialResult = new Object[2]; resultCount = new LongWritable(); resultSum = new HiveDecimalWritable(); partialResult[0] = resultCount; partialResult[1] = resultSum; }
@Override protected void doTerminatePartial(AverageAggregationBuffer<HiveDecimal> aggregation) { if(partialResult[1] == null && aggregation.sum != null) { partialResult[1] = new HiveDecimalWritable(HiveDecimal.ZERO); } ((LongWritable) partialResult[0]).set(aggregation.count); if (aggregation.sum != null) { ((HiveDecimalWritable) partialResult[1]).set(aggregation.sum); } else { partialResult[1] = null; } }
public static void ceiling(int i, HiveDecimal input, DecimalColumnVector outputColVector) { HiveDecimalWritable decWritable = outputColVector.vector[i]; decWritable.set(input); decWritable.mutateSetScale(0, HiveDecimal.ROUND_CEILING); decWritable.mutateEnforcePrecisionScale(outputColVector.precision, outputColVector.scale); if (!decWritable.isSet()) { outputColVector.noNulls = false; outputColVector.isNull[i] = true; } }
public static void subtractChecked(int i, HiveDecimalWritable left, HiveDecimalWritable right, DecimalColumnVector outputColVector) { HiveDecimalWritable decWritable = outputColVector.vector[i]; decWritable.set(left); decWritable.mutateSubtract(right); decWritable.mutateEnforcePrecisionScale(outputColVector.precision, outputColVector.scale); if (!decWritable.isSet()) { outputColVector.noNulls = false; outputColVector.isNull[i] = true; } }
public static void multiplyChecked(int i, HiveDecimal left, HiveDecimal right, DecimalColumnVector outputColVector) { HiveDecimalWritable decWritable = outputColVector.vector[i]; decWritable.set(left); decWritable.mutateMultiply(right); decWritable.mutateEnforcePrecisionScale(outputColVector.precision, outputColVector.scale); if (!decWritable.isSet()) { outputColVector.noNulls = false; outputColVector.isNull[i] = true; } }
actualValue = new SqlDate(((DateWritable) actualValue).getDays()); actualValue = ((FloatWritable) actualValue).get(); actualValue = ((IntWritable) actualValue).get(); actualValue = ((HiveCharWritable) actualValue).getPaddedValue().toString(); actualValue = ((LongWritable) actualValue).get(); actualValue = ((ShortWritable) actualValue).get(); HiveDecimalWritable writable = (HiveDecimalWritable) actualValue; BigInteger rescaledValue = rescale(writable.getHiveDecimal().unscaledValue(), writable.getScale(), decimalType.getScale()); actualValue = new SqlDecimal(rescaledValue, decimalType.getPrecision(), decimalType.getScale()); actualValue = sqlTimestampOf((timestamp.getSeconds() * 1000) + (timestamp.getNanos() / 1000000L), SESSION);
return new ByteWritable((byte) 0); case SHORT: return new ShortWritable((short) 0); case INT: return new IntWritable(0); case LONG: return new LongWritable(0); case TIMESTAMP: return new TimestampWritable(new Timestamp(0)); case DATE: return new DateWritable(new Date(0)); case FLOAT: return new FloatWritable(0); case DOUBLE: return new DoubleWritable(0); case BINARY: return new BytesWritable(ArrayUtils.EMPTY_BYTE_ARRAY); case STRING: return new Text(ArrayUtils.EMPTY_BYTE_ARRAY); case VARCHAR: return new HiveVarcharWritable(new HiveVarchar(StringUtils.EMPTY, -1)); case CHAR: return new HiveCharWritable(new HiveChar(StringUtils.EMPTY, -1)); case DECIMAL: return new HiveDecimalWritable(); case INTERVAL_YEAR_MONTH: return new HiveIntervalYearMonthWritable();
private Object fromWritable(Writable writable, Schema schema) { if (writable instanceof IntWritable) { return ((IntWritable) writable).get(); } else if (writable instanceof LongWritable) { return ((LongWritable) writable).get(); } else if (writable instanceof ShortWritable) { return ((ShortWritable) writable).get(); return ((DoubleWritable) writable).get(); } else if (writable instanceof FloatWritable) { return ((FloatWritable) writable).get(); } else if (writable instanceof Text) { return writable.toString(); return ((ByteWritable) writable).get(); } else if (writable instanceof DateWritable) { return ((DateWritable) writable).get().toLocalDate().toEpochDay(); } else if (writable instanceof org.apache.hadoop.hive.serde2.io.ShortWritable) { return ((org.apache.hadoop.hive.serde2.io.ShortWritable) writable).get(); } else if (writable instanceof HiveBaseCharWritable) { return ((HiveBaseCharWritable) writable).getTextValue().toString(); } else if (writable instanceof TimestampWritable) { return toEpochTimestamp(((TimestampWritable) writable).getTimestamp(), schema); } else if (writable instanceof org.apache.hadoop.hive.serde2.io.DoubleWritable) { return ((org.apache.hadoop.hive.serde2.io.DoubleWritable) writable).get(); } else if (writable instanceof HiveDecimalWritable) { return ((HiveDecimalWritable) writable).getHiveDecimal(); } else if (writable instanceof NullWritable) { return null;
private Object parseAsPrimitive(JsonNode value, TypeInfo typeInfo) throws SerDeException { switch (TypeInfoFactory.getPrimitiveTypeInfo(typeInfo.getTypeName()).getPrimitiveCategory()) { case TIMESTAMP: TimestampWritable timestampWritable = new TimestampWritable(); timestampWritable.setTime(TS_PARSER.get().parseMillis(value.textValue())); return timestampWritable; return new ByteWritable((byte) value.intValue()); case SHORT: return (new ShortWritable(value.shortValue())); case INT: return new IntWritable(value.intValue()); case LONG: return (new LongWritable((value.longValue()))); case FLOAT: return (new FloatWritable(value.floatValue())); case DOUBLE: return (new DoubleWritable(value.doubleValue())); case DECIMAL: return (new HiveDecimalWritable(HiveDecimal.create(value.decimalValue()))); case CHAR: return (new HiveCharWritable(new HiveChar(value.textValue(), ((CharTypeInfo) typeInfo).getLength()))); case VARCHAR: return (new HiveVarcharWritable(new HiveVarchar(value.textValue(), ((CharTypeInfo) typeInfo).getLength()))); case STRING: return (new Text(value.textValue())); case BOOLEAN: return (new BooleanWritable(value.isBoolean() ? value.booleanValue() : Boolean.valueOf(value.textValue())));
case BYTE: return new ByteWritable(); case SHORT: return new ShortWritable(); case INT: return new IntWritable(); case LONG: return new LongWritable(); case FLOAT: return new FloatWritable(); case DOUBLE: return new DoubleWritable(); case BINARY: return new BytesWritable(); case VARCHAR: case STRING: return new Text(); case DATE: return new DateWritable(); case TIMESTAMP: return new OrcTimestamp(); case DECIMAL: return new HiveDecimalWritable(); case STRUCT: { OrcStruct result = new OrcStruct(type);
@Test public void testDecimal() throws HiveException { GenericUDFOPNegative udf = new GenericUDFOPNegative(); HiveDecimalWritable input = new HiveDecimalWritable(HiveDecimal.create("32300.004747")); DecimalTypeInfo inputTypeInfo = TypeInfoFactory.getDecimalTypeInfo(11, 6); ObjectInspector[] inputOIs = { PrimitiveObjectInspectorFactory.getPrimitiveWritableObjectInspector(inputTypeInfo), }; DeferredObject[] args = { new DeferredJavaObject(input) }; PrimitiveObjectInspector oi = (PrimitiveObjectInspector) udf.initialize(inputOIs); Assert.assertEquals(inputTypeInfo, oi.getTypeInfo()); HiveDecimalWritable res = (HiveDecimalWritable) udf.evaluate(args); Assert.assertEquals(HiveDecimal.create("-32300.004747"), res.getHiveDecimal()); }
switch (resultOI.getPrimitiveCategory()) { case BYTE: byteWritable.set((byte) -(((ByteWritable)input).get())); return byteWritable; case SHORT: shortWritable.set((short) -(((ShortWritable)input).get())); return shortWritable; case INT: intWritable.set(-(((IntWritable)input).get())); return intWritable; case LONG: longWritable.set(-(((LongWritable)input).get())); return longWritable; case FLOAT: floatWritable.set(-(((FloatWritable)input).get())); return floatWritable; case DOUBLE: doubleWritable.set(-(((DoubleWritable)input).get())); return doubleWritable; case DECIMAL: decimalWritable.set((HiveDecimalWritable)input); decimalWritable.mutateNegate(); return decimalWritable; case INTERVAL_YEAR_MONTH: resultOI.getPrimitiveCategory());
case INT: valObject = inputConverter.convert(valObject); resultInt.set(10 + ((IntWritable) valObject).get()); return resultInt; case LONG: valObject = inputConverter.convert(valObject); resultLong.set(10 + ((LongWritable) valObject).get()); return resultLong; case FLOAT: case DOUBLE: valObject = inputConverter.convert(valObject); resultDouble.set(10.0 + ((DoubleWritable) valObject).get()); return resultDouble; case DECIMAL: resultDecimal.set(val.getHiveDecimal().add(HiveDecimal.create("10"))); val = resultDecimal;
((Text) convertSourceWritable).set( deserializeRead.currentBytes, deserializeRead.currentBytesStart, maxLengths[logicalColumnIndex]); ((HiveVarcharWritable) convertSourceWritable).set( new String( deserializeRead.currentBytes, maxLengths[logicalColumnIndex]); ((HiveCharWritable) convertSourceWritable).set( new String( deserializeRead.currentBytes, ((HiveDecimalWritable) convertSourceWritable).set( deserializeRead.currentHiveDecimalWritable); break;
(PrimitiveObjectInspector) this.objectInspectors[3]); switch (((PrimitiveObjectInspector) this.commonExprMinMaxOI).getPrimitiveCategory()) { case SHORT: return evaluate(((ShortWritable) exprValue).get(), ((ShortWritable) minValue).get(), ((ShortWritable) maxValue).get(), numBuckets); case INT: return evaluate(((IntWritable) exprValue).get(), ((IntWritable) minValue).get(), ((IntWritable) maxValue).get(), numBuckets); case LONG: return evaluate(((LongWritable) exprValue).get(), ((LongWritable) minValue).get(), ((LongWritable) maxValue).get(), numBuckets); case FLOAT: return evaluate(((FloatWritable) exprValue).get(), ((FloatWritable) minValue).get(), ((FloatWritable) maxValue).get(), numBuckets); case DOUBLE: return evaluate(((DoubleWritable) exprValue).get(), ((DoubleWritable) minValue).get(), ((DoubleWritable) maxValue).get(), numBuckets); case DECIMAL: return evaluate(((HiveDecimalWritable) exprValue).getHiveDecimal(), ((HiveDecimalWritable) minValue).getHiveDecimal(), ((HiveDecimalWritable) maxValue).getHiveDecimal(), numBuckets); case BYTE:
case INT: valObject = inputConverter.convert(valObject); resultInt.set(Math.abs(((IntWritable) valObject).get())); return resultInt; case LONG: valObject = inputConverter.convert(valObject); resultLong.set(Math.abs(((LongWritable) valObject).get())); return resultLong; case FLOAT: return null; resultDouble.set(Math.abs(((DoubleWritable) valObject).get())); return resultDouble; case DECIMAL: resultDecimal.set(val); resultDecimal.mutateAbs(); val = resultDecimal;
@Override public Object evaluate(DeferredObject[] arguments) throws HiveException { Object targetObject = targetOI.getPrimitiveJavaObject(arguments[0].get()); if (targetObject == null) { return null; return null; switch (returnOI.getPrimitiveCategory()) { case VOID: return null; return returnObj; case DECIMAL: ((HiveDecimalWritable)returnObj).set((HiveDecimal)result); return returnObj; throw new HiveException("Invalid type " + returnOI.getPrimitiveCategory());
} else if (arr[0] instanceof LongWritable) { LongWritable lw = (LongWritable) arr[0]; assertEquals(key, expected, lw.get()); } else if (arr[0] instanceof Text) { Text tx = (Text) arr[0]; String sbw = tx.toString(); assertEquals(key, expected, sbw); } else if (arr[0] instanceof DoubleWritable) { DoubleWritable dw = (DoubleWritable) arr[0]; assertEquals (key, expected, dw.get()); } else if (arr[0] instanceof Double) { assertEquals (key, expected, arr[0]); } else if (arr[0] instanceof HiveDecimalWritable) { HiveDecimalWritable hdw = (HiveDecimalWritable) arr[0]; HiveDecimal hd = hdw.getHiveDecimal(); HiveDecimal expectedDec = (HiveDecimal)expected; assertEquals (key, expectedDec, hd);
@Override public InspectableObject[] getExpectedResult() { DataBuilder db = new DataBuilder(); db.setColumnNames("_col1", "_col2", "_col3", "_col4", "_col5", "_col6", "_col7", "_col8"); db.setColumnTypes(PrimitiveObjectInspectorFactory.javaStringObjectInspector, PrimitiveObjectInspectorFactory.writableIntObjectInspector, PrimitiveObjectInspectorFactory.writableDoubleObjectInspector, PrimitiveObjectInspectorFactory.writableFloatObjectInspector, PrimitiveObjectInspectorFactory.writableByteObjectInspector, PrimitiveObjectInspectorFactory.writableShortObjectInspector, PrimitiveObjectInspectorFactory.writableLongObjectInspector, PrimitiveObjectInspectorFactory.writableHiveDecimalObjectInspector); db.addRow(null, new IntWritable(170), new DoubleWritable(1.1), new FloatWritable(32f), new ByteWritable((byte)0), new ShortWritable((short)1234), new LongWritable(123500L), new HiveDecimalWritable(HiveDecimal.create("983.724"))); db.addRow(new DoubleWritable(-200), null, null, new FloatWritable(0f), new ByteWritable((byte)100), new ShortWritable((short)551), new LongWritable(900L), new HiveDecimalWritable(HiveDecimal.create("983723.005"))); db.addRow(new DoubleWritable(500), new IntWritable(22345), new DoubleWritable(-23.000), new FloatWritable(-3f), new ByteWritable((byte)100), new ShortWritable((short)2321), new LongWritable(9200L), new HiveDecimalWritable(HiveDecimal.create("-932032.7"))); return db.createRows(); }