You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hive.apache.org by br...@apache.org on 2013/10/22 19:59:08 UTC
svn commit: r1534711 [13/15] - in /hive/branches/maven: ./
ant/src/org/apache/hadoop/hive/ant/
beeline/src/java/org/apache/hive/beeline/ bin/ bin/ext/
cli/src/java/org/apache/hadoop/hive/cli/ common/
common/src/java/org/apache/hadoop/hive/common/type/ ...
Modified: hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/JavaStringObjectInspector.java
URL: http://svn.apache.org/viewvc/hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/JavaStringObjectInspector.java?rev=1534711&r1=1534710&r2=1534711&view=diff
==============================================================================
--- hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/JavaStringObjectInspector.java (original)
+++ hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/JavaStringObjectInspector.java Tue Oct 22 17:58:59 2013
@@ -17,6 +17,7 @@
*/
package org.apache.hadoop.hive.serde2.objectinspector.primitive;
+import org.apache.hadoop.hive.serde2.typeinfo.TypeInfoFactory;
import org.apache.hadoop.io.Text;
/**
@@ -27,7 +28,7 @@ public class JavaStringObjectInspector e
SettableStringObjectInspector {
JavaStringObjectInspector() {
- super(PrimitiveObjectInspectorUtils.stringTypeEntry);
+ super(TypeInfoFactory.stringTypeInfo);
}
@Override
Modified: hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/JavaTimestampObjectInspector.java
URL: http://svn.apache.org/viewvc/hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/JavaTimestampObjectInspector.java?rev=1534711&r1=1534710&r2=1534711&view=diff
==============================================================================
--- hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/JavaTimestampObjectInspector.java (original)
+++ hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/JavaTimestampObjectInspector.java Tue Oct 22 17:58:59 2013
@@ -20,13 +20,14 @@ package org.apache.hadoop.hive.serde2.ob
import java.sql.Timestamp;
import org.apache.hadoop.hive.serde2.io.TimestampWritable;
+import org.apache.hadoop.hive.serde2.typeinfo.TypeInfoFactory;
public class JavaTimestampObjectInspector
extends AbstractPrimitiveJavaObjectInspector
implements SettableTimestampObjectInspector {
protected JavaTimestampObjectInspector() {
- super(PrimitiveObjectInspectorUtils.timestampTypeEntry);
+ super(TypeInfoFactory.timestampTypeInfo);
}
public TimestampWritable getPrimitiveWritableObject(Object o) {
Modified: hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/JavaVoidObjectInspector.java
URL: http://svn.apache.org/viewvc/hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/JavaVoidObjectInspector.java?rev=1534711&r1=1534710&r2=1534711&view=diff
==============================================================================
--- hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/JavaVoidObjectInspector.java (original)
+++ hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/JavaVoidObjectInspector.java Tue Oct 22 17:58:59 2013
@@ -17,6 +17,7 @@
*/
package org.apache.hadoop.hive.serde2.objectinspector.primitive;
+import org.apache.hadoop.hive.serde2.typeinfo.TypeInfoFactory;
import org.apache.hadoop.io.NullWritable;
/**
@@ -26,7 +27,7 @@ public class JavaVoidObjectInspector ext
AbstractPrimitiveJavaObjectInspector implements VoidObjectInspector {
JavaVoidObjectInspector() {
- super(PrimitiveObjectInspectorUtils.voidTypeEntry);
+ super(TypeInfoFactory.voidTypeInfo);
}
@Override
Modified: hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/PrimitiveObjectInspectorConverter.java
URL: http://svn.apache.org/viewvc/hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/PrimitiveObjectInspectorConverter.java?rev=1534711&r1=1534710&r2=1534711&view=diff
==============================================================================
--- hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/PrimitiveObjectInspectorConverter.java (original)
+++ hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/PrimitiveObjectInspectorConverter.java Tue Oct 22 17:58:59 2013
@@ -29,7 +29,6 @@ import org.apache.hadoop.hive.serde2.laz
import org.apache.hadoop.hive.serde2.lazy.LazyLong;
import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspectorConverters.Converter;
import org.apache.hadoop.hive.serde2.objectinspector.PrimitiveObjectInspector;
-import org.apache.hadoop.hive.serde2.typeinfo.VarcharTypeParams;
import org.apache.hadoop.io.Text;
/**
@@ -302,12 +301,7 @@ public class PrimitiveObjectInspectorCon
return null;
}
- try {
- return outputOI.set(r, PrimitiveObjectInspectorUtils.getHiveDecimal(input,
- inputOI));
- } catch (NumberFormatException e) {
- return null;
- }
+ return outputOI.set(r, PrimitiveObjectInspectorUtils.getHiveDecimal(input, inputOI));
}
}
@@ -452,7 +446,6 @@ public class PrimitiveObjectInspectorCon
SettableHiveVarcharObjectInspector outputOI) {
this.inputOI = inputOI;
this.outputOI = outputOI;
- VarcharTypeParams typeParams = (VarcharTypeParams) outputOI.getTypeParams();
// unfortunately we seem to get instances of varchar object inspectors without params
// when an old-style UDF has an evaluate() method with varchar arguments.
Modified: hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/PrimitiveObjectInspectorFactory.java
URL: http://svn.apache.org/viewvc/hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/PrimitiveObjectInspectorFactory.java?rev=1534711&r1=1534710&r2=1534711&view=diff
==============================================================================
--- hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/PrimitiveObjectInspectorFactory.java (original)
+++ hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/PrimitiveObjectInspectorFactory.java Tue Oct 22 17:58:59 2013
@@ -18,8 +18,12 @@
package org.apache.hadoop.hive.serde2.objectinspector.primitive;
+import java.util.EnumMap;
import java.util.HashMap;
+import java.util.Map;
+import org.apache.hadoop.hive.common.type.HiveVarchar;
+import org.apache.hadoop.hive.serde.serdeConstants;
import org.apache.hadoop.hive.serde2.io.ByteWritable;
import org.apache.hadoop.hive.serde2.io.DateWritable;
import org.apache.hadoop.hive.serde2.io.DoubleWritable;
@@ -30,11 +34,10 @@ import org.apache.hadoop.hive.serde2.io.
import org.apache.hadoop.hive.serde2.objectinspector.ConstantObjectInspector;
import org.apache.hadoop.hive.serde2.objectinspector.PrimitiveObjectInspector;
import org.apache.hadoop.hive.serde2.objectinspector.PrimitiveObjectInspector.PrimitiveCategory;
-import org.apache.hadoop.hive.serde2.objectinspector.primitive.PrimitiveObjectInspectorUtils.ParameterizedObjectInspectorMap;
import org.apache.hadoop.hive.serde2.objectinspector.primitive.PrimitiveObjectInspectorUtils.PrimitiveTypeEntry;
-import org.apache.hadoop.hive.serde2.typeinfo.BaseTypeParams;
-import org.apache.hadoop.hive.serde2.typeinfo.PrimitiveTypeSpec;
-import org.apache.hadoop.hive.serde2.typeinfo.VarcharTypeParams;
+import org.apache.hadoop.hive.serde2.typeinfo.PrimitiveTypeInfo;
+import org.apache.hadoop.hive.serde2.typeinfo.TypeInfoFactory;
+import org.apache.hadoop.hive.serde2.typeinfo.VarcharTypeInfo;
import org.apache.hadoop.io.BooleanWritable;
import org.apache.hadoop.io.BytesWritable;
import org.apache.hadoop.io.FloatWritable;
@@ -54,35 +57,6 @@ import org.apache.hadoop.io.Writable;
*/
public final class PrimitiveObjectInspectorFactory {
- public static final JavaBooleanObjectInspector javaBooleanObjectInspector =
- new JavaBooleanObjectInspector();
- public static final JavaByteObjectInspector javaByteObjectInspector =
- new JavaByteObjectInspector();
- public static final JavaShortObjectInspector javaShortObjectInspector =
- new JavaShortObjectInspector();
- public static final JavaIntObjectInspector javaIntObjectInspector =
- new JavaIntObjectInspector();
- public static final JavaLongObjectInspector javaLongObjectInspector =
- new JavaLongObjectInspector();
- public static final JavaFloatObjectInspector javaFloatObjectInspector =
- new JavaFloatObjectInspector();
- public static final JavaDoubleObjectInspector javaDoubleObjectInspector =
- new JavaDoubleObjectInspector();
- public static final JavaStringObjectInspector javaStringObjectInspector =
- new JavaStringObjectInspector();
- public static final JavaHiveVarcharObjectInspector javaHiveVarcharObjectInspector =
- new JavaHiveVarcharObjectInspector(PrimitiveObjectInspectorUtils.varcharTypeEntry);
- public static final JavaVoidObjectInspector javaVoidObjectInspector =
- new JavaVoidObjectInspector();
- public static final JavaDateObjectInspector javaDateObjectInspector =
- new JavaDateObjectInspector();
- public static final JavaTimestampObjectInspector javaTimestampObjectInspector =
- new JavaTimestampObjectInspector();
- public static final JavaBinaryObjectInspector javaByteArrayObjectInspector =
- new JavaBinaryObjectInspector();
- public static final JavaHiveDecimalObjectInspector javaHiveDecimalObjectInspector =
- new JavaHiveDecimalObjectInspector();
-
public static final WritableBooleanObjectInspector writableBooleanObjectInspector =
new WritableBooleanObjectInspector();
public static final WritableByteObjectInspector writableByteObjectInspector =
@@ -99,8 +73,6 @@ public final class PrimitiveObjectInspec
new WritableDoubleObjectInspector();
public static final WritableStringObjectInspector writableStringObjectInspector =
new WritableStringObjectInspector();
- public static final WritableHiveVarcharObjectInspector writableHiveVarcharObjectInspector =
- new WritableHiveVarcharObjectInspector(PrimitiveObjectInspectorUtils.varcharTypeEntry);
public static final WritableVoidObjectInspector writableVoidObjectInspector =
new WritableVoidObjectInspector();
public static final WritableDateObjectInspector writableDateObjectInspector =
@@ -112,85 +84,132 @@ public final class PrimitiveObjectInspec
public static final WritableHiveDecimalObjectInspector writableHiveDecimalObjectInspector =
new WritableHiveDecimalObjectInspector();
- private static HashMap<PrimitiveCategory, AbstractPrimitiveWritableObjectInspector> cachedPrimitiveWritableInspectorCache =
- new HashMap<PrimitiveCategory, AbstractPrimitiveWritableObjectInspector>();
+ // Map from PrimitiveTypeInfo to AbstractPrimitiveWritableObjectInspector.
+ private static HashMap<PrimitiveTypeInfo, AbstractPrimitiveWritableObjectInspector> cachedPrimitiveWritableInspectorCache =
+ new HashMap<PrimitiveTypeInfo, AbstractPrimitiveWritableObjectInspector>();
static {
- cachedPrimitiveWritableInspectorCache.put(PrimitiveCategory.BOOLEAN,
+ cachedPrimitiveWritableInspectorCache.put(TypeInfoFactory.getPrimitiveTypeInfo(serdeConstants.BOOLEAN_TYPE_NAME),
writableBooleanObjectInspector);
- cachedPrimitiveWritableInspectorCache.put(PrimitiveCategory.BYTE,
+ cachedPrimitiveWritableInspectorCache.put(TypeInfoFactory.getPrimitiveTypeInfo(serdeConstants.TINYINT_TYPE_NAME),
writableByteObjectInspector);
- cachedPrimitiveWritableInspectorCache.put(PrimitiveCategory.SHORT,
+ cachedPrimitiveWritableInspectorCache.put(TypeInfoFactory.getPrimitiveTypeInfo(serdeConstants.SMALLINT_TYPE_NAME),
writableShortObjectInspector);
- cachedPrimitiveWritableInspectorCache.put(PrimitiveCategory.INT,
+ cachedPrimitiveWritableInspectorCache.put(TypeInfoFactory.getPrimitiveTypeInfo(serdeConstants.INT_TYPE_NAME),
writableIntObjectInspector);
- cachedPrimitiveWritableInspectorCache.put(PrimitiveCategory.LONG,
+ cachedPrimitiveWritableInspectorCache.put(TypeInfoFactory.getPrimitiveTypeInfo(serdeConstants.BIGINT_TYPE_NAME),
writableLongObjectInspector);
- cachedPrimitiveWritableInspectorCache.put(PrimitiveCategory.FLOAT,
+ cachedPrimitiveWritableInspectorCache.put(TypeInfoFactory.getPrimitiveTypeInfo(serdeConstants.FLOAT_TYPE_NAME),
writableFloatObjectInspector);
- cachedPrimitiveWritableInspectorCache.put(PrimitiveCategory.DOUBLE,
+ cachedPrimitiveWritableInspectorCache.put(TypeInfoFactory.getPrimitiveTypeInfo(serdeConstants.DOUBLE_TYPE_NAME),
writableDoubleObjectInspector);
- cachedPrimitiveWritableInspectorCache.put(PrimitiveCategory.STRING,
+ cachedPrimitiveWritableInspectorCache.put(TypeInfoFactory.getPrimitiveTypeInfo(serdeConstants.STRING_TYPE_NAME),
writableStringObjectInspector);
- cachedPrimitiveWritableInspectorCache.put(PrimitiveCategory.VARCHAR,
- writableHiveVarcharObjectInspector);
- cachedPrimitiveWritableInspectorCache.put(PrimitiveCategory.VOID,
+ cachedPrimitiveWritableInspectorCache.put(TypeInfoFactory.getPrimitiveTypeInfo(serdeConstants.VOID_TYPE_NAME),
writableVoidObjectInspector);
- cachedPrimitiveWritableInspectorCache.put(PrimitiveCategory.DATE,
+ cachedPrimitiveWritableInspectorCache.put(TypeInfoFactory.getPrimitiveTypeInfo(serdeConstants.DATE_TYPE_NAME),
writableDateObjectInspector);
- cachedPrimitiveWritableInspectorCache.put(PrimitiveCategory.TIMESTAMP,
+ cachedPrimitiveWritableInspectorCache.put(TypeInfoFactory.getPrimitiveTypeInfo(serdeConstants.TIMESTAMP_TYPE_NAME),
writableTimestampObjectInspector);
- cachedPrimitiveWritableInspectorCache.put(PrimitiveCategory.BINARY,
+ cachedPrimitiveWritableInspectorCache.put(TypeInfoFactory.getPrimitiveTypeInfo(serdeConstants.BINARY_TYPE_NAME),
writableBinaryObjectInspector);
- cachedPrimitiveWritableInspectorCache.put(PrimitiveCategory.DECIMAL,
+ cachedPrimitiveWritableInspectorCache.put(TypeInfoFactory.getPrimitiveTypeInfo(serdeConstants.DECIMAL_TYPE_NAME),
writableHiveDecimalObjectInspector);
}
- private static HashMap<PrimitiveCategory, AbstractPrimitiveJavaObjectInspector> cachedPrimitiveJavaInspectorCache =
- new HashMap<PrimitiveCategory, AbstractPrimitiveJavaObjectInspector>();
+ private static Map<PrimitiveCategory, AbstractPrimitiveWritableObjectInspector> primitiveCategoryToWritableOI =
+ new EnumMap<PrimitiveCategory, AbstractPrimitiveWritableObjectInspector>(PrimitiveCategory.class);
+ static {
+ primitiveCategoryToWritableOI.put(PrimitiveCategory.BOOLEAN, writableBooleanObjectInspector);
+ primitiveCategoryToWritableOI.put(PrimitiveCategory.BYTE, writableByteObjectInspector);
+ primitiveCategoryToWritableOI.put(PrimitiveCategory.SHORT, writableShortObjectInspector);
+ primitiveCategoryToWritableOI.put(PrimitiveCategory.INT, writableIntObjectInspector);
+ primitiveCategoryToWritableOI.put(PrimitiveCategory.LONG, writableLongObjectInspector);
+ primitiveCategoryToWritableOI.put(PrimitiveCategory.FLOAT, writableFloatObjectInspector);
+ primitiveCategoryToWritableOI.put(PrimitiveCategory.DOUBLE, writableDoubleObjectInspector);
+ primitiveCategoryToWritableOI.put(PrimitiveCategory.STRING, writableStringObjectInspector);
+ primitiveCategoryToWritableOI.put(PrimitiveCategory.VOID, writableVoidObjectInspector);
+ primitiveCategoryToWritableOI.put(PrimitiveCategory.DATE, writableDateObjectInspector);
+ primitiveCategoryToWritableOI.put(PrimitiveCategory.TIMESTAMP, writableTimestampObjectInspector);
+ primitiveCategoryToWritableOI.put(PrimitiveCategory.BINARY, writableBinaryObjectInspector);
+ primitiveCategoryToWritableOI.put(PrimitiveCategory.DECIMAL, writableHiveDecimalObjectInspector);
+ }
+
+ public static final JavaBooleanObjectInspector javaBooleanObjectInspector =
+ new JavaBooleanObjectInspector();
+ public static final JavaByteObjectInspector javaByteObjectInspector =
+ new JavaByteObjectInspector();
+ public static final JavaShortObjectInspector javaShortObjectInspector =
+ new JavaShortObjectInspector();
+ public static final JavaIntObjectInspector javaIntObjectInspector =
+ new JavaIntObjectInspector();
+ public static final JavaLongObjectInspector javaLongObjectInspector =
+ new JavaLongObjectInspector();
+ public static final JavaFloatObjectInspector javaFloatObjectInspector =
+ new JavaFloatObjectInspector();
+ public static final JavaDoubleObjectInspector javaDoubleObjectInspector =
+ new JavaDoubleObjectInspector();
+ public static final JavaStringObjectInspector javaStringObjectInspector =
+ new JavaStringObjectInspector();
+ public static final JavaVoidObjectInspector javaVoidObjectInspector =
+ new JavaVoidObjectInspector();
+ public static final JavaDateObjectInspector javaDateObjectInspector =
+ new JavaDateObjectInspector();
+ public static final JavaTimestampObjectInspector javaTimestampObjectInspector =
+ new JavaTimestampObjectInspector();
+ public static final JavaBinaryObjectInspector javaByteArrayObjectInspector =
+ new JavaBinaryObjectInspector();
+ public static final JavaHiveDecimalObjectInspector javaHiveDecimalObjectInspector =
+ new JavaHiveDecimalObjectInspector();
+
+ // Map from PrimitiveTypeInfo to AbstractPrimitiveJavaObjectInspector.
+ private static HashMap<PrimitiveTypeInfo, AbstractPrimitiveJavaObjectInspector> cachedPrimitiveJavaInspectorCache =
+ new HashMap<PrimitiveTypeInfo, AbstractPrimitiveJavaObjectInspector>();
static {
- cachedPrimitiveJavaInspectorCache.put(PrimitiveCategory.BOOLEAN,
+ cachedPrimitiveJavaInspectorCache.put(TypeInfoFactory.getPrimitiveTypeInfo(serdeConstants.BOOLEAN_TYPE_NAME),
javaBooleanObjectInspector);
- cachedPrimitiveJavaInspectorCache.put(PrimitiveCategory.BYTE,
+ cachedPrimitiveJavaInspectorCache.put(TypeInfoFactory.getPrimitiveTypeInfo(serdeConstants.TINYINT_TYPE_NAME),
javaByteObjectInspector);
- cachedPrimitiveJavaInspectorCache.put(PrimitiveCategory.SHORT,
+ cachedPrimitiveJavaInspectorCache.put(TypeInfoFactory.getPrimitiveTypeInfo(serdeConstants.SMALLINT_TYPE_NAME),
javaShortObjectInspector);
- cachedPrimitiveJavaInspectorCache.put(PrimitiveCategory.INT,
+ cachedPrimitiveJavaInspectorCache.put(TypeInfoFactory.getPrimitiveTypeInfo(serdeConstants.INT_TYPE_NAME),
javaIntObjectInspector);
- cachedPrimitiveJavaInspectorCache.put(PrimitiveCategory.LONG,
+ cachedPrimitiveJavaInspectorCache.put(TypeInfoFactory.getPrimitiveTypeInfo(serdeConstants.BIGINT_TYPE_NAME),
javaLongObjectInspector);
- cachedPrimitiveJavaInspectorCache.put(PrimitiveCategory.FLOAT,
+ cachedPrimitiveJavaInspectorCache.put(TypeInfoFactory.getPrimitiveTypeInfo(serdeConstants.FLOAT_TYPE_NAME),
javaFloatObjectInspector);
- cachedPrimitiveJavaInspectorCache.put(PrimitiveCategory.DOUBLE,
+ cachedPrimitiveJavaInspectorCache.put(TypeInfoFactory.getPrimitiveTypeInfo(serdeConstants.DOUBLE_TYPE_NAME),
javaDoubleObjectInspector);
- cachedPrimitiveJavaInspectorCache.put(PrimitiveCategory.STRING,
+ cachedPrimitiveJavaInspectorCache.put(TypeInfoFactory.getPrimitiveTypeInfo(serdeConstants.STRING_TYPE_NAME),
javaStringObjectInspector);
- cachedPrimitiveJavaInspectorCache.put(PrimitiveCategory.VARCHAR,
- javaHiveVarcharObjectInspector);
- cachedPrimitiveJavaInspectorCache.put(PrimitiveCategory.VOID,
+ cachedPrimitiveJavaInspectorCache.put(TypeInfoFactory.getPrimitiveTypeInfo(serdeConstants.VOID_TYPE_NAME),
javaVoidObjectInspector);
- cachedPrimitiveJavaInspectorCache.put(PrimitiveCategory.DATE,
+ cachedPrimitiveJavaInspectorCache.put(TypeInfoFactory.getPrimitiveTypeInfo(serdeConstants.DATE_TYPE_NAME),
javaDateObjectInspector);
- cachedPrimitiveJavaInspectorCache.put(PrimitiveCategory.TIMESTAMP,
+ cachedPrimitiveJavaInspectorCache.put(TypeInfoFactory.getPrimitiveTypeInfo(serdeConstants.TIMESTAMP_TYPE_NAME),
javaTimestampObjectInspector);
- cachedPrimitiveJavaInspectorCache.put(PrimitiveCategory.BINARY,
+ cachedPrimitiveJavaInspectorCache.put(TypeInfoFactory.getPrimitiveTypeInfo(serdeConstants.BINARY_TYPE_NAME),
javaByteArrayObjectInspector);
- cachedPrimitiveJavaInspectorCache.put(PrimitiveCategory.DECIMAL,
+ cachedPrimitiveJavaInspectorCache.put(TypeInfoFactory.getPrimitiveTypeInfo(serdeConstants.DECIMAL_TYPE_NAME),
javaHiveDecimalObjectInspector);
}
- /**
- * Cached Writable object inspectors for parameterized primitive types.
- */
- private static ParameterizedObjectInspectorMap
- cachedParameterizedPrimitiveWritableObjectInspectorCache =
- new ParameterizedObjectInspectorMap();
-
- /**
- * Cached Java object inspectors for parameterized primitive types.
- */
- private static ParameterizedObjectInspectorMap
- cachedParameterizedPrimitiveJavaObjectInspectorCache =
- new ParameterizedObjectInspectorMap();
+ private static Map<PrimitiveCategory, AbstractPrimitiveJavaObjectInspector> primitiveCategoryToJavaOI =
+ new EnumMap<PrimitiveCategory, AbstractPrimitiveJavaObjectInspector>(PrimitiveCategory.class);
+ static {
+ primitiveCategoryToJavaOI.put(PrimitiveCategory.BOOLEAN, javaBooleanObjectInspector);
+ primitiveCategoryToJavaOI.put(PrimitiveCategory.BYTE, javaByteObjectInspector);
+ primitiveCategoryToJavaOI.put(PrimitiveCategory.SHORT, javaShortObjectInspector);
+ primitiveCategoryToJavaOI.put(PrimitiveCategory.INT, javaIntObjectInspector);
+ primitiveCategoryToJavaOI.put(PrimitiveCategory.LONG, javaLongObjectInspector);
+ primitiveCategoryToJavaOI.put(PrimitiveCategory.FLOAT, javaFloatObjectInspector);
+ primitiveCategoryToJavaOI.put(PrimitiveCategory.DOUBLE, javaDoubleObjectInspector);
+ primitiveCategoryToJavaOI.put(PrimitiveCategory.STRING, javaStringObjectInspector);
+ primitiveCategoryToJavaOI.put(PrimitiveCategory.VOID, javaVoidObjectInspector);
+ primitiveCategoryToJavaOI.put(PrimitiveCategory.DATE, javaDateObjectInspector);
+ primitiveCategoryToJavaOI.put(PrimitiveCategory.TIMESTAMP, javaTimestampObjectInspector);
+ primitiveCategoryToJavaOI.put(PrimitiveCategory.BINARY, javaByteArrayObjectInspector);
+ primitiveCategoryToJavaOI.put(PrimitiveCategory.DECIMAL, javaHiveDecimalObjectInspector);
+ }
/**
* Returns the PrimitiveWritableObjectInspector for the PrimitiveCategory.
@@ -199,75 +218,38 @@ public final class PrimitiveObjectInspec
*/
public static AbstractPrimitiveWritableObjectInspector getPrimitiveWritableObjectInspector(
PrimitiveCategory primitiveCategory) {
- AbstractPrimitiveWritableObjectInspector result =
- cachedPrimitiveWritableInspectorCache.get(primitiveCategory);
+ AbstractPrimitiveWritableObjectInspector result = primitiveCategoryToWritableOI.get(primitiveCategory);
+
if (result == null) {
throw new RuntimeException("Internal error: Cannot find ObjectInspector "
+ " for " + primitiveCategory);
}
+
return result;
}
/**
- * Returns the PrimitiveWritableObjectInspector for the PrimitiveCategory, with option to
- * pass in parameters for the primitive type (such as char(10)).
- * Ideally this method should be used over the method without type parameters,
- * and the type parameters (or lack of parameters) can be determined from
- * the input ObjectInspector, TypeInfo, or TypeEntry.
- * However there are situations where it is not possible to get any information about
- * type parameters, such as when getting an object inspector based on reflection from
- * the java or primitive class.
- * @param primitiveCategory Primitve type category
- * @param primitiveTypeParams Type parameters for the primitve type.
- * Set to null if there are no type parameters
- * @return
+ * Returns the PrimitiveWritableObjectInspector for the given type info
+ * @param PrimitiveTypeInfo PrimitiveTypeInfo instance
+ * @return AbstractPrimitiveWritableObjectInspector instance
*/
public static AbstractPrimitiveWritableObjectInspector getPrimitiveWritableObjectInspector(
- PrimitiveTypeSpec typeSpec) {
- PrimitiveCategory primitiveCategory = typeSpec.getPrimitiveCategory();
- BaseTypeParams primitiveTypeParams = typeSpec.getTypeParams();
-
- if (primitiveTypeParams == null) {
- // No type params, just search the unparameterized types
- return getPrimitiveWritableObjectInspector(primitiveCategory);
- } else {
- // Check our cached set of parameterized object inspectors for the primitive category,
- // or create a new object inspector if one doesn't exist yet.
- PrimitiveObjectInspector oi =
- cachedParameterizedPrimitiveWritableObjectInspectorCache.getObjectInspector(
- typeSpec);
- if (oi == null) {
- // Do a bit of validation - not all primitive types use parameters.
- switch (primitiveCategory) {
- case VARCHAR:
- PrimitiveTypeEntry typeEntry = PrimitiveObjectInspectorUtils.getTypeEntryFromTypeSpecs(
- primitiveCategory,
- primitiveTypeParams);
- oi = new WritableHiveVarcharObjectInspector(typeEntry);
- oi.setTypeParams(primitiveTypeParams);
- cachedParameterizedPrimitiveWritableObjectInspectorCache.setObjectInspector(oi);
- break;
- default:
- throw new RuntimeException(
- "Primitve type " + primitiveCategory + " should not take parameters");
- }
- }
- return (AbstractPrimitiveWritableObjectInspector)oi;
+ PrimitiveTypeInfo typeInfo) {
+ AbstractPrimitiveWritableObjectInspector result = cachedPrimitiveWritableInspectorCache.get(typeInfo);
+ if (result != null) {
+ return result;
}
- }
- /**
- * Returns a PrimitiveWritableObjectInspector which implements ConstantObjectInspector
- * for the PrimitiveCategory.
- *
- * @param primitiveCategory
- * @param value
- */
- public static ConstantObjectInspector getPrimitiveWritableConstantObjectInspector(
- PrimitiveCategory primitiveCategory, Object value) {
- return getPrimitiveWritableConstantObjectInspector(
- PrimitiveObjectInspectorUtils.getTypeEntryFromTypeSpecs(primitiveCategory, null),
- value);
+ switch (typeInfo.getPrimitiveCategory()) {
+ case VARCHAR:
+ result = new WritableHiveVarcharObjectInspector((VarcharTypeInfo)typeInfo);
+ break;
+ default:
+ throw new RuntimeException("Failed to create WritableHiveVarcharObjectInspector for " + typeInfo );
+ }
+
+ cachedPrimitiveWritableInspectorCache.put(typeInfo, result);
+ return result;
}
/**
@@ -275,15 +257,11 @@ public final class PrimitiveObjectInspec
* for the PrimitiveCategory.
*
* @param primitiveCategory
- * @param typeParams Type qualifiers for the type (if applicable)
* @param value
*/
public static ConstantObjectInspector getPrimitiveWritableConstantObjectInspector(
- PrimitiveTypeSpec typeSpecs, Object value) {
- PrimitiveCategory primitiveCategory = typeSpecs.getPrimitiveCategory();
- BaseTypeParams typeParams = typeSpecs.getTypeParams();
-
- switch (primitiveCategory) {
+ PrimitiveTypeInfo typeInfo, Object value) {
+ switch (typeInfo.getPrimitiveCategory()) {
case BOOLEAN:
return new WritableConstantBooleanObjectInspector((BooleanWritable)value);
case BYTE:
@@ -301,8 +279,8 @@ public final class PrimitiveObjectInspec
case STRING:
return new WritableConstantStringObjectInspector((Text)value);
case VARCHAR:
- return new WritableConstantHiveVarcharObjectInspector((HiveVarcharWritable)value,
- (VarcharTypeParams) typeParams);
+ return new WritableConstantHiveVarcharObjectInspector((VarcharTypeInfo)typeInfo,
+ (HiveVarcharWritable)value);
case DATE:
return new WritableConstantDateObjectInspector((DateWritable)value);
case TIMESTAMP:
@@ -315,7 +293,7 @@ public final class PrimitiveObjectInspec
return new WritableVoidObjectInspector();
default:
throw new RuntimeException("Internal error: Cannot find "
- + "ConstantObjectInspector for " + primitiveCategory);
+ + "ConstantObjectInspector for " + typeInfo);
}
}
@@ -326,62 +304,40 @@ public final class PrimitiveObjectInspec
*/
public static AbstractPrimitiveJavaObjectInspector getPrimitiveJavaObjectInspector(
PrimitiveCategory primitiveCategory) {
- AbstractPrimitiveJavaObjectInspector result =
- cachedPrimitiveJavaInspectorCache.get(primitiveCategory);
+ AbstractPrimitiveJavaObjectInspector result = primitiveCategoryToJavaOI.get(primitiveCategory);
+
if (result == null) {
throw new RuntimeException("Internal error: Cannot find ObjectInspector "
+ " for " + primitiveCategory);
}
+
return result;
}
/**
- * Returns the PrimitiveJavaObjectInspector for the PrimitiveCategory, with option to
- * pass in parameters for the primitive type (such as char(10)).
- * Ideally this method should be used over the method without type parameters,
- * and the type parameters (or lack of parameters) can be determined from
- * the input ObjectInspector, TypeInfo, or TypeEntry.
- * However there are situations where it is not possible to get any information about
- * type parameters, such as when getting an object inspector based on reflection from
- * the java or primitive class.
- * @param primitiveCategory Primitve type category
- * @param primitiveTypeParams Type parameters for the primitve type.
- * Set to null if there are no type parameters
- * @return
+ * Returns the PrimitiveJavaObjectInspector for the given PrimitiveTypeInfo instance,
+ * @param PrimitiveTypeInfo PrimitiveTypeInfo instance
+ * @return AbstractPrimitiveJavaObjectInspector instance
*/
public static AbstractPrimitiveJavaObjectInspector getPrimitiveJavaObjectInspector(
- PrimitiveTypeSpec typeSpec) {
- PrimitiveCategory primitiveCategory = typeSpec.getPrimitiveCategory();
- BaseTypeParams primitiveTypeParams = typeSpec.getTypeParams();
-
- if (primitiveTypeParams == null) {
- // No type params, just search the unparameterized types
- return getPrimitiveJavaObjectInspector(primitiveCategory);
- } else {
- // Check our cached set of parameterized object inspectors for the primitive category,
- // or create a new object inspector if one doesn't exist yet.
- PrimitiveObjectInspector oi =
- cachedParameterizedPrimitiveJavaObjectInspectorCache.getObjectInspector(
- typeSpec);
- if (oi == null) {
- // Do a bit of validation - not all primitive types use parameters.
- switch (primitiveCategory) {
- case VARCHAR:
- PrimitiveTypeEntry typeEntry = PrimitiveObjectInspectorUtils.getTypeEntryFromTypeSpecs(
- primitiveCategory,
- primitiveTypeParams);
- oi = new JavaHiveVarcharObjectInspector(typeEntry);
- oi.setTypeParams(primitiveTypeParams);
- cachedParameterizedPrimitiveJavaObjectInspectorCache.setObjectInspector(oi);
- break;
- default:
- throw new RuntimeException(
- "Primitve type " + primitiveCategory + " should not take parameters");
- }
- }
- return (AbstractPrimitiveJavaObjectInspector)oi;
+ PrimitiveTypeInfo typeInfo) {
+ AbstractPrimitiveJavaObjectInspector result = cachedPrimitiveJavaInspectorCache.get(typeInfo);
+ if (result != null) {
+ return result;
}
+
+ switch (typeInfo.getPrimitiveCategory()) {
+ case VARCHAR:
+ result = new JavaHiveVarcharObjectInspector((VarcharTypeInfo)typeInfo);
+ break;
+ default:
+ throw new RuntimeException("Failed to create JavaHiveVarcharObjectInspector for " + typeInfo );
+ }
+
+ cachedPrimitiveJavaInspectorCache.put(typeInfo, result);
+ return result;
}
+
/**
* Returns an ObjectInspector for a primitive Class. The Class can be a Hive
* Writable class, or a Java Primitive Class.
Modified: hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/PrimitiveObjectInspectorUtils.java
URL: http://svn.apache.org/viewvc/hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/PrimitiveObjectInspectorUtils.java?rev=1534711&r1=1534710&r2=1534711&view=diff
==============================================================================
--- hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/PrimitiveObjectInspectorUtils.java (original)
+++ hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/PrimitiveObjectInspectorUtils.java Tue Oct 22 17:58:59 2013
@@ -31,7 +31,6 @@ import org.apache.commons.logging.LogFac
import org.apache.hadoop.hive.common.type.HiveDecimal;
import org.apache.hadoop.hive.common.type.HiveVarchar;
import org.apache.hadoop.hive.serde.serdeConstants;
-import org.apache.hadoop.hive.serde2.SerDeException;
import org.apache.hadoop.hive.serde2.io.ByteWritable;
import org.apache.hadoop.hive.serde2.io.DateWritable;
import org.apache.hadoop.hive.serde2.io.DoubleWritable;
@@ -45,9 +44,6 @@ import org.apache.hadoop.hive.serde2.obj
import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector.Category;
import org.apache.hadoop.hive.serde2.objectinspector.PrimitiveObjectInspector;
import org.apache.hadoop.hive.serde2.objectinspector.PrimitiveObjectInspector.PrimitiveCategory;
-import org.apache.hadoop.hive.serde2.typeinfo.BaseTypeParams;
-import org.apache.hadoop.hive.serde2.typeinfo.PrimitiveTypeSpec;
-import org.apache.hadoop.hive.serde2.typeinfo.VarcharTypeParams;
import org.apache.hadoop.io.BooleanWritable;
import org.apache.hadoop.io.BytesWritable;
import org.apache.hadoop.io.FloatWritable;
@@ -71,7 +67,7 @@ public final class PrimitiveObjectInspec
/**
* TypeEntry stores information about a Hive Primitive TypeInfo.
*/
- public static class PrimitiveTypeEntry implements Writable, Cloneable, PrimitiveTypeSpec {
+ public static class PrimitiveTypeEntry implements Writable, Cloneable {
/**
* The category of the PrimitiveType.
@@ -96,22 +92,19 @@ public final class PrimitiveObjectInspec
* typeName is the name of the type as in DDL.
*/
public String typeName;
- public Class<?> typeParamsClass;
- public BaseTypeParams typeParams;
protected PrimitiveTypeEntry() {
super();
}
-
+
PrimitiveTypeEntry(
PrimitiveObjectInspector.PrimitiveCategory primitiveCategory,
String typeName, Class<?> primitiveType, Class<?> javaClass,
- Class<?> hiveClass, Class<?>paramsClass) {
+ Class<?> hiveClass) {
this.primitiveCategory = primitiveCategory;
primitiveJavaType = primitiveType;
primitiveJavaClass = javaClass;
primitiveWritableClass = hiveClass;
- typeParamsClass = paramsClass;
this.typeName = typeName;
}
@@ -120,71 +113,23 @@ public final class PrimitiveObjectInspec
primitiveCategory = WritableUtils.readEnum(in,
PrimitiveObjectInspector.PrimitiveCategory.class);
typeName = WritableUtils.readString(in);
- int typeParamsIndicator = WritableUtils.readVInt(in);
try {
primitiveJavaType = Class.forName(WritableUtils.readString(in));
primitiveJavaClass = Class.forName(WritableUtils.readString(in));
primitiveWritableClass = Class.forName(WritableUtils.readString(in));
- if (typeParamsIndicator == 1) {
- typeParamsClass = Class.forName(WritableUtils.readString(in));
- typeParams = (BaseTypeParams)typeParamsClass.newInstance();
- typeParams.readFields(in);
- } else {
- typeParamsClass = null;
- typeParams = null;
- }
} catch (ClassNotFoundException e) {
throw new IOException(e);
- } catch (IllegalAccessException e) {
- throw new IOException(e);
- } catch (InstantiationException e) {
- throw new IOException(e);
}
}
@Override
public void write(DataOutput out) throws IOException {
- int typeParamsIndicator = (isParameterized() && typeParams != null) ? 1 : 0;
WritableUtils.writeEnum(out, primitiveCategory);
WritableUtils.writeString(out, typeName);
- WritableUtils.writeVInt(out, typeParamsIndicator);
WritableUtils.writeString(out, primitiveJavaType.getName());
WritableUtils.writeString(out, primitiveJavaClass.getName());
WritableUtils.writeString(out, primitiveWritableClass.getName());
- if (typeParamsIndicator == 1) {
- WritableUtils.writeString(out, typeParamsClass.getName());
- typeParams.write(out);
- }
- }
-
- public PrimitiveTypeEntry addParameters(String[] parameters) {
- if (parameters == null || parameters.length == 0) {
- return this;
- }
-
- PrimitiveTypeEntry result;
- try {
- BaseTypeParams newTypeParams = (BaseTypeParams)typeParamsClass.newInstance();
- newTypeParams.set(parameters);
- String typeNameWithParams = this.typeName + newTypeParams.toString();
- if (typeNameToTypeEntry.containsKey(typeNameWithParams)) {
- return typeNameToTypeEntry.get(typeNameWithParams);
- }
- result = (PrimitiveTypeEntry)this.clone();
- result.typeParams = newTypeParams;
-
- PrimitiveObjectInspectorUtils.addParameterizedType(result);
-
- return result;
- } catch (Exception err) {
- LOG.error("Error while setting type parameters: " + err);
- throw new RuntimeException(err);
- }
- }
-
- public boolean isParameterized() {
- return (null != typeParamsClass);
}
@Override
@@ -194,52 +139,24 @@ public final class PrimitiveObjectInspec
this.typeName,
this.primitiveJavaType,
this.primitiveJavaClass,
- this.primitiveWritableClass,
- this.typeParamsClass);
+ this.primitiveWritableClass);
return result;
}
@Override
public String toString() {
- if (typeParams != null) {
- return typeName + typeParams.toString();
- }
return typeName;
}
- public static BaseTypeParams createTypeParams(String typeName, String[] parameters)
- throws SerDeException {
- try {
- PrimitiveTypeEntry typeEntry = getTypeEntryFromTypeName(typeName);
- if (typeEntry != null && typeEntry.typeParamsClass != null) {
- BaseTypeParams newTypeParams = (BaseTypeParams)typeEntry.typeParamsClass.newInstance();
- newTypeParams.set(parameters);
- return newTypeParams;
- } else {
- return null;
- }
- } catch (Exception err) {
- throw new SerDeException("Error creating type params for " + typeName
- + ": " + err, err);
- }
- }
-
- @Override
- public PrimitiveCategory getPrimitiveCategory() {
- return primitiveCategory;
- }
-
- @Override
- public BaseTypeParams getTypeParams() {
- return typeParams;
- }
}
static final Map<PrimitiveCategory, PrimitiveTypeEntry> primitiveCategoryToTypeEntry = new HashMap<PrimitiveCategory, PrimitiveTypeEntry>();
static final Map<Class<?>, PrimitiveTypeEntry> primitiveJavaTypeToTypeEntry = new HashMap<Class<?>, PrimitiveTypeEntry>();
static final Map<Class<?>, PrimitiveTypeEntry> primitiveJavaClassToTypeEntry = new HashMap<Class<?>, PrimitiveTypeEntry>();
static final Map<Class<?>, PrimitiveTypeEntry> primitiveWritableClassToTypeEntry = new HashMap<Class<?>, PrimitiveTypeEntry>();
- static final Map<String, PrimitiveTypeEntry> typeNameToTypeEntry = new HashMap<String, PrimitiveTypeEntry>();
+
+ // Base type name to PrimitiveTypeEntry map.
+ private static final Map<String, PrimitiveTypeEntry> typeNameToTypeEntry = new HashMap<String, PrimitiveTypeEntry>();
static void addParameterizedType(PrimitiveTypeEntry t) {
typeNameToTypeEntry.put(t.toString(), t);
@@ -265,52 +182,52 @@ public final class PrimitiveObjectInspec
public static final PrimitiveTypeEntry binaryTypeEntry = new PrimitiveTypeEntry(
PrimitiveCategory.BINARY, serdeConstants.BINARY_TYPE_NAME, byte[].class,
- byte[].class, BytesWritable.class, null);
+ byte[].class, BytesWritable.class);
public static final PrimitiveTypeEntry stringTypeEntry = new PrimitiveTypeEntry(
PrimitiveCategory.STRING, serdeConstants.STRING_TYPE_NAME, null, String.class,
- Text.class, null);
+ Text.class);
public static final PrimitiveTypeEntry booleanTypeEntry = new PrimitiveTypeEntry(
PrimitiveCategory.BOOLEAN, serdeConstants.BOOLEAN_TYPE_NAME, Boolean.TYPE,
- Boolean.class, BooleanWritable.class, null);
+ Boolean.class, BooleanWritable.class);
public static final PrimitiveTypeEntry intTypeEntry = new PrimitiveTypeEntry(
PrimitiveCategory.INT, serdeConstants.INT_TYPE_NAME, Integer.TYPE,
- Integer.class, IntWritable.class, null);
+ Integer.class, IntWritable.class);
public static final PrimitiveTypeEntry longTypeEntry = new PrimitiveTypeEntry(
PrimitiveCategory.LONG, serdeConstants.BIGINT_TYPE_NAME, Long.TYPE,
- Long.class, LongWritable.class, null);
+ Long.class, LongWritable.class);
public static final PrimitiveTypeEntry floatTypeEntry = new PrimitiveTypeEntry(
PrimitiveCategory.FLOAT, serdeConstants.FLOAT_TYPE_NAME, Float.TYPE,
- Float.class, FloatWritable.class, null);
+ Float.class, FloatWritable.class);
public static final PrimitiveTypeEntry voidTypeEntry = new PrimitiveTypeEntry(
PrimitiveCategory.VOID, serdeConstants.VOID_TYPE_NAME, Void.TYPE, Void.class,
- NullWritable.class, null);
+ NullWritable.class);
// No corresponding Writable classes for the following 3 in hadoop 0.17.0
public static final PrimitiveTypeEntry doubleTypeEntry = new PrimitiveTypeEntry(
PrimitiveCategory.DOUBLE, serdeConstants.DOUBLE_TYPE_NAME, Double.TYPE,
- Double.class, DoubleWritable.class, null);
+ Double.class, DoubleWritable.class);
public static final PrimitiveTypeEntry byteTypeEntry = new PrimitiveTypeEntry(
PrimitiveCategory.BYTE, serdeConstants.TINYINT_TYPE_NAME, Byte.TYPE,
- Byte.class, ByteWritable.class, null);
+ Byte.class, ByteWritable.class);
public static final PrimitiveTypeEntry shortTypeEntry = new PrimitiveTypeEntry(
PrimitiveCategory.SHORT, serdeConstants.SMALLINT_TYPE_NAME, Short.TYPE,
- Short.class, ShortWritable.class, null);
+ Short.class, ShortWritable.class);
public static final PrimitiveTypeEntry dateTypeEntry = new PrimitiveTypeEntry(
PrimitiveCategory.DATE, serdeConstants.DATE_TYPE_NAME, null,
- Date.class, DateWritable.class, null);
+ Date.class, DateWritable.class);
public static final PrimitiveTypeEntry timestampTypeEntry = new PrimitiveTypeEntry(
PrimitiveCategory.TIMESTAMP, serdeConstants.TIMESTAMP_TYPE_NAME, null,
- Timestamp.class, TimestampWritable.class, null);
+ Timestamp.class, TimestampWritable.class);
public static final PrimitiveTypeEntry decimalTypeEntry = new PrimitiveTypeEntry(
PrimitiveCategory.DECIMAL, serdeConstants.DECIMAL_TYPE_NAME, null,
- HiveDecimal.class, HiveDecimalWritable.class, null);
+ HiveDecimal.class, HiveDecimalWritable.class);
public static final PrimitiveTypeEntry varcharTypeEntry = new PrimitiveTypeEntry(
PrimitiveCategory.VARCHAR, serdeConstants.VARCHAR_TYPE_NAME, null, HiveVarchar.class,
- HiveVarcharWritable.class, VarcharTypeParams.class);
+ HiveVarcharWritable.class);
// The following is a complex type for special handling
public static final PrimitiveTypeEntry unknownTypeEntry = new PrimitiveTypeEntry(
- PrimitiveCategory.UNKNOWN, "unknown", null, Object.class, null, null);
+ PrimitiveCategory.UNKNOWN, "unknown", null, Object.class, null);
static {
registerType(binaryTypeEntry);
@@ -431,39 +348,12 @@ public final class PrimitiveObjectInspec
}
/**
- * Get the TypeEntry for a Primitive Writable Class.
+ * Get the TypeEntry for the given base type name (int, varchar, etc).
*/
public static PrimitiveTypeEntry getTypeEntryFromTypeName(String typeName) {
return typeNameToTypeEntry.get(typeName);
}
- public static PrimitiveTypeEntry getTypeEntryFromTypeSpecs(
- PrimitiveCategory primitiveCategory,
- BaseTypeParams typeParams) {
- if (typeParams == null) {
- // No type params, can just use the primitive category
- return getTypeEntryFromPrimitiveCategory(primitiveCategory);
- }
-
- // Type params were passed in. First check for cached version
- String typeString = primitiveCategory.toString().toLowerCase();
- typeString += typeParams.toString();
- PrimitiveTypeEntry typeEntry = getTypeEntryFromTypeName(typeString);
- if (typeEntry == null) {
- // Parameterized type doesn't exist yet, create now.
- typeEntry =
- (PrimitiveTypeEntry) getTypeEntryFromPrimitiveCategory(primitiveCategory).clone();
- if (!typeEntry.isParameterized()) {
- throw new IllegalArgumentException(
- primitiveCategory + " type was being used with type parameters "
- + typeParams + ", which should not be allowed");
- }
- typeEntry.typeParams = typeParams;
- addParameterizedType(typeEntry);
- }
- return typeEntry;
- }
-
/**
* Compare 2 primitive objects. Conversion not allowed. Note that NULL does
* not equal to NULL according to SQL standard.
@@ -992,35 +882,35 @@ public final class PrimitiveObjectInspec
HiveDecimal.ONE : HiveDecimal.ZERO;
break;
case BYTE:
- result = new HiveDecimal(((ByteObjectInspector) oi).get(o));
+ result = HiveDecimal.create(((ByteObjectInspector) oi).get(o));
break;
case SHORT:
- result = new HiveDecimal(((ShortObjectInspector) oi).get(o));
+ result = HiveDecimal.create(((ShortObjectInspector) oi).get(o));
break;
case INT:
- result = new HiveDecimal(((IntObjectInspector) oi).get(o));
+ result = HiveDecimal.create(((IntObjectInspector) oi).get(o));
break;
case LONG:
- result = new HiveDecimal(((LongObjectInspector) oi).get(o));
+ result = HiveDecimal.create(((LongObjectInspector) oi).get(o));
break;
case FLOAT:
Float f = ((FloatObjectInspector) oi).get(o);
- result = new HiveDecimal(f.toString());
+ result = HiveDecimal.create(f.toString());
break;
case DOUBLE:
Double d = ((DoubleObjectInspector) oi).get(o);
- result = new HiveDecimal(d.toString());
+ result = HiveDecimal.create(d.toString());
break;
case STRING:
- result = new HiveDecimal(((StringObjectInspector) oi).getPrimitiveJavaObject(o));
+ result = HiveDecimal.create(((StringObjectInspector) oi).getPrimitiveJavaObject(o));
break;
case VARCHAR:
- result = new HiveDecimal(getString(o, oi));
+ result = HiveDecimal.create(getString(o, oi));
break;
case TIMESTAMP:
Double ts = ((TimestampObjectInspector) oi).getPrimitiveWritableObject(o)
.getDouble();
- result = new HiveDecimal(ts.toString());
+ result = HiveDecimal.create(ts.toString());
break;
case DECIMAL:
result = ((HiveDecimalObjectInspector) oi).getPrimitiveJavaObject(o);
@@ -1208,37 +1098,4 @@ public final class PrimitiveObjectInspec
// prevent instantiation
}
- /**
- * Helper class to store parameterized primitive object inspectors, which can be
- * used by the various object inspector factory methods.
- */
- public static class ParameterizedObjectInspectorMap {
- HashMap<PrimitiveCategory, HashMap<String, PrimitiveObjectInspector>> entries;
-
- public ParameterizedObjectInspectorMap() {
- entries =
- new HashMap<PrimitiveCategory, HashMap<String, PrimitiveObjectInspector>>();
- }
-
- public PrimitiveObjectInspector getObjectInspector(
- PrimitiveTypeSpec typeSpec) {
- PrimitiveCategory category = typeSpec.getPrimitiveCategory();
- BaseTypeParams params = typeSpec.getTypeParams();
- HashMap<String, PrimitiveObjectInspector> entriesForCategory = entries.get(category);
- if (entriesForCategory == null) {
- return null;
- }
- return (PrimitiveObjectInspector)entriesForCategory.get(params.toString());
- }
-
- public void setObjectInspector(PrimitiveObjectInspector oi) {
- PrimitiveCategory category = oi.getPrimitiveCategory();
- HashMap<String, PrimitiveObjectInspector> entriesForCategory = entries.get(category);
- if (entriesForCategory == null) {
- entriesForCategory = new HashMap<String, PrimitiveObjectInspector>();
- entries.put(category, entriesForCategory);
- }
- entriesForCategory.put(oi.getTypeParams().toString(), oi);
- }
- }
}
Modified: hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableBinaryObjectInspector.java
URL: http://svn.apache.org/viewvc/hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableBinaryObjectInspector.java?rev=1534711&r1=1534710&r2=1534711&view=diff
==============================================================================
--- hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableBinaryObjectInspector.java (original)
+++ hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableBinaryObjectInspector.java Tue Oct 22 17:58:59 2013
@@ -21,6 +21,7 @@ package org.apache.hadoop.hive.serde2.ob
import java.util.Arrays;
import org.apache.hadoop.hive.serde2.lazy.LazyUtils;
+import org.apache.hadoop.hive.serde2.typeinfo.TypeInfoFactory;
import org.apache.hadoop.io.BytesWritable;
/**
* A WritableBinaryObjectInspector inspects a BytesWritable Object.
@@ -29,7 +30,7 @@ public class WritableBinaryObjectInspect
implements SettableBinaryObjectInspector {
WritableBinaryObjectInspector() {
- super(PrimitiveObjectInspectorUtils.binaryTypeEntry);
+ super(TypeInfoFactory.binaryTypeInfo);
}
@Override
Modified: hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableBooleanObjectInspector.java
URL: http://svn.apache.org/viewvc/hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableBooleanObjectInspector.java?rev=1534711&r1=1534710&r2=1534711&view=diff
==============================================================================
--- hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableBooleanObjectInspector.java (original)
+++ hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableBooleanObjectInspector.java Tue Oct 22 17:58:59 2013
@@ -17,6 +17,7 @@
*/
package org.apache.hadoop.hive.serde2.objectinspector.primitive;
+import org.apache.hadoop.hive.serde2.typeinfo.TypeInfoFactory;
import org.apache.hadoop.io.BooleanWritable;
/**
@@ -27,7 +28,7 @@ public class WritableBooleanObjectInspec
SettableBooleanObjectInspector {
WritableBooleanObjectInspector() {
- super(PrimitiveObjectInspectorUtils.booleanTypeEntry);
+ super(TypeInfoFactory.booleanTypeInfo);
}
@Override
Modified: hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableByteObjectInspector.java
URL: http://svn.apache.org/viewvc/hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableByteObjectInspector.java?rev=1534711&r1=1534710&r2=1534711&view=diff
==============================================================================
--- hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableByteObjectInspector.java (original)
+++ hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableByteObjectInspector.java Tue Oct 22 17:58:59 2013
@@ -18,6 +18,7 @@
package org.apache.hadoop.hive.serde2.objectinspector.primitive;
import org.apache.hadoop.hive.serde2.io.ByteWritable;
+import org.apache.hadoop.hive.serde2.typeinfo.TypeInfoFactory;
/**
* A WritableByteObjectInspector inspects a ByteWritable Object.
@@ -26,8 +27,8 @@ public class WritableByteObjectInspector
AbstractPrimitiveWritableObjectInspector implements
SettableByteObjectInspector {
- WritableByteObjectInspector() {
- super(PrimitiveObjectInspectorUtils.byteTypeEntry);
+ public WritableByteObjectInspector() {
+ super(TypeInfoFactory.byteTypeInfo);
}
@Override
Modified: hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableConstantHiveVarcharObjectInspector.java
URL: http://svn.apache.org/viewvc/hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableConstantHiveVarcharObjectInspector.java?rev=1534711&r1=1534710&r2=1534711&view=diff
==============================================================================
--- hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableConstantHiveVarcharObjectInspector.java (original)
+++ hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableConstantHiveVarcharObjectInspector.java Tue Oct 22 17:58:59 2013
@@ -19,7 +19,7 @@ package org.apache.hadoop.hive.serde2.ob
import org.apache.hadoop.hive.serde2.io.HiveVarcharWritable;
import org.apache.hadoop.hive.serde2.objectinspector.ConstantObjectInspector;
-import org.apache.hadoop.hive.serde2.typeinfo.VarcharTypeParams;
+import org.apache.hadoop.hive.serde2.typeinfo.VarcharTypeInfo;
/**
* A WritableConstantHiveVarcharObjectInspector is a WritableHiveVarcharObjectInspector
@@ -35,29 +35,15 @@ public class WritableConstantHiveVarchar
WritableConstantHiveVarcharObjectInspector() {
}
- WritableConstantHiveVarcharObjectInspector(HiveVarcharWritable value) {
- this(value, null);
- }
-
- WritableConstantHiveVarcharObjectInspector(HiveVarcharWritable value,
- VarcharTypeParams typeParams) {
- super(PrimitiveObjectInspectorUtils.varcharTypeEntry);
+ WritableConstantHiveVarcharObjectInspector(VarcharTypeInfo typeInfo,
+ HiveVarcharWritable value) {
+ super(typeInfo);
this.value = value;
-
- // If we have been provided with type params, then use them.
- // Otherwise determine character length and update type params/typeinfo accordingly.
- if (typeParams == null) {
- typeParams = new VarcharTypeParams();
- typeParams.length = this.value.getCharacterLength();
- }
- setTypeParams(typeParams);
- this.typeEntry = PrimitiveObjectInspectorUtils.getTypeEntryFromTypeSpecs(
- PrimitiveCategory.VARCHAR,
- typeParams);
}
@Override
public HiveVarcharWritable getWritableConstantValue() {
+ // TODO: enforce max length
return value;
}
}
Modified: hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableDateObjectInspector.java
URL: http://svn.apache.org/viewvc/hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableDateObjectInspector.java?rev=1534711&r1=1534710&r2=1534711&view=diff
==============================================================================
--- hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableDateObjectInspector.java (original)
+++ hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableDateObjectInspector.java Tue Oct 22 17:58:59 2013
@@ -20,6 +20,7 @@ package org.apache.hadoop.hive.serde2.ob
import java.sql.Date;
import org.apache.hadoop.hive.serde2.io.DateWritable;
+import org.apache.hadoop.hive.serde2.typeinfo.TypeInfoFactory;
/**
* A WritableDateObjectInspector inspects a DateWritable Object.
@@ -29,7 +30,7 @@ public class WritableDateObjectInspector
SettableDateObjectInspector {
public WritableDateObjectInspector() {
- super(PrimitiveObjectInspectorUtils.dateTypeEntry);
+ super(TypeInfoFactory.dateTypeInfo);
}
@Override
Modified: hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableDoubleObjectInspector.java
URL: http://svn.apache.org/viewvc/hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableDoubleObjectInspector.java?rev=1534711&r1=1534710&r2=1534711&view=diff
==============================================================================
--- hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableDoubleObjectInspector.java (original)
+++ hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableDoubleObjectInspector.java Tue Oct 22 17:58:59 2013
@@ -18,6 +18,7 @@
package org.apache.hadoop.hive.serde2.objectinspector.primitive;
import org.apache.hadoop.hive.serde2.io.DoubleWritable;
+import org.apache.hadoop.hive.serde2.typeinfo.TypeInfoFactory;
/**
* A WritableDoubleObjectInspector inspects a DoubleWritable Object.
@@ -27,7 +28,7 @@ public class WritableDoubleObjectInspect
SettableDoubleObjectInspector {
WritableDoubleObjectInspector() {
- super(PrimitiveObjectInspectorUtils.doubleTypeEntry);
+ super(TypeInfoFactory.doubleTypeInfo);
}
@Override
Modified: hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableFloatObjectInspector.java
URL: http://svn.apache.org/viewvc/hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableFloatObjectInspector.java?rev=1534711&r1=1534710&r2=1534711&view=diff
==============================================================================
--- hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableFloatObjectInspector.java (original)
+++ hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableFloatObjectInspector.java Tue Oct 22 17:58:59 2013
@@ -17,6 +17,7 @@
*/
package org.apache.hadoop.hive.serde2.objectinspector.primitive;
+import org.apache.hadoop.hive.serde2.typeinfo.TypeInfoFactory;
import org.apache.hadoop.io.FloatWritable;
/**
@@ -27,7 +28,7 @@ public class WritableFloatObjectInspecto
SettableFloatObjectInspector {
WritableFloatObjectInspector() {
- super(PrimitiveObjectInspectorUtils.floatTypeEntry);
+ super(TypeInfoFactory.floatTypeInfo);
}
@Override
Modified: hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableHiveDecimalObjectInspector.java
URL: http://svn.apache.org/viewvc/hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableHiveDecimalObjectInspector.java?rev=1534711&r1=1534710&r2=1534711&view=diff
==============================================================================
--- hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableHiveDecimalObjectInspector.java (original)
+++ hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableHiveDecimalObjectInspector.java Tue Oct 22 17:58:59 2013
@@ -20,13 +20,14 @@ package org.apache.hadoop.hive.serde2.ob
import org.apache.hadoop.hive.common.type.HiveDecimal;
import org.apache.hadoop.hive.serde2.io.HiveDecimalWritable;
+import org.apache.hadoop.hive.serde2.typeinfo.TypeInfoFactory;
public class WritableHiveDecimalObjectInspector
extends AbstractPrimitiveWritableObjectInspector
implements SettableHiveDecimalObjectInspector {
protected WritableHiveDecimalObjectInspector() {
- super(PrimitiveObjectInspectorUtils.decimalTypeEntry);
+ super(TypeInfoFactory.decimalTypeInfo);
}
@Override
@@ -52,12 +53,20 @@ public class WritableHiveDecimalObjectIn
@Override
public Object set(Object o, HiveDecimal t) {
+ if (t == null) {
+ return null;
+ }
+
((HiveDecimalWritable) o).set(t);
return o;
}
@Override
public Object set(Object o, HiveDecimalWritable t) {
+ if (t == null) {
+ return null;
+ }
+
((HiveDecimalWritable) o).set(t);
return o;
}
@@ -69,6 +78,10 @@ public class WritableHiveDecimalObjectIn
@Override
public Object create(HiveDecimal t) {
+ if (t == null) {
+ return null;
+ }
+
return new HiveDecimalWritable(t);
}
Modified: hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableHiveVarcharObjectInspector.java
URL: http://svn.apache.org/viewvc/hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableHiveVarcharObjectInspector.java?rev=1534711&r1=1534710&r2=1534711&view=diff
==============================================================================
--- hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableHiveVarcharObjectInspector.java (original)
+++ hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableHiveVarcharObjectInspector.java Tue Oct 22 17:58:59 2013
@@ -21,26 +21,19 @@ import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.hadoop.hive.common.type.HiveVarchar;
import org.apache.hadoop.hive.serde2.io.HiveVarcharWritable;
-import org.apache.hadoop.hive.serde2.objectinspector.primitive.PrimitiveObjectInspectorUtils.PrimitiveTypeEntry;
-import org.apache.hadoop.hive.serde2.typeinfo.ParameterizedPrimitiveTypeUtils;
-import org.apache.hadoop.hive.serde2.typeinfo.VarcharTypeParams;
-
-public class WritableHiveVarcharObjectInspector
- extends AbstractPrimitiveWritableObjectInspector
- implements SettableHiveVarcharObjectInspector {
+import org.apache.hadoop.hive.serde2.typeinfo.VarcharTypeInfo;
+import org.apache.hadoop.hive.serde2.typeinfo.VarcharUtils;
+public class WritableHiveVarcharObjectInspector extends AbstractPrimitiveWritableObjectInspector
+implements SettableHiveVarcharObjectInspector {
private static final Log LOG = LogFactory.getLog(WritableHiveVarcharObjectInspector.class);
// no-arg ctor required for Kyro serialization
public WritableHiveVarcharObjectInspector() {
}
- public WritableHiveVarcharObjectInspector(PrimitiveTypeEntry typeEntry) {
- super(typeEntry);
- if (typeEntry.primitiveCategory != PrimitiveCategory.VARCHAR) {
- throw new RuntimeException(
- "TypeEntry of type varchar expected, got " + typeEntry.primitiveCategory);
- }
+ public WritableHiveVarcharObjectInspector(VarcharTypeInfo typeInfo) {
+ super(typeInfo);
}
@Override
@@ -85,8 +78,8 @@ public class WritableHiveVarcharObjectIn
}
private boolean doesWritableMatchTypeParams(HiveVarcharWritable writable) {
- return ParameterizedPrimitiveTypeUtils.doesWritableMatchTypeParams(
- writable, (VarcharTypeParams)getTypeParams());
+ return VarcharUtils.doesWritableMatchTypeParams(
+ writable, (VarcharTypeInfo)typeInfo);
}
@Override
@@ -124,8 +117,7 @@ public class WritableHiveVarcharObjectIn
}
public int getMaxLength() {
- VarcharTypeParams typeParams = (VarcharTypeParams)getTypeParams();
- return typeParams != null ? typeParams.length : -1;
+ return ((VarcharTypeInfo)typeInfo).getLength();
}
}
Modified: hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableIntObjectInspector.java
URL: http://svn.apache.org/viewvc/hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableIntObjectInspector.java?rev=1534711&r1=1534710&r2=1534711&view=diff
==============================================================================
--- hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableIntObjectInspector.java (original)
+++ hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableIntObjectInspector.java Tue Oct 22 17:58:59 2013
@@ -17,6 +17,7 @@
*/
package org.apache.hadoop.hive.serde2.objectinspector.primitive;
+import org.apache.hadoop.hive.serde2.typeinfo.TypeInfoFactory;
import org.apache.hadoop.io.IntWritable;
/**
@@ -27,7 +28,7 @@ public class WritableIntObjectInspector
SettableIntObjectInspector {
WritableIntObjectInspector() {
- super(PrimitiveObjectInspectorUtils.intTypeEntry);
+ super(TypeInfoFactory.intTypeInfo);
}
@Override
Modified: hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableLongObjectInspector.java
URL: http://svn.apache.org/viewvc/hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableLongObjectInspector.java?rev=1534711&r1=1534710&r2=1534711&view=diff
==============================================================================
--- hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableLongObjectInspector.java (original)
+++ hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableLongObjectInspector.java Tue Oct 22 17:58:59 2013
@@ -17,6 +17,7 @@
*/
package org.apache.hadoop.hive.serde2.objectinspector.primitive;
+import org.apache.hadoop.hive.serde2.typeinfo.TypeInfoFactory;
import org.apache.hadoop.io.LongWritable;
/**
@@ -27,7 +28,7 @@ public class WritableLongObjectInspector
SettableLongObjectInspector {
WritableLongObjectInspector() {
- super(PrimitiveObjectInspectorUtils.longTypeEntry);
+ super(TypeInfoFactory.longTypeInfo);
}
@Override
Modified: hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableShortObjectInspector.java
URL: http://svn.apache.org/viewvc/hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableShortObjectInspector.java?rev=1534711&r1=1534710&r2=1534711&view=diff
==============================================================================
--- hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableShortObjectInspector.java (original)
+++ hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableShortObjectInspector.java Tue Oct 22 17:58:59 2013
@@ -18,6 +18,7 @@
package org.apache.hadoop.hive.serde2.objectinspector.primitive;
import org.apache.hadoop.hive.serde2.io.ShortWritable;
+import org.apache.hadoop.hive.serde2.typeinfo.TypeInfoFactory;
/**
* A WritableShortObjectInspector inspects a ShortWritable Object.
@@ -27,7 +28,7 @@ public class WritableShortObjectInspecto
SettableShortObjectInspector {
WritableShortObjectInspector() {
- super(PrimitiveObjectInspectorUtils.shortTypeEntry);
+ super(TypeInfoFactory.shortTypeInfo);
}
@Override
Modified: hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableStringObjectInspector.java
URL: http://svn.apache.org/viewvc/hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableStringObjectInspector.java?rev=1534711&r1=1534710&r2=1534711&view=diff
==============================================================================
--- hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableStringObjectInspector.java (original)
+++ hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableStringObjectInspector.java Tue Oct 22 17:58:59 2013
@@ -17,6 +17,7 @@
*/
package org.apache.hadoop.hive.serde2.objectinspector.primitive;
+import org.apache.hadoop.hive.serde2.typeinfo.TypeInfoFactory;
import org.apache.hadoop.io.Text;
/**
@@ -27,7 +28,7 @@ public class WritableStringObjectInspect
SettableStringObjectInspector {
WritableStringObjectInspector() {
- super(PrimitiveObjectInspectorUtils.stringTypeEntry);
+ super(TypeInfoFactory.stringTypeInfo);
}
@Override
Modified: hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableTimestampObjectInspector.java
URL: http://svn.apache.org/viewvc/hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableTimestampObjectInspector.java?rev=1534711&r1=1534710&r2=1534711&view=diff
==============================================================================
--- hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableTimestampObjectInspector.java (original)
+++ hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableTimestampObjectInspector.java Tue Oct 22 17:58:59 2013
@@ -20,13 +20,14 @@ package org.apache.hadoop.hive.serde2.ob
import java.sql.Timestamp;
import org.apache.hadoop.hive.serde2.io.TimestampWritable;
+import org.apache.hadoop.hive.serde2.typeinfo.TypeInfoFactory;
public class WritableTimestampObjectInspector extends
AbstractPrimitiveWritableObjectInspector implements
SettableTimestampObjectInspector {
public WritableTimestampObjectInspector() {
- super(PrimitiveObjectInspectorUtils.timestampTypeEntry);
+ super(TypeInfoFactory.timestampTypeInfo);
}
@Override
Modified: hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableVoidObjectInspector.java
URL: http://svn.apache.org/viewvc/hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableVoidObjectInspector.java?rev=1534711&r1=1534710&r2=1534711&view=diff
==============================================================================
--- hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableVoidObjectInspector.java (original)
+++ hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/WritableVoidObjectInspector.java Tue Oct 22 17:58:59 2013
@@ -18,6 +18,7 @@
package org.apache.hadoop.hive.serde2.objectinspector.primitive;
import org.apache.hadoop.hive.serde2.objectinspector.ConstantObjectInspector;
+import org.apache.hadoop.hive.serde2.typeinfo.TypeInfoFactory;
/**
* A WritableVoidObjectInspector inspects a NullWritable Object.
@@ -28,7 +29,7 @@ public class WritableVoidObjectInspector
VoidObjectInspector, ConstantObjectInspector {
WritableVoidObjectInspector() {
- super(PrimitiveObjectInspectorUtils.voidTypeEntry);
+ super(TypeInfoFactory.voidTypeInfo);
}
@Override
Modified: hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/typeinfo/PrimitiveTypeInfo.java
URL: http://svn.apache.org/viewvc/hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/typeinfo/PrimitiveTypeInfo.java?rev=1534711&r1=1534710&r2=1534711&view=diff
==============================================================================
--- hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/typeinfo/PrimitiveTypeInfo.java (original)
+++ hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/typeinfo/PrimitiveTypeInfo.java Tue Oct 22 17:58:59 2013
@@ -32,12 +32,11 @@ import org.apache.hadoop.hive.serde2.obj
* Always use the TypeInfoFactory to create new TypeInfo objects, instead of
* directly creating an instance of this class.
*/
-public class PrimitiveTypeInfo extends TypeInfo implements Serializable, PrimitiveTypeSpec {
-
+public class PrimitiveTypeInfo extends TypeInfo implements Serializable {
private static final long serialVersionUID = 1L;
+ // Base name (varchar vs fully qualified name such as varchar(200)).
protected String typeName;
- protected BaseTypeParams typeParams;
/**
* For java serialization use only.
@@ -65,11 +64,11 @@ public class PrimitiveTypeInfo extends T
}
public Class<?> getPrimitiveWritableClass() {
- return PrimitiveObjectInspectorUtils.getTypeEntryFromTypeName(typeName).primitiveWritableClass;
+ return getPrimitiveTypeEntry().primitiveWritableClass;
}
public Class<?> getPrimitiveJavaClass() {
- return PrimitiveObjectInspectorUtils.getTypeEntryFromTypeName(typeName).primitiveJavaClass;
+ return getPrimitiveTypeEntry().primitiveJavaClass;
}
// The following 2 methods are for java serialization use only.
@@ -82,43 +81,19 @@ public class PrimitiveTypeInfo extends T
return typeName;
}
- /**
- * If the type has type parameters (such as varchar length, or decimal precision/scale),
- * then return the parameters for the type.
- * @return A BaseTypeParams object representing the parameters for the type, or null
- */
- public BaseTypeParams getTypeParams() {
- return typeParams;
- }
-
- /**
- * Set the type parameters for the type.
- * @param typeParams type parameters for the type
- */
- public void setTypeParams(BaseTypeParams typeParams) {
- // Ideally could check here to make sure the type really supports parameters,
- // however during deserialization some of the required fields are not set at the
- // time that the type params are set. We would have to customize the way this class
- // is serialized/deserialized for the check to work.
- //if (typeParams != null && !getPrimitiveTypeEntry().isParameterized()) {
- // throw new UnsupportedOperationException(
- // "Attempting to add type parameters " + typeParams + " to type " + getTypeName());
- //}
- this.typeParams = typeParams;
- }
-
public PrimitiveTypeEntry getPrimitiveTypeEntry() {
- return PrimitiveObjectInspectorUtils.getTypeEntryFromTypeName(
- TypeInfoUtils.getBaseName(typeName));
+ return PrimitiveObjectInspectorUtils.getTypeEntryFromTypeName(typeName);
}
- /**
- * Compare if 2 TypeInfos are the same. We use TypeInfoFactory to cache
- * TypeInfos, so we only need to compare the Object pointer.
- */
@Override
public boolean equals(Object other) {
- return this == other;
+ if (other == null || !(other instanceof PrimitiveTypeInfo)) {
+ return false;
+ }
+
+ PrimitiveTypeInfo pti = (PrimitiveTypeInfo) other;
+
+ return this.typeName.equals(pti.typeName);
}
/**
Modified: hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/typeinfo/TypeInfoFactory.java
URL: http://svn.apache.org/viewvc/hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/typeinfo/TypeInfoFactory.java?rev=1534711&r1=1534710&r2=1534711&view=diff
==============================================================================
--- hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/typeinfo/TypeInfoFactory.java (original)
+++ hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/typeinfo/TypeInfoFactory.java Tue Oct 22 17:58:59 2013
@@ -25,7 +25,6 @@ import java.util.concurrent.ConcurrentHa
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.hadoop.hive.serde.serdeConstants;
-import org.apache.hadoop.hive.serde2.objectinspector.PrimitiveObjectInspector.PrimitiveCategory;
import org.apache.hadoop.hive.serde2.objectinspector.primitive.PrimitiveObjectInspectorUtils;
import org.apache.hadoop.hive.serde2.objectinspector.primitive.PrimitiveObjectInspectorUtils.PrimitiveTypeEntry;
@@ -38,71 +37,106 @@ import org.apache.hadoop.hive.serde2.obj
*/
public final class TypeInfoFactory {
private static Log LOG = LogFactory.getLog(TypeInfoFactory.class);
- static ConcurrentHashMap<String, TypeInfo> cachedPrimitiveTypeInfo = new ConcurrentHashMap<String, TypeInfo>();
private TypeInfoFactory() {
// prevent instantiation
}
- public static TypeInfo getPrimitiveTypeInfo(String typeName) {
- PrimitiveTypeEntry typeEntry = PrimitiveObjectInspectorUtils
- .getTypeEntryFromTypeName(TypeInfoUtils.getBaseName(typeName));
- if (null == typeEntry) {
- throw new RuntimeException("Cannot getPrimitiveTypeInfo for " + typeName);
+ public static final PrimitiveTypeInfo voidTypeInfo = new PrimitiveTypeInfo(serdeConstants.VOID_TYPE_NAME);
+ public static final PrimitiveTypeInfo booleanTypeInfo = new PrimitiveTypeInfo(serdeConstants.BOOLEAN_TYPE_NAME);
+ public static final PrimitiveTypeInfo intTypeInfo = new PrimitiveTypeInfo(serdeConstants.INT_TYPE_NAME);
+ public static final PrimitiveTypeInfo longTypeInfo = new PrimitiveTypeInfo(serdeConstants.BIGINT_TYPE_NAME);
+ public static final PrimitiveTypeInfo stringTypeInfo = new PrimitiveTypeInfo(serdeConstants.STRING_TYPE_NAME);
+ public static final PrimitiveTypeInfo floatTypeInfo = new PrimitiveTypeInfo(serdeConstants.FLOAT_TYPE_NAME);
+ public static final PrimitiveTypeInfo doubleTypeInfo = new PrimitiveTypeInfo(serdeConstants.DOUBLE_TYPE_NAME);
+ public static final PrimitiveTypeInfo byteTypeInfo = new PrimitiveTypeInfo(serdeConstants.TINYINT_TYPE_NAME);
+ public static final PrimitiveTypeInfo shortTypeInfo = new PrimitiveTypeInfo(serdeConstants.SMALLINT_TYPE_NAME);
+ public static final PrimitiveTypeInfo dateTypeInfo = new PrimitiveTypeInfo(serdeConstants.DATE_TYPE_NAME);
+ public static final PrimitiveTypeInfo timestampTypeInfo = new PrimitiveTypeInfo(serdeConstants.TIMESTAMP_TYPE_NAME);
+ public static final PrimitiveTypeInfo binaryTypeInfo = new PrimitiveTypeInfo(serdeConstants.BINARY_TYPE_NAME);
+ public static final PrimitiveTypeInfo decimalTypeInfo = new PrimitiveTypeInfo(serdeConstants.DECIMAL_TYPE_NAME);
+
+ public static final PrimitiveTypeInfo unknownTypeInfo = new PrimitiveTypeInfo("unknown");
+
+ // Map from type name (such as int or varchar(40) to the corresponding PrimitiveTypeInfo
+ // instance.
+ private static ConcurrentHashMap<String, PrimitiveTypeInfo> cachedPrimitiveTypeInfo =
+ new ConcurrentHashMap<String, PrimitiveTypeInfo>();
+ static {
+ cachedPrimitiveTypeInfo.put(serdeConstants.VOID_TYPE_NAME, voidTypeInfo);
+ cachedPrimitiveTypeInfo.put(serdeConstants.BOOLEAN_TYPE_NAME, booleanTypeInfo);
+ cachedPrimitiveTypeInfo.put(serdeConstants.INT_TYPE_NAME, intTypeInfo);
+ cachedPrimitiveTypeInfo.put(serdeConstants.BIGINT_TYPE_NAME, longTypeInfo);
+ cachedPrimitiveTypeInfo.put(serdeConstants.STRING_TYPE_NAME, stringTypeInfo);
+ cachedPrimitiveTypeInfo.put(serdeConstants.FLOAT_TYPE_NAME, floatTypeInfo);
+ cachedPrimitiveTypeInfo.put(serdeConstants.DOUBLE_TYPE_NAME, doubleTypeInfo);
+ cachedPrimitiveTypeInfo.put(serdeConstants.TINYINT_TYPE_NAME, byteTypeInfo);
+ cachedPrimitiveTypeInfo.put(serdeConstants.SMALLINT_TYPE_NAME, shortTypeInfo);
+ cachedPrimitiveTypeInfo.put(serdeConstants.DATE_TYPE_NAME, dateTypeInfo);
+ cachedPrimitiveTypeInfo.put(serdeConstants.TIMESTAMP_TYPE_NAME, timestampTypeInfo);
+ cachedPrimitiveTypeInfo.put(serdeConstants.BINARY_TYPE_NAME, binaryTypeInfo);
+ cachedPrimitiveTypeInfo.put(serdeConstants.DECIMAL_TYPE_NAME, decimalTypeInfo);
+ cachedPrimitiveTypeInfo.put("unknown", unknownTypeInfo);
+ }
+
+ /**
+ * Get PrimitiveTypeInfo instance for the given type name of a type
+ * including types with parameters, such as varchar(20).
+ *
+ * @param typeName type name possibly with parameters.
+ * @return aPrimitiveTypeInfo instance
+ */
+ public static PrimitiveTypeInfo getPrimitiveTypeInfo(String typeName) {
+ PrimitiveTypeInfo result = cachedPrimitiveTypeInfo.get(typeName);
+ if (result != null) {
+ return result;
}
- TypeInfo result = cachedPrimitiveTypeInfo.get(typeName);
+
+ // Not found in the cache. Must be parameterized types. Create it.
+ result = createPrimitiveTypeInfo(typeName);
if (result == null) {
- TypeInfoUtils.PrimitiveParts parts = TypeInfoUtils.parsePrimitiveParts(typeName);
- // Create params if there are any
- if (parts.typeParams != null && parts.typeParams.length > 0) {
- // The type string came with parameters. Parse and add to TypeInfo
- try {
- BaseTypeParams typeParams = PrimitiveTypeEntry.createTypeParams(
- parts.typeName, parts.typeParams);
- result = new PrimitiveTypeInfo(typeName);
- ((PrimitiveTypeInfo) result).setTypeParams(typeParams);
- } catch (Exception err) {
- LOG.error(err);
- throw new RuntimeException("Error creating type parameters for " + typeName
- + ": " + err, err);
- }
- } else {
- // No type params
+ throw new RuntimeException("Error creating PrimitiveTypeInfo instance for " + typeName);
+ }
- // Prevent creation of varchar TypeInfo with no length specification.
- // This can happen if an old-style UDF uses a varchar type either as an
- // argument or return type in an evaluate() function, or other instances
- // of using reflection-based methods for retrieving a TypeInfo.
- if (typeEntry.primitiveCategory == PrimitiveCategory.VARCHAR) {
- LOG.error("varchar type used with no type params");
- throw new RuntimeException("varchar type used with no type params");
- }
+ cachedPrimitiveTypeInfo.put(typeName, result);
+ return result;
+ }
- result = new PrimitiveTypeInfo(parts.typeName);
- }
+ /**
+ * Create PrimitiveTypeInfo instance for the given full name of the type. The returned
+ * type is one of the parameterized type info such as VarcharTypeInfo.
+ *
+ * @param fullName Fully qualified name of the type
+ * @return PrimitiveTypeInfo instance
+ */
+ private static PrimitiveTypeInfo createPrimitiveTypeInfo(String fullName) {
+ String baseName = TypeInfoUtils.getBaseName(fullName);
+ PrimitiveTypeEntry typeEntry =
+ PrimitiveObjectInspectorUtils.getTypeEntryFromTypeName(baseName);
+ if (null == typeEntry) {
+ throw new RuntimeException("Unknown type " + fullName);
+ }
- cachedPrimitiveTypeInfo.put(typeName, result);
+ TypeInfoUtils.PrimitiveParts parts = TypeInfoUtils.parsePrimitiveParts(fullName);
+ if (parts.typeParams == null || parts.typeParams.length < 1) {
+ return null;
}
- return result;
- }
- public static final TypeInfo voidTypeInfo = getPrimitiveTypeInfo(serdeConstants.VOID_TYPE_NAME);
- public static final TypeInfo booleanTypeInfo = getPrimitiveTypeInfo(serdeConstants.BOOLEAN_TYPE_NAME);
- public static final TypeInfo intTypeInfo = getPrimitiveTypeInfo(serdeConstants.INT_TYPE_NAME);
- public static final TypeInfo longTypeInfo = getPrimitiveTypeInfo(serdeConstants.BIGINT_TYPE_NAME);
- public static final TypeInfo stringTypeInfo = getPrimitiveTypeInfo(serdeConstants.STRING_TYPE_NAME);
- public static final TypeInfo floatTypeInfo = getPrimitiveTypeInfo(serdeConstants.FLOAT_TYPE_NAME);
- public static final TypeInfo doubleTypeInfo = getPrimitiveTypeInfo(serdeConstants.DOUBLE_TYPE_NAME);
- public static final TypeInfo byteTypeInfo = getPrimitiveTypeInfo(serdeConstants.TINYINT_TYPE_NAME);
- public static final TypeInfo shortTypeInfo = getPrimitiveTypeInfo(serdeConstants.SMALLINT_TYPE_NAME);
- public static final TypeInfo dateTypeInfo = getPrimitiveTypeInfo(serdeConstants.DATE_TYPE_NAME);
- public static final TypeInfo timestampTypeInfo = getPrimitiveTypeInfo(serdeConstants.TIMESTAMP_TYPE_NAME);
- public static final TypeInfo binaryTypeInfo = getPrimitiveTypeInfo(serdeConstants.BINARY_TYPE_NAME);
- public static final TypeInfo decimalTypeInfo = getPrimitiveTypeInfo(serdeConstants.DECIMAL_TYPE_NAME);
- // Disallow usage of varchar without length specifier.
- //public static final TypeInfo varcharTypeInfo = getPrimitiveTypeInfo(serdeConstants.VARCHAR_TYPE_NAME);
+ switch (typeEntry.primitiveCategory) {
+ case VARCHAR:
+ if (parts.typeParams.length != 1) {
+ return null;
+ }
+ return new VarcharTypeInfo(Integer.valueOf(parts.typeParams[0]));
+ default:
+ return null;
+ }
+ }
- public static final TypeInfo unknownTypeInfo = getPrimitiveTypeInfo("unknown");
+ public static VarcharTypeInfo getVarcharTypeInfo(int length) {
+ String fullName = BaseCharTypeInfo.getQualifiedName(serdeConstants.VARCHAR_TYPE_NAME, length);
+ return (VarcharTypeInfo) getPrimitiveTypeInfo(fullName);
+ }
public static TypeInfo getPrimitiveTypeInfoFromPrimitiveWritable(
Class<?> clazz) {
Modified: hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/typeinfo/TypeInfoUtils.java
URL: http://svn.apache.org/viewvc/hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/typeinfo/TypeInfoUtils.java?rev=1534711&r1=1534710&r2=1534711&view=diff
==============================================================================
--- hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/typeinfo/TypeInfoUtils.java (original)
+++ hive/branches/maven/serde/src/java/org/apache/hadoop/hive/serde2/typeinfo/TypeInfoUtils.java Tue Oct 22 17:58:59 2013
@@ -29,7 +29,6 @@ import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
-import org.apache.commons.lang.StringUtils;
import org.apache.hadoop.hive.common.type.HiveVarchar;
import org.apache.hadoop.hive.serde.serdeConstants;
import org.apache.hadoop.hive.serde2.objectinspector.ListObjectInspector;
@@ -392,15 +391,30 @@ public final class TypeInfoUtils {
Token t = expect("type");
// Is this a primitive type?
- PrimitiveTypeEntry primitiveType = PrimitiveObjectInspectorUtils
- .getTypeEntryFromTypeName(t.text);
- if (primitiveType != null
- && !primitiveType.primitiveCategory.equals(PrimitiveCategory.UNKNOWN)) {
- if (primitiveType.isParameterized()) {
- primitiveType = primitiveType.addParameters(parseParams());
+ PrimitiveTypeEntry typeEntry =
+ PrimitiveObjectInspectorUtils.getTypeEntryFromTypeName(t.text);
+ if (typeEntry != null && typeEntry.primitiveCategory != PrimitiveCategory.UNKNOWN ) {
+ String qualifiedTypeName = typeEntry.typeName;
+ if (typeEntry.primitiveCategory == PrimitiveCategory.VARCHAR) {
+ int length = HiveVarchar.MAX_VARCHAR_LENGTH;
+
+ String[] params = parseParams();
+ if (params == null || params.length == 0) {
+ throw new RuntimeException( "Varchar type is specified without length: " + typeInfoString);
+ }
+
+ if (params.length == 1) {
+ length = Integer.valueOf(params[0]);
+ VarcharUtils.validateParameter(length);
+ } else if (params.length > 1) {
+ throw new RuntimeException("Type varchar only takes one parameter, but " +
+ params.length + " is seen");
+ }
+
+ qualifiedTypeName = BaseCharTypeInfo.getQualifiedName(typeEntry.typeName, length);
}
- // If type has qualifiers, the TypeInfo needs them in its type string
- return TypeInfoFactory.getPrimitiveTypeInfo(primitiveType.toString());
+
+ return TypeInfoFactory.getPrimitiveTypeInfo(qualifiedTypeName);
}
// Is this a list type?
@@ -749,11 +763,8 @@ public final class TypeInfoUtils {
case STRING:
return HiveVarchar.MAX_VARCHAR_LENGTH;
case VARCHAR:
- VarcharTypeParams varcharParams = (VarcharTypeParams) typeInfo.getTypeParams();
- if (varcharParams == null) {
- throw new RuntimeException("varchar type used without type params");
- }
- return varcharParams.getLength();
+ VarcharTypeInfo varcharTypeInfo = (VarcharTypeInfo) typeInfo;
+ return varcharTypeInfo.getLength();
default:
return 0;
}
Modified: hive/branches/maven/serde/src/test/org/apache/hadoop/hive/serde2/binarysortable/TestBinarySortableSerDe.java
URL: http://svn.apache.org/viewvc/hive/branches/maven/serde/src/test/org/apache/hadoop/hive/serde2/binarysortable/TestBinarySortableSerDe.java?rev=1534711&r1=1534710&r2=1534711&view=diff
==============================================================================
--- hive/branches/maven/serde/src/test/org/apache/hadoop/hive/serde2/binarysortable/TestBinarySortableSerDe.java (original)
+++ hive/branches/maven/serde/src/test/org/apache/hadoop/hive/serde2/binarysortable/TestBinarySortableSerDe.java Tue Oct 22 17:58:59 2013
@@ -150,7 +150,7 @@ public class TestBinarySortableSerDe ext
sb.append(getRandString(r, DECIMAL_CHARS, l2));
}
- HiveDecimal bd = new HiveDecimal(sb.toString());
+ HiveDecimal bd = HiveDecimal.create(sb.toString());
return bd;
}