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;
   }