private Converter checkIntArguments(ObjectInspector[] arguments, int i) throws UDFArgumentException { if (arguments[i].getCategory() != ObjectInspector.Category.PRIMITIVE) { throw new UDFArgumentTypeException(i, "Only primitive type arguments are accepted but " + arguments[i].getTypeName() + " is passed."); } PrimitiveCategory inputType = ((PrimitiveObjectInspector) arguments[i]).getPrimitiveCategory(); Converter converter; switch (inputType) { case INT: case SHORT: case BYTE: converter = ObjectInspectorConverters.getConverter((PrimitiveObjectInspector) arguments[i], PrimitiveObjectInspectorFactory.writableIntObjectInspector); break; default: throw new UDFArgumentTypeException(i + 1, udfName + " only takes INT/SHORT/BYTE types as " + (i + 1) + "-ths argument, got " + inputType); } return converter; } }
void updateRank(List<Object> oRow) { int r = (Integer) fnOutOI.getPrimitiveJavaObject(oRow.get(rankFnIdx)); if ( r > currentRank ) { currentRank = r; } }
final ArrayWritable mapObj = (ArrayWritable) obj; final Writable[] arr = mapObj.get(); if (key.equals(arr[0]) || key.equals(((PrimitiveObjectInspector) keyInspector).getPrimitiveJavaObject(arr[0])) || key.equals(((PrimitiveObjectInspector) keyInspector).getPrimitiveWritableObject(arr[0]))) { return arr[1]; if (key.equals(((PrimitiveObjectInspector) keyInspector).getPrimitiveJavaObject(entry.getKey())) || key.equals(((PrimitiveObjectInspector) keyInspector).getPrimitiveWritableObject(entry.getKey()))) { return entry.getValue();
/** * Helper function to help GenericUDFs determine the return type * character length for char/varchar. * @param poi PrimitiveObjectInspector representing the type * @return character length of the type * @throws UDFArgumentException */ public static int getFixedStringSizeForType(PrimitiveObjectInspector poi) throws UDFArgumentException { // TODO: we can support date, int, .. any types which would have a fixed length value switch (poi.getPrimitiveCategory()) { case CHAR: case VARCHAR: BaseCharTypeInfo typeInfo = (BaseCharTypeInfo) poi.getTypeInfo(); return typeInfo.getLength(); default: throw new UDFArgumentException("No fixed size for type " + poi.getTypeName()); } }
@Override public ObjectInspector initialize(ObjectInspector[] arguments) throws UDFArgumentException { if (arguments.length != 1) { throw new UDFArgumentException(opName + " requires one argument."); } Category category = arguments[0].getCategory(); if (category != Category.PRIMITIVE) { throw new UDFArgumentTypeException(0, "The " + GenericUDFUtils.getOrdinal(1) + " argument of " + opName + " is expected to a " + Category.PRIMITIVE.toString().toLowerCase() + " type, but " + category.toString().toLowerCase() + " is found"); } inputOI = (PrimitiveObjectInspector) arguments[0]; if (!FunctionRegistry.isNumericType(inputOI.getTypeInfo()) && (inputOI.getTypeInfo() != TypeInfoFactory.intervalDayTimeTypeInfo) && (inputOI.getTypeInfo() != TypeInfoFactory.intervalYearMonthTypeInfo)) { throw new UDFArgumentTypeException(0, "The " + GenericUDFUtils.getOrdinal(1) + " argument of " + opName + " is expected to be a " + "numeric or interval type, but " + inputOI.getTypeName() + " is found"); } PrimitiveTypeInfo resultTypeInfo = deriveResultTypeInfo(inputOI.getTypeInfo()); resultOI = PrimitiveObjectInspectorFactory.getPrimitiveWritableObjectInspector(resultTypeInfo); converter = ObjectInspectorConverters.getConverter(inputOI, resultOI); return resultOI; }
if (arguments[0].getCategory() != ObjectInspector.Category.PRIMITIVE) { throw new UDFArgumentException( "CHARACTER_LENGTH only takes primitive types, got " + argumentOI.getTypeName()); PrimitiveObjectInspector.PrimitiveCategory inputType = argumentOI.getPrimitiveCategory(); ObjectInspector outputOI = null; switch (inputType) { throw new UDFArgumentException( " CHARACTER_LENGTH() only takes STRING/CHAR/VARCHAR/BINARY types as first argument, got " + inputType);
switch (oi.getCategory()) { case PRIMITIVE: { PrimitiveObjectInspector loi = (PrimitiveObjectInspector) oi; if (objectInspectorOption == ObjectInspectorCopyOption.DEFAULT) { objectInspectorOption = loi.preferWritable() ? ObjectInspectorCopyOption.WRITABLE : ObjectInspectorCopyOption.JAVA; result = loi.getPrimitiveJavaObject(o); if (loi.getPrimitiveCategory() == PrimitiveObjectInspector.PrimitiveCategory.TIMESTAMP) { result = PrimitiveObjectInspectorFactory.javaTimestampObjectInspector.copyObject(result); } else if (loi.getPrimitiveCategory() == PrimitiveObjectInspector.PrimitiveCategory.TIMESTAMPLOCALTZ) { result = PrimitiveObjectInspectorFactory.javaTimestampTZObjectInspector. result = loi.getPrimitiveWritableObject(loi.copyObject(o)); break; int length = loi.getListLength(o); ArrayList<Object> list = new ArrayList<Object>(length); for (int i = 0; i < length; i++) { list.add(copyToStandardObject(loi.getListElement(o, i), loi .getListElementObjectInspector(), objectInspectorOption)); for (StructField f : fields) { struct.add(copyToStandardObject(soi.getStructFieldData(o, f), f .getFieldObjectInspector(), objectInspectorOption));
switch (outputOI.getCategory()) { case PRIMITIVE: return PrimitiveObjectInspectorFactory.getPrimitiveWritableObjectInspector( primOutputOI.getTypeInfo()); case STRUCT: StructObjectInspector structOutputOI = (StructObjectInspector) outputOI; structFieldNames.add(listField.getFieldName()); structFieldObjectInspectors.add(getConvertedOI(listField.getFieldObjectInspector(), listField.getFieldObjectInspector(), oiSettableProperties, false)); getConvertedOI(listOutputOI.getListElementObjectInspector(), listOutputOI.getListElementObjectInspector(), oiSettableProperties, false)); case MAP: MapObjectInspector mapOutputOI = (MapObjectInspector) outputOI; getConvertedOI(mapOutputOI.getMapKeyObjectInspector(), mapOutputOI.getMapKeyObjectInspector(), oiSettableProperties, false), getConvertedOI(mapOutputOI.getMapValueObjectInspector(), + inputOI.getTypeName() + " to " + outputOI.getTypeName() + " not supported yet.");
switch (oi.getCategory()) { case PRIMITIVE: { PrimitiveObjectInspector poi = (PrimitiveObjectInspector) oi; result = poi.getTypeInfo(); break; ListObjectInspector loi = (ListObjectInspector) oi; result = TypeInfoFactory .getListTypeInfo(getTypeInfoFromObjectInspector(loi .getListElementObjectInspector())); break; result = TypeInfoFactory.getMapTypeInfo( getTypeInfoFromObjectInspector(moi.getMapKeyObjectInspector()), getTypeInfoFromObjectInspector(moi.getMapValueObjectInspector())); List<TypeInfo> fieldTypeInfos = new ArrayList<TypeInfo>(fields.size()); for (StructField f : fields) { fieldNames.add(f.getFieldName()); fieldTypeInfos.add(getTypeInfoFromObjectInspector(f .getFieldObjectInspector())); result = TypeInfoFactory.getStructTypeInfo(fieldNames, fieldTypeInfos); break;
public static ObjectInspector getStandardObjectInspector(ObjectInspector oi, ObjectInspectorCopyOption objectInspectorOption) { ObjectInspector result = null; switch (oi.getCategory()) { case PRIMITIVE: { PrimitiveObjectInspector poi = (PrimitiveObjectInspector) oi; switch (objectInspectorOption) { case DEFAULT: { if (poi.preferWritable()) { result = PrimitiveObjectInspectorFactory.getPrimitiveWritableObjectInspector( poi.getTypeInfo()); } else { result = PrimitiveObjectInspectorFactory.getPrimitiveJavaObjectInspector( poi.getTypeInfo()); result = PrimitiveObjectInspectorFactory.getPrimitiveJavaObjectInspector( poi.getTypeInfo()); break; result = PrimitiveObjectInspectorFactory.getPrimitiveWritableObjectInspector( poi.getTypeInfo()); break; result = ObjectInspectorFactory .getStandardListObjectInspector(getStandardObjectInspector(loi .getListElementObjectInspector(), objectInspectorOption)); break;
private String describeOi(String desc, ObjectInspector keyOi) { for (StructField field : ((StructObjectInspector)keyOi).getAllStructFieldRefs()) { ObjectInspector oi = field.getFieldObjectInspector(); String cat = oi.getCategory().toString(); if (oi.getCategory() == Category.PRIMITIVE) { cat = ((PrimitiveObjectInspector)oi).getPrimitiveCategory().toString(); } desc += field.getFieldName() + ":" + cat + ", "; } return desc; } }
ObjectInspectorConverters.getConverter(oi, writableOI).convert(value); switch (writableOI.getCategory()) { case PRIMITIVE: PrimitiveObjectInspector poi = (PrimitiveObjectInspector) oi; return PrimitiveObjectInspectorFactory.getPrimitiveWritableConstantObjectInspector( poi.getTypeInfo(), writableValue); case LIST: ListObjectInspector loi = (ListObjectInspector) oi; return ObjectInspectorFactory.getStandardConstantListObjectInspector( getStandardObjectInspector( loi.getListElementObjectInspector(), ObjectInspectorCopyOption.WRITABLE ), fields.size()); for (StructField f : fields) { fieldNames.add(f.getFieldName()); fieldObjectInspectors.add(getStandardObjectInspector(f .getFieldObjectInspector(), ObjectInspectorCopyOption.WRITABLE)); default: throw new IllegalArgumentException( writableOI.getCategory() + " not yet supported for constant OI");
switch (objInspector.getCategory()) { case PRIMITIVE: PrimitiveObjectInspector oi = (PrimitiveObjectInspector) objInspector; if (oi.getPrimitiveCategory() == PrimitiveCategory.BINARY) { BytesWritable bw = ((BinaryObjectInspector) oi).getPrimitiveWritableObject(obj); byte[] toWrite = new byte[bw.getLength()]; separator = (char) separators[level]; ListObjectInspector loi = (ListObjectInspector) objInspector; list = loi.getList(obj); ObjectInspector eoi = loi.getListElementObjectInspector(); if (list == null) { out.write(nullSequence.getBytes(), 0, nullSequence.getLength()); out.write(separator); serializeNoEncode(out, list.get(i), fields.get(i).getFieldObjectInspector(), separators, level + 1, nullSequence, escaped, escapeChar, needsEscape); throw new RuntimeException("Unknown category type: "+ objInspector.getCategory());
private static List<?> serializeList(Object f, ListObjectInspector loi) throws SerDeException { List l = loi.getList(f); if (l == null) { return null; ObjectInspector eloi = loi.getListElementObjectInspector(); if (eloi.getCategory() == Category.PRIMITIVE) { List<Object> list = new ArrayList<Object>(l.size()); for (int i = 0; i < l.size(); i++) { list.add(((PrimitiveObjectInspector) eloi).getPrimitiveJavaObject(l.get(i))); } else if (eloi.getCategory() == Category.STRUCT) { List<List<?>> list = new ArrayList<List<?>>(l.size()); for (int i = 0; i < l.size(); i++) { } else if (eloi.getCategory() == Category.LIST) { List<List<?>> list = new ArrayList<List<?>>(l.size()); for (int i = 0; i < l.size(); i++) {
switch (oi.getCategory()) { case PRIMITIVE: Writable writable = (Writable) ((PrimitiveObjectInspector) oi).getPrimitiveWritableObject(data); return writableWriter.write(writable, generator); generator.writeBeginArray(); for (int i = 0; i < loi.getListLength(data); i++) { Result result = write(loi.getListElement(data, i), loi.getListElementObjectInspector(), generator); if (!result.isSuccesful()) { return result; String actualFieldName = alias.toES(structField.getFieldName()); if (shouldKeep(generator.getParentPath(), actualFieldName)) { generator.writeFieldName(actualFieldName); Result result = write(soi.getStructFieldData(data, structField), structField.getFieldObjectInspector(), generator); if (!result.isSuccesful()) { return result;
@Override public Writable serialize(Object obj, ObjectInspector objInspector) throws SerDeException { if (objInspector.getCategory() != Category.STRUCT) { throw new SerDeException(getClass().toString() + " can only serialize struct types, but we got: " + objInspector.getTypeName()); ObjectInspector foi = fields.get(i).getFieldObjectInspector(); Object f = (list == null ? null : list.get(i)); if ((f != null) && (foi.getCategory().equals(ObjectInspector.Category.PRIMITIVE)) && ((PrimitiveObjectInspector) foi).getPrimitiveCategory().equals( PrimitiveObjectInspector.PrimitiveCategory.STRING) && ((StringObjectInspector) foi).getPrimitiveJavaObject(f).length() == 0) {
ObjectInspector oi = ht.getObjectInspector(); Assert.isTrue(Category.STRUCT == oi.getCategory(), String.format("Unexpected object category, expecting [%s], given [%s]", Category.STRUCT, oi.getTypeName())); ObjectInspector foi = structField.getFieldObjectInspector(); Assert.isTrue(Category.PRIMITIVE == foi.getCategory(), String.format("Unexpected object category, expecting [%s], given [%s]", Category.PRIMITIVE, oi.getTypeName())); Object writable = ((PrimitiveObjectInspector) foi).getPrimitiveWritableObject(soi.getStructFieldData(ht.getObject(), structField));
@Override public ObjectInspector initialize(ObjectInspector[] arguments) throws UDFArgumentException { for (int idx = 0; idx < Math.min(arguments.length, 3); ++idx) { if (arguments[idx].getCategory() != Category.PRIMITIVE || PrimitiveObjectInspectorUtils.getPrimitiveGrouping( ((PrimitiveObjectInspector) arguments[idx]).getPrimitiveCategory()) != PrimitiveGrouping.STRING_GROUP) { throw new UDFArgumentException("All argument should be string/character type"); } } soi_text = ObjectInspectorConverters.getConverter(arguments[0], PrimitiveObjectInspectorFactory.javaStringObjectInspector); if (arguments.length > 1) { soi_de1 = ObjectInspectorConverters.getConverter(arguments[1], PrimitiveObjectInspectorFactory.javaStringObjectInspector); } if (arguments.length > 2) { soi_de2 = ObjectInspectorConverters.getConverter(arguments[2], PrimitiveObjectInspectorFactory.javaStringObjectInspector); } return ObjectInspectorFactory.getStandardMapObjectInspector( PrimitiveObjectInspectorFactory.javaStringObjectInspector, PrimitiveObjectInspectorFactory.javaStringObjectInspector); }
public static boolean isSupportedField(ObjectInspector foi) { if (foi.getCategory() != Category.PRIMITIVE) return false; // not supported PrimitiveCategory pc = ((PrimitiveObjectInspector)foi).getPrimitiveCategory(); if (!SUPPORTED_PRIMITIVES.contains(pc)) return false; // not supported return true; }
for (int fieldIndex = 0; fieldIndex < fields.size(); fieldIndex++) { final StructField field = fields.get(fieldIndex); final ObjectInspector fieldObjInspector = field.getFieldObjectInspector(); switch (fieldObjInspector.getCategory()) { case PRIMITIVE: final PrimitiveObjectInspector primitiveObjInspector = (PrimitiveObjectInspector) fieldObjInspector; switch (primitiveObjInspector.getPrimitiveCategory()) { case STRING: case VARCHAR: