Java TypeDescription.getCategory方法代码示例

import org.apache.orc.TypeDescription; //导入方法依赖的package包/类
public static void processRow(JSONWriter writer, VectorizedRowBatch batch,
        TypeDescription schema, int row) throws JSONException {
    if (schema.getCategory() == TypeDescription.Category.STRUCT) {
        List<TypeDescription> fieldTypes = schema.getChildren();
        List<String> fieldNames = schema.getFieldNames();
        writer.object();
        for (int c = 0; c < batch.cols.length; ++c) {
            writer.key(fieldNames.get(c));
            setValue(writer, batch.cols[c], fieldTypes.get(c), row);
        }
        writer.endObject();
    } else {
        setValue(writer, batch.cols[0], schema, row);
    }
}
 

import org.apache.orc.TypeDescription; //导入方法依赖的package包/类
public static JsonConverter createConverter(TypeDescription schema) {
    switch (schema.getCategory()) {
    case BYTE:
    case SHORT:
    case INT:
    case LONG:
        return new LongColumnConverter();
    case FLOAT:
    case DOUBLE:
        return new DoubleColumnConverter();
    case CHAR:
    case VARCHAR:
    case STRING:
        return new StringColumnConverter();
    case DECIMAL:
        return new DecimalColumnConverter();
    case TIMESTAMP:
        return new TimestampColumnConverter();
    case BINARY:
        return new BinaryColumnConverter();
    case BOOLEAN:
        return new BooleanColumnConverter();
    case STRUCT:
        return new StructColumnConverter(schema);
    case LIST:
        return new ListColumnConverter(schema);
    default:
        throw new IllegalArgumentException("Unhandled type " + schema);
    }
}
 

import org.apache.orc.TypeDescription; //导入方法依赖的package包/类
private static TreeWriter createTreeWriter(TypeDescription schema, StreamFactory streamFactory,
    boolean nullable) throws IOException {
  switch (schema.getCategory()) {
    case BOOLEAN:
      return new BooleanTreeWriter(streamFactory.getNextColumnId(), schema, streamFactory,
          nullable);
    case BYTE:
      return new ByteTreeWriter(streamFactory.getNextColumnId(), schema, streamFactory, nullable);
    case SHORT:
    case INT:
    case LONG:
      return new IntegerTreeWriter(streamFactory.getNextColumnId(), schema, streamFactory,
          nullable);
    case FLOAT:
      return new FloatTreeWriter(streamFactory.getNextColumnId(), schema, streamFactory,
          nullable);
    case DOUBLE:
      return new DoubleTreeWriter(streamFactory.getNextColumnId(), schema, streamFactory,
          nullable);
    case STRING:
      return new StringTreeWriter(streamFactory.getNextColumnId(), schema, streamFactory,
          nullable);
    case CHAR:
      return new CharTreeWriter(streamFactory.getNextColumnId(), schema, streamFactory, nullable);
    case VARCHAR:
      return new VarcharTreeWriter(streamFactory.getNextColumnId(), schema, streamFactory,
          nullable);
    case BINARY:
      return new BinaryTreeWriter(streamFactory.getNextColumnId(), schema, streamFactory,
          nullable);
    case TIMESTAMP:
      return new TimestampTreeWriter(streamFactory.getNextColumnId(), schema, streamFactory,
          nullable);
    case DATE:
      return new DateTreeWriter(streamFactory.getNextColumnId(), schema, streamFactory, nullable);
    case DECIMAL:
      return new DecimalTreeWriter(streamFactory.getNextColumnId(), schema, streamFactory,
          nullable);
    case STRUCT:
      return new StructTreeWriter(streamFactory.getNextColumnId(), schema, streamFactory,
          nullable);
    case MAP:
      return new MapTreeWriter(streamFactory.getNextColumnId(), schema, streamFactory, nullable);
    case LIST:
      return new ListTreeWriter(streamFactory.getNextColumnId(), schema, streamFactory, nullable);
    case UNION:
      return new UnionTreeWriter(streamFactory.getNextColumnId(), schema, streamFactory,
          nullable);
    default:
      throw new IllegalArgumentException("Bad category: " + schema.getCategory());
  }
}
 

import org.apache.orc.TypeDescription; //导入方法依赖的package包/类
private long getRawDataSize(TreeWriter child, TypeDescription schema) {
  long total = 0;
  long numVals = child.fileStatistics.getNumberOfValues();
  switch (schema.getCategory()) {
    case BOOLEAN:
    case BYTE:
    case SHORT:
    case INT:
    case FLOAT:
      return numVals * JavaDataModel.get().primitive1();
    case LONG:
    case DOUBLE:
      return numVals * JavaDataModel.get().primitive2();
    case STRING:
    case VARCHAR:
    case CHAR:
      // ORC strings are converted to java Strings. so use JavaDataModel to
      // compute the overall size of strings
      StringColumnStatistics scs = (StringColumnStatistics) child.fileStatistics;
      numVals = numVals == 0 ? 1 : numVals;
      int avgStringLen = (int) (scs.getSum() / numVals);
      return numVals * JavaDataModel.get().lengthForStringOfLength(avgStringLen);
    case DECIMAL:
      return numVals * JavaDataModel.get().lengthOfDecimal();
    case DATE:
      return numVals * JavaDataModel.get().lengthOfDate();
    case BINARY:
      // get total length of binary blob
      BinaryColumnStatistics bcs = (BinaryColumnStatistics) child.fileStatistics;
      return bcs.getSum();
    case TIMESTAMP:
      return numVals * JavaDataModel.get().lengthOfTimestamp();
    case LIST:
    case MAP:
    case UNION:
    case STRUCT: {
      TreeWriter[] childWriters = child.getChildrenWriters();
      List<TypeDescription> childTypes = schema.getChildren();
      for (int i = 0; i < childWriters.length; ++i) {
        total += getRawDataSize(childWriters[i], childTypes.get(i));
      }
      break;
    }
    default:
      LOG.debug("Unknown object inspector category.");
      break;
  }
  return total;
}
 

import org.apache.orc.TypeDescription; //导入方法依赖的package包/类
/**
 * Converts an ORC schema to a Flink TypeInformation.
 *
 * @param schema The ORC schema.
 * @return The TypeInformation that corresponds to the ORC schema.
 */
static TypeInformation schemaToTypeInfo(TypeDescription schema) {
	switch (schema.getCategory()) {
		case BOOLEAN:
			return BasicTypeInfo.BOOLEAN_TYPE_INFO;
		case BYTE:
			return BasicTypeInfo.BYTE_TYPE_INFO;
		case SHORT:
			return BasicTypeInfo.SHORT_TYPE_INFO;
		case INT:
			return BasicTypeInfo.INT_TYPE_INFO;
		case LONG:
			return BasicTypeInfo.LONG_TYPE_INFO;
		case FLOAT:
			return BasicTypeInfo.FLOAT_TYPE_INFO;
		case DOUBLE:
			return BasicTypeInfo.DOUBLE_TYPE_INFO;
		case DECIMAL:
			return BasicTypeInfo.BIG_DEC_TYPE_INFO;
		case STRING:
		case CHAR:
		case VARCHAR:
			return BasicTypeInfo.STRING_TYPE_INFO;
		case DATE:
			return SqlTimeTypeInfo.DATE;
		case TIMESTAMP:
			return SqlTimeTypeInfo.TIMESTAMP;
		case BINARY:
			return PrimitiveArrayTypeInfo.BYTE_PRIMITIVE_ARRAY_TYPE_INFO;
		case STRUCT:
			List<TypeDescription> fieldSchemas = schema.getChildren();
			TypeInformation[] fieldTypes = new TypeInformation[fieldSchemas.size()];
			for (int i = 0; i < fieldSchemas.size(); i++) {
				fieldTypes[i] = schemaToTypeInfo(fieldSchemas.get(i));
			}
			String[] fieldNames = schema.getFieldNames().toArray(new String[]{});
			return new RowTypeInfo(fieldTypes, fieldNames);
		case LIST:
			TypeDescription elementSchema = schema.getChildren().get(0);
			TypeInformation<?> elementType = schemaToTypeInfo(elementSchema);
			// arrays of primitive types are handled as object arrays to support null values
			return ObjectArrayTypeInfo.getInfoFor(elementType);
		case MAP:
			TypeDescription keySchema = schema.getChildren().get(0);
			TypeDescription valSchema = schema.getChildren().get(1);
			TypeInformation<?> keyType = schemaToTypeInfo(keySchema);
			TypeInformation<?> valType = schemaToTypeInfo(valSchema);
			return new MapTypeInfo<>(keyType, valType);
		case UNION:
			throw new UnsupportedOperationException("UNION type is not supported yet.");
		default:
			throw new IllegalArgumentException("Unknown type " + schema);
	}
}
 

import org.apache.orc.TypeDescription; //导入方法依赖的package包/类
static void setValue(JSONWriter writer, ColumnVector vector,
        TypeDescription schema, int row) throws JSONException {
    if (vector.isRepeating) {
        row = 0;
    }
    if (vector.noNulls || !vector.isNull[row]) {
        switch (schema.getCategory()) {
        case BOOLEAN:
            writer.value(((LongColumnVector) vector).vector[row] != 0);
            break;
        case BYTE:
        case SHORT:
        case INT:
        case LONG:
            writer.value(((LongColumnVector) vector).vector[row]);
            break;
        case FLOAT:
        case DOUBLE:
            writer.value(((DoubleColumnVector) vector).vector[row]);
            break;
        case STRING:
        case CHAR:
        case VARCHAR:
            writer.value(((BytesColumnVector) vector).toString(row));
            break;
        case DECIMAL:
            writer.value(((DecimalColumnVector) vector).vector[row]
                    .toString());
            break;
        case DATE:
            writer.value(new DateWritable(
                    (int) ((LongColumnVector) vector).vector[row])
                    .toString());
            break;
        case TIMESTAMP:
            writer.value(((TimestampColumnVector) vector)
                    .asScratchTimestamp(row).toString());
            break;
        case LIST:
            setList(writer, (ListColumnVector) vector, schema, row);
            break;
        case STRUCT:
            setStruct(writer, (StructColumnVector) vector, schema, row);
            break;
        case UNION:
            // printUnion(writer, (UnionColumnVector) vector, schema, row);
            break;
        case BINARY:
            // printBinary(writer, (BytesColumnVector) vector, row);
            break;
        case MAP:
            // printMap(writer, (MapColumnVector) vector, schema, row);
            break;
        default:
            throw new IllegalArgumentException("Unknown type "
                    + schema.toString());
        }
    } else {
        writer.value(null);
    }
}