You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hive.apache.org by zs...@apache.org on 2010/01/21 10:39:14 UTC
svn commit: r901618 [1/3] - in
/hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector:
./ primitive/
Author: zshao
Date: Thu Jan 21 09:35:09 2010
New Revision: 901618
URL: http://svn.apache.org/viewvc?rev=901618&view=rev
Log:
HIVE-1081. Automated source code cleanup - Part 2 - serde. (Carl Steinbach via zshao)
Modified:
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/ColumnarStructObjectInspector.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/InspectableObject.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/ListObjectInspector.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/MapObjectInspector.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/MetadataListStructObjectInspector.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/ObjectInspector.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/ObjectInspectorConverters.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/ObjectInspectorFactory.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/ObjectInspectorUtils.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/PrimitiveObjectInspector.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/ReflectionStructObjectInspector.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/SettableListObjectInspector.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/SettableMapObjectInspector.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/SettableStructObjectInspector.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/StandardListObjectInspector.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/StandardMapObjectInspector.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/StandardStructObjectInspector.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/StructField.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/StructObjectInspector.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/ThriftStructObjectInspector.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/UnionStructObjectInspector.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/AbstractPrimitiveJavaObjectInspector.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/AbstractPrimitiveObjectInspector.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/AbstractPrimitiveWritableObjectInspector.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/BooleanObjectInspector.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/ByteObjectInspector.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/DoubleObjectInspector.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/FloatObjectInspector.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/IntObjectInspector.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/JavaBooleanObjectInspector.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/JavaByteObjectInspector.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/JavaDoubleObjectInspector.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/JavaFloatObjectInspector.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/JavaIntObjectInspector.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/JavaLongObjectInspector.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/JavaShortObjectInspector.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/JavaStringObjectInspector.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/JavaVoidObjectInspector.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/LongObjectInspector.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/PrimitiveObjectInspectorConverter.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/PrimitiveObjectInspectorFactory.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/PrimitiveObjectInspectorUtils.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/SettableBooleanObjectInspector.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/SettableByteObjectInspector.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/SettableDoubleObjectInspector.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/SettableFloatObjectInspector.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/SettableIntObjectInspector.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/SettableLongObjectInspector.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/SettableShortObjectInspector.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/SettableStringObjectInspector.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/ShortObjectInspector.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/StringObjectInspector.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/VoidObjectInspector.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableBooleanObjectInspector.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableByteObjectInspector.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableDoubleObjectInspector.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableFloatObjectInspector.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableIntObjectInspector.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableLongObjectInspector.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableShortObjectInspector.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableStringObjectInspector.java
hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableVoidObjectInspector.java
Modified: hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/ColumnarStructObjectInspector.java
URL: http://svn.apache.org/viewvc/hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/ColumnarStructObjectInspector.java?rev=901618&r1=901617&r2=901618&view=diff
==============================================================================
--- hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/ColumnarStructObjectInspector.java (original)
+++ hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/ColumnarStructObjectInspector.java Thu Jan 21 09:35:09 2010
@@ -65,6 +65,7 @@
return fieldObjectInspector;
}
+ @Override
public String toString() {
return "" + fieldID + ":" + fieldName;
}
Modified: hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/InspectableObject.java
URL: http://svn.apache.org/viewvc/hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/InspectableObject.java?rev=901618&r1=901617&r2=901618&view=diff
==============================================================================
--- hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/InspectableObject.java (original)
+++ hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/InspectableObject.java Thu Jan 21 09:35:09 2010
@@ -21,24 +21,24 @@
/**
* Simple wrapper of object with ObjectInspector.
*
- * TODO: we need to redefine the hashCode and equals methods, so that
- * it can be put into a HashMap as a key.
+ * TODO: we need to redefine the hashCode and equals methods, so that it can be
+ * put into a HashMap as a key.
*
- * This class also serves as a facility for a function that returns
- * both an object and an ObjectInspector.
+ * This class also serves as a facility for a function that returns both an
+ * object and an ObjectInspector.
*/
public class InspectableObject {
public Object o;
public ObjectInspector oi;
-
+
public InspectableObject() {
- this(null,null);
+ this(null, null);
}
+
public InspectableObject(Object o, ObjectInspector oi) {
this.o = o;
this.oi = oi;
}
-
}
Modified: hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/ListObjectInspector.java
URL: http://svn.apache.org/viewvc/hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/ListObjectInspector.java?rev=901618&r1=901617&r2=901618&view=diff
==============================================================================
--- hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/ListObjectInspector.java (original)
+++ hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/ListObjectInspector.java Thu Jan 21 09:35:09 2010
@@ -19,28 +19,30 @@
import java.util.List;
-
public interface ListObjectInspector extends ObjectInspector {
// ** Methods that does not need a data object **
public ObjectInspector getListElementObjectInspector();
// ** Methods that need a data object **
- /** returns null for null list, out-of-the-range index.
+ /**
+ * returns null for null list, out-of-the-range index.
*/
public Object getListElement(Object data, int index);
- /** returns -1 for data = null.
+ /**
+ * returns -1 for data = null.
*/
public int getListLength(Object data);
-
- /** returns null for data = null.
- *
- * Note: This method should not return a List object that is reused by the
- * same ListObjectInspector, because it's possible that the same
- * ListObjectInspector will be used in multiple places in the code.
- *
- * However it's OK if the List object is part of the Object data.
+
+ /**
+ * returns null for data = null.
+ *
+ * Note: This method should not return a List object that is reused by the
+ * same ListObjectInspector, because it's possible that the same
+ * ListObjectInspector will be used in multiple places in the code.
+ *
+ * However it's OK if the List object is part of the Object data.
*/
public List<?> getList(Object data);
Modified: hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/MapObjectInspector.java
URL: http://svn.apache.org/viewvc/hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/MapObjectInspector.java?rev=901618&r1=901617&r2=901618&view=diff
==============================================================================
--- hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/MapObjectInspector.java (original)
+++ hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/MapObjectInspector.java Thu Jan 21 09:35:09 2010
@@ -19,7 +19,6 @@
import java.util.Map;
-
public interface MapObjectInspector extends ObjectInspector {
// ** Methods that does not need a data object **
@@ -31,19 +30,21 @@
// ** Methods that need a data object **
// In this function, key has to be of the same structure as the Map expects.
// Most cases key will be primitive type, so it's OK.
- // In rare cases that key is not primitive, the user is responsible for defining
+ // In rare cases that key is not primitive, the user is responsible for
+ // defining
// the hashCode() and equals() methods of the key class.
public Object getMapValueElement(Object data, Object key);
- /** returns null for data = null.
- *
- * Note: This method should not return a Map object that is reused by the
- * same MapObjectInspector, because it's possible that the same
- * MapObjectInspector will be used in multiple places in the code.
- *
- * However it's OK if the Map object is part of the Object data.
+ /**
+ * returns null for data = null.
+ *
+ * Note: This method should not return a Map object that is reused by the same
+ * MapObjectInspector, because it's possible that the same MapObjectInspector
+ * will be used in multiple places in the code.
+ *
+ * However it's OK if the Map object is part of the Object data.
*/
- public Map<?,?> getMap(Object data);
+ public Map<?, ?> getMap(Object data);
/**
* returns -1 for NULL map.
Modified: hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/MetadataListStructObjectInspector.java
URL: http://svn.apache.org/viewvc/hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/MetadataListStructObjectInspector.java?rev=901618&r1=901617&r2=901618&view=diff
==============================================================================
--- hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/MetadataListStructObjectInspector.java (original)
+++ hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/MetadataListStructObjectInspector.java Thu Jan 21 09:35:09 2010
@@ -27,21 +27,24 @@
import org.apache.hadoop.hive.serde2.objectinspector.primitive.PrimitiveObjectInspectorFactory;
/**
- * StructObjectInspector works on struct data that is stored as a Java List or Java Array object.
- * Basically, the fields are stored sequentially in the List object.
+ * StructObjectInspector works on struct data that is stored as a Java List or
+ * Java Array object. Basically, the fields are stored sequentially in the List
+ * object.
*
- * The names of the struct fields and the internal structure of the struct fields are specified in
- * the ctor of the StructObjectInspector.
+ * The names of the struct fields and the internal structure of the struct
+ * fields are specified in the ctor of the StructObjectInspector.
*
*/
-public class MetadataListStructObjectInspector extends StandardStructObjectInspector {
+public class MetadataListStructObjectInspector extends
+ StandardStructObjectInspector {
- static HashMap<List<String>, MetadataListStructObjectInspector> cached
- = new HashMap<List<String>, MetadataListStructObjectInspector>();
-// public static MetadataListStructObjectInspector getInstance(int fields) {
-// return getInstance(ObjectInspectorUtils.getIntegerArray(fields));
-// }
- public static MetadataListStructObjectInspector getInstance(List<String> columnNames) {
+ static HashMap<List<String>, MetadataListStructObjectInspector> cached = new HashMap<List<String>, MetadataListStructObjectInspector>();
+
+ // public static MetadataListStructObjectInspector getInstance(int fields) {
+ // return getInstance(ObjectInspectorUtils.getIntegerArray(fields));
+ // }
+ public static MetadataListStructObjectInspector getInstance(
+ List<String> columnNames) {
MetadataListStructObjectInspector result = cached.get(columnNames);
if (result == null) {
result = new MetadataListStructObjectInspector(columnNames);
@@ -52,27 +55,31 @@
static ArrayList<ObjectInspector> getFieldObjectInspectors(int fields) {
ArrayList<ObjectInspector> r = new ArrayList<ObjectInspector>(fields);
- for(int i=0; i<fields; i++) {
- r.add(PrimitiveObjectInspectorFactory.getPrimitiveJavaObjectInspector(PrimitiveCategory.STRING));
+ for (int i = 0; i < fields; i++) {
+ r.add(PrimitiveObjectInspectorFactory
+ .getPrimitiveJavaObjectInspector(PrimitiveCategory.STRING));
}
return r;
}
-
+
MetadataListStructObjectInspector(List<String> columnNames) {
super(columnNames, getFieldObjectInspectors(columnNames.size()));
}
-
+
// Get col object out
+ @Override
public Object getStructFieldData(Object data, StructField fieldRef) {
if (data instanceof ColumnSet) {
- data = ((ColumnSet)data).col;
+ data = ((ColumnSet) data).col;
}
return super.getStructFieldData(data, fieldRef);
}
+
// Get col object out
+ @Override
public List<Object> getStructFieldsDataAsList(Object data) {
if (data instanceof ColumnSet) {
- data = ((ColumnSet)data).col;
+ data = ((ColumnSet) data).col;
}
return super.getStructFieldsDataAsList(data);
}
Modified: hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/ObjectInspector.java
URL: http://svn.apache.org/viewvc/hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/ObjectInspector.java?rev=901618&r1=901617&r2=901618&view=diff
==============================================================================
--- hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/ObjectInspector.java (original)
+++ hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/ObjectInspector.java Thu Jan 21 09:35:09 2010
@@ -21,18 +21,19 @@
/**
* ObjectInspector helps us to look into the internal structure of a complex
* object.
- *
+ *
* A (probably configured) ObjectInspector instance stands for a specific type
* and a specific way to store the data of that type in the memory.
*
- * For native java Object, we can directly access the internal structure through
- * member fields and methods. ObjectInspector is a way to delegate that functionality
- * away from the Object, so that we have more control on the behavior of those actions.
+ * For native java Object, we can directly access the internal structure through
+ * member fields and methods. ObjectInspector is a way to delegate that
+ * functionality away from the Object, so that we have more control on the
+ * behavior of those actions.
*
- * An efficient implementation of ObjectInspector should rely on factory, so that we can
- * make sure the same ObjectInspector only has one instance. That also makes sure
- * hashCode() and equals() methods of java.lang.Object directly works for ObjectInspector
- * as well.
+ * An efficient implementation of ObjectInspector should rely on factory, so
+ * that we can make sure the same ObjectInspector only has one instance. That
+ * also makes sure hashCode() and equals() methods of java.lang.Object directly
+ * works for ObjectInspector as well.
*/
public interface ObjectInspector {
@@ -41,22 +42,19 @@
};
/**
- * Returns the name of the data type that is inspected by this ObjectInspector.
- * This is used to display the type information to the user.
+ * Returns the name of the data type that is inspected by this
+ * ObjectInspector. This is used to display the type information to the user.
*
- * For primitive types, the type name is standardized.
- * For other types, the type name can be something like "list<int>", "map<int,string>",
- * java class names, or user-defined type names similar to typedef.
+ * For primitive types, the type name is standardized. For other types, the
+ * type name can be something like "list<int>", "map<int,string>", java class
+ * names, or user-defined type names similar to typedef.
*/
public String getTypeName();
-
+
/**
- * An ObjectInspector must inherit from one of the following interfaces
- * if getCategory() returns:
- * PRIMITIVE: PrimitiveObjectInspector
- * LIST: ListObjectInspector
- * MAP: MapObjectInspector
- * STRUCT: StructObjectInspector
+ * An ObjectInspector must inherit from one of the following interfaces if
+ * getCategory() returns: PRIMITIVE: PrimitiveObjectInspector LIST:
+ * ListObjectInspector MAP: MapObjectInspector STRUCT: StructObjectInspector
*/
public Category getCategory();
Modified: hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/ObjectInspectorConverters.java
URL: http://svn.apache.org/viewvc/hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/ObjectInspectorConverters.java?rev=901618&r1=901617&r2=901618&view=diff
==============================================================================
--- hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/ObjectInspectorConverters.java (original)
+++ hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/ObjectInspectorConverters.java Thu Jan 21 09:35:09 2010
@@ -33,7 +33,6 @@
import org.apache.hadoop.hive.serde2.objectinspector.primitive.SettableShortObjectInspector;
import org.apache.hadoop.hive.serde2.objectinspector.primitive.WritableStringObjectInspector;
-
public class ObjectInspectorConverters {
/**
@@ -42,84 +41,88 @@
public static interface Converter {
public Object convert(Object input);
}
-
+
public static class IdentityConverter implements Converter {
public Object convert(Object input) {
return input;
}
}
-
+
/**
- * Returns a converter that converts objects from one OI to another OI.
- * The returned (converted) object belongs to this converter, so that it can be reused
- * across different calls.
+ * Returns a converter that converts objects from one OI to another OI. The
+ * returned (converted) object belongs to this converter, so that it can be
+ * reused across different calls.
*/
- public static Converter getConverter(ObjectInspector inputOI, ObjectInspector outputOI) {
- // If the inputOI is the same as the outputOI, just return an IdentityConverter.
+ public static Converter getConverter(ObjectInspector inputOI,
+ ObjectInspector outputOI) {
+ // If the inputOI is the same as the outputOI, just return an
+ // IdentityConverter.
if (inputOI == outputOI) {
return new IdentityConverter();
}
switch (outputOI.getCategory()) {
- case PRIMITIVE:
- switch (((PrimitiveObjectInspector)outputOI).getPrimitiveCategory()) {
- case BOOLEAN:
- return new PrimitiveObjectInspectorConverter.BooleanConverter(
- (PrimitiveObjectInspector)inputOI,
- (SettableBooleanObjectInspector)outputOI);
- case BYTE:
- return new PrimitiveObjectInspectorConverter.ByteConverter(
- (PrimitiveObjectInspector)inputOI,
- (SettableByteObjectInspector)outputOI);
- case SHORT:
- return new PrimitiveObjectInspectorConverter.ShortConverter(
- (PrimitiveObjectInspector)inputOI,
- (SettableShortObjectInspector)outputOI);
- case INT:
- return new PrimitiveObjectInspectorConverter.IntConverter(
- (PrimitiveObjectInspector)inputOI,
- (SettableIntObjectInspector)outputOI);
- case LONG:
- return new PrimitiveObjectInspectorConverter.LongConverter(
- (PrimitiveObjectInspector)inputOI,
- (SettableLongObjectInspector)outputOI);
- case FLOAT:
- return new PrimitiveObjectInspectorConverter.FloatConverter(
- (PrimitiveObjectInspector)inputOI,
- (SettableFloatObjectInspector)outputOI);
- case DOUBLE:
- return new PrimitiveObjectInspectorConverter.DoubleConverter(
- (PrimitiveObjectInspector)inputOI,
- (SettableDoubleObjectInspector)outputOI);
- case STRING:
- if (outputOI instanceof WritableStringObjectInspector) {
- return new PrimitiveObjectInspectorConverter.TextConverter(
- (PrimitiveObjectInspector)inputOI);
- } else if (outputOI instanceof JavaStringObjectInspector) {
- return new PrimitiveObjectInspectorConverter.StringConverter(
- (PrimitiveObjectInspector)inputOI);
- }
- default:
- throw new RuntimeException("Hive internal error: conversion of "
- + inputOI.getTypeName() + " to " + outputOI.getTypeName() + " not supported yet.");
+ case PRIMITIVE:
+ switch (((PrimitiveObjectInspector) outputOI).getPrimitiveCategory()) {
+ case BOOLEAN:
+ return new PrimitiveObjectInspectorConverter.BooleanConverter(
+ (PrimitiveObjectInspector) inputOI,
+ (SettableBooleanObjectInspector) outputOI);
+ case BYTE:
+ return new PrimitiveObjectInspectorConverter.ByteConverter(
+ (PrimitiveObjectInspector) inputOI,
+ (SettableByteObjectInspector) outputOI);
+ case SHORT:
+ return new PrimitiveObjectInspectorConverter.ShortConverter(
+ (PrimitiveObjectInspector) inputOI,
+ (SettableShortObjectInspector) outputOI);
+ case INT:
+ return new PrimitiveObjectInspectorConverter.IntConverter(
+ (PrimitiveObjectInspector) inputOI,
+ (SettableIntObjectInspector) outputOI);
+ case LONG:
+ return new PrimitiveObjectInspectorConverter.LongConverter(
+ (PrimitiveObjectInspector) inputOI,
+ (SettableLongObjectInspector) outputOI);
+ case FLOAT:
+ return new PrimitiveObjectInspectorConverter.FloatConverter(
+ (PrimitiveObjectInspector) inputOI,
+ (SettableFloatObjectInspector) outputOI);
+ case DOUBLE:
+ return new PrimitiveObjectInspectorConverter.DoubleConverter(
+ (PrimitiveObjectInspector) inputOI,
+ (SettableDoubleObjectInspector) outputOI);
+ case STRING:
+ if (outputOI instanceof WritableStringObjectInspector) {
+ return new PrimitiveObjectInspectorConverter.TextConverter(
+ (PrimitiveObjectInspector) inputOI);
+ } else if (outputOI instanceof JavaStringObjectInspector) {
+ return new PrimitiveObjectInspectorConverter.StringConverter(
+ (PrimitiveObjectInspector) inputOI);
}
- case STRUCT: {
- return new StructConverter((StructObjectInspector)inputOI,
- (SettableStructObjectInspector)outputOI);
- }
- case LIST: {
- return new ListConverter((ListObjectInspector)inputOI,
- (SettableListObjectInspector)outputOI);
- }
- case MAP: {
- return new MapConverter((MapObjectInspector)inputOI,
- (SettableMapObjectInspector)outputOI);
- }
default:
throw new RuntimeException("Hive internal error: conversion of "
- + inputOI.getTypeName() + " to " + outputOI.getTypeName() + " not supported yet.");
+ + inputOI.getTypeName() + " to " + outputOI.getTypeName()
+ + " not supported yet.");
+ }
+ case STRUCT: {
+ return new StructConverter((StructObjectInspector) inputOI,
+ (SettableStructObjectInspector) outputOI);
+ }
+ case LIST: {
+ return new ListConverter((ListObjectInspector) inputOI,
+ (SettableListObjectInspector) outputOI);
+ }
+ case MAP: {
+ return new MapConverter((MapObjectInspector) inputOI,
+ (SettableMapObjectInspector) outputOI);
+ }
+ default:
+ throw new RuntimeException("Hive internal error: conversion of "
+ + inputOI.getTypeName() + " to " + outputOI.getTypeName()
+ + " not supported yet.");
}
}
-
+
/**
* A converter class for List.
*/
@@ -127,15 +130,16 @@
ListObjectInspector inputOI;
SettableListObjectInspector outputOI;
-
+
ObjectInspector inputElementOI;
ObjectInspector outputElementOI;
ArrayList<Converter> elementConverters;
-
+
Object output;
-
- public ListConverter(ListObjectInspector inputOI, SettableListObjectInspector outputOI) {
+
+ public ListConverter(ListObjectInspector inputOI,
+ SettableListObjectInspector outputOI) {
this.inputOI = inputOI;
this.outputOI = outputOI;
inputElementOI = inputOI.getListElementObjectInspector();
@@ -143,7 +147,7 @@
output = outputOI.create(0);
elementConverters = new ArrayList<Converter>();
}
-
+
@Override
public Object convert(Object input) {
if (input == null) {
@@ -158,19 +162,19 @@
while (elementConverters.size() < size) {
elementConverters.add(getConverter(inputElementOI, outputElementOI));
}
-
+
// Convert the elements
outputOI.resize(output, size);
for (int index = 0; index < size; index++) {
Object inputElement = inputOI.getListElement(input, index);
- Object outputElement = elementConverters.get(index).convert(inputElement);
+ Object outputElement = elementConverters.get(index).convert(
+ inputElement);
outputOI.set(output, index, outputElement);
}
return output;
}
-
- }
+ }
/**
* A converter class for Struct.
@@ -179,44 +183,45 @@
StructObjectInspector inputOI;
SettableStructObjectInspector outputOI;
-
+
List<? extends StructField> inputFields;
List<? extends StructField> outputFields;
ArrayList<Converter> fieldConverters;
-
+
Object output;
-
- public StructConverter(StructObjectInspector inputOI, SettableStructObjectInspector outputOI) {
-
+
+ public StructConverter(StructObjectInspector inputOI,
+ SettableStructObjectInspector outputOI) {
+
this.inputOI = inputOI;
this.outputOI = outputOI;
inputFields = inputOI.getAllStructFieldRefs();
outputFields = outputOI.getAllStructFieldRefs();
- assert(inputFields.size() == outputFields.size());
-
+ assert (inputFields.size() == outputFields.size());
+
fieldConverters = new ArrayList<Converter>(inputFields.size());
for (int f = 0; f < inputFields.size(); f++) {
- fieldConverters.add(getConverter(
- inputFields.get(f).getFieldObjectInspector(),
- outputFields.get(f).getFieldObjectInspector()));
+ fieldConverters.add(getConverter(inputFields.get(f)
+ .getFieldObjectInspector(), outputFields.get(f)
+ .getFieldObjectInspector()));
}
output = outputOI.create();
}
-
+
@Override
public Object convert(Object input) {
if (input == null) {
return null;
}
-
+
// Convert the fields
for (int f = 0; f < inputFields.size(); f++) {
- Object inputFieldValue = inputOI.getStructFieldData(input,
- inputFields.get(f));
- Object outputFieldValue = fieldConverters.get(f)
- .convert(inputFieldValue);
- outputOI.setStructFieldData(output, outputFields.get(f),
+ Object inputFieldValue = inputOI.getStructFieldData(input, inputFields
+ .get(f));
+ Object outputFieldValue = fieldConverters.get(f).convert(
+ inputFieldValue);
+ outputOI.setStructFieldData(output, outputFields.get(f),
outputFieldValue);
}
return output;
@@ -230,19 +235,20 @@
MapObjectInspector inputOI;
SettableMapObjectInspector outputOI;
-
+
ObjectInspector inputKeyOI;
ObjectInspector outputKeyOI;
ObjectInspector inputValueOI;
ObjectInspector outputValueOI;
-
+
ArrayList<Converter> keyConverters;
ArrayList<Converter> valueConverters;
-
+
Object output;
-
- public MapConverter(MapObjectInspector inputOI, SettableMapObjectInspector outputOI) {
+
+ public MapConverter(MapObjectInspector inputOI,
+ SettableMapObjectInspector outputOI) {
this.inputOI = inputOI;
this.outputOI = outputOI;
inputKeyOI = inputOI.getMapKeyObjectInspector();
@@ -253,7 +259,7 @@
valueConverters = new ArrayList<Converter>();
output = outputOI.create();
}
-
+
@Override
public Object convert(Object input) {
if (input == null) {
@@ -264,37 +270,35 @@
// because the key/valueConverters can reuse the internal object.
// So it's not safe to use the same key/valueConverter to convert multiple
// key/values.
-
+
// NOTE: This code tries to get all key-value pairs out of the map.
// It's not very efficient. The more efficient way should be to let MapOI
- // return an Iterator. This is currently not supported by MapOI yet.
-
+ // return an Iterator. This is currently not supported by MapOI yet.
+
Map<?, ?> map = inputOI.getMap(input);
int size = map.size();
-
+
while (keyConverters.size() < size) {
keyConverters.add(getConverter(inputKeyOI, outputKeyOI));
valueConverters.add(getConverter(inputValueOI, outputValueOI));
}
-
+
// CLear the output
outputOI.clear(output);
-
+
// Convert the key/value pairs
int entryID = 0;
- for (Map.Entry<?, ?> entry: map.entrySet()) {
+ for (Map.Entry<?, ?> entry : map.entrySet()) {
Object inputKey = entry.getKey();
Object inputValue = entry.getValue();
Object outputKey = keyConverters.get(entryID).convert(inputKey);
Object outputValue = valueConverters.get(entryID).convert(inputValue);
- entryID ++;
+ entryID++;
outputOI.put(output, outputKey, outputValue);
}
return output;
}
-
+
}
-
-
}
Modified: hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/ObjectInspectorFactory.java
URL: http://svn.apache.org/viewvc/hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/ObjectInspectorFactory.java?rev=901618&r1=901617&r2=901618&view=diff
==============================================================================
--- hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/ObjectInspectorFactory.java (original)
+++ hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/ObjectInspectorFactory.java Thu Jan 21 09:35:09 2010
@@ -20,7 +20,6 @@
import java.lang.reflect.Field;
import java.lang.reflect.GenericArrayType;
-import java.lang.reflect.Modifier;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
@@ -28,137 +27,152 @@
import java.util.List;
import java.util.Map;
-import javax.swing.event.ListSelectionEvent;
-
import org.apache.hadoop.hive.serde2.objectinspector.primitive.PrimitiveObjectInspectorFactory;
import org.apache.hadoop.hive.serde2.objectinspector.primitive.PrimitiveObjectInspectorUtils;
import org.apache.hadoop.io.Text;
-
/**
- * ObjectInspectorFactory is the primary way to create new ObjectInspector instances.
+ * ObjectInspectorFactory is the primary way to create new ObjectInspector
+ * instances.
*
- * SerDe classes should call the static functions in this library to create an ObjectInspector
- * to return to the caller of SerDe2.getObjectInspector().
+ * SerDe classes should call the static functions in this library to create an
+ * ObjectInspector to return to the caller of SerDe2.getObjectInspector().
*
- * The reason of having caches here is that ObjectInspector is because ObjectInspectors do
- * not have an internal state - so ObjectInspectors with the same construction parameters should
- * result in exactly the same ObjectInspector.
+ * The reason of having caches here is that ObjectInspector is because
+ * ObjectInspectors do not have an internal state - so ObjectInspectors with the
+ * same construction parameters should result in exactly the same
+ * ObjectInspector.
*/
public class ObjectInspectorFactory {
-
/**
- * ObjectInspectorOptions describes what ObjectInspector to use.
- * JAVA is to use pure JAVA reflection. THRIFT is to use JAVA reflection and filter out __isset fields.
- * New ObjectInspectorOptions can be added here when available.
+ * ObjectInspectorOptions describes what ObjectInspector to use. JAVA is to
+ * use pure JAVA reflection. THRIFT is to use JAVA reflection and filter out
+ * __isset fields. New ObjectInspectorOptions can be added here when
+ * available.
*
- * We choose to use a single HashMap objectInspectorCache to cache all situations for efficiency and code
- * simplicity. And we don't expect a case that a user need to create 2 or more different types of
- * ObjectInspectors for the same Java type.
+ * We choose to use a single HashMap objectInspectorCache to cache all
+ * situations for efficiency and code simplicity. And we don't expect a case
+ * that a user need to create 2 or more different types of ObjectInspectors
+ * for the same Java type.
*/
public enum ObjectInspectorOptions {
- JAVA,
- THRIFT
+ JAVA, THRIFT
};
-
+
private static HashMap<Type, ObjectInspector> objectInspectorCache = new HashMap<Type, ObjectInspector>();
-
- public static ObjectInspector getReflectionObjectInspector(Type t, ObjectInspectorOptions options) {
+
+ public static ObjectInspector getReflectionObjectInspector(Type t,
+ ObjectInspectorOptions options) {
ObjectInspector oi = objectInspectorCache.get(t);
if (oi == null) {
oi = getReflectionObjectInspectorNoCache(t, options);
objectInspectorCache.put(t, oi);
}
- if ((options.equals(ObjectInspectorOptions.JAVA) && oi.getClass().equals(ThriftStructObjectInspector.class))
- || (options.equals(ObjectInspectorOptions.THRIFT) && oi.getClass().equals(ReflectionStructObjectInspector.class))) {
- throw new RuntimeException("Cannot call getObjectInspectorByReflection with both JAVA and THRIFT !");
+ if ((options.equals(ObjectInspectorOptions.JAVA) && oi.getClass().equals(
+ ThriftStructObjectInspector.class))
+ || (options.equals(ObjectInspectorOptions.THRIFT) && oi.getClass()
+ .equals(ReflectionStructObjectInspector.class))) {
+ throw new RuntimeException(
+ "Cannot call getObjectInspectorByReflection with both JAVA and THRIFT !");
}
return oi;
}
-
- private static ObjectInspector getReflectionObjectInspectorNoCache(Type t, ObjectInspectorOptions options) {
+
+ private static ObjectInspector getReflectionObjectInspectorNoCache(Type t,
+ ObjectInspectorOptions options) {
if (t instanceof GenericArrayType) {
- GenericArrayType at = (GenericArrayType)t;
- return getStandardListObjectInspector(
- getReflectionObjectInspector(at.getGenericComponentType(), options));
+ GenericArrayType at = (GenericArrayType) t;
+ return getStandardListObjectInspector(getReflectionObjectInspector(at
+ .getGenericComponentType(), options));
}
if (t instanceof ParameterizedType) {
- ParameterizedType pt = (ParameterizedType)t;
+ ParameterizedType pt = (ParameterizedType) t;
// List?
- if (List.class.isAssignableFrom((Class<?>)pt.getRawType())) {
- return getStandardListObjectInspector(
- getReflectionObjectInspector(pt.getActualTypeArguments()[0], options));
+ if (List.class.isAssignableFrom((Class<?>) pt.getRawType())) {
+ return getStandardListObjectInspector(getReflectionObjectInspector(pt
+ .getActualTypeArguments()[0], options));
}
// Map?
- if (Map.class.isAssignableFrom((Class<?>)pt.getRawType())) {
- return getStandardMapObjectInspector(
- getReflectionObjectInspector(pt.getActualTypeArguments()[0], options),
- getReflectionObjectInspector(pt.getActualTypeArguments()[1], options));
+ if (Map.class.isAssignableFrom((Class<?>) pt.getRawType())) {
+ return getStandardMapObjectInspector(getReflectionObjectInspector(pt
+ .getActualTypeArguments()[0], options),
+ getReflectionObjectInspector(pt.getActualTypeArguments()[1],
+ options));
}
- // Otherwise convert t to RawType so we will fall into the following if block.
+ // Otherwise convert t to RawType so we will fall into the following if
+ // block.
t = pt.getRawType();
}
-
+
// Must be a class.
if (!(t instanceof Class)) {
- throw new RuntimeException(ObjectInspectorFactory.class.getName() + " internal error:"
- + t);
+ throw new RuntimeException(ObjectInspectorFactory.class.getName()
+ + " internal error:" + t);
}
- Class<?> c = (Class<?>)t;
-
+ Class<?> c = (Class<?>) t;
+
// Java Primitive Type?
if (PrimitiveObjectInspectorUtils.isPrimitiveJavaType(c)) {
- return PrimitiveObjectInspectorFactory.getPrimitiveJavaObjectInspector(
- PrimitiveObjectInspectorUtils.getTypeEntryFromPrimitiveJavaType(c).primitiveCategory);
+ return PrimitiveObjectInspectorFactory
+ .getPrimitiveJavaObjectInspector(PrimitiveObjectInspectorUtils
+ .getTypeEntryFromPrimitiveJavaType(c).primitiveCategory);
}
// Java Primitive Class?
if (PrimitiveObjectInspectorUtils.isPrimitiveJavaClass(c)) {
- return PrimitiveObjectInspectorFactory.getPrimitiveJavaObjectInspector(
- PrimitiveObjectInspectorUtils.getTypeEntryFromPrimitiveJavaClass(c).primitiveCategory);
+ return PrimitiveObjectInspectorFactory
+ .getPrimitiveJavaObjectInspector(PrimitiveObjectInspectorUtils
+ .getTypeEntryFromPrimitiveJavaClass(c).primitiveCategory);
}
-
+
// Primitive Writable class?
if (PrimitiveObjectInspectorUtils.isPrimitiveWritableClass(c)) {
- return PrimitiveObjectInspectorFactory.getPrimitiveWritableObjectInspector(
- PrimitiveObjectInspectorUtils.getTypeEntryFromPrimitiveWritableClass(c).primitiveCategory);
+ return PrimitiveObjectInspectorFactory
+ .getPrimitiveWritableObjectInspector(PrimitiveObjectInspectorUtils
+ .getTypeEntryFromPrimitiveWritableClass(c).primitiveCategory);
}
// Must be struct because List and Map need to be ParameterizedType
- assert(!List.class.isAssignableFrom(c));
- assert(!Map.class.isAssignableFrom(c));
-
+ assert (!List.class.isAssignableFrom(c));
+ assert (!Map.class.isAssignableFrom(c));
+
// Create StructObjectInspector
ReflectionStructObjectInspector oi;
- switch(options) {
- case JAVA:
+ switch (options) {
+ case JAVA:
oi = new ReflectionStructObjectInspector();
break;
- case THRIFT:
+ case THRIFT:
oi = new ThriftStructObjectInspector();
break;
default:
- throw new RuntimeException(ObjectInspectorFactory.class.getName() + ": internal error.");
+ throw new RuntimeException(ObjectInspectorFactory.class.getName()
+ + ": internal error.");
}
- // put it into the cache BEFORE it is initialized to make sure we can catch recursive types.
+ // put it into the cache BEFORE it is initialized to make sure we can catch
+ // recursive types.
objectInspectorCache.put(t, oi);
Field[] fields = ObjectInspectorUtils.getDeclaredNonStaticFields(c);
- ArrayList<ObjectInspector> structFieldObjectInspectors = new ArrayList<ObjectInspector>(fields.length);
- for(int i=0; i<fields.length; i++) {
+ ArrayList<ObjectInspector> structFieldObjectInspectors = new ArrayList<ObjectInspector>(
+ fields.length);
+ for (int i = 0; i < fields.length; i++) {
if (!oi.shouldIgnoreField(fields[i].getName())) {
- structFieldObjectInspectors.add(getReflectionObjectInspector(fields[i].getGenericType(), options));
+ structFieldObjectInspectors.add(getReflectionObjectInspector(fields[i]
+ .getGenericType(), options));
}
}
oi.init(c, structFieldObjectInspectors);
return oi;
}
-
- static HashMap<ObjectInspector, StandardListObjectInspector> cachedStandardListObjectInspector =
- new HashMap<ObjectInspector, StandardListObjectInspector>();
- public static StandardListObjectInspector getStandardListObjectInspector(ObjectInspector listElementObjectInspector) {
- StandardListObjectInspector result = cachedStandardListObjectInspector.get(listElementObjectInspector);
+
+ static HashMap<ObjectInspector, StandardListObjectInspector> cachedStandardListObjectInspector = new HashMap<ObjectInspector, StandardListObjectInspector>();
+
+ public static StandardListObjectInspector getStandardListObjectInspector(
+ ObjectInspector listElementObjectInspector) {
+ StandardListObjectInspector result = cachedStandardListObjectInspector
+ .get(listElementObjectInspector);
if (result == null) {
result = new StandardListObjectInspector(listElementObjectInspector);
cachedStandardListObjectInspector.put(listElementObjectInspector, result);
@@ -166,46 +180,54 @@
return result;
}
- static HashMap<List<ObjectInspector>, StandardMapObjectInspector> cachedStandardMapObjectInspector =
- new HashMap<List<ObjectInspector>, StandardMapObjectInspector>();
- public static StandardMapObjectInspector getStandardMapObjectInspector(ObjectInspector mapKeyObjectInspector, ObjectInspector mapValueObjectInspector) {
+ static HashMap<List<ObjectInspector>, StandardMapObjectInspector> cachedStandardMapObjectInspector = new HashMap<List<ObjectInspector>, StandardMapObjectInspector>();
+
+ public static StandardMapObjectInspector getStandardMapObjectInspector(
+ ObjectInspector mapKeyObjectInspector,
+ ObjectInspector mapValueObjectInspector) {
ArrayList<ObjectInspector> signature = new ArrayList<ObjectInspector>(2);
signature.add(mapKeyObjectInspector);
signature.add(mapValueObjectInspector);
- StandardMapObjectInspector result = cachedStandardMapObjectInspector.get(signature);
+ StandardMapObjectInspector result = cachedStandardMapObjectInspector
+ .get(signature);
if (result == null) {
- result = new StandardMapObjectInspector(mapKeyObjectInspector, mapValueObjectInspector);
+ result = new StandardMapObjectInspector(mapKeyObjectInspector,
+ mapValueObjectInspector);
cachedStandardMapObjectInspector.put(signature, result);
}
return result;
}
-
- static HashMap<ArrayList<List<?>>, StandardStructObjectInspector> cachedStandardStructObjectInspector =
- new HashMap<ArrayList<List<?>>, StandardStructObjectInspector>();
- public static StandardStructObjectInspector getStandardStructObjectInspector(List<String> structFieldNames, List<ObjectInspector> structFieldObjectInspectors) {
+
+ static HashMap<ArrayList<List<?>>, StandardStructObjectInspector> cachedStandardStructObjectInspector = new HashMap<ArrayList<List<?>>, StandardStructObjectInspector>();
+
+ public static StandardStructObjectInspector getStandardStructObjectInspector(
+ List<String> structFieldNames,
+ List<ObjectInspector> structFieldObjectInspectors) {
ArrayList<List<?>> signature = new ArrayList<List<?>>();
signature.add(structFieldNames);
signature.add(structFieldObjectInspectors);
- StandardStructObjectInspector result = cachedStandardStructObjectInspector.get(signature);
+ StandardStructObjectInspector result = cachedStandardStructObjectInspector
+ .get(signature);
if (result == null) {
- result = new StandardStructObjectInspector(structFieldNames, structFieldObjectInspectors);
+ result = new StandardStructObjectInspector(structFieldNames,
+ structFieldObjectInspectors);
cachedStandardStructObjectInspector.put(signature, result);
}
return result;
}
-
- static HashMap<List<StructObjectInspector>, UnionStructObjectInspector> cachedUnionStructObjectInspector =
- new HashMap<List<StructObjectInspector>, UnionStructObjectInspector>();
- public static UnionStructObjectInspector getUnionStructObjectInspector(List<StructObjectInspector> structObjectInspectors) {
- UnionStructObjectInspector result = cachedUnionStructObjectInspector.get(structObjectInspectors);
+ static HashMap<List<StructObjectInspector>, UnionStructObjectInspector> cachedUnionStructObjectInspector = new HashMap<List<StructObjectInspector>, UnionStructObjectInspector>();
+
+ public static UnionStructObjectInspector getUnionStructObjectInspector(
+ List<StructObjectInspector> structObjectInspectors) {
+ UnionStructObjectInspector result = cachedUnionStructObjectInspector
+ .get(structObjectInspectors);
if (result == null) {
result = new UnionStructObjectInspector(structObjectInspectors);
cachedUnionStructObjectInspector.put(structObjectInspectors, result);
}
return result;
}
-
static HashMap<ArrayList<Object>, ColumnarStructObjectInspector> cachedColumnarStructObjectInspector = new HashMap<ArrayList<Object>, ColumnarStructObjectInspector>();
@@ -225,5 +247,5 @@
}
return result;
}
-
+
}
Modified: hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/ObjectInspectorUtils.java
URL: http://svn.apache.org/viewvc/hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/ObjectInspectorUtils.java?rev=901618&r1=901617&r2=901618&view=diff
==============================================================================
--- hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/ObjectInspectorUtils.java (original)
+++ hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/ObjectInspectorUtils.java Thu Jan 21 09:35:09 2010
@@ -27,7 +27,6 @@
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
-import org.apache.hadoop.hive.serde2.objectinspector.primitive.AbstractPrimitiveWritableObjectInspector;
import org.apache.hadoop.hive.serde2.objectinspector.primitive.BooleanObjectInspector;
import org.apache.hadoop.hive.serde2.objectinspector.primitive.ByteObjectInspector;
import org.apache.hadoop.hive.serde2.objectinspector.primitive.DoubleObjectInspector;
@@ -42,29 +41,29 @@
import org.apache.hadoop.io.Text;
/**
- * ObjectInspectorFactory is the primary way to create new ObjectInspector instances.
+ * ObjectInspectorFactory is the primary way to create new ObjectInspector
+ * instances.
*
- * SerDe classes should call the static functions in this library to create an ObjectInspector
- * to return to the caller of SerDe2.getObjectInspector().
+ * SerDe classes should call the static functions in this library to create an
+ * ObjectInspector to return to the caller of SerDe2.getObjectInspector().
*/
public class ObjectInspectorUtils {
- private static Log LOG = LogFactory.getLog(ObjectInspectorUtils.class.getName());
+ private static Log LOG = LogFactory.getLog(ObjectInspectorUtils.class
+ .getName());
/**
* This enum controls how we copy primitive objects.
*
- * DEFAULT means choosing the most efficient way between JAVA and WRITABLE.
+ * DEFAULT means choosing the most efficient way between JAVA and WRITABLE.
* JAVA means converting all primitive objects to java primitive objects.
- * WRITABLE means converting all primitive objects to writable objects.
- *
+ * WRITABLE means converting all primitive objects to writable objects.
+ *
*/
public enum ObjectInspectorCopyOption {
- DEFAULT,
- JAVA,
- WRITABLE
+ DEFAULT, JAVA, WRITABLE
}
-
+
/**
* Get the corresponding standard ObjectInspector for an ObjectInspector.
*
@@ -73,64 +72,74 @@
public static ObjectInspector getStandardObjectInspector(ObjectInspector oi) {
return getStandardObjectInspector(oi, ObjectInspectorCopyOption.DEFAULT);
}
-
- public static ObjectInspector getStandardObjectInspector(ObjectInspector oi, ObjectInspectorCopyOption objectInspectorOption) {
+
+ 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.getPrimitiveCategory());
- } else {
- result = PrimitiveObjectInspectorFactory.getPrimitiveJavaObjectInspector(poi.getPrimitiveCategory());
- }
- break;
- }
- case JAVA: {
- result = PrimitiveObjectInspectorFactory.getPrimitiveJavaObjectInspector(poi.getPrimitiveCategory());
- break;
- }
- case WRITABLE: {
- result = PrimitiveObjectInspectorFactory.getPrimitiveWritableObjectInspector(poi.getPrimitiveCategory());
- break;
- }
+ case PRIMITIVE: {
+ PrimitiveObjectInspector poi = (PrimitiveObjectInspector) oi;
+ switch (objectInspectorOption) {
+ case DEFAULT: {
+ if (poi.preferWritable()) {
+ result = PrimitiveObjectInspectorFactory
+ .getPrimitiveWritableObjectInspector(poi.getPrimitiveCategory());
+ } else {
+ result = PrimitiveObjectInspectorFactory
+ .getPrimitiveJavaObjectInspector(poi.getPrimitiveCategory());
}
break;
}
- case LIST: {
- ListObjectInspector loi = (ListObjectInspector)oi;
- result = ObjectInspectorFactory.getStandardListObjectInspector(
- getStandardObjectInspector(loi.getListElementObjectInspector(), objectInspectorOption));
+ case JAVA: {
+ result = PrimitiveObjectInspectorFactory
+ .getPrimitiveJavaObjectInspector(poi.getPrimitiveCategory());
break;
}
- case MAP: {
- MapObjectInspector moi = (MapObjectInspector)oi;
- result = ObjectInspectorFactory.getStandardMapObjectInspector(
- getStandardObjectInspector(moi.getMapKeyObjectInspector(), objectInspectorOption),
- getStandardObjectInspector(moi.getMapValueObjectInspector(), objectInspectorOption));
+ case WRITABLE: {
+ result = PrimitiveObjectInspectorFactory
+ .getPrimitiveWritableObjectInspector(poi.getPrimitiveCategory());
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;
- }
- default: {
- throw new RuntimeException("Unknown ObjectInspector category!");
}
+ 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;
+ }
+ default: {
+ throw new RuntimeException("Unknown ObjectInspector category!");
+ }
}
return result;
}
-
+
/**
* Returns a deep copy of the Object o that can be scanned by a
* StandardObjectInspector returned by getStandardObjectInspector(oi).
@@ -138,83 +147,88 @@
public static Object copyToStandardObject(Object o, ObjectInspector oi) {
return copyToStandardObject(o, oi, ObjectInspectorCopyOption.DEFAULT);
}
-
- public static Object copyToStandardObject(Object o, ObjectInspector oi, ObjectInspectorCopyOption objectInspectorOption) {
+
+ public static Object copyToStandardObject(Object o, ObjectInspector oi,
+ ObjectInspectorCopyOption objectInspectorOption) {
if (o == null) {
return null;
}
-
+
Object result = null;
switch (oi.getCategory()) {
- case PRIMITIVE: {
- PrimitiveObjectInspector loi = (PrimitiveObjectInspector)oi;
- switch (objectInspectorOption) {
- case DEFAULT: {
- if (loi.preferWritable()) {
- result = loi.getPrimitiveWritableObject(loi.copyObject(o));
- } else {
- result = loi.getPrimitiveJavaObject(o);
- }
- break;
- }
- case JAVA: {
- result = loi.getPrimitiveJavaObject(o);
- break;
- }
- case WRITABLE: {
- result = loi.getPrimitiveWritableObject(loi.copyObject(o));
- break;
- }
+ case PRIMITIVE: {
+ PrimitiveObjectInspector loi = (PrimitiveObjectInspector) oi;
+ switch (objectInspectorOption) {
+ case DEFAULT: {
+ if (loi.preferWritable()) {
+ result = loi.getPrimitiveWritableObject(loi.copyObject(o));
+ } else {
+ result = loi.getPrimitiveJavaObject(o);
}
break;
}
- case LIST: {
- ListObjectInspector loi = (ListObjectInspector)oi;
- 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));
- }
- result = list;
+ case JAVA: {
+ result = loi.getPrimitiveJavaObject(o);
break;
}
- case MAP: {
- MapObjectInspector moi = (MapObjectInspector)oi;
- HashMap<Object, Object> map = new HashMap<Object, Object>();
- Map<? extends Object, ? extends Object> omap = moi.getMap(o);
- for(Map.Entry<? extends Object, ? extends Object> entry: omap.entrySet()) {
- map.put(copyToStandardObject(entry.getKey(), moi.getMapKeyObjectInspector(), objectInspectorOption),
- copyToStandardObject(entry.getValue(), moi.getMapValueObjectInspector(), objectInspectorOption));
- }
- result = map;
+ case WRITABLE: {
+ result = loi.getPrimitiveWritableObject(loi.copyObject(o));
break;
}
- case STRUCT: {
- StructObjectInspector soi = (StructObjectInspector)oi;
- List<? extends StructField> fields = soi.getAllStructFieldRefs();
- ArrayList<Object> struct = new ArrayList<Object>(fields.size());
- for(StructField f : fields) {
- struct.add(copyToStandardObject(soi.getStructFieldData(o, f), f.getFieldObjectInspector(), objectInspectorOption));
- }
- result = struct;
- break;
}
- default: {
- throw new RuntimeException("Unknown ObjectInspector category!");
+ break;
+ }
+ case LIST: {
+ ListObjectInspector loi = (ListObjectInspector) oi;
+ 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));
+ }
+ result = list;
+ break;
+ }
+ case MAP: {
+ MapObjectInspector moi = (MapObjectInspector) oi;
+ HashMap<Object, Object> map = new HashMap<Object, Object>();
+ Map<? extends Object, ? extends Object> omap = moi.getMap(o);
+ for (Map.Entry<? extends Object, ? extends Object> entry : omap
+ .entrySet()) {
+ map.put(copyToStandardObject(entry.getKey(), moi
+ .getMapKeyObjectInspector(), objectInspectorOption),
+ copyToStandardObject(entry.getValue(), moi
+ .getMapValueObjectInspector(), objectInspectorOption));
+ }
+ result = map;
+ break;
+ }
+ case STRUCT: {
+ StructObjectInspector soi = (StructObjectInspector) oi;
+ List<? extends StructField> fields = soi.getAllStructFieldRefs();
+ ArrayList<Object> struct = new ArrayList<Object>(fields.size());
+ for (StructField f : fields) {
+ struct.add(copyToStandardObject(soi.getStructFieldData(o, f), f
+ .getFieldObjectInspector(), objectInspectorOption));
}
+ result = struct;
+ break;
+ }
+ default: {
+ throw new RuntimeException("Unknown ObjectInspector category!");
+ }
}
return result;
- }
-
+ }
+
public static String getStandardStructTypeName(StructObjectInspector soi) {
StringBuilder sb = new StringBuilder();
sb.append("struct<");
- List<? extends StructField> fields = soi.getAllStructFieldRefs();
- for(int i=0; i<fields.size(); i++) {
- if (i>0) sb.append(",");
+ List<? extends StructField> fields = soi.getAllStructFieldRefs();
+ for (int i = 0; i < fields.size(); i++) {
+ if (i > 0) {
+ sb.append(",");
+ }
sb.append(fields.get(i).getFieldName());
sb.append(":");
sb.append(fields.get(i).getFieldObjectInspector().getTypeName());
@@ -222,10 +236,11 @@
sb.append(">");
return sb.toString();
}
-
- public static StructField getStandardStructFieldRef(String fieldName, List<? extends StructField> fields) {
+
+ public static StructField getStandardStructFieldRef(String fieldName,
+ List<? extends StructField> fields) {
fieldName = fieldName.toLowerCase();
- for(int i=0; i<fields.size(); i++) {
+ for (int i = 0; i < fields.size(); i++) {
if (fields.get(i).getFieldName().equals(fieldName)) {
return fields.get(i);
}
@@ -233,13 +248,14 @@
// For backward compatibility: fieldNames can also be integer Strings.
try {
int i = Integer.parseInt(fieldName);
- if (i>=0 && i<fields.size()) {
+ if (i >= 0 && i < fields.size()) {
return fields.get(i);
}
} catch (NumberFormatException e) {
// ignore
}
- throw new RuntimeException("cannot find field " + fieldName + " from " + fields);
+ throw new RuntimeException("cannot find field " + fieldName + " from "
+ + fields);
// return null;
}
@@ -260,44 +276,48 @@
}
return r;
}
-
+
/**
- * Get the class names of the ObjectInspector hierarchy. Mainly used for debugging.
+ * Get the class names of the ObjectInspector hierarchy. Mainly used for
+ * debugging.
*/
public static String getObjectInspectorName(ObjectInspector oi) {
switch (oi.getCategory()) {
- case PRIMITIVE: {
- return oi.getClass().getSimpleName();
- }
- case LIST: {
- ListObjectInspector loi = (ListObjectInspector)oi;
- return oi.getClass().getSimpleName() + "<" + getObjectInspectorName(loi.getListElementObjectInspector()) + ">";
- }
- case MAP: {
- MapObjectInspector moi = (MapObjectInspector)oi;
- return oi.getClass().getSimpleName() + "<" + getObjectInspectorName(moi.getMapKeyObjectInspector())
- + "," + getObjectInspectorName(moi.getMapValueObjectInspector()) + ">";
- }
- case STRUCT: {
- StringBuffer result = new StringBuffer();
- result.append(oi.getClass().getSimpleName() + "<");
- StructObjectInspector soi = (StructObjectInspector)oi;
- List<? extends StructField> fields = soi.getAllStructFieldRefs();
- for(int i = 0; i<fields.size(); i++) {
- result.append(fields.get(i).getFieldName());
- result.append(":");
- result.append(getObjectInspectorName(fields.get(i).getFieldObjectInspector()));
- if (i == fields.size() - 1) {
- result.append(">");
- } else {
- result.append(",");
- }
+ case PRIMITIVE: {
+ return oi.getClass().getSimpleName();
+ }
+ case LIST: {
+ ListObjectInspector loi = (ListObjectInspector) oi;
+ return oi.getClass().getSimpleName() + "<"
+ + getObjectInspectorName(loi.getListElementObjectInspector()) + ">";
+ }
+ case MAP: {
+ MapObjectInspector moi = (MapObjectInspector) oi;
+ return oi.getClass().getSimpleName() + "<"
+ + getObjectInspectorName(moi.getMapKeyObjectInspector()) + ","
+ + getObjectInspectorName(moi.getMapValueObjectInspector()) + ">";
+ }
+ case STRUCT: {
+ StringBuffer result = new StringBuffer();
+ result.append(oi.getClass().getSimpleName() + "<");
+ StructObjectInspector soi = (StructObjectInspector) oi;
+ List<? extends StructField> fields = soi.getAllStructFieldRefs();
+ for (int i = 0; i < fields.size(); i++) {
+ result.append(fields.get(i).getFieldName());
+ result.append(":");
+ result.append(getObjectInspectorName(fields.get(i)
+ .getFieldObjectInspector()));
+ if (i == fields.size() - 1) {
+ result.append(">");
+ } else {
+ result.append(",");
}
- return result.toString();
- }
- default: {
- throw new RuntimeException("Unknown ObjectInspector category!");
}
+ return result.toString();
+ }
+ default: {
+ throw new RuntimeException("Unknown ObjectInspector category!");
+ }
}
}
@@ -306,58 +326,68 @@
return 0;
}
switch (objIns.getCategory()) {
- case PRIMITIVE: {
- PrimitiveObjectInspector poi = ((PrimitiveObjectInspector)objIns);
- switch (poi.getPrimitiveCategory()) {
- case VOID: return 0;
- case BOOLEAN: return ((BooleanObjectInspector)poi).get(o) ? 1 : 0;
- case BYTE: return ((ByteObjectInspector)poi).get(o);
- case SHORT: return ((ShortObjectInspector)poi).get(o);
- case INT: return ((IntObjectInspector)poi).get(o);
- case LONG: {
- long a = ((LongObjectInspector)poi).get(o);
- return (int)((a >>> 32) ^ a);
- }
- case FLOAT: return Float.floatToIntBits(((FloatObjectInspector)poi).get(o));
- case DOUBLE: {
- // This hash function returns the same result as Double.hashCode()
- // while DoubleWritable.hashCode returns a different result.
- long a = Double.doubleToLongBits(((DoubleObjectInspector)poi).get(o));
- return (int)((a >>> 32) ^ a);
- }
- case STRING: {
- // This hash function returns the same result as String.hashCode() when
- // all characters are ASCII, while Text.hashCode() always returns a
- // different result.
- Text t = ((StringObjectInspector)poi).getPrimitiveWritableObject(o);
- int r = 0;
- for (int i=0; i<t.getLength(); i++) {
- r = r * 31 + (int)t.getBytes()[i];
- }
- return r;
- }
- default: {
- throw new RuntimeException("Unknown type: " + poi.getPrimitiveCategory());
- }
+ case PRIMITIVE: {
+ PrimitiveObjectInspector poi = ((PrimitiveObjectInspector) objIns);
+ switch (poi.getPrimitiveCategory()) {
+ case VOID:
+ return 0;
+ case BOOLEAN:
+ return ((BooleanObjectInspector) poi).get(o) ? 1 : 0;
+ case BYTE:
+ return ((ByteObjectInspector) poi).get(o);
+ case SHORT:
+ return ((ShortObjectInspector) poi).get(o);
+ case INT:
+ return ((IntObjectInspector) poi).get(o);
+ case LONG: {
+ long a = ((LongObjectInspector) poi).get(o);
+ return (int) ((a >>> 32) ^ a);
+ }
+ case FLOAT:
+ return Float.floatToIntBits(((FloatObjectInspector) poi).get(o));
+ case DOUBLE: {
+ // This hash function returns the same result as Double.hashCode()
+ // while DoubleWritable.hashCode returns a different result.
+ long a = Double.doubleToLongBits(((DoubleObjectInspector) poi).get(o));
+ return (int) ((a >>> 32) ^ a);
+ }
+ case STRING: {
+ // This hash function returns the same result as String.hashCode() when
+ // all characters are ASCII, while Text.hashCode() always returns a
+ // different result.
+ Text t = ((StringObjectInspector) poi).getPrimitiveWritableObject(o);
+ int r = 0;
+ for (int i = 0; i < t.getLength(); i++) {
+ r = r * 31 + t.getBytes()[i];
}
+ return r;
+ }
+ default: {
+ throw new RuntimeException("Unknown type: "
+ + poi.getPrimitiveCategory());
+ }
}
- case STRUCT:
- case LIST:
- case MAP:
- default:
- throw new RuntimeException("Hash code on complex types not supported yet.");
+ }
+ case STRUCT:
+ case LIST:
+ case MAP:
+ default:
+ throw new RuntimeException(
+ "Hash code on complex types not supported yet.");
}
}
/**
- * Compare two arrays of objects with their respective arrays of ObjectInspectors.
+ * Compare two arrays of objects with their respective arrays of
+ * ObjectInspectors.
*/
- public static int compare(Object[] o1, ObjectInspector[] oi1, Object[] o2, ObjectInspector[] oi2) {
- assert(o1.length == oi1.length);
- assert(o2.length == oi2.length);
- assert(o1.length == o2.length);
-
- for (int i=0; i<o1.length; i++) {
+ public static int compare(Object[] o1, ObjectInspector[] oi1, Object[] o2,
+ ObjectInspector[] oi2) {
+ assert (o1.length == oi1.length);
+ assert (o2.length == oi2.length);
+ assert (o1.length == o2.length);
+
+ for (int i = 0; i < o1.length; i++) {
int r = compare(o1[i], oi1[i], o2[i], oi2[i]);
if (r != 0) {
return r;
@@ -369,7 +399,8 @@
/**
* Compare two objects with their respective ObjectInspectors.
*/
- public static int compare(Object o1, ObjectInspector oi1, Object o2, ObjectInspector oi2) {
+ public static int compare(Object o1, ObjectInspector oi1, Object o2,
+ ObjectInspector oi2) {
if (oi1.getCategory() != oi2.getCategory()) {
return oi1.getCategory().compareTo(oi2.getCategory());
}
@@ -379,107 +410,108 @@
} else if (o2 == null) {
return 1;
}
-
+
switch (oi1.getCategory()) {
- case PRIMITIVE: {
- PrimitiveObjectInspector poi1 = ((PrimitiveObjectInspector)oi1);
- PrimitiveObjectInspector poi2 = ((PrimitiveObjectInspector)oi2);
- if (poi1.getPrimitiveCategory() != poi2.getPrimitiveCategory()) {
- return poi1.getPrimitiveCategory().compareTo(poi2.getPrimitiveCategory());
- }
- switch (poi1.getPrimitiveCategory()) {
- case VOID: return 0;
- case BOOLEAN: {
- int v1 = ((BooleanObjectInspector)poi1).get(o1) ? 1 : 0;
- int v2 = ((BooleanObjectInspector)poi2).get(o2) ? 1 : 0;
- return v1 - v2;
- }
- case BYTE: {
- int v1 = ((ByteObjectInspector)poi1).get(o1);
- int v2 = ((ByteObjectInspector)poi2).get(o2);
- return v1 - v2;
- }
- case SHORT: {
- int v1 = ((ShortObjectInspector)poi1).get(o1);
- int v2 = ((ShortObjectInspector)poi2).get(o2);
- return v1 - v2;
- }
- case INT: {
- int v1 = ((IntObjectInspector)poi1).get(o1);
- int v2 = ((IntObjectInspector)poi2).get(o2);
- return v1 > v2 ? 1 : (v1 < v2 ? -1 : 0);
- }
- case LONG: {
- long v1 = ((LongObjectInspector)poi1).get(o1);
- long v2 = ((LongObjectInspector)poi2).get(o2);
- return v1 > v2 ? 1 : (v1 < v2 ? -1 : 0);
- }
- case FLOAT: {
- float v1 = ((FloatObjectInspector)poi1).get(o1);
- float v2 = ((FloatObjectInspector)poi2).get(o2);
- return v1 > v2 ? 1 : (v1 < v2 ? -1 : 0);
- }
- case DOUBLE: {
- double v1 = ((DoubleObjectInspector)poi1).get(o1);
- double v2 = ((DoubleObjectInspector)poi2).get(o2);
- return v1 > v2 ? 1 : (v1 < v2 ? -1 : 0);
- }
- case STRING: {
- if (poi1.preferWritable() || poi2.preferWritable()) {
- Text t1 = (Text)poi1.getPrimitiveWritableObject(o1);
- Text t2 = (Text)poi2.getPrimitiveWritableObject(o2);
- return t1 == null
- ? (t2 == null ? 0 : -1)
- : (t2 == null ? 1 :
- ShimLoader.getHadoopShims().compareText(t1, t2));
- } else {
- String s1 = (String)poi1.getPrimitiveJavaObject(o1);
- String s2 = (String)poi2.getPrimitiveJavaObject(o2);
- return s1 == null
- ? (s2 == null ? 0 : -1)
- : (s2 == null ? 1 : s1.compareTo(s2));
- }
- }
- default: {
- throw new RuntimeException("Unknown type: " + poi1.getPrimitiveCategory());
- }
+ case PRIMITIVE: {
+ PrimitiveObjectInspector poi1 = ((PrimitiveObjectInspector) oi1);
+ PrimitiveObjectInspector poi2 = ((PrimitiveObjectInspector) oi2);
+ if (poi1.getPrimitiveCategory() != poi2.getPrimitiveCategory()) {
+ return poi1.getPrimitiveCategory().compareTo(
+ poi2.getPrimitiveCategory());
+ }
+ switch (poi1.getPrimitiveCategory()) {
+ case VOID:
+ return 0;
+ case BOOLEAN: {
+ int v1 = ((BooleanObjectInspector) poi1).get(o1) ? 1 : 0;
+ int v2 = ((BooleanObjectInspector) poi2).get(o2) ? 1 : 0;
+ return v1 - v2;
+ }
+ case BYTE: {
+ int v1 = ((ByteObjectInspector) poi1).get(o1);
+ int v2 = ((ByteObjectInspector) poi2).get(o2);
+ return v1 - v2;
+ }
+ case SHORT: {
+ int v1 = ((ShortObjectInspector) poi1).get(o1);
+ int v2 = ((ShortObjectInspector) poi2).get(o2);
+ return v1 - v2;
+ }
+ case INT: {
+ int v1 = ((IntObjectInspector) poi1).get(o1);
+ int v2 = ((IntObjectInspector) poi2).get(o2);
+ return v1 > v2 ? 1 : (v1 < v2 ? -1 : 0);
+ }
+ case LONG: {
+ long v1 = ((LongObjectInspector) poi1).get(o1);
+ long v2 = ((LongObjectInspector) poi2).get(o2);
+ return v1 > v2 ? 1 : (v1 < v2 ? -1 : 0);
+ }
+ case FLOAT: {
+ float v1 = ((FloatObjectInspector) poi1).get(o1);
+ float v2 = ((FloatObjectInspector) poi2).get(o2);
+ return v1 > v2 ? 1 : (v1 < v2 ? -1 : 0);
+ }
+ case DOUBLE: {
+ double v1 = ((DoubleObjectInspector) poi1).get(o1);
+ double v2 = ((DoubleObjectInspector) poi2).get(o2);
+ return v1 > v2 ? 1 : (v1 < v2 ? -1 : 0);
+ }
+ case STRING: {
+ if (poi1.preferWritable() || poi2.preferWritable()) {
+ Text t1 = (Text) poi1.getPrimitiveWritableObject(o1);
+ Text t2 = (Text) poi2.getPrimitiveWritableObject(o2);
+ return t1 == null ? (t2 == null ? 0 : -1) : (t2 == null ? 1
+ : ShimLoader.getHadoopShims().compareText(t1, t2));
+ } else {
+ String s1 = (String) poi1.getPrimitiveJavaObject(o1);
+ String s2 = (String) poi2.getPrimitiveJavaObject(o2);
+ return s1 == null ? (s2 == null ? 0 : -1) : (s2 == null ? 1 : s1
+ .compareTo(s2));
}
}
- case STRUCT: {
- StructObjectInspector soi1 = (StructObjectInspector)oi1;
- StructObjectInspector soi2 = (StructObjectInspector)oi2;
- List<? extends StructField> fields1 = soi1.getAllStructFieldRefs();
- List<? extends StructField> fields2 = soi2.getAllStructFieldRefs();
- int minimum = Math.min(fields1.size(), fields2.size());
- for (int i=0; i<minimum; i++) {
- int r = compare(
- soi1.getStructFieldData(o1, fields1.get(i)),
- fields1.get(i).getFieldObjectInspector(),
- soi2.getStructFieldData(o2, fields2.get(i)),
- fields2.get(i).getFieldObjectInspector());
- if (r != 0) return r;
- }
- return fields1.size() - fields2.size();
- }
- case LIST: {
- ListObjectInspector loi1 = (ListObjectInspector)oi1;
- ListObjectInspector loi2 = (ListObjectInspector)oi2;
- int minimum = Math.min(loi1.getListLength(o1), loi2.getListLength(o2));
- for (int i=0; i<minimum; i++) {
- int r = compare(
- loi1.getListElement(o1, i),
- loi1.getListElementObjectInspector(),
- loi2.getListElement(o2, i),
- loi2.getListElementObjectInspector());
- if (r != 0) return r;
- }
- return loi1.getListLength(o1) - loi2.getListLength(o2);
+ default: {
+ throw new RuntimeException("Unknown type: "
+ + poi1.getPrimitiveCategory());
}
- case MAP: {
- throw new RuntimeException("Compare on map type not supported!");
}
- default:
- throw new RuntimeException("Compare on unknown type: " + oi1.getCategory());
+ }
+ case STRUCT: {
+ StructObjectInspector soi1 = (StructObjectInspector) oi1;
+ StructObjectInspector soi2 = (StructObjectInspector) oi2;
+ List<? extends StructField> fields1 = soi1.getAllStructFieldRefs();
+ List<? extends StructField> fields2 = soi2.getAllStructFieldRefs();
+ int minimum = Math.min(fields1.size(), fields2.size());
+ for (int i = 0; i < minimum; i++) {
+ int r = compare(soi1.getStructFieldData(o1, fields1.get(i)), fields1
+ .get(i).getFieldObjectInspector(), soi2.getStructFieldData(o2,
+ fields2.get(i)), fields2.get(i).getFieldObjectInspector());
+ if (r != 0) {
+ return r;
+ }
+ }
+ return fields1.size() - fields2.size();
+ }
+ case LIST: {
+ ListObjectInspector loi1 = (ListObjectInspector) oi1;
+ ListObjectInspector loi2 = (ListObjectInspector) oi2;
+ int minimum = Math.min(loi1.getListLength(o1), loi2.getListLength(o2));
+ for (int i = 0; i < minimum; i++) {
+ int r = compare(loi1.getListElement(o1, i), loi1
+ .getListElementObjectInspector(), loi2.getListElement(o2, i), loi2
+ .getListElementObjectInspector());
+ if (r != 0) {
+ return r;
+ }
+ }
+ return loi1.getListLength(o1) - loi2.getListLength(o2);
+ }
+ case MAP: {
+ throw new RuntimeException("Compare on map type not supported!");
+ }
+ default:
+ throw new RuntimeException("Compare on unknown type: "
+ + oi1.getCategory());
}
}
@@ -489,7 +521,7 @@
public static String getFieldNames(StructObjectInspector soi) {
List<? extends StructField> fields = soi.getAllStructFieldRefs();
StringBuilder sb = new StringBuilder();
- for (int i=0; i<fields.size(); i++) {
+ for (int i = 0; i < fields.size(); i++) {
if (i > 0) {
sb.append(",");
}
@@ -504,16 +536,14 @@
public static String getFieldTypes(StructObjectInspector soi) {
List<? extends StructField> fields = soi.getAllStructFieldRefs();
StringBuilder sb = new StringBuilder();
- for (int i=0; i<fields.size(); i++) {
+ for (int i = 0; i < fields.size(); i++) {
if (i > 0) {
sb.append(":");
}
- sb.append(
- TypeInfoUtils.getTypeInfoFromObjectInspector(
- fields.get(i).getFieldObjectInspector()).getTypeName());
+ sb.append(TypeInfoUtils.getTypeInfoFromObjectInspector(
+ fields.get(i).getFieldObjectInspector()).getTypeName());
}
return sb.toString();
}
-
}
Modified: hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/PrimitiveObjectInspector.java
URL: http://svn.apache.org/viewvc/hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/PrimitiveObjectInspector.java?rev=901618&r1=901617&r2=901618&view=diff
==============================================================================
--- hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/PrimitiveObjectInspector.java (original)
+++ hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/PrimitiveObjectInspector.java Thu Jan 21 09:35:09 2010
@@ -20,31 +20,31 @@
public interface PrimitiveObjectInspector extends ObjectInspector {
/**
- * The primitive types supported by Hive.
+ * The primitive types supported by Hive.
*/
public static enum PrimitiveCategory {
VOID, BOOLEAN, BYTE, SHORT, INT, LONG, FLOAT, DOUBLE, STRING, UNKNOWN
};
-
+
/**
* Get the primitive category of the PrimitiveObjectInspector.
*/
public PrimitiveCategory getPrimitiveCategory();
-
+
/**
- * Get the Primitive Writable class which is the return type of
+ * Get the Primitive Writable class which is the return type of
* getPrimitiveWritableObject() and copyToPrimitiveWritableObject()
*/
public Class<?> getPrimitiveWritableClass();
/**
- * Return the data in an instance of primitive writable Object. If the
- * Object is already a primitive writable Object, just return o.
+ * Return the data in an instance of primitive writable Object. If the Object
+ * is already a primitive writable Object, just return o.
*/
public Object getPrimitiveWritableObject(Object o);
-
+
/**
- * Get the Java Primitive class which is the return type of
+ * Get the Java Primitive class which is the return type of
* getJavaPrimitiveObject().
*/
public Class<?> getJavaPrimitiveClass();
@@ -53,21 +53,20 @@
* Get the Java Primitive object.
*/
public Object getPrimitiveJavaObject(Object o);
-
+
/**
- * Get a copy of the Object in the same class, so the return value can be
+ * Get a copy of the Object in the same class, so the return value can be
* stored independently of the parameter.
*
* If the Object is a Primitive Java Object, we just return the parameter
* since Primitive Java Object is immutable.
*/
public Object copyObject(Object o);
-
+
/**
* Whether the ObjectInspector prefers to return a Primitive Writable Object
- * instead of a Primitive Java Object.
- * This can be useful for determining the most efficient way to getting
- * data out of the Object.
+ * instead of a Primitive Java Object. This can be useful for determining the
+ * most efficient way to getting data out of the Object.
*/
public boolean preferWritable();
}