Class<T> fromClass = conversion.getConvertedType(); switch (schema.getType()) { case RECORD: return conversion.toRecord(fromClass.cast(datum), schema, type); case ENUM: return conversion.toEnumSymbol(fromClass.cast(datum), schema, type); case ARRAY: return conversion.toArray(fromClass.cast(datum), schema, type); case MAP: return conversion.toMap(fromClass.cast(datum), schema, type); case FIXED: return conversion.toFixed(fromClass.cast(datum), schema, type); case STRING: return conversion.toCharSequence(fromClass.cast(datum), schema, type); case BYTES: return conversion.toBytes(fromClass.cast(datum), schema, type); case INT: return conversion.toInt(fromClass.cast(datum), schema, type); case LONG: return conversion.toLong(fromClass.cast(datum), schema, type); case FLOAT: return conversion.toFloat(fromClass.cast(datum), schema, type); case DOUBLE: return conversion.toDouble(fromClass.cast(datum), schema, type); case BOOLEAN: return conversion.toBoolean(fromClass.cast(datum), schema, type);
case RECORD: return conversion.fromRecord((IndexedRecord) datum, schema, type); case ENUM: return conversion.fromEnumSymbol((GenericEnumSymbol) datum, schema, type); case ARRAY: return conversion.fromArray((Collection) datum, schema, type); case MAP: return conversion.fromMap((Map<?, ?>) datum, schema, type); case FIXED: return conversion.fromFixed((GenericFixed) datum, schema, type); case STRING: return conversion.fromCharSequence((CharSequence) datum, schema, type); case BYTES: return conversion.fromBytes((ByteBuffer) datum, schema, type); case INT: return conversion.fromInt((Integer) datum, schema, type); case LONG: return conversion.fromLong((Long) datum, schema, type); case FLOAT: return conversion.fromFloat((Float) datum, schema, type); case DOUBLE: return conversion.fromDouble((Double) datum, schema, type); case BOOLEAN: return conversion.fromBoolean((Boolean) datum, schema, type);
/** * Registers the given conversion to be used when reading and writing with * this data model. * * @param conversion a logical type Conversion. */ public void addLogicalTypeConversion(Conversion<?> conversion) { conversions.put(conversion.getLogicalTypeName(), conversion); Class<?> type = conversion.getConvertedType(); if (conversionsByClass.containsKey(type)) { conversionsByClass.get(type).put( conversion.getLogicalTypeName(), conversion); } else { Map<String, Conversion<?>> conversions = new LinkedHashMap<String, Conversion<?>>(); conversions.put(conversion.getLogicalTypeName(), conversion); conversionsByClass.put(type, conversions); } }
public Collection<String> getUsedConversionClasses(Schema schema) { LinkedHashMap<String, Conversion<?>> classnameToConversion = new LinkedHashMap<>(); for (Conversion<?> conversion : specificData.getConversions()) { classnameToConversion.put(conversion.getConvertedType().getCanonicalName(), conversion); } Collection<String> result = new HashSet<>(); for (String className : getClassNamesOfPrimitiveFields(schema)) { if (classnameToConversion.containsKey(className)) { result.add(classnameToConversion.get(className).getClass().getCanonicalName()); } } return result; }
@Test public void testReadDecimalBytes() throws IOException { LogicalType decimal = LogicalTypes.decimal(9, 2); Schema bytesSchema = Schema.create(Schema.Type.BYTES); Schema decimalSchema = decimal.addToSchema(Schema.create(Schema.Type.BYTES)); BigDecimal d1 = new BigDecimal("-34.34"); BigDecimal d2 = new BigDecimal("117230.00"); List<BigDecimal> expected = Arrays.asList(d1, d2); Conversion<BigDecimal> conversion = new Conversions.DecimalConversion(); // use the conversion directly instead of relying on the write side ByteBuffer d1bytes = conversion.toBytes(d1, bytesSchema, decimal); ByteBuffer d2bytes = conversion.toBytes(d2, bytesSchema, decimal); File test = write(bytesSchema, d1bytes, d2bytes); Assert.assertEquals("Should convert bytes to BigDecimals", expected, read(GENERIC.createDatumReader(decimalSchema), test)); }
@Test public void testReadDecimalFixed() throws IOException { LogicalType decimal = LogicalTypes.decimal(9, 2); Schema fixedSchema = Schema.createFixed("aFixed", null, null, 4); Schema decimalSchema = decimal.addToSchema( Schema.createFixed("aFixed", null, null, 4)); BigDecimal d1 = new BigDecimal("-34.34"); BigDecimal d2 = new BigDecimal("117230.00"); List<BigDecimal> expected = Arrays.asList(d1, d2); Conversion<BigDecimal> conversion = new Conversions.DecimalConversion(); // use the conversion directly instead of relying on the write side GenericFixed d1fixed = conversion.toFixed(d1, fixedSchema, decimal); GenericFixed d2fixed = conversion.toFixed(d2, fixedSchema, decimal); File test = write(fixedSchema, d1fixed, d2fixed); Assert.assertEquals("Should convert fixed to BigDecimals", expected, read(GENERIC.createDatumReader(decimalSchema), test)); }
@Override public void add(Object value) { parent.add(conversion.fromBoolean( (Boolean) value, schema, logicalType)); } };
@Override public void add(Object value) { parent.add(conversion.fromDouble( (Double) value, schema, logicalType)); } };
@Override public void add(Object value) { parent.add(conversion.fromBytes( (ByteBuffer) value, schema, logicalType)); } };
@Override public void add(Object value) { parent.add(conversion.fromArray( (Collection<?>) value, schema, logicalType)); } };
@Override public void add(Object value) { parent.add(conversion.fromEnumSymbol( (GenericEnumSymbol) value, schema, logicalType)); } };
@Override public void add(Object value) { parent.add(conversion.fromCharSequence( (CharSequence) value, schema, logicalType)); } };
@Override public void add(Object value) { parent.add(conversion.fromFixed( (GenericData.Fixed) value, schema, logicalType)); } };
private String getConvertedLogicalType(Schema schema) { if (enableDecimalLogicalType || !(schema.getLogicalType() instanceof LogicalTypes.Decimal)) { Conversion<?> conversion = specificData .getConversionFor(schema.getLogicalType()); if (conversion != null) { return conversion.getConvertedType().getName(); } } return null; }
/** * Registers the given conversion to be used when reading and writing with * this data model. * * @param conversion a logical type Conversion. */ public void addLogicalTypeConversion(Conversion<?> conversion) { conversions.put(conversion.getLogicalTypeName(), conversion); Class<?> type = conversion.getConvertedType(); if (conversionsByClass.containsKey(type)) { conversionsByClass.get(type).put( conversion.getLogicalTypeName(), conversion); } else { Map<String, Conversion<?>> conversions = new LinkedHashMap<>(); conversions.put(conversion.getLogicalTypeName(), conversion); conversionsByClass.put(type, conversions); } }
@Test public void testWriteDecimalBytes() throws IOException { LogicalType decimal = LogicalTypes.decimal(9, 2); Schema bytesSchema = Schema.create(Schema.Type.BYTES); Schema decimalSchema = decimal.addToSchema(Schema.create(Schema.Type.BYTES)); BigDecimal d1 = new BigDecimal("-34.34"); BigDecimal d2 = new BigDecimal("117230.00"); Conversion<BigDecimal> conversion = new Conversions.DecimalConversion(); // use the conversion directly instead of relying on the write side ByteBuffer d1bytes = conversion.toBytes(d1, bytesSchema, decimal); ByteBuffer d2bytes = conversion.toBytes(d2, bytesSchema, decimal); List<ByteBuffer> expected = Arrays.asList(d1bytes, d2bytes); File test = write(GENERIC, decimalSchema, d1bytes, d2bytes); Assert.assertEquals("Should read BigDecimals as bytes", expected, read(GenericData.get().createDatumReader(bytesSchema), test)); }
@Test public void testWriteDecimalFixed() throws IOException { LogicalType decimal = LogicalTypes.decimal(9, 2); Schema fixedSchema = Schema.createFixed("aFixed", null, null, 4); Schema decimalSchema = decimal.addToSchema( Schema.createFixed("aFixed", null, null, 4)); BigDecimal d1 = new BigDecimal("-34.34"); BigDecimal d2 = new BigDecimal("117230.00"); Conversion<BigDecimal> conversion = new Conversions.DecimalConversion(); GenericFixed d1fixed = conversion.toFixed(d1, fixedSchema, decimal); GenericFixed d2fixed = conversion.toFixed(d2, fixedSchema, decimal); List<GenericFixed> expected = Arrays.asList(d1fixed, d2fixed); File test = write(GENERIC, decimalSchema, d1, d2); Assert.assertEquals("Should read BigDecimals as fixed", expected, read(GenericData.get().createDatumReader(fixedSchema), test)); }
@Override public void addBoolean(boolean value) { wrapped.add(conversion.fromBoolean(value, schema, logicalType)); } }
@Override public void addDouble(double value) { wrapped.add(conversion.fromDouble(value, schema, logicalType)); }
Class<T> fromClass = conversion.getConvertedType(); switch (schema.getType()) { case RECORD: return conversion.toRecord(fromClass.cast(datum), schema, type); case ENUM: return conversion.toEnumSymbol(fromClass.cast(datum), schema, type); case ARRAY: return conversion.toArray(fromClass.cast(datum), schema, type); case MAP: return conversion.toMap(fromClass.cast(datum), schema, type); case FIXED: return conversion.toFixed(fromClass.cast(datum), schema, type); case STRING: return conversion.toCharSequence(fromClass.cast(datum), schema, type); case BYTES: return conversion.toBytes(fromClass.cast(datum), schema, type); case INT: return conversion.toInt(fromClass.cast(datum), schema, type); case LONG: return conversion.toLong(fromClass.cast(datum), schema, type); case FLOAT: return conversion.toFloat(fromClass.cast(datum), schema, type); case DOUBLE: return conversion.toDouble(fromClass.cast(datum), schema, type); case BOOLEAN: return conversion.toBoolean(fromClass.cast(datum), schema, type);