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"
+    }
+  }
+]