private Writable allocateWritable(Type type) { switch (type) { case BYTE: return new ByteWritable(); case BOOL: return new BooleanWritable(); case INT: return new IntWritable(); case SHORT: return new ShortWritable(); case LONG: return new LongWritable(); case FLOAT: return new FloatWritable(); case DOUBLE: return new DoubleWritable(); case STRING: return new Text(); default: assert false; // not supported } return null; }
@Override public Object terminate(AggregationBuffer agg) throws HiveException { BinaryStatsAgg myagg = (BinaryStatsAgg) agg; double avgLength = 0.0; long count = myagg.count + myagg.countNulls; if (count != 0) { avgLength = myagg.sumLength / (1.0 * (myagg.count + myagg.countNulls)); } // Serialize the result struct ((Text) result[0]).set(myagg.columnType); ((LongWritable) result[1]).set(myagg.maxLength); ((DoubleWritable) result[2]).set(avgLength); ((LongWritable) result[3]).set(myagg.countNulls); return result; } }
@Override protected Object doTerminate(AverageAggregationBuffer<Double> aggregation) { if(aggregation.count == 0) { return null; } else { DoubleWritable result = new DoubleWritable(0); result.set(aggregation.sum / aggregation.count); return result; } } @Override
@Override public DoubleWritable div(DoubleWritable sum, long numRows) { if (sum == null || numRows == 0) return null; return new DoubleWritable(sum.get() / (double)numRows); } }
switch (poi.getPrimitiveCategory()) { case INT: return Bytes.toBytes(((IntWritable) writable).get()); case BOOLEAN: return Bytes.toBytes(((BooleanWritable) writable).get()); case LONG: return Bytes.toBytes(((LongWritable) writable).get()); case FLOAT: return Bytes.toBytes(((FloatWritable) writable).get()); case DOUBLE: return Bytes.toBytes(((DoubleWritable) writable).get()); case SHORT: return Bytes.toBytes(((ShortWritable) writable).get()); case STRING: return Bytes.toBytes(((Text) writable).toString()); case BYTE: return Bytes.toBytes(((ByteWritable) writable).get());
@Test public void testDruidObjectSerializerwithNullTimestamp() throws Exception { // Create, initialize, and test the SerDe DruidSerDe serDe = new DruidSerDe(); Configuration conf = new Configuration(); Properties tbl; // Mixed source (all types) tbl = createPropertiesSource(COLUMN_NAMES, COLUMN_TYPES); SerDeUtils.initializeSerDe(serDe, conf, tbl, null); Object[] row = new Object[]{ null, new Text("dim1_val"), new HiveCharWritable(new HiveChar("dim2_v", 6)), new HiveVarcharWritable(new HiveVarchar("dim3_val", 8)), new DoubleWritable(10669.3D), new FloatWritable(10669.45F), new LongWritable(1113939), new IntWritable(1112123), new ShortWritable((short) 12), new ByteWritable((byte) 0), null // granularity }; expectedEx.expect(NullPointerException.class); expectedEx.expectMessage("Timestamp column cannot have null value"); // should fail as timestamp is null serializeObject(tbl, serDe, row, DRUID_WRITABLE); }
/** * Convert from string to a double. This is called for CAST(... AS DOUBLE) * * @param i * The string value to convert * @return DoubleWritable */ public DoubleWritable evaluate(Text i) { if (i == null) { return null; } else { if (!LazyUtils.isNumberMaybe(i.getBytes(), 0, i.getLength())) { return null; } try { doubleWritable.set(Double.parseDouble(i.toString())); return doubleWritable; } catch (NumberFormatException e) { // MySQL returns 0 if the string is not a well-formed double value. // But we decided to return NULL instead, which is more conservative. return null; } } }
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:
udf.initialize(inputOIs); Object i1 = asList(new Text("a"), new DoubleWritable(3.1415), new DateWritableV2(Date.of(2015, 5, 26)), asList(new IntWritable(1), new IntWritable(3), new IntWritable(2), new IntWritable(4))); Object i2 = asList(new Text("b"), new DoubleWritable(3.14), new DateWritableV2(Date.of(2015, 5, 26)), asList(new IntWritable(1), new IntWritable(3), new IntWritable(2), new IntWritable(4))); Object i3 = asList(new Text("a"), new DoubleWritable(3.1415), new DateWritableV2(Date.of(2015, 5, 25)), asList(new IntWritable(1), new IntWritable(3), new IntWritable(2), new IntWritable(5))); Object i4 = asList(new Text("a"), new DoubleWritable(3.1415), new DateWritableV2(Date.of(2015, 5, 25)), asList(new IntWritable(1), new IntWritable(3),
@Test public void testString() throws HiveException { GenericUDFOPPositive udf = new GenericUDFOPPositive(); Text input = new Text("32300.004747"); ObjectInspector[] inputOIs = { PrimitiveObjectInspectorFactory.writableStringObjectInspector, }; DeferredObject[] args = { new DeferredJavaObject(input) }; PrimitiveObjectInspector oi = (PrimitiveObjectInspector) udf.initialize(inputOIs); Assert.assertEquals(TypeInfoFactory.doubleTypeInfo, oi.getTypeInfo()); DoubleWritable res = (DoubleWritable) udf.evaluate(args); Assert.assertEquals(new Double(32300.004747), new Double(res.get())); }
public VectorUDAFVarPopDecimal() { super(); partialResult = new Object[3]; resultCount = new LongWritable(); resultSum = new DoubleWritable(); resultVariance = new DoubleWritable(); partialResult[0] = resultCount; partialResult[1] = resultSum; partialResult[2] = resultVariance; initPartialResultInspector(); }
return returnObj; case BYTE: ((ByteWritable)returnObj).set((Byte)result); return returnObj; case SHORT: ((ShortWritable)returnObj).set((Short)result); return returnObj; case INT: ((IntWritable)returnObj).set((Integer)result); return returnObj; case LONG: ((LongWritable)returnObj).set((Long)result); return returnObj; case FLOAT: ((FloatWritable)returnObj).set((Float)result); return returnObj; case DOUBLE: ((DoubleWritable)returnObj).set((Double)result); return returnObj; case STRING: ((Text)returnObj).set((String)result); return returnObj; case TIMESTAMP:
@Test public void testSortPrimitiveTupleOneField() throws HiveException { List<ObjectInspector> tuple = new ArrayList<ObjectInspector>(); tuple.add(PrimitiveObjectInspectorFactory.writableStringObjectInspector); tuple.add(PrimitiveObjectInspectorFactory.writableDoubleObjectInspector); ObjectInspector[] inputOIs = { ObjectInspectorFactory.getStandardListObjectInspector(ObjectInspectorFactory .getStandardStructObjectInspector(asList("Company", "Salary"), tuple)), PrimitiveObjectInspectorFactory.writableHiveVarcharObjectInspector }; udf.initialize(inputOIs); Object i1 = asList(new Text("Facebook"), new DoubleWritable(80223.25)); Object i2 = asList(new Text("Facebook"), new DoubleWritable(50223.25)); Object i3 = asList(new Text("Facebook"), new DoubleWritable(40223.25)); Object i4 = asList(new Text("Facebook"), new DoubleWritable(60223.25)); HiveVarchar vc = new HiveVarchar(); vc.setValue("Salary"); GenericUDF.DeferredJavaObject[] argas = { new GenericUDF.DeferredJavaObject(asList(i1, i2, i3, i4)), new GenericUDF.DeferredJavaObject( new HiveVarcharWritable(vc)) }; runAndVerify(argas, asList(i3, i2, i4, i1)); }
public void testText() throws HiveException { GenericUDFAbs udf = new GenericUDFAbs(); ObjectInspector valueOI = PrimitiveObjectInspectorFactory.writableStringObjectInspector; ObjectInspector[] arguments = {valueOI}; udf.initialize(arguments); DeferredObject valueObj = new DeferredJavaObject(new Text("123.45")); DeferredObject[] args = {valueObj}; DoubleWritable output = (DoubleWritable) udf.evaluate(args); assertEquals("abs() test for String failed ", "123.45", output.toString()); valueObj = new DeferredJavaObject(new Text("-123.45")); args[0] = valueObj; output = (DoubleWritable) udf.evaluate(args); assertEquals("abs() test for String failed ", "123.45", output.toString()); valueObj = new DeferredJavaObject(new Text("foo")); args[0] = valueObj; output = (DoubleWritable) udf.evaluate(args); assertEquals("abs() test for String failed ", null, output); }
@Test public void testVarcharMinusInt() throws HiveException { GenericUDFOPMinus udf = new GenericUDFOPMinus(); HiveVarcharWritable left = new HiveVarcharWritable(); left.set("123"); IntWritable right = new IntWritable(456); ObjectInspector[] inputOIs = { PrimitiveObjectInspectorFactory.writableHiveVarcharObjectInspector, PrimitiveObjectInspectorFactory.writableIntObjectInspector }; DeferredObject[] args = { new DeferredJavaObject(left), new DeferredJavaObject(right), }; PrimitiveObjectInspector oi = (PrimitiveObjectInspector) udf.initialize(inputOIs); Assert.assertEquals(oi.getTypeInfo(), TypeInfoFactory.doubleTypeInfo); DoubleWritable res = (DoubleWritable) udf.evaluate(args); Assert.assertEquals(new Double(-333.0), new Double(res.get())); }
@Override public Object terminate(AggregationBuffer agg) throws HiveException { ArrayList<IntWritable> ranks = ((RankBuffer) agg).rowNums; double sz = ranks.size(); if (sz > 1) { sz = sz - 1; } ArrayList<DoubleWritable> pranks = new ArrayList<DoubleWritable>(ranks.size()); for (IntWritable i : ranks) { double pr = ((double) i.get() - 1) / sz; pranks.add(new DoubleWritable(pr)); } return pranks; } }