{"record":{"id":"bcf08bc7d936ba66","repo":"apache/beam","slug":"beam-registerschemaprovider-unsupported-type-kind-for-schema","errorCode":null,"errorMessage":"beam.RegisterSchemaProvider: unsupported type kind for schema provider %v is a %v, must be interface, struct or *struct.","messagePattern":"beam\\.RegisterSchemaProvider: unsupported type kind for schema provider (.+?) is a (.+?), must be interface, struct or \\*struct\\.","errorType":"panic","errorClass":null,"httpStatus":null,"severity":"error","filePath":"sdks/go/pkg/beam/schema.go","lineNumber":64,"sourceCode":"// Representative Schema types must be structs with only exported fields.\n//\n// A provider should be thread safe, but it's not required that a produced\n// encoder or decoder is thread safe, since a separate encoder or decoder\n// will be used for simultaneously executed bundles.\n//\n// If the supported type is an interface, that interface must have a non-empty\n// method set. That is, it cannot be the empty interface.\n//\n// RegisterSchemaProvider must be called before beam.Init(), and conventionally\n// is called in a package init() function.\nfunc RegisterSchemaProvider(rt reflect.Type, provider any) {\n\tp := provider.(SchemaProvider)\n\tswitch rt.Kind() {\n\tcase reflect.Interface:\n\t\tschema.RegisterLogicalTypeProvider(rt, p.FromLogicalType)\n\tcase reflect.Ptr:\n\t\tif rt.Elem().Kind() != reflect.Struct {\n\t\t\tpanic(fmt.Sprintf(\"beam.RegisterSchemaProvider: unsupported type kind for schema provider %v is a %v, must be interface, struct or *struct.\", rt, rt.Kind()))\n\t\t}\n\t\tfallthrough\n\tcase reflect.Struct:\n\t\tst, err := p.FromLogicalType(rt)\n\t\tif err != nil {\n\t\t\tpanic(fmt.Sprintf(\"beam.RegisterSchemaProvider: schema type provider for %v, doesn't support that type\", rt))\n\t\t}\n\t\tschema.RegisterLogicalType(schema.ToLogicalType(rt.Name(), rt, st))\n\tdefault:\n\t\tpanic(fmt.Sprintf(\"beam.RegisterSchemaProvider: unsupported type kind for schema provider %v is a %v, must be interface, struct or *struct.\", rt, rt.Kind()))\n\t}\n\n\tcoder.RegisterSchemaProviders(rt, p.BuildEncoder, p.BuildDecoder)\n}\n\n// RegisterSchemaProviderWithURN is for internal use only. Users are recommended to use\n// beam.RegisterSchemaProvider() instead.\n// RegisterSchemaProviderWithURN registers a new schema provider for a new logical type defined","sourceCodeStart":46,"sourceCodeEnd":82,"githubUrl":"https://github.com/apache/beam/blob/12126d8942aaf848030c478b4c6a28c6af861c66/sdks/go/pkg/beam/schema.go#L46-L82","documentation":"beam.RegisterSchemaProvider only accepts providers for interface, struct, or *struct reflect.Kinds. A pointer to a non-struct is rejected with this panic, since the schema package can only register logical-type providers for those kinds.","triggerScenarios":"Calling beam.RegisterSchemaProvider(rt, provider) with rt = reflect.TypeOf(x) where x is e.g. *int, *string, *map[...], or any pointer to a non-struct type.","commonSituations":"Typos in generic registration helpers that pass reflect.TypeOf(&someValue) for non-struct values; registering schema providers for primitive aliases or pointers to slices/maps.","solutions":["Pass a struct type or pointer-to-struct to RegisterSchemaProvider (e.g. reflect.TypeOf(MyStruct{}) or &MyStruct{}).","If the target is a pointer to a non-struct, register the underlying struct type instead.","For interfaces, register the interface reflect.Type; for anything else, write a custom coder rather than a schema provider.","Guard registrations with rt.Kind() checks in shared registration helpers."],"exampleFix":"// before\nbeam.RegisterSchemaProvider(reflect.TypeOf(&myInt), provider) // *int panics\n// after\nbeam.RegisterSchemaProvider(reflect.TypeOf(MyStruct{}), provider)","handlingStrategy":"validation","validationCode":"rt := reflect.TypeOf(v)\nif k := rt.Kind(); k != reflect.Struct && !(k == reflect.Ptr && rt.Elem().Kind() == reflect.Struct) && k != reflect.Interface {\n    return fmt.Errorf(\"unsupported schema provider kind %v\", k)\n}","typeGuard":null,"tryCatchPattern":"defer func(){ if r := recover(); r != nil && strings.Contains(fmt.Sprint(r), \"unsupported type kind for schema provider\") { /* fix registration type */ } }()","preventionTips":["Only register struct, *struct, or interface types","Double-check reflect.TypeOf(&x) targets for non-structs","Validate kinds in shared registration helpers"],"tags":["go","apache-beam","schema","reflection"],"backgroundTag":"invalid-argument-value","analyzedSha":"12126d8942aaf848030c478b4c6a28c6af861c66","analyzedAt":"2026-09-13T01:50:10.254Z","contentChangedAt":"2026-09-13T01:50:10.254Z","schemaVersion":2},"datasetVersion":"2026-09-20T03:17:13.778Z"}