Use enum default values to parse unknown values

v10/compiler/method.go

@@ -291,10 +291,30 @@ func (p *irMethod) compileRecord(writer, reader *schema.RecordDefinition) error
 
 func (p *irMethod) compileEnum(writer, reader *schema.EnumDefinition) error {
  log("compileEnum()\n writer:\n %v\n---\nreader: %v\n---\n", writer, reader)
- p.addLiteral(vm.Read, vm.Int)
+ p.addLiteral(vm.Read, vm.Long)
+ errId := p.addError("Unexpected value for enum")
+ switchId := p.addSwitchStart(len(writer.Symbols()), errId)
  if reader != nil {
- p.addLiteral(vm.Set, vm.Int)
+ for i, wSymbol := range writer.Symbols() {
+ p.addSwitchCase(switchId, i, -1)
+ rIdx := reader.SymbolIndex(wSymbol)
+ if rIdx > -1 {
+ p.addLiteral(vm.SetInt, rIdx)
+ p.addLiteral(vm.Set, vm.Int)
+ } else if reader.Default() != "" {
+ rIdx = reader.SymbolIndex(reader.Default())
+ if rIdx == -1 {
+ return fmt.Errorf("Reader schema has invalid default symbol %q", reader.Default())
+ }
+ p.addLiteral(vm.SetInt, rIdx)
+ p.addLiteral(vm.Set, vm.Int)
+ } else {
+ typedErrId := p.addError(fmt.Sprintf("Reader schema has no value for symbol %q in enum", wSymbol))
+ p.addLiteral(vm.Halt, typedErrId)
+ }
+ }
  }
+ p.addSwitchEnd(switchId)
  return nil
 }
 
@@ -323,7 +343,7 @@ writer:
  return err
  }
  } else if unionReader, ok := reader.(*schema.UnionField); ok {
- // Always try to find an extact match by name before trying to handle evolution
+ // Always try to find an exact match by name before trying to handle evolution
  for readerIndex, r := range unionReader.AvroTypes() {
  if r.Name() == t.Name() {
  log("Union types have exact match by name: %q %q", r.Name(), t.Name())

v10/generator/flat/templates/enum.go

@@ -10,6 +10,8 @@ import (
  "github.com/actgardner/gogen-avro/v10/vm"
 )
 
+var _ = fmt.Printf
+
 {{ if ne .Doc "" }}// {{ .Doc}}{{ end }} 
 type {{ .GoType }} int32
 
@@ -41,7 +43,11 @@ func {{ .FromStringMethod }}(raw string) (r {{ .GoType }}, err error) {
 {{ end -}}
  }
 
+{{ if ne .Default "" }} 
+ return {{ $.SymbolName .Default }}, nil
+{{ else }}
  return -1, fmt.Errorf("invalid value for {{ $.GoType }}: '%s'", raw)
+{{ end }}
 }
 
 func (b {{ .GoType }}) MarshalJSON() ([]byte, error) {

v10/parser/namespace.go

@@ -213,6 +213,14 @@ func (n *Namespace) decodeEnumDefinition(namespace string, schemaMap map[string]
  return nil, err
  }
 
+ var defaultStr string
+ if dv, ok := schemaMap["default"]; ok {
+ defaultStr, ok = dv.(string)
+ if !ok {
+ return nil, NewWrongMapValueTypeError("default", "string", dv)
+ }
+ }
+
  symbolStr, ok := interfaceSliceToStringSlice(symbolSlice)
  if !ok {
  return nil, fmt.Errorf("'symbols' must be an array of strings")
@@ -230,7 +238,7 @@ func (n *Namespace) decodeEnumDefinition(namespace string, schemaMap map[string]
  }
  }
 
- return avro.NewEnumDefinition(name, aliases, symbolStr, docString, schemaMap), nil
+ return avro.NewEnumDefinition(name, aliases, symbolStr, docString, defaultStr, schemaMap), nil
 }
 
 // decodeFixedDefinition accepts a namespace and a map representing a fixed definition,

v10/schema/enum.go

@@ -8,20 +8,22 @@ import (
 )
 
 type EnumDefinition struct {
- name QualifiedName
- aliases []QualifiedName
- symbols []string
- doc string
- definition map[string]interface{}
+ name QualifiedName
+ aliases []QualifiedName
+ symbols []string
+ doc string
+ defaultValue string
+ definition map[string]interface{}
 }
 
-func NewEnumDefinition(name QualifiedName, aliases []QualifiedName, symbols []string, doc string, definition map[string]interface{}) *EnumDefinition {
+func NewEnumDefinition(name QualifiedName, aliases []QualifiedName, symbols []string, doc string, defaultValue string, definition map[string]interface{}) *EnumDefinition {
  return &EnumDefinition{
- name: name,
- aliases: aliases,
- symbols: symbols,
- doc: doc,
- definition: definition,
+ name: name,
+ aliases: aliases,
+ symbols: symbols,
+ doc: doc,
+ defaultValue: defaultValue,
+ definition: definition,
  }
 }
 
@@ -41,6 +43,15 @@ func (e *EnumDefinition) Aliases() []QualifiedName {
  return e.aliases
 }
 
+func (e *EnumDefinition) SymbolIndex(symbol string) int {
+ for i, s := range e.symbols {
+ if s == symbol {
+ return i
+ }
+ }
+ return -1
+}
+
 func (e *EnumDefinition) Symbols() []string {
  return e.symbols
 }
@@ -99,3 +110,7 @@ func (s *EnumDefinition) WrapperPointer() bool { return false }
 func (s *EnumDefinition) Children() []AvroType {
  return []AvroType{}
 }
+
+func (s *EnumDefinition) Default() string {
+ return s.defaultValue
+}

v10/test/enum-default/evolution.avsc

@@ -0,0 +1,16 @@
+{
+ "type": "record",
+ "name": "EnumTestRecord",
+ "fields": [
+ {
+ "name": "EnumField", 
+ "type": {
+ "name": "TestEnumType",
+ "type": "enum",
+ "doc": "Test \nenum",
+ "symbols": ["TestSymbol3", "TestSymbol1"],
+ "default": "TestSymbol1"
+ }
+ }
+ ]
+}

v10/test/enum-default/evolution.json

@@ -0,0 +1,18 @@
+[
+ {
+ "data": {
+ "EnumField": "TestSymbol2"
+ },
+ "expected": {
+ "EnumField": "TestSymbol1"
+ }
+ },
+ {
+ "data": {
+ "EnumField": "TestSymbol3"
+ },
+ "expected": {
+ "EnumField": "TestSymbol3"
+ }
+ }
+]