public static int hashCode(Object o, ObjectInspector objIns) {
    if (o == null) {
      return 0;
    }
    switch (objIns.getCategory()) {
    case PRIMITIVE: {
      PrimitiveObjectInspector poi = ((PrimitiveObjectInspector) objIns);
      switch (poi.getPrimitiveCategory()) {
      case VOID:
        return 0;
      case BOOLEAN:
        return ((BooleanObjectInspector) poi).get(o) ? 1 : 0;
      case BYTE:
        return ((ByteObjectInspector) poi).get(o);
      case SHORT:
        return ((ShortObjectInspector) poi).get(o);
      case INT:
        return ((IntObjectInspector) poi).get(o);
      case LONG: {
        long a = ((LongObjectInspector) poi).get(o);
        return (int) ((a >>> 32) ^ a);
      }
      case FLOAT:
        return Float.floatToIntBits(((FloatObjectInspector) poi).get(o));
      case DOUBLE: {
        // This hash function returns the same result as Double.hashCode()
        // while DoubleWritable.hashCode returns a different result.
        long a = Double.doubleToLongBits(((DoubleObjectInspector) poi).get(o));
        return (int) ((a >>> 32) ^ a);
      }
      case STRING: {
        // This hash function returns the same result as String.hashCode() when
        // all characters are ASCII, while Text.hashCode() always returns a
        // different result.
        Text t = ((StringObjectInspector) poi).getPrimitiveWritableObject(o);
        int r = 0;
        for (int i = 0; i < t.getLength(); i++) {
          r = r * 31 + t.getBytes()[i];
        }
        return r;
      }
      case CHAR:
        return ((HiveCharObjectInspector) poi).getPrimitiveWritableObject(o).hashCode();
      case VARCHAR:
        return ((HiveVarcharObjectInspector)poi).getPrimitiveWritableObject(o).hashCode();
      case BINARY:
        return ((BinaryObjectInspector) poi).getPrimitiveWritableObject(o).hashCode();

      case DATE:
        return ((DateObjectInspector) poi).getPrimitiveWritableObject(o).hashCode();
      case TIMESTAMP:
        // Use old timestamp writable hash code for backwards compatibility
        TimestampWritable ts = new TimestampWritable(
            java.sql.Timestamp.valueOf(
                ((TimestampObjectInspector) poi).getPrimitiveWritableObject(o).toString()));
        return ts.hashCode();
      case TIMESTAMPLOCALTZ:
        TimestampLocalTZWritable tstz = ((TimestampLocalTZObjectInspector) poi).getPrimitiveWritableObject(o);
        return tstz.hashCode();
      case INTERVAL_YEAR_MONTH:
        HiveIntervalYearMonthWritable intervalYearMonth = ((HiveIntervalYearMonthObjectInspector) poi)
            .getPrimitiveWritableObject(o);
        return intervalYearMonth.hashCode();
      case INTERVAL_DAY_TIME:
        HiveIntervalDayTimeWritable intervalDayTime = ((HiveIntervalDayTimeObjectInspector) poi)
            .getPrimitiveWritableObject(o);
        return intervalDayTime.hashCode();
      case DECIMAL:
        // Since getBucketHashCode uses this, HiveDecimal return the old (much slower) but
        // compatible hash code.
        return ((HiveDecimalObjectInspector) poi).getPrimitiveWritableObject(o).hashCode();

      default: {
        throw new RuntimeException("Unknown type: "
            + poi.getPrimitiveCategory());
      }
      }
    }
    case LIST: {
      int r = 0;
      ListObjectInspector listOI = (ListObjectInspector)objIns;
      ObjectInspector elemOI = listOI.getListElementObjectInspector();
      for (int ii = 0; ii < listOI.getListLength(o); ++ii) {
        r = 31 * r + hashCode(listOI.getListElement(o, ii), elemOI);
      }
      return r;
    }
    case MAP: {
      int r = 0;
      MapObjectInspector mapOI = (MapObjectInspector)objIns;
      ObjectInspector keyOI = mapOI.getMapKeyObjectInspector();
      ObjectInspector valueOI = mapOI.getMapValueObjectInspector();
      Map<?, ?> map = mapOI.getMap(o);
      for (Map.Entry<?,?> entry : map.entrySet()) {
        r += hashCode(entry.getKey(), keyOI) ^
             hashCode(entry.getValue(), valueOI);
      }
      return r;
    }
    case STRUCT:
      int r = 0;
      StructObjectInspector structOI = (StructObjectInspector)objIns;
      List<? extends StructField> fields = structOI.getAllStructFieldRefs();
      for (StructField field : fields) {
        r = 31 * r + hashCode(structOI.getStructFieldData(o, field),
            field.getFieldObjectInspector());
      }
      return r;

    case UNION:
      UnionObjectInspector uOI = (UnionObjectInspector)objIns;
      byte tag = uOI.getTag(o);
      return hashCode(uOI.getField(o), uOI.getObjectInspectors().get(tag));

    default:
      throw new RuntimeException("Unknown type: "+ objIns.getTypeName());
    }
  }
Computes the hash code for the given bucketed fields
@param bucketFields
@param bucketFieldInspectors
@return
serde/src/java/org/apache/hadoop/hive/serde2/objectinspector/ObjectInspectorUtils.java