feat: add support for schema evolution (#329)

codec.go

@@ -34,7 +34,8 @@ type ValEncoder interface {
 
 // ReadVal parses Avro value and stores the result in the value pointed to by obj.
 func (r *Reader) ReadVal(schema Schema, obj any) {
- decoder := r.cfg.getDecoderFromCache(schema.Fingerprint(), reflect2.RTypeOf(obj))
+ key := cacheFingerprintOf(schema)
+ decoder := r.cfg.getDecoderFromCache(key, reflect2.RTypeOf(obj))
  if decoder == nil {
  typ := reflect2.TypeOf(obj)
  if typ.Kind() != reflect.Ptr {
@@ -65,14 +66,15 @@ func (w *Writer) WriteVal(schema Schema, val any) {
 
 func (c *frozenConfig) DecoderOf(schema Schema, typ reflect2.Type) ValDecoder {
  rtype := typ.RType()
- decoder := c.getDecoderFromCache(schema.Fingerprint(), rtype)
+ key := cacheFingerprintOf(schema)
+ decoder := c.getDecoderFromCache(key, rtype)
  if decoder != nil {
  return decoder
  }
 
  ptrType := typ.(*reflect2.UnsafePtrType)
  decoder = decoderOfType(c, schema, ptrType.Elem())
- c.addDecoderToCache(schema.Fingerprint(), rtype, decoder)
+ c.addDecoderToCache(key, rtype, decoder)
  return decoder
 }
 

codec_default.go

@@ -0,0 +1,57 @@
+package avro
+
+import (
+ "fmt"
+ "unsafe"
+
+ "github.com/modern-go/reflect2"
+)
+
+func createDefaultDecoder(cfg *frozenConfig, field *Field, typ reflect2.Type) ValDecoder {
+ fn := func(def any) ([]byte, error) {
+ defaultType := reflect2.TypeOf(def)
+ if defaultType == nil {
+ defaultType = reflect2.TypeOf((*null)(nil))
+ }
+ defaultEncoder := encoderOfType(cfg, field.Type(), defaultType)
+ if defaultType.LikePtr() {
+ defaultEncoder = &onePtrEncoder{defaultEncoder}
+ }
+ w := cfg.borrowWriter()
+ defer cfg.returnWriter(w)
+
+ defaultEncoder.Encode(reflect2.PtrOf(def), w)
+ if w.Error != nil {
+ return nil, w.Error
+ }
+ b := w.Buffer()
+ data := make([]byte, len(b))
+ copy(data, b)
+
+ return data, nil
+ }
+
+ b, err := field.encodeDefault(fn)
+ if err != nil {
+ return &errorDecoder{err: fmt.Errorf("decode default: %w", err)}
+ }
+ return &defaultDecoder{
+ data: b,
+ decoder: decoderOfType(cfg, field.Type(), typ),
+ }
+}
+
+type defaultDecoder struct {
+ data []byte
+ decoder ValDecoder
+}
+
+// Decode implements ValDecoder.
+func (d *defaultDecoder) Decode(ptr unsafe.Pointer, r *Reader) {
+ rr := r.cfg.borrowReader(d.data)
+ defer r.cfg.returnReader(rr)
+
+ d.decoder.Decode(ptr, rr)
+}
+
+var _ ValDecoder = &defaultDecoder{}