Java TimestampObjectInspector类代码示例

import org.apache.hadoop.hive.serde2.objectinspector.primitive.TimestampObjectInspector; //导入依赖的package包/类
private static Writable createPrimitive(Object obj, PrimitiveObjectInspector inspector)
        throws SerDeException {
    if (obj == null) {
        return null;
    }
    switch (inspector.getPrimitiveCategory()) {
        case DOUBLE:
            return new DoubleWritable(((DoubleObjectInspector) inspector).get(obj));
        case FLOAT:
            return new FloatWritable(((FloatObjectInspector) inspector).get(obj));
        case INT:
            return new IntWritable(((IntObjectInspector) inspector).get(obj));
        case LONG:
            return new LongWritable(((LongObjectInspector) inspector).get(obj));
        case STRING:
            return new Text(((StringObjectInspector) inspector).getPrimitiveJavaObject(obj));
        case DATE:
            return ((DateObjectInspector) inspector).getPrimitiveWritableObject(obj);
        case TIMESTAMP:
            return ((TimestampObjectInspector) inspector).getPrimitiveWritableObject(obj);
        default:
            throw new SerDeException("Can't serialize primitive : " + inspector.getPrimitiveCategory());
    }
}
 

import org.apache.hadoop.hive.serde2.objectinspector.primitive.TimestampObjectInspector; //导入依赖的package包/类
@Override
public ObjectInspector initialize(ObjectInspector[] arguments) throws UDFArgumentException {
    dateOi = arguments[0];
    if (!(dateOi instanceof StringObjectInspector ||  dateOi instanceof TimestampObjectInspector)) {
        throw new IllegalArgumentException("Can only call this UDF on types 'string' and 'timestamp'. " +
                "Given " + dateOi.getTypeName());
    }

    hasSecondArg = arguments.length > 1;

    if (hasSecondArg) {
        ObjectInspector oi = arguments[1];
        if (oi instanceof WritableConstantStringObjectInspector) {
            constSecondArg = ((WritableConstantStringObjectInspector) oi).getWritableConstantValue().toString();
        } else if (oi instanceof StringObjectInspector) {
            formatOi = (StringObjectInspector) oi;
        } else {
            throw new IllegalArgumentException("Second argument must be of String type");
        }
    }
    return PrimitiveObjectInspectorFactory.javaLongObjectInspector;
}
 

import org.apache.hadoop.hive.serde2.objectinspector.primitive.TimestampObjectInspector; //导入依赖的package包/类
@Override
void write(Object obj) throws IOException {
  // Raw data size is:
  //   the number of bytes needed to store the milliseconds since the epoch
  //   (8 since it's a long)
  //   +
  //   the number of bytes needed to store the nanos field (4 since it's an int)
  super.write(obj, RawDatasizeConst.TIMESTAMP_SIZE);
  if (obj != null) {
    Timestamp val =
        ((TimestampObjectInspector) inspector).
            getPrimitiveJavaObject(obj);
    seconds.write((val.getTime() / MILLIS_PER_SECOND) - BASE_TIMESTAMP);
    nanos.write(formatNanos(val.getNanos()));
  }
}
 

import org.apache.hadoop.hive.serde2.objectinspector.primitive.TimestampObjectInspector; //导入依赖的package包/类
@Override
public void setSafeValue(ObjectInspector oi, Object hiveFieldValue, ValueVector outputVV, int outputIndex) {
  final TimestampWritable value = ((TimestampObjectInspector)oi).getPrimitiveWritableObject(hiveFieldValue);
  long seconds = value.getSeconds();
  long nanos = value.getNanos();
  long millis = seconds * 1000 + nanos/1000/1000;
  ((NullableTimeStampMilliVector) outputVV).getMutator().setSafe(outputIndex, millis);
}
 

import org.apache.hadoop.hive.serde2.objectinspector.primitive.TimestampObjectInspector; //导入依赖的package包/类
private static Timestamp getTimestamp(Object object, TimestampObjectInspector inspector)
{
    // handle broken ObjectInspectors
    if (object instanceof TimestampWritable) {
        return ((TimestampWritable) object).getTimestamp();
    }
    return inspector.getPrimitiveJavaObject(object);
}
 

import org.apache.hadoop.hive.serde2.objectinspector.primitive.TimestampObjectInspector; //导入依赖的package包/类
@Override
public Object evaluate(DeferredObject[] arguments) throws HiveException {
    if (dateOi instanceof StringObjectInspector) {
        String dateStr = ((StringObjectInspector) dateOi).getPrimitiveJavaObject(arguments[0].get());
        DateTimeFormatter dtf;
        if (hasSecondArg) {
            if (constSecondArg == null) {
                dtf = DateTimeFormat.forPattern(formatOi.getPrimitiveJavaObject(arguments[1].get()));
            } else {
                dtf = DateTimeFormat.forPattern(constSecondArg);
            }
        } else {
            dtf = ISODateTimeFormat.dateTimeParser().withOffsetParsed();
        }
        return dtf.parseDateTime(dateStr).getMillis();
    } else if (dateOi instanceof TimestampObjectInspector) {
        Timestamp ts = ((TimestampObjectInspector) dateOi).getPrimitiveJavaObject(arguments[0].get());
        if (hasSecondArg) {
            DateTime dt;
            if (constSecondArg == null) {
                dt = new DateTime(ts.getTime(), DateTimeZone.forID(
                        formatOi.getPrimitiveJavaObject(arguments[1].get())));
            } else {
                dt = new DateTime(ts.getTime(), DateTimeZone.forID(constSecondArg));
            }
            return dt.getMillis();
        } else {
            return ts.getTime();
        }
    }

    return null;
}
 

import org.apache.hadoop.hive.serde2.objectinspector.primitive.TimestampObjectInspector; //导入依赖的package包/类
@Test
public void testOneArgTimestampInput() throws HiveException {
    ToEpoch udf = new ToEpoch();

    TimestampObjectInspector soi = PrimitiveObjectInspectorFactory.javaTimestampObjectInspector;
    udf.initialize(new ObjectInspector[]{soi});

    Timestamp ts = new Timestamp(1397483853809L);

    long output = (Long) udf.evaluate(new GenericUDF.DeferredObject[]{new GenericUDF.DeferredJavaObject(ts)});
    Assert.assertEquals(1397483853809L, output);
}
 

import org.apache.hadoop.hive.serde2.objectinspector.primitive.TimestampObjectInspector; //导入依赖的package包/类
/**
 * Tests that after copying a lazy timestamp object, calling materialize on the original and the
 * copy doesn't advance the tree reader twice
 * @throws Exception
 */
@Test
public void TestCopyTimestamp() throws Exception {
  ReaderWriterProfiler.setProfilerOptions(null);
  OrcLazyTimestamp lazyTimestamp = new OrcLazyTimestamp(new LazyTimestampTreeReader(0, 0) {
    int nextCalls = 0;

    @Override
    public Object next(Object previous) throws IOException {
      if (nextCalls == 0) {
        return new TimestampWritable(new Timestamp(1));
      }

      throw new IOException("next should only be called once");
    }

    @Override
    protected boolean seekToRow(long currentRow) throws IOException {
      return true;
    }
  });

  TimestampObjectInspector timestampOI = (TimestampObjectInspector)
      OrcLazyObjectInspectorUtils.createLazyObjectInspector(TypeInfoFactory.timestampTypeInfo);

  OrcLazyTimestamp lazyTimestamp2 = (OrcLazyTimestamp) timestampOI.copyObject(lazyTimestamp);

  Assert.assertEquals(new Timestamp(1), ((TimestampWritable) lazyTimestamp.materialize()).getTimestamp());
  Assert.assertEquals(new Timestamp(1), ((TimestampWritable) lazyTimestamp2.materialize()).getTimestamp());
}
 

import org.apache.hadoop.hive.serde2.objectinspector.primitive.TimestampObjectInspector; //导入依赖的package包/类
@Override
public void setSafeValue(ObjectInspector oi, Object hiveFieldValue, ValueVector outputVV, int outputIndex) {
  final java.sql.Timestamp value = ((TimestampObjectInspector)oi).getPrimitiveJavaObject(hiveFieldValue);
  final DateTime ts = new DateTime(value.getTime()).withZoneRetainFields(DateTimeZone.UTC);
  ((NullableTimeStampVector) outputVV).getMutator().setSafe(outputIndex, ts.getMillis());
}
 

import org.apache.hadoop.hive.serde2.objectinspector.primitive.TimestampObjectInspector; //导入依赖的package包/类
@Override
public Object evaluate(DeferredObject[] arguments) throws HiveException {
  if (arguments[0] == null || arguments[0].get() == null) {
    return null;
  }

  Object input = arguments[0].get();
  switch(inputType) {
    case BOOLEAN:
      return ((BooleanObjectInspector)argumentOI).get(input) ? Boolean.TRUE : Boolean.FALSE;
    case BYTE:
      return new Byte(((ByteObjectInspector)argumentOI).get(input));
    case SHORT:
      return new Short(((ShortObjectInspector)argumentOI).get(input));
    case INT:
      return new Integer(((IntObjectInspector)argumentOI).get(input));
    case LONG:
      return new Long(((LongObjectInspector)argumentOI).get(input));
    case FLOAT:
      return new Float(((FloatObjectInspector)argumentOI).get(input));
    case DOUBLE:
      return new Double(((DoubleObjectInspector)argumentOI).get(input));
    case STRING:
      return PrimitiveObjectInspectorUtils.getString(input, (StringObjectInspector)argumentOI);
    case BINARY:
      return PrimitiveObjectInspectorUtils.getBinary(input, (BinaryObjectInspector) argumentOI).getBytes();
    case VARCHAR:
      return PrimitiveObjectInspectorUtils.getHiveVarchar(input, (HiveVarcharObjectInspector)argumentOI);
    case DATE:
      return PrimitiveObjectInspectorUtils.getDate(input, (DateObjectInspector) argumentOI);
    case TIMESTAMP:
      return PrimitiveObjectInspectorUtils.getTimestamp(input, (TimestampObjectInspector) argumentOI);
    case DECIMAL:
      // return type is a HiveVarchar
      HiveDecimal decimalValue =
          PrimitiveObjectInspectorUtils.getHiveDecimal(input, (HiveDecimalObjectInspector) argumentOI);
      return new HiveVarchar(decimalValue.toString(), HiveVarchar.MAX_VARCHAR_LENGTH);
  }

  throw new UnsupportedOperationException(String.format("Unexpected input type '%s' in Test UDF", inputType));
}
 

import org.apache.hadoop.hive.serde2.objectinspector.primitive.TimestampObjectInspector; //导入依赖的package包/类
@Override
public Object evaluate(DeferredObject[] arguments) throws HiveException {
  if (arguments[0] == null || arguments[0].get() == null) {
    return null;
  }

  Object input = arguments[0].get();
  switch(inputType) {
    case BOOLEAN:
      return ((BooleanObjectInspector)argumentOI).get(input) ? Boolean.TRUE : Boolean.FALSE;
    case BYTE:
      return new Byte(((ByteObjectInspector)argumentOI).get(input));
    case SHORT:
      return new Short(((ShortObjectInspector)argumentOI).get(input));
    case INT:
      return new Integer(((IntObjectInspector)argumentOI).get(input));
    case LONG:
      return new Long(((LongObjectInspector)argumentOI).get(input));
    case FLOAT:
      return new Float(((FloatObjectInspector)argumentOI).get(input));
    case DOUBLE:
      return new Double(((DoubleObjectInspector)argumentOI).get(input));
    case STRING:
      return PrimitiveObjectInspectorUtils.getString(input, (StringObjectInspector)argumentOI);
    case BINARY:
      return PrimitiveObjectInspectorUtils.getBinary(input, (BinaryObjectInspector) argumentOI).getBytes();
    case VARCHAR:
      if (outputType == PrimitiveCategory.CHAR) {
        HiveVarchar hiveVarchar = PrimitiveObjectInspectorUtils.getHiveVarchar(input, (HiveVarcharObjectInspector) argumentOI);
        return new HiveChar(hiveVarchar.getValue(), HiveChar.MAX_CHAR_LENGTH);
      } else {
        return PrimitiveObjectInspectorUtils.getHiveVarchar(input, (HiveVarcharObjectInspector)argumentOI);
      }
    case CHAR:
      return PrimitiveObjectInspectorUtils.getHiveChar(input, (HiveCharObjectInspector) argumentOI);
    case DATE:
      return PrimitiveObjectInspectorUtils.getDate(input, (DateObjectInspector) argumentOI);
    case TIMESTAMP:
      return PrimitiveObjectInspectorUtils.getTimestamp(input, (TimestampObjectInspector) argumentOI);
    case DECIMAL:
      // return type is a HiveVarchar
      HiveDecimal decimalValue =
          PrimitiveObjectInspectorUtils.getHiveDecimal(input, (HiveDecimalObjectInspector) argumentOI);
      return new HiveVarchar(decimalValue.toString(), HiveVarchar.MAX_VARCHAR_LENGTH);
  }

  throw new UnsupportedOperationException(String.format("Unexpected input type '%s' in Test UDF", inputType));
}
 

import org.apache.hadoop.hive.serde2.objectinspector.primitive.TimestampObjectInspector; //导入依赖的package包/类
private static void serializePrimitive(BlockBuilder builder, Object object, PrimitiveObjectInspector inspector)
{
    requireNonNull(builder, "parent builder is null");

    if (object == null) {
        builder.appendNull();
        return;
    }

    switch (inspector.getPrimitiveCategory()) {
        case BOOLEAN:
            BooleanType.BOOLEAN.writeBoolean(builder, ((BooleanObjectInspector) inspector).get(object));
            return;
        case BYTE:
            BigintType.BIGINT.writeLong(builder, ((ByteObjectInspector) inspector).get(object));
            return;
        case SHORT:
            BigintType.BIGINT.writeLong(builder, ((ShortObjectInspector) inspector).get(object));
            return;
        case INT:
            BigintType.BIGINT.writeLong(builder, ((IntObjectInspector) inspector).get(object));
            return;
        case LONG:
            BigintType.BIGINT.writeLong(builder, ((LongObjectInspector) inspector).get(object));
            return;
        case FLOAT:
            DoubleType.DOUBLE.writeDouble(builder, ((FloatObjectInspector) inspector).get(object));
            return;
        case DOUBLE:
            DoubleType.DOUBLE.writeDouble(builder, ((DoubleObjectInspector) inspector).get(object));
            return;
        case STRING:
            VarcharType.VARCHAR.writeSlice(builder, Slices.utf8Slice(((StringObjectInspector) inspector).getPrimitiveJavaObject(object)));
            return;
        case DATE:
            DateType.DATE.writeLong(builder, formatDateAsLong(object, (DateObjectInspector) inspector));
            return;
        case TIMESTAMP:
            TimestampType.TIMESTAMP.writeLong(builder, formatTimestampAsLong(object, (TimestampObjectInspector) inspector));
            return;
        case BINARY:
            VARBINARY.writeSlice(builder, Slices.wrappedBuffer(((BinaryObjectInspector) inspector).getPrimitiveJavaObject(object)));
            return;
    }
    throw new RuntimeException("Unknown primitive type: " + inspector.getPrimitiveCategory());
}
 

import org.apache.hadoop.hive.serde2.objectinspector.primitive.TimestampObjectInspector; //导入依赖的package包/类
private static long formatTimestampAsLong(Object object, TimestampObjectInspector inspector)
{
    Timestamp timestamp = getTimestamp(object, inspector);
    return timestamp.getTime();
}