internal static ObjectInspector getStandardListObjectInspector(ObjectInspector elementObjectInspector)
{
throw new NotImplementedException();
}
internal static ObjectInspector getStandardMapObjectInspector(ObjectInspector keyObjectInspector, ObjectInspector valueObjectInspector)
{
throw new NotImplementedException();
}
public DictionaryObjectInspector(ObjectInspector keyInspector, ObjectInspector valueInspector)
{
this.keyInspector = keyInspector;
this.valueInspector = valueInspector;
}
private static ObjectInspector makeReflectionObjectInspector(Type type)
{
switch (Type.GetTypeCode(type))
{
case TypeCode.Boolean:
return(PrimitiveObjectInspectorFactory.writableBooleanObjectInspector);
case TypeCode.SByte:
return(PrimitiveObjectInspectorFactory.writableByteObjectInspector);
case TypeCode.DateTime:
return(PrimitiveObjectInspectorFactory.writableTimestampObjectInspector);
case TypeCode.Double:
return(PrimitiveObjectInspectorFactory.writableDoubleObjectInspector);
case TypeCode.Int16:
return(PrimitiveObjectInspectorFactory.writableShortObjectInspector);
case TypeCode.Int32:
return(PrimitiveObjectInspectorFactory.writableIntObjectInspector);
case TypeCode.Int64:
return(PrimitiveObjectInspectorFactory.writableLongObjectInspector);
case TypeCode.Single:
return(PrimitiveObjectInspectorFactory.writableFloatObjectInspector);
case TypeCode.String:
return(PrimitiveObjectInspectorFactory.writableStringObjectInspector);
case TypeCode.Char:
case TypeCode.DBNull:
case TypeCode.Decimal:
case TypeCode.Empty:
case TypeCode.Byte:
case TypeCode.UInt16:
case TypeCode.UInt32:
case TypeCode.UInt64:
throw new NotSupportedException();
}
if (type == typeof(Date))
{
return(new DateObjectInspector());
}
if (type == typeof(Timestamp))
{
return(new TimestampObjectInspector());
}
if (type == typeof(HiveDecimal))
{
return(new HiveDecimalObjectInspector(HiveDecimal.MAX_PRECISION, HiveDecimal.MAX_SCALE));
}
if (type == typeof(byte[]))
{
return(PrimitiveObjectInspectorFactory.writableBinaryObjectInspector);
}
if (type.IsArray && type.GetArrayRank() == 1)
{
Type elementType = type.GetElementType();
ObjectInspector elementInspector = getReflectionObjectInspector(elementType);
ConstructorInfo ctor = typeof(ArrayObjectInspector <>).MakeGenericType(elementType).GetConstructor(new[] { typeof(ObjectInspector) });
return((ObjectInspector)ctor.Invoke(new[] { elementInspector }));
}
if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable <>))
{
return(getReflectionObjectInspector(type.GetGenericArguments()[0]));
}
if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(List <>))
{
Type elementType = type.GetGenericArguments()[0];
ObjectInspector elementInspector = getReflectionObjectInspector(elementType);
ConstructorInfo ctor = typeof(ArrayObjectInspector <>).MakeGenericType(elementType).GetConstructor(new[] { typeof(ObjectInspector) });
return((ObjectInspector)ctor.Invoke(new[] { elementInspector }));
}
if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Dictionary <,>))
{
Type[] types = type.GetGenericArguments();
Type keyType = types[0];
ObjectInspector keyInspector = getReflectionObjectInspector(keyType);
Type valueType = types[1];
ObjectInspector valueInspector = getReflectionObjectInspector(valueType);
ConstructorInfo ctor = typeof(DictionaryObjectInspector <,>).MakeGenericType(keyType, valueType).GetConstructor(new[] { typeof(ObjectInspector), typeof(ObjectInspector) });
return((ObjectInspector)ctor.Invoke(new[] { keyInspector, valueInspector }));
}
FieldInfo[] objectFields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
FieldInfoField[] fields = objectFields.Select(f => new FieldInfoField(f, getReflectionObjectInspector(f.FieldType))).ToArray();
return(new FieldsObjectInspector(fields));
}
public ArrayObjectInspector(ObjectInspector elementInspector)
{
this.elementInspector = elementInspector;
}
/**
* Get the TypeInfo object from the ObjectInspector object by recursively
* going into the ObjectInspector structure.
*/
public static TypeInfo getTypeInfoFromObjectInspector(ObjectInspector oi)
{
// OPTIMIZATION for later.
// if (oi instanceof TypeInfoBasedObjectInspector) {
// TypeInfoBasedObjectInspector typeInfoBasedObjectInspector =
// (ObjectInspector)oi;
// return typeInfoBasedObjectInspector.getTypeInfo();
// }
if (oi == null)
{
return(null);
}
// Recursively going into ObjectInspector structure
TypeInfo result = null;
switch (oi.getCategory())
{
case ObjectInspectorCategory.PRIMITIVE:
{
PrimitiveObjectInspector poi = (PrimitiveObjectInspector)oi;
result = poi.getTypeInfo();
break;
}
case ObjectInspectorCategory.LIST:
{
ListObjectInspector loi = (ListObjectInspector)oi;
result = TypeInfoFactory
.getListTypeInfo(getTypeInfoFromObjectInspector(loi
.getListElementObjectInspector()));
break;
}
case ObjectInspectorCategory.MAP:
{
MapObjectInspector moi = (MapObjectInspector)oi;
result = TypeInfoFactory.getMapTypeInfo(
getTypeInfoFromObjectInspector(moi.getMapKeyObjectInspector()),
getTypeInfoFromObjectInspector(moi.getMapValueObjectInspector()));
break;
}
case ObjectInspectorCategory.STRUCT:
{
StructObjectInspector soi = (StructObjectInspector)oi;
IList <StructField> fields = soi.getAllStructFieldRefs();
List <String> fieldNames = new List <String>(fields.Count);
List <TypeInfo> fieldTypeInfos = new List <TypeInfo>(fields.Count);
foreach (StructField f in fields)
{
fieldNames.Add(f.getFieldName());
fieldTypeInfos.Add(getTypeInfoFromObjectInspector(f
.getFieldObjectInspector()));
}
result = TypeInfoFactory.getStructTypeInfo(fieldNames, fieldTypeInfos);
break;
}
case ObjectInspectorCategory.UNION:
{
UnionObjectInspector uoi = (UnionObjectInspector)oi;
List <TypeInfo> objectTypeInfos = new List <TypeInfo>();
foreach (ObjectInspector eoi in uoi.getObjectInspectors())
{
objectTypeInfos.Add(getTypeInfoFromObjectInspector(eoi));
}
result = TypeInfoFactory.getUnionTypeInfo(objectTypeInfos);
break;
}
default:
{
throw new InvalidOperationException("Unknown ObjectInspector category!");
}
}
return(result);
}
/**
* Returns the standard object inspector that can be used to translate an
* object of that typeInfo to a standard object type.
*/
public static ObjectInspector getStandardJavaObjectInspectorFromTypeInfo(
TypeInfo typeInfo)
{
ObjectInspector result = cachedStandardJavaObjectInspector.get(typeInfo);
if (result == null)
{
switch (typeInfo.getCategory())
{
case ObjectInspectorCategory.PRIMITIVE:
{
// NOTE: we use JavaPrimitiveObjectInspector instead of
// StandardPrimitiveObjectInspector
result = PrimitiveObjectInspectorFactory
.getPrimitiveJavaObjectInspector((PrimitiveTypeInfo)typeInfo);
break;
}
case ObjectInspectorCategory.LIST:
{
ObjectInspector elementObjectInspector =
getStandardJavaObjectInspectorFromTypeInfo(((ListTypeInfo)typeInfo)
.getListElementTypeInfo());
result = ObjectInspectorFactory
.getStandardListObjectInspector(elementObjectInspector);
break;
}
case ObjectInspectorCategory.MAP:
{
MapTypeInfo mapTypeInfo = (MapTypeInfo)typeInfo;
ObjectInspector keyObjectInspector = getStandardJavaObjectInspectorFromTypeInfo(mapTypeInfo
.getMapKeyTypeInfo());
ObjectInspector valueObjectInspector =
getStandardJavaObjectInspectorFromTypeInfo(mapTypeInfo.getMapValueTypeInfo());
result = ObjectInspectorFactory.getStandardMapObjectInspector(
keyObjectInspector, valueObjectInspector);
break;
}
case ObjectInspectorCategory.STRUCT:
{
StructTypeInfo strucTypeInfo = (StructTypeInfo)typeInfo;
List <String> fieldNames = strucTypeInfo.getAllStructFieldNames();
List <TypeInfo> fieldTypeInfos = strucTypeInfo
.getAllStructFieldTypeInfos();
List <ObjectInspector> fieldObjectInspectors = new List <ObjectInspector>(
fieldTypeInfos.Count);
for (int i = 0; i < fieldTypeInfos.Count; i++)
{
fieldObjectInspectors
.Add(getStandardJavaObjectInspectorFromTypeInfo(fieldTypeInfos[i]));
}
result = ObjectInspectorFactory.getStandardStructObjectInspector(
fieldNames, fieldObjectInspectors);
break;
}
case ObjectInspectorCategory.UNION:
{
UnionTypeInfo unionTypeInfo = (UnionTypeInfo)typeInfo;
List <TypeInfo> objectTypeInfos = unionTypeInfo
.getAllUnionObjectTypeInfos();
List <ObjectInspector> fieldObjectInspectors =
new List <ObjectInspector>(objectTypeInfos.Count);
for (int i = 0; i < objectTypeInfos.Count; i++)
{
fieldObjectInspectors
.Add(getStandardJavaObjectInspectorFromTypeInfo(objectTypeInfos[i]));
}
result = ObjectInspectorFactory.getStandardUnionObjectInspector(
fieldObjectInspectors);
break;
}
default:
{
result = null;
break;
}
}
ObjectInspector prev =
cachedStandardJavaObjectInspector.putIfAbsent(typeInfo, result);
if (prev != null)
{
result = prev;
}
}
return(result);
}
internal ObjectInspector putIfAbsent(TypeInfo typeInfo, ObjectInspector result)
{
throw new NotImplementedException();
}
public FieldInfoField(FieldInfo field, ObjectInspector inspector)
{
this.field = field;
this.inspector = inspector;
}
