Refine search
.toArray(String[]::new); ColumnPath columnPath = ColumnPath.get(path); PrimitiveTypeName primitiveTypeName = messageType.getType(columnPath.toArray()).asPrimitiveType().getPrimitiveTypeName(); ColumnChunkMetaData column = ColumnChunkMetaData.get( columnPath,
protected Type buildSchema() { return new PrimitiveType(this.repeated ? REPEATED : this.jsonSchema.optionalOrRequired(), this.outputType, this.jsonSchema.getColumnName()); }
public void add(int fieldIndex, Binary value) { switch (this.getType().getType(fieldIndex).asPrimitiveType().getPrimitiveTypeName()) { case BINARY: this.add(fieldIndex, new BinaryValue(value)); break; case INT96: this.add(fieldIndex, new Int96Value(value)); break; default: throw new UnsupportedOperationException( this.getType().asPrimitiveType().getName() + " not supported for Binary"); } }
public RichColumnDescriptor( ColumnDescriptor descriptor, PrimitiveType primitiveType) { super(descriptor.getPath(), primitiveType.getPrimitiveTypeName(), primitiveType.getTypeLength(), descriptor.getMaxRepetitionLevel(), descriptor.getMaxDefinitionLevel()); this.primitiveType = primitiveType; this.required = primitiveType.getRepetition() != OPTIONAL; }
public static Optional<Type> createDecimalType(RichColumnDescriptor descriptor) { if (descriptor.getPrimitiveType().getOriginalType() != DECIMAL) { return Optional.empty(); } return Optional.of(createDecimalType(descriptor.getPrimitiveType().getDecimalMetadata())); }
private void validate(PrimitiveTypeName p) { Type currentType = types.peek().asGroupType().getType(fields.peek()); int c = fieldValueCount.pop() + 1; fieldValueCount.push(c); if (DEBUG) LOG.debug("validate " + p + " for " + currentType.getName()); switch (currentType.getRepetition()) { case OPTIONAL: case REQUIRED: if (c > 1) { throw new InvalidRecordException("repeated value when the type is not repeated in " + currentType); } break; case REPEATED: break; default: throw new InvalidRecordException("unknown repetition " + currentType.getRepetition() + " in " + currentType); } if (!currentType.isPrimitive() || currentType.asPrimitiveType().getPrimitiveTypeName() != p) { throw new InvalidRecordException("expected type " + currentType + " but got "+ p); } }
if (parquetType.isPrimitive()) { final PrimitiveType.PrimitiveTypeName parquetPrimitiveTypeName = parquetType.asPrimitiveType() .getPrimitiveTypeName(); final OriginalType originalType = parquetType.getOriginalType(); if (originalType == OriginalType.DECIMAL) { final DecimalMetadata decimalMetadata = parquetType.asPrimitiveType().getDecimalMetadata(); return field.append("DECIMAL(").append(decimalMetadata.getPrecision()).append(" , ") .append(decimalMetadata.getScale()).append(")").toString(); if (!keyType.isPrimitive() || !keyType.asPrimitiveType().getPrimitiveTypeName() .equals(PrimitiveType.PrimitiveTypeName.BINARY) || !keyType.getOriginalType().equals(OriginalType.UTF8)) {
private Column convertPrimitiveField(final Type fieldType) { final String fieldName = fieldType.getName(); final PrimitiveTypeName parquetPrimitiveTypeName = fieldType.asPrimitiveType().getPrimitiveTypeName(); final OriginalType originalType = fieldType.getOriginalType(); return parquetPrimitiveTypeName.convert( new PrimitiveType.PrimitiveTypeNameConverter<Column, RuntimeException>() {
private void writeValue(Type type, FieldSchema pigType, Tuple t, int i) { try { if (type.isPrimitive()) { switch (type.asPrimitiveType().getPrimitiveTypeName()) { break; default: throw new UnsupportedOperationException(type.asPrimitiveType().getPrimitiveTypeName().name());
public ColumnDescriptor getColumnDescription(String[] path) { int maxRep = getMaxRepetitionLevel(path); int maxDef = getMaxDefinitionLevel(path); PrimitiveType type = getType(path).asPrimitiveType(); return new ColumnDescriptor(path, type.getPrimitiveTypeName(), type.getTypeLength(), maxRep, maxDef); }
/** * {@inheritDoc} */ @Override protected boolean typeEquals(Type other) { if (other.isPrimitive()) { PrimitiveType primitiveType = other.asPrimitiveType(); return getRepetition() == primitiveType.getRepetition() && getPrimitiveTypeName().equals(primitiveType.getPrimitiveTypeName()) && getName().equals(primitiveType.getName()); } else { return false; } }
@Override protected Type union(Type toMerge, boolean strict) { if (!toMerge.isPrimitive() || (strict && !primitive.equals(toMerge.asPrimitiveType().getPrimitiveTypeName()))) { throw new IncompatibleSchemaModificationException("can not merge type " + toMerge + " into " + this); } Types.PrimitiveBuilder<PrimitiveType> builder = Types.primitive( primitive, toMerge.getRepetition()); if (PrimitiveTypeName.FIXED_LEN_BYTE_ARRAY == primitive) { builder.length(length); } return builder.named(getName()); } }
private boolean isCompatible(Type sourceType, PropertyDescriptor target) { ParquetValueDriver driver = ParquetValueDrivers.of( target.getTypeInfo(), target.getValueClass()); Type targetType = driver.getType(target.getFieldName()); if (sourceType.getOriginalType() != null) { if (sourceType.getOriginalType() == targetType.getOriginalType()) { return true; } } if (sourceType.isPrimitive()) { if (targetType.isPrimitive() == false) { return false; } return sourceType.asPrimitiveType().getPrimitiveTypeName() == targetType.asPrimitiveType().getPrimitiveTypeName(); } return false; }
int i = 0; for (Type field : parquetSchema.getFields()) { if (field.isPrimitive() && field.isRepetition(Repetition.OPTIONAL)) { PrimitiveType primitiveType = field.asPrimitiveType(); switch (primitiveType.getPrimitiveTypeName()) { case INT32: currentTuple.set(i, I32_ZERO);
/** * {@inheritDoc} */ @Override protected boolean equals(Type other) { if (!other.isPrimitive()) { return false; } PrimitiveType otherPrimitive = other.asPrimitiveType(); return super.equals(other) && primitive == otherPrimitive.getPrimitiveTypeName() && length == otherPrimitive.length && eqOrBothNull(decimalMeta, otherPrimitive.decimalMeta); }
@Override public void visit(PrimitiveType primitiveType) { if (!currentRequestedType.isPrimitive() || (this.strictTypeChecking && currentRequestedType.asPrimitiveType().getPrimitiveTypeName() != primitiveType.getPrimitiveTypeName())) { incompatibleSchema(primitiveType, currentRequestedType); } PrimitiveColumnIO newIO = new PrimitiveColumnIO(primitiveType, current, currentRequestedIndex, leaves.size()); current.add(newIO); leaves.add(newIO); }
private FieldSchema getSimpleFieldSchema(final String fieldName, Type parquetType) throws FrontendException { final PrimitiveTypeName parquetPrimitiveTypeName = parquetType.asPrimitiveType().getPrimitiveTypeName(); final OriginalType originalType = parquetType.getOriginalType(); return parquetPrimitiveTypeName.convert( new PrimitiveTypeNameConverter<Schema.FieldSchema, FrontendException>() {
@Override public void visit(PrimitiveType primitiveType) { SchemaElement element = new SchemaElement(primitiveType.getName()); element.setRepetition_type(toParquetRepetition(primitiveType.getRepetition())); element.setType(getType(primitiveType.getPrimitiveTypeName())); if (primitiveType.getOriginalType() != null) { element.setConverted_type(getConvertedType(primitiveType.getOriginalType())); } if (primitiveType.getDecimalMetadata() != null) { element.setPrecision(primitiveType.getDecimalMetadata().getPrecision()); element.setScale(primitiveType.getDecimalMetadata().getScale()); } if (primitiveType.getTypeLength() > 0) { element.setType_length(primitiveType.getTypeLength()); } result.add(element); }
private static void showDetails(PrettyPrintWriter out, PrimitiveType type, int depth, MessageType container, List<String> cpath) { String name = Strings.repeat(".", depth) + type.getName(); OriginalType otype = type.getOriginalType(); Repetition rep = type.getRepetition(); PrimitiveTypeName ptype = type.getPrimitiveTypeName(); out.format("%s: %s %s", name, rep, ptype); if (otype != null) out.format(" O:%s", otype); if (container != null) { cpath.add(type.getName()); String[] paths = cpath.toArray(new String[cpath.size()]); cpath.remove(cpath.size() - 1); ColumnDescriptor desc = container.getColumnDescription(paths); int defl = desc.getMaxDefinitionLevel(); int repl = desc.getMaxRepetitionLevel(); out.format(" R:%d D:%d", repl, defl); } out.println(); }
public static GroupType mapType(Repetition repetition, String alias, Type valueType) { if (!valueType.getName().equals("value")) { throw new RuntimeException(valueType.getName() + " should be value"); } return listWrapper( repetition, alias, MAP, new GroupType( Repetition.REPEATED, "map", MAP_KEY_VALUE, new PrimitiveType(Repetition.REQUIRED, PrimitiveTypeName.BINARY, "key"), valueType) ); }