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; }
LazyBinaryByte(LazyBinaryByte copy) { super(copy); data = new ByteWritable(copy.data.get()); }
public ByteWritable readByte(ByteWritable bw) throws IOException { if (bw == null) { bw = new ByteWritable(); } bw.set(in.readByte()); return bw; }
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());
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:
ByteWritable r = reuse == null ? new ByteWritable() : (ByteWritable) reuse; r.set(boi.get(o)); tbOut.write(r); return; ShortWritable r = reuse == null ? new ShortWritable() : (ShortWritable) reuse; r.set(spoi.get(o)); tbOut.write(r); return; IntWritable r = reuse == null ? new IntWritable() : (IntWritable) reuse; r.set(ioi.get(o)); tbOut.write(r); return; LongWritable r = reuse == null ? new LongWritable() : (LongWritable) reuse; r.set(loi.get(o)); tbOut.write(r); return; FloatWritable r = reuse == null ? new FloatWritable() : (FloatWritable) reuse; r.set(foi.get(o)); tbOut.write(r); return;
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:
protected Integer getConstantIntValue(ObjectInspector[] arguments, int i) throws UDFArgumentTypeException { Object constValue = ((ConstantObjectInspector) arguments[i]).getWritableConstantValue(); if (constValue == null) { return null; } int v; if (constValue instanceof IntWritable) { v = ((IntWritable) constValue).get(); } else if (constValue instanceof ShortWritable) { v = ((ShortWritable) constValue).get(); } else if (constValue instanceof ByteWritable) { v = ((ByteWritable) constValue).get(); } else { throw new UDFArgumentTypeException(i, getFuncName() + " only takes INT/SHORT/BYTE types as " + getArgOrder(i) + " argument, got " + constValue.getClass()); } return v; }
@Test public void testByte() throws HiveException { GenericUDFFloor udf = new GenericUDFFloor(); ByteWritable input = new ByteWritable((byte) 4); ObjectInspector[] inputOIs = { PrimitiveObjectInspectorFactory.writableByteObjectInspector, }; DeferredObject[] args = { new DeferredJavaObject(input) }; PrimitiveObjectInspector oi = (PrimitiveObjectInspector) udf.initialize(inputOIs); Assert.assertEquals(TypeInfoFactory.longTypeInfo, oi.getTypeInfo()); LongWritable res = (LongWritable) udf.evaluate(args); Assert.assertEquals(4L, res.get()); }
@Test public void testIntWritable() { IntWritable obj = new IntWritable(10); assertEquals(new ByteWritable((byte) 10), inspector.getPrimitiveWritableObject(obj)); assertEquals((byte) 10, inspector.getPrimitiveJavaObject(obj)); }
@Test public void testByteMinusShort() throws HiveException { GenericUDFOPMinus udf = new GenericUDFOPMinus(); ByteWritable left = new ByteWritable((byte) 4); ShortWritable right = new ShortWritable((short) 6); ObjectInspector[] inputOIs = { PrimitiveObjectInspectorFactory.writableByteObjectInspector, PrimitiveObjectInspectorFactory.writableShortObjectInspector }; DeferredObject[] args = { new DeferredJavaObject(left), new DeferredJavaObject(right), }; PrimitiveObjectInspector oi = (PrimitiveObjectInspector) udf.initialize(inputOIs); Assert.assertEquals(oi.getTypeInfo(), TypeInfoFactory.shortTypeInfo); ShortWritable res = (ShortWritable) udf.evaluate(args); Assert.assertEquals(-2, res.get()); }
@Override public Object getWritableConstantValue() { if (value==null) { return null; } return new ByteWritable(value); } }
@Test public void testBytePowerShort() throws HiveException { GenericUDFPower udf = new GenericUDFPower(); ByteWritable left = new ByteWritable((byte) 2); ShortWritable right = new ShortWritable((short) 4); ObjectInspector[] inputOIs = { PrimitiveObjectInspectorFactory.writableByteObjectInspector, PrimitiveObjectInspectorFactory.writableShortObjectInspector }; DeferredObject[] args = { new DeferredJavaObject(left), new DeferredJavaObject(right), }; PrimitiveObjectInspector oi = (PrimitiveObjectInspector) udf.initialize(inputOIs); Assert.assertEquals(TypeInfoFactory.doubleTypeInfo, oi.getTypeInfo()); DoubleWritable res = (DoubleWritable) udf.evaluate(args); Assert.assertEquals(new Double(16), new Double(res.get())); }