private ObjectInspector solveOi(ObjectInspector arg) { switch (arg.getCategory()) { case PRIMITIVE: // VOID, BOOLEAN, BYTE, SHORT, INT, LONG, FLOAT, DOUBLE, STRING, TIMESTAMP, BINARY, DECIMAL, // UNKNOWN PrimitiveObjectInspector poi = (PrimitiveObjectInspector) arg; return PrimitiveObjectInspectorFactory.getPrimitiveJavaObjectInspector( poi.getPrimitiveCategory()); case LIST: return ObjectInspectorFactory.getStandardListObjectInspector( solveOi(((ListObjectInspector) arg).getListElementObjectInspector())); case MAP: return ObjectInspectorFactory.getStandardMapObjectInspector( solveOi(((MapObjectInspector) arg).getMapKeyObjectInspector()), solveOi(((MapObjectInspector) arg).getMapValueObjectInspector())); case STRUCT: StructObjectInspector soi = (StructObjectInspector) arg; int size = soi.getAllStructFieldRefs().size(); ArrayList<String> fnl = new ArrayList<String>(size); ArrayList<ObjectInspector> foil = new ArrayList<ObjectInspector>(size); for (StructField sf : ((StructObjectInspector) arg).getAllStructFieldRefs()) { fnl.add(sf.getFieldName()); foil.add(solveOi(sf.getFieldObjectInspector())); } return JsonStructObjectInspector.getJsonStructObjectInspector(fnl, foil); default: return arg; } }
public static ConstantObjectInspector getConstantObjectInspector( ObjectInspector oi, Object value) { if (oi instanceof ConstantObjectInspector) { return (ConstantObjectInspector) oi; } ObjectInspector writableOI = getStandardObjectInspector(oi, ObjectInspectorCopyOption.WRITABLE); Object writableValue = 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), (List<?>) writableValue); case MAP: MapObjectInspector moi = (MapObjectInspector) oi; return ObjectInspectorFactory.getStandardConstantMapObjectInspector( getStandardObjectInspector( moi.getMapKeyObjectInspector(), ObjectInspectorCopyOption.WRITABLE), getStandardObjectInspector( moi.getMapValueObjectInspector(), ObjectInspectorCopyOption.WRITABLE), (Map<?, ?>) writableValue); default: throw new IllegalArgumentException( writableOI.getCategory() + " not yet supported for constant OI"); } }
/** * This method is only intended to be used by Utilities class in this package. The reason that * this method is not recursive by itself is because we want to allow recursive types. */ @Override protected void init(Class<?> objectClass, ObjectInspectorFactory.ObjectInspectorOptions options) { verifyObjectClassType(objectClass); this.objectClass = objectClass; final Field fieldMetaData; try { fieldMetaData = objectClass.getDeclaredField(FIELD_METADATA_MAP); assert (Map.class.isAssignableFrom(fieldMetaData.getType())); fieldMetaData.setAccessible(true); } catch (NoSuchFieldException e) { throw new RuntimeException("Unable to find field metadata for thrift union field ", e); } try { final Map<? extends TFieldIdEnum, FieldMetaData> fieldMap = (Map<? extends TFieldIdEnum, FieldMetaData>) fieldMetaData.get(null); fields = new ArrayList<StandardStructObjectInspector.MyField>(fieldMap.size()); this.ois = new ArrayList<ObjectInspector>(); for (Map.Entry<? extends TFieldIdEnum, FieldMetaData> metadata : fieldMap.entrySet()) { int fieldId = metadata.getKey().getThriftFieldId(); String fieldName = metadata.getValue().fieldName; final Type fieldType = ThriftObjectInspectorUtils.getFieldType(objectClass, fieldName); final ObjectInspector reflectionObjectInspector = ObjectInspectorFactory.getReflectionObjectInspector(fieldType, options); fields.add( new StandardStructObjectInspector.MyField( fieldId, fieldName, reflectionObjectInspector)); this.ois.add(reflectionObjectInspector); } } catch (IllegalAccessException e) { throw new RuntimeException("Unable to find field metadata for thrift union field ", e); } }
/** Get the type name of the Java class. */ public static String getTypeNameFromJavaClass(Type t) { try { ObjectInspector oi = ObjectInspectorFactory.getReflectionObjectInspector(t, ObjectInspectorOptions.JAVA); return oi.getTypeName(); } catch (Throwable e) { LOG.info(StringUtils.stringifyException(e)); return "unknown"; } }
public void testUnionStructObjectInspector() throws Throwable { try { ArrayList<String> fieldNames1 = new ArrayList<String>(); fieldNames1.add("firstInteger"); fieldNames1.add("secondString"); fieldNames1.add("thirdBoolean"); ArrayList<ObjectInspector> fieldObjectInspectors1 = new ArrayList<ObjectInspector>(); fieldObjectInspectors1.add(PrimitiveObjectInspectorFactory.javaIntObjectInspector); fieldObjectInspectors1.add(PrimitiveObjectInspectorFactory.javaStringObjectInspector); fieldObjectInspectors1.add(PrimitiveObjectInspectorFactory.javaBooleanObjectInspector); StandardStructObjectInspector soi1 = ObjectInspectorFactory.getStandardStructObjectInspector( fieldNames1, fieldObjectInspectors1); ArrayList<String> fieldNames2 = new ArrayList<String>(); fieldNames2.add("fourthDouble"); fieldNames2.add("fifthLong"); ArrayList<ObjectInspector> fieldObjectInspectors2 = new ArrayList<ObjectInspector>(); fieldObjectInspectors2.add(PrimitiveObjectInspectorFactory.javaDoubleObjectInspector); fieldObjectInspectors2.add(PrimitiveObjectInspectorFactory.javaLongObjectInspector); StandardStructObjectInspector soi2 = ObjectInspectorFactory.getStandardStructObjectInspector( fieldNames2, fieldObjectInspectors2); UnionStructObjectInspector usoi1 = ObjectInspectorFactory.getUnionStructObjectInspector( Arrays.asList(new StructObjectInspector[] {soi1, soi2})); UnionStructObjectInspector usoi2 = ObjectInspectorFactory.getUnionStructObjectInspector( Arrays.asList(new StructObjectInspector[] {soi1, soi2})); assertEquals(usoi1, usoi2); // metadata assertEquals(Category.STRUCT, usoi1.getCategory()); List<? extends StructField> fields = usoi1.getAllStructFieldRefs(); assertEquals(5, fields.size()); for (int i = 0; i < 5; i++) { if (i <= 2) { assertEquals(fieldNames1.get(i).toLowerCase(), fields.get(i).getFieldName()); assertEquals(fieldObjectInspectors1.get(i), fields.get(i).getFieldObjectInspector()); } else { assertEquals(fieldNames2.get(i - 3).toLowerCase(), fields.get(i).getFieldName()); assertEquals(fieldObjectInspectors2.get(i - 3), fields.get(i).getFieldObjectInspector()); } } assertEquals(fields.get(1), usoi1.getStructFieldRef("secondString")); assertEquals(fields.get(4), usoi1.getStructFieldRef("fifthLong")); // null for (int i = 0; i < 5; i++) { assertNull(usoi1.getStructFieldData(null, fields.get(i))); } // real struct ArrayList<Object> struct1 = new ArrayList<Object>(3); struct1.add(1); struct1.add("two"); struct1.add(true); ArrayList<Object> struct2 = new ArrayList<Object>(2); struct2.add(1.0); struct2.add(new Long(111)); ArrayList<Object> struct = new ArrayList<Object>(2); struct.add(struct1); struct.add(struct2); ArrayList<Object> all = new ArrayList<Object>(5); all.addAll(struct1); all.addAll(struct2); for (int i = 0; i < 5; i++) { assertEquals(all.get(i), usoi1.getStructFieldData(struct, fields.get(i))); } } catch (Throwable e) { e.printStackTrace(); throw e; } }
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()); } break; } case JAVA: { result = PrimitiveObjectInspectorFactory.getPrimitiveJavaObjectInspector( poi.getTypeInfo()); break; } case WRITABLE: result = PrimitiveObjectInspectorFactory.getPrimitiveWritableObjectInspector( poi.getTypeInfo()); break; } break; } case LIST: { ListObjectInspector loi = (ListObjectInspector) oi; result = ObjectInspectorFactory.getStandardListObjectInspector( getStandardObjectInspector( loi.getListElementObjectInspector(), objectInspectorOption)); break; } case MAP: { MapObjectInspector moi = (MapObjectInspector) oi; result = ObjectInspectorFactory.getStandardMapObjectInspector( getStandardObjectInspector(moi.getMapKeyObjectInspector(), objectInspectorOption), getStandardObjectInspector( moi.getMapValueObjectInspector(), objectInspectorOption)); break; } case STRUCT: { StructObjectInspector soi = (StructObjectInspector) oi; List<? extends StructField> fields = soi.getAllStructFieldRefs(); List<String> fieldNames = new ArrayList<String>(fields.size()); List<ObjectInspector> fieldObjectInspectors = new ArrayList<ObjectInspector>(fields.size()); for (StructField f : fields) { fieldNames.add(f.getFieldName()); fieldObjectInspectors.add( getStandardObjectInspector(f.getFieldObjectInspector(), objectInspectorOption)); } result = ObjectInspectorFactory.getStandardStructObjectInspector( fieldNames, fieldObjectInspectors); break; } case UNION: { UnionObjectInspector uoi = (UnionObjectInspector) oi; List<ObjectInspector> ois = new ArrayList<ObjectInspector>(); for (ObjectInspector eoi : uoi.getObjectInspectors()) { ois.add(getStandardObjectInspector(eoi, objectInspectorOption)); } result = ObjectInspectorFactory.getStandardUnionObjectInspector(ois); break; } default: { throw new RuntimeException("Unknown ObjectInspector category!"); } } return result; }