@Override public void writeRequest(Schema schema, Object request, Encoder out) throws IOException { new GenericDatumWriter<>(schema, data).write(request, out); }
@Override public Void call() throws Exception { w.write(a, e); return null; } });
@Override public Void call() throws Exception { w.write(m, e); return null; } });
public static String jsonFromGenericRecord(GenericRecord record) { ByteArrayOutputStream out = new ByteArrayOutputStream(); GenericDatumWriter<GenericRecord> writer = new GenericDatumWriter<>(DefaultTopicSchema.MESSAGE_V0); try { Encoder encoder = new JsonEncoder(DefaultTopicSchema.MESSAGE_V0, out); writer.write(record, encoder); encoder.flush(); } catch (IOException e) { LOG.error("Unable to serialize avro record due to error " + e); } return out.toString(); }
public byte[] serialize(GenericRecord record) throws IOException { this.outputStream.reset(); this.writer.write(record, this.encoder); this.encoder.flush(); return this.outputStream.toByteArray(); } }
@Override public Iterable<byte[]> convertRecord(String outputSchema, GenericRecord inputRecord, WorkUnitState workUnit) throws DataConversionException { try { ByteArrayOutputStream bytesOut = new ByteArrayOutputStream(); BinaryEncoder encoder = EncoderFactory.get().binaryEncoder(bytesOut, encoderCache.get()); encoderCache.set(encoder); writer.write(inputRecord, encoder); encoder.flush(); return Collections.singleton(bytesOut.toByteArray()); } catch (IOException e) { throw new DataConversionException("Error serializing record", e); } } }
@Override public synchronized byte[] encode(GenericRecord message) { checkArgument(message instanceof GenericAvroRecord); GenericAvroRecord gar = (GenericAvroRecord) message; try { datumWriter.write(gar.getAvroRecord(), this.encoder); this.encoder.flush(); return this.byteArrayOutputStream.toByteArray(); } catch (Exception e) { throw new SchemaSerializationException(e); } finally { this.byteArrayOutputStream.reset(); } }
@Override void writeInternal(Encoder e) throws IOException { GenericDatumWriter<Object> writer = new GenericDatumWriter<>(schema); for (int i = 0; i < sourceData.length; i++) { GenericRecord rec = sourceData[i]; writer.write(rec, e); } } @Override
@Override void writeInternal(Encoder e) throws IOException { GenericDatumWriter<Object> writer = new GenericDatumWriter<>(writeSchema); for (int i = 0; i < sourceData.length; i++) { writer.write(sourceData[i], e); } }
/** Called to write a single field of a record. May be overridden for more * efficient or alternate implementations.*/ protected void writeField(Object datum, Field f, Encoder out, Object state) throws IOException { Object value = data.getField(datum, f.name(), f.pos(), state); try { write(f.schema(), value, out); } catch (NullPointerException e) { throw npe(e, " in field " + f.name()); } }
/** Called to write a single field of a record. May be overridden for more * efficient or alternate implementations.*/ protected void writeField(Object datum, Field f, Encoder out, Object state) throws IOException { Object value = data.getField(datum, f.name(), f.pos(), state); try { write(f.schema(), value, out); } catch (NullPointerException e) { throw npe(e, " in field " + f.name()); } }
@Override public void write(DataOutput out) throws IOException { // Write schema since we need it to pull the data out. (see point #1 above) String schemaString = record.getSchema().toString(false); out.writeUTF(schemaString); schemaString = fileSchema.toString(false); out.writeUTF(schemaString); recordReaderID.write(out); // Write record to byte buffer GenericDatumWriter<GenericRecord> gdw = new GenericDatumWriter<GenericRecord>(); BinaryEncoder be = EncoderFactory.get().directBinaryEncoder((DataOutputStream)out, null); gdw.setSchema(record.getSchema()); gdw.write(record, be); }
@Override public void write(Kryo kryo, Output output, GenericContainer record) { String fingerPrint = this.getFingerprint(record.getSchema()); output.writeString(fingerPrint); GenericDatumWriter<GenericContainer> writer = new GenericDatumWriter<>(record.getSchema()); BinaryEncoder encoder = EncoderFactory .get() .directBinaryEncoder(output, null); try { writer.write(record, encoder); } catch (IOException e) { throw new RuntimeException(e); } }
@Override public byte[] getBytes(AvroGenericRecordWritable writable) { GenericRecord record = writable.getRecord(); byte[] valueBytes = null; try (ByteArrayOutputStream out = new ByteArrayOutputStream()) { BinaryEncoder be = EncoderFactory.get().directBinaryEncoder(out, null); gdw.setSchema(record.getSchema()); gdw.write(record, be); out.flush(); valueBytes = out.toByteArray(); } catch (IOException e) { Throwables.propagate(new SerDeException(e)); } return valueBytes; }
public byte[] toBytes(Object object) { ByteArrayOutputStream output = new ByteArrayOutputStream(); Encoder encoder = new BinaryEncoder(output); GenericDatumWriter<Object> datumWriter = null; try { datumWriter = new GenericDatumWriter<Object>(typeDef); datumWriter.write(object, encoder); encoder.flush(); } catch(IOException e) { throw new SerializationException(e); } finally { SerializationUtils.close(output); } return output.toByteArray(); }
/** * Writes given record using specified schema. * @param record record to serialize * @param schema schema to use for serialization * @return serialized record */ public static byte[] writeRecord(GenericRecord record, Schema schema) throws IOException { ByteArrayOutputStream stream = new ByteArrayOutputStream(); BinaryEncoder encoder = EncoderFactory.get().binaryEncoder(stream, null); new GenericDatumWriter<>(schema).write(record, encoder); encoder.flush(); return stream.toByteArray(); } }
private void writeObject(Schema schema, GenericRecord datum) throws Exception { BinaryEncoder encoder = EncoderFactory.get().binaryEncoder(new ByteArrayOutputStream(), null); GenericDatumWriter<GenericData.Record> writer = new GenericDatumWriter<>(schema); writer.write(schema, datum, encoder); }
public GenericRecord reencode(GenericRecord r) throws AvroSerdeException { baos.reset(); BinaryEncoder be = EncoderFactory.get().directBinaryEncoder(baos, null); gdw.setSchema(r.getSchema()); try { gdw.write(r, be); ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); binaryDecoder = DecoderFactory.defaultFactory().createBinaryDecoder(bais, binaryDecoder); return gdr.read(r, binaryDecoder); } catch (IOException e) { throw new AvroSerdeException("Exception trying to re-encode record to new schema", e); } } }
@Test public void testJsonEncoderNewlineDelimited() throws IOException { OutputStream out = new ByteArrayOutputStream(); Schema ints = Schema.create(Type.INT); Encoder e = factory.jsonEncoder(ints, out); String separator = System.getProperty("line.separator"); GenericDatumWriter<Integer> writer = new GenericDatumWriter<>(ints); writer.write(1, e); writer.write(2, e); e.flush(); Assert.assertEquals("1"+separator+"2", out.toString()); }
private void testWithBuffer(ByteBuffer buffer) throws IOException { assertThat(asList(buffer.position(), buffer.remaining()), is(asList(0, EXAMPLE_DATA_SIZE))); ByteArrayOutputStream output = new ByteArrayOutputStream(EXAMPLE_DATA_SIZE * 2); EncoderFactory encoderFactory = new EncoderFactory(); encoderFactory.configureBufferSize(ENCODER_BUFFER_SIZE); Encoder encoder = encoderFactory.binaryEncoder(output, null); new GenericDatumWriter<ByteBuffer>(Schema.create(Schema.Type.BYTES)).write(buffer, encoder); encoder.flush(); assertThat(output.toByteArray(), equalTo(avroEncoded(someBytes(EXAMPLE_DATA_SIZE)))); assertThat(asList(buffer.position(), buffer.remaining()), is(asList(0, EXAMPLE_DATA_SIZE))); // fails if buffer is not array-backed and buffer overflow occurs }