CtrlK
BlogDocsLog inGet started
Tessl Logo

tessl/maven-org-apache-avro--avro

Apache Avro core components for data serialization with rich data structures, compact binary format, and schema evolution support

—

Pending
Overview
Eval results
Files

generic-data.mddocs/

Generic Data Operations

Generic data operations provide runtime data handling without code generation, offering maximum flexibility for dynamic data processing. Generic operations work directly with Avro's data model using runtime schema information, making them ideal for applications that process schemas dynamically.

Capabilities

Generic Data Utilities

Core utilities for working with generic data representations, validation, and comparison operations.

public class GenericData {
    public static GenericData get();
    
    // Data creation
    public Object createDatum(Schema schema);
    public GenericRecord newRecord(GenericRecord original, Schema schema);
    public Object newInstance(Class<?> c, Schema schema);
    
    // Validation
    public boolean validate(Schema schema, Object datum);
    
    // Comparison and hashing
    public int compare(Object o1, Object o2, Schema s);
    public int compare(Object o1, Object o2, Schema s, boolean equals);
    public int hashCode(Object o, Schema s);
    
    // String type handling
    public void setStringType(StringType stringType);
    public StringType getStringType();
    
    public enum StringType { CharSequence, String, Utf8 }
}

Usage Examples:

// Create generic data instance
GenericData genericData = GenericData.get();

// Create datum for schema
Schema userSchema = new Schema.Parser().parse(userSchemaJson);
Object userDatum = genericData.createDatum(userSchema);

// Validate data against schema
GenericRecord user = new GenericData.Record(userSchema);
user.put("name", "John Doe");
user.put("age", 30);

boolean isValid = genericData.validate(userSchema, user);
System.out.println("User record is valid: " + isValid);

// Compare two records
GenericRecord user1 = createUser("Alice", 25);
GenericRecord user2 = createUser("Bob", 30);
int comparison = genericData.compare(user1, user2, userSchema);

// Calculate hash code
int hashCode = genericData.hashCode(user1, userSchema);

Generic Record Interface

Interface for generic record implementations providing field access by name and index.

public interface GenericRecord extends IndexedRecord {
    void put(String key, Object v);
    Object get(String key);
}

public interface IndexedRecord extends GenericContainer {
    void put(int i, Object v);
    Object get(int i);
}

public interface GenericContainer {
    Schema getSchema();
}

Usage Examples:

// Create and populate generic record
Schema schema = new Schema.Parser().parse(schemaJson);
GenericRecord record = new GenericData.Record(schema);

// Set values by field name
record.put("name", "John Doe");
record.put("age", 30);
record.put("email", "john@example.com");

// Get values by field name
String name = (String) record.get("name");
Integer age = (Integer) record.get("age");

// Access by index (IndexedRecord interface)
record.put(0, "Jane Doe");    // Set first field
Object firstField = record.get(0);  // Get first field

// Get schema
Schema recordSchema = record.getSchema();
System.out.println("Record type: " + recordSchema.getName());

Generic Record Builder

Builder pattern implementation for constructing generic records with validation and default value handling.

public class GenericRecordBuilder implements RecordBuilder<GenericRecord> {
    public GenericRecordBuilder(Schema schema);
    public GenericRecordBuilder(GenericRecordBuilder other);
    public GenericRecordBuilder(GenericRecord other);
    
    // Field setting
    public GenericRecordBuilder set(String fieldName, Object value);
    public GenericRecordBuilder set(Schema.Field field, Object value);
    public GenericRecordBuilder set(int pos, Object value);
    
    // Field checking
    public boolean has(String fieldName);
    public boolean has(Schema.Field field);
    public boolean has(int pos);
    
    // Field getting
    public Object get(String fieldName);
    public Object get(Schema.Field field);
    public Object get(int pos);
    
    // Field clearing
    public GenericRecordBuilder clear(String fieldName);
    public GenericRecordBuilder clear(Schema.Field field);
    public GenericRecordBuilder clear(int pos);
    
    // Build record
    public GenericRecord build();
}

Usage Examples:

// Build record using builder pattern
Schema userSchema = new Schema.Parser().parse(userSchemaJson);

GenericRecord user = new GenericRecordBuilder(userSchema)
    .set("id", 123L)
    .set("name", "John Doe")
    .set("email", "john@example.com")
    .set("age", 30)
    .build();

// Check if fields are set
GenericRecordBuilder builder = new GenericRecordBuilder(userSchema);
builder.set("name", "Alice");

if (builder.has("name")) {
    System.out.println("Name is set to: " + builder.get("name"));
}

// Build with partial data (uses defaults where available)
GenericRecord partialUser = new GenericRecordBuilder(userSchema)
    .set("name", "Bob")
    .build(); // Other fields will use default values if defined

// Copy and modify existing record
GenericRecord modifiedUser = new GenericRecordBuilder(user)
    .set("age", 31)
    .set("email", "newemail@example.com")
    .build();

Generic Array Interface

Interface for generic array implementations supporting list operations and generic container functionality.

public interface GenericArray<T> extends List<T>, GenericContainer {
    void reverse();
    T peek();
    
    // Inherited from List<T>
    boolean add(T element);
    void add(int index, T element);
    T get(int index);
    T set(int index, T element);
    T remove(int index);
    int size();
    boolean isEmpty();
    void clear();
}

Usage Examples:

// Create generic array
Schema arraySchema = Schema.createArray(Schema.create(Schema.Type.STRING));
GenericArray<String> genericArray = new GenericData.Array<>(arraySchema, new ArrayList<>());

// Add elements
genericArray.add("first");
genericArray.add("second");
genericArray.add("third");

// Access elements
String first = genericArray.get(0);
System.out.println("First element: " + first);

// Use list operations
genericArray.set(1, "modified second");
genericArray.remove(2);

// Reverse array
genericArray.reverse();

// Peek at last element
String last = genericArray.peek();

// Get schema
Schema schema = genericArray.getSchema();
Schema elementType = schema.getElementType();

Generic Fixed Interface

Interface for generic fixed-length data implementations.

public interface GenericFixed extends GenericContainer {
    byte[] bytes();
}

Usage Examples:

// Create fixed schema
Schema fixedSchema = Schema.createFixed("MD5Hash", "MD5 hash value", null, 16);

// Create generic fixed
GenericFixed hash = new GenericData.Fixed(fixedSchema);
byte[] hashBytes = "1234567890123456".getBytes();
System.arraycopy(hashBytes, 0, hash.bytes(), 0, 16);

// Access bytes
byte[] bytes = hash.bytes();
System.out.println("Hash length: " + bytes.length);

// Get schema
Schema schema = hash.getSchema();
int expectedSize = schema.getFixedSize();

Generic Datum Reader

DatumReader implementation for deserializing data into generic representations.

public class GenericDatumReader<D> implements DatumReader<D> {
    public GenericDatumReader();
    public GenericDatumReader(Schema schema);
    public GenericDatumReader(Schema writer, Schema reader);
    
    // Schema management
    public void setSchema(Schema schema);
    public void setExpected(Schema reader);
    public Schema getSchema();
    public Schema getExpected();
    
    // Reading operations
    public D read(D reuse, Decoder in) throws IOException;
    
    // Data model access
    public GenericData getData();
    public void setData(GenericData data);
}

Usage Examples:

// Create reader for schema
Schema schema = new Schema.Parser().parse(schemaJson);
GenericDatumReader<GenericRecord> reader = new GenericDatumReader<>(schema);

// Read from decoder
InputStream inputStream = new FileInputStream("data.avro");
BinaryDecoder decoder = DecoderFactory.get().binaryDecoder(inputStream, null);
GenericRecord record = reader.read(null, decoder);

// Schema evolution - different writer and reader schemas
Schema writerSchema = new Schema.Parser().parse(writerSchemaJson);
Schema readerSchema = new Schema.Parser().parse(readerSchemaJson);
GenericDatumReader<GenericRecord> evolvingReader = 
    new GenericDatumReader<>(writerSchema, readerSchema);

// Reuse objects for performance
GenericRecord reusedRecord = null;
while (decoder.hasMore()) {
    reusedRecord = reader.read(reusedRecord, decoder);
    processRecord(reusedRecord);
}

Generic Datum Writer

DatumWriter implementation for serializing generic data representations.

public class GenericDatumWriter<D> implements DatumWriter<D> {
    public GenericDatumWriter();
    public GenericDatumWriter(Schema schema);
    
    // Schema management
    public void setSchema(Schema schema);
    public Schema getSchema();
    
    // Writing operations
    public void write(D datum, Encoder out) throws IOException;
    
    // Data model access
    public GenericData getData();
    public void setData(GenericData data);
}

Usage Examples:

// Create writer for schema
Schema schema = new Schema.Parser().parse(schemaJson);
GenericDatumWriter<GenericRecord> writer = new GenericDatumWriter<>(schema);

// Write to encoder
OutputStream outputStream = new FileOutputStream("output.avro");
BinaryEncoder encoder = EncoderFactory.get().binaryEncoder(outputStream, null);

GenericRecord record = new GenericData.Record(schema);
record.put("name", "John Doe");
record.put("age", 30);

writer.write(record, encoder);
encoder.flush();

// Write multiple records
List<GenericRecord> records = createRecords();
for (GenericRecord record : records) {
    writer.write(record, encoder);
}
encoder.flush();
outputStream.close();

Types

public class GenericData {
    public enum StringType { CharSequence, String, Utf8 }
    
    public static class Record implements GenericRecord, Comparable<Record> {
        public Record(Schema schema);
        public Record(Record other, boolean deepCopy);
    }
    
    public static class Array<T> extends AbstractList<T> implements GenericArray<T> {
        public Array(Schema schema, Collection<T> c);
        public Array(int capacity, Schema schema);
    }
    
    public static class Fixed implements GenericFixed {
        public Fixed(Schema schema);
        public Fixed(Schema schema, byte[] bytes);
    }
    
    public static class EnumSymbol implements GenericEnumSymbol {
        public EnumSymbol(Schema schema, String symbol);
    }
}

public interface GenericContainer {
    Schema getSchema();
}

public interface GenericRecord extends IndexedRecord {
    void put(String key, Object v);
    Object get(String key);
}

public interface IndexedRecord extends GenericContainer {
    void put(int i, Object v);
    Object get(int i);
}

public interface GenericArray<T> extends List<T>, GenericContainer {
    void reverse();
    T peek();
}

public interface GenericFixed extends GenericContainer {
    byte[] bytes();
}

public interface GenericEnumSymbol extends GenericContainer {
    String toString();
}

public class GenericRecordBuilder implements RecordBuilder<GenericRecord> {
    // Builder implementation for GenericRecord
}

Install with Tessl CLI

npx tessl i tessl/maven-org-apache-avro--avro

docs

code-generation.md

encoding-decoding.md

file-operations.md

generic-data.md

index.md

message-operations.md

reflection-operations.md

schema-evolution.md

schema-system.md

tile.json