Java BooleanObjectInspector类代码示例

import org.apache.hadoop.hive.serde2.objectinspector.primitive.BooleanObjectInspector; //导入依赖的package包/类
public static IHivePrimitiveConverter get( final ObjectInspector objectInspector ){

    switch( objectInspector.getCategory() ){
      case PRIMITIVE:
        PrimitiveObjectInspector primitiveInspector = (PrimitiveObjectInspector)objectInspector;
        switch( primitiveInspector.getPrimitiveCategory() ){
          case BINARY:
            return new HiveBytesPrimitiveConverter( (BinaryObjectInspector)objectInspector );
          case BOOLEAN:
            return new HiveBooleanPrimitiveConverter( (BooleanObjectInspector)objectInspector );
          case BYTE:
            return new HiveBytePrimitiveConverter( (ByteObjectInspector)objectInspector );
          case DOUBLE:
            return new HiveDoublePrimitiveConverter( (DoubleObjectInspector)objectInspector );
          case FLOAT:
            return new HiveFloatPrimitiveConverter( (FloatObjectInspector)objectInspector );
          case INT:
            return new HiveIntegerPrimitiveConverter( (IntObjectInspector)objectInspector );
          case LONG:
            return new HiveLongPrimitiveConverter( (LongObjectInspector)objectInspector );
          case SHORT:
            return new HiveShortPrimitiveConverter( (ShortObjectInspector)objectInspector );
          case STRING:
            return new HiveStringPrimitiveConverter( (StringObjectInspector)objectInspector );
          case DATE:
          case TIMESTAMP:
          case VOID:
          case UNKNOWN:
          default:
            return new HiveDefaultPrimitiveConverter();
        }
      default :
        return new HiveDefaultPrimitiveConverter();
    }
  }
 

import org.apache.hadoop.hive.serde2.objectinspector.primitive.BooleanObjectInspector; //导入依赖的package包/类
private static int asIntLabel(@Nonnull final Object o,
        @Nonnull final BooleanObjectInspector booleanOI) {
    if (booleanOI.get(o)) {
        return 1;
    } else {
        return 0;
    }
}
 

import org.apache.hadoop.hive.serde2.objectinspector.primitive.BooleanObjectInspector; //导入依赖的package包/类
@Nonnull
public static BooleanObjectInspector asBooleanOI(@Nonnull final ObjectInspector argOI)
        throws UDFArgumentException {
    if (!BOOLEAN_TYPE_NAME.equals(argOI.getTypeName())) {
        throw new UDFArgumentException("Argument type must be Boolean: " + argOI.getTypeName());
    }
    return (BooleanObjectInspector) argOI;
}
 

import org.apache.hadoop.hive.serde2.objectinspector.primitive.BooleanObjectInspector; //导入依赖的package包/类
private Writable createPrimitive(final Object obj, final PrimitiveObjectInspector inspector)
    throws SerDeException {
  if (obj == null) {
    return null;
  }
  switch (inspector.getPrimitiveCategory()) {
  case VOID:
    return null;
  case BOOLEAN:
    return new BooleanWritable(((BooleanObjectInspector) inspector).get(obj) ? Boolean.TRUE : Boolean.FALSE);
  case BYTE:
    return new ByteWritable((byte) ((ByteObjectInspector) inspector).get(obj));
  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 SHORT:
    return new ShortWritable((short) ((ShortObjectInspector) inspector).get(obj));
  case STRING:
    return new BinaryWritable(Binary.fromString(((StringObjectInspector) inspector).getPrimitiveJavaObject(obj)));
  default:
    throw new SerDeException("Unknown primitive : " + inspector.getPrimitiveCategory());
  }
}
 

import org.apache.hadoop.hive.serde2.objectinspector.primitive.BooleanObjectInspector; //导入依赖的package包/类
@Override
void write(Object obj) throws IOException {
  super.write(obj, RawDatasizeConst.BOOLEAN_SIZE);
  if (obj != null) {
    boolean val = ((BooleanObjectInspector) inspector).get(obj);
    indexStatistics.updateBoolean(val);
    writer.write(val ? 1 : 0);
  }
}
 

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

    @Override
    public Object next(Object previous) throws IOException {
      if (nextCalls == 0) {
        return new BooleanWritable(true);
      }

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

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

  BooleanObjectInspector booleanOI = (BooleanObjectInspector)
      OrcLazyObjectInspectorUtils.createLazyObjectInspector(TypeInfoFactory.booleanTypeInfo);

  OrcLazyBoolean lazyBoolean2 = (OrcLazyBoolean) booleanOI.copyObject(lazyBoolean);

  Assert.assertEquals(true, ((BooleanWritable) lazyBoolean.materialize()).get());
  Assert.assertEquals(true, ((BooleanWritable) lazyBoolean2.materialize()).get());
}
 

import org.apache.hadoop.hive.serde2.objectinspector.primitive.BooleanObjectInspector; //导入依赖的package包/类
@Override
public void setSafeValue(ObjectInspector oi, Object hiveFieldValue, ValueVector outputVV, int outputIndex) {
  final boolean value = (boolean) ((BooleanObjectInspector)oi).getPrimitiveJavaObject(hiveFieldValue);
  ((NullableBitVector) outputVV).getMutator().setSafe(outputIndex, value ? 1 : 0);
}
 

import org.apache.hadoop.hive.serde2.objectinspector.primitive.BooleanObjectInspector; //导入依赖的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.BooleanObjectInspector; //导入依赖的package包/类
public HiveBooleanPrimitiveConverter( final BooleanObjectInspector inspector ){
  this.inspector = inspector;
}
 

import org.apache.hadoop.hive.serde2.objectinspector.primitive.BooleanObjectInspector; //导入依赖的package包/类
public OrcBooleanPrimitiveConverter( final BooleanObjectInspector inspector ){
  this.inspector = inspector;
}
 

import org.apache.hadoop.hive.serde2.objectinspector.primitive.BooleanObjectInspector; //导入依赖的package包/类
public Object asBoolean() {
	return ((BooleanObjectInspector) oi).get(obj);
}
 

import org.apache.hadoop.hive.serde2.objectinspector.primitive.BooleanObjectInspector; //导入依赖的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.BooleanObjectInspector; //导入依赖的package包/类
public Boolean getBoolean(Object data, ObjectInspector objectInspector) {
          return ((BooleanObjectInspector) objectInspector).get(data);
}
 

import org.apache.hadoop.hive.serde2.objectinspector.primitive.BooleanObjectInspector; //导入依赖的package包/类
@Override
public void iterate(@SuppressWarnings("deprecation") AggregationBuffer agg,
        Object[] parameters) throws HiveException {
    FMeasureAggregationBuffer myAggr = (FMeasureAggregationBuffer) agg;
    boolean isList = HiveUtils.isListOI(actualOI) && HiveUtils.isListOI(predictedOI);

    final List<?> actual;
    final List<?> predicted;

    if (isList) {// array case
        if ("binary".equals(average)) {
            throw new UDFArgumentException(
                "\"-average binary\" is not supported when `predict` is array");
        }
        actual = ((ListObjectInspector) actualOI).getList(parameters[0]);
        predicted = ((ListObjectInspector) predictedOI).getList(parameters[1]);
    } else {//binary case
        if (HiveUtils.isBooleanOI(actualOI)) { // boolean case
            actual = Arrays.asList(asIntLabel(parameters[0],
                (BooleanObjectInspector) actualOI));
            predicted = Arrays.asList(asIntLabel(parameters[1],
                (BooleanObjectInspector) predictedOI));
        } else { // int case
            final int actualLabel = asIntLabel(parameters[0], (IntObjectInspector) actualOI);
            if (actualLabel == 0 && "binary".equals(average)) {
                actual = Collections.emptyList();
            } else {
                actual = Arrays.asList(actualLabel);
            }

            final int predictedLabel = asIntLabel(parameters[1],
                (IntObjectInspector) predictedOI);
            if (predictedLabel == 0 && "binary".equals(average)) {
                predicted = Collections.emptyList();
            } else {
                predicted = Arrays.asList(predictedLabel);
            }
        }
    }
    myAggr.iterate(actual, predicted);
}
 

import org.apache.hadoop.hive.serde2.objectinspector.primitive.BooleanObjectInspector; //导入依赖的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());
}