beam.RegisterSchemaProvider: schema type provider for

Error message

beam.RegisterSchemaProvider: schema type provider for %v, doesn't support that type

What it means

After kind validation, RegisterSchemaProvider calls p.FromLogicalType(rt) to obtain the storage type. If the provider itself cannot produce a schema for that type, the registration panics — the codebase treats an unusable provider as a programming error at startup rather than a recoverable failure.

Solutions

Ensure the SchemaProvider's FromLogicalType supports exactly the type being registered (test it directly before registering).
Register each provider only for the specific struct/interface type it implements.
Check the wrapped error/logic in FromLogicalType for field/type mismatches and fix the provider implementation.
Wrap registrations in a helper that validates p.FromLogicalType(rt) succeeds before committing.

Example fix

// before
beam.RegisterSchemaProvider(reflect.TypeOf(MyType{}), genericProvider) // FromLogicalType fails
// after
beam.RegisterSchemaProvider(reflect.TypeOf(MyType{}), myTypeProvider) // supports MyType

Defensive patterns

Strategy: validation

Validate before calling

p := provider.(beam.SchemaProvider)
if _, err := p.FromLogicalType(rt); err != nil { /* provider does not support rt; fix before registering */ }

Try / catch

defer func(){ if r := recover(); r != nil && strings.Contains(fmt.Sprint(r), "doesn't support that type") { /* swap in the correct provider */ } }()

Prevention

Register each provider only for the type it implements
Test FromLogicalType for each registered type
Keep providers in sync with schema type changes

When it happens

Trigger: Calling beam.RegisterSchemaProvider(rt, provider) where provider's FromLogicalType(rt) returns an error, i.e. the provider does not actually support the registered type despite its kind being valid.

Common situations: Reusing a generic schema provider for a type it wasn't written for; registering logical types in package init() where the provider's type assumptions no longer hold after a refactor; type-name or field changes breaking the provider.

Understand the failure class

Background: "Must be a positive integer", "Invalid value", "Unsupported": the invalid-argument-value error family, when a library rejects the value you pass — this error's family across 35 libraries.

Related errors

AI-assisted analysis of apache/beam@12126d8942 (2026-09-13). Data as JSON: /api/errors/28cdf681b0ec6914. Report an issue: GitHub.

Appendix: source

Thrown at sdks/go/pkg/beam/schema.go:70

// If the supported type is an interface, that interface must have a non-empty
// method set. That is, it cannot be the empty interface.
//
// RegisterSchemaProvider must be called before beam.Init(), and conventionally
// is called in a package init() function.
func RegisterSchemaProvider(rt reflect.Type, provider any) {
	p := provider.(SchemaProvider)
	switch rt.Kind() {
	case reflect.Interface:
		schema.RegisterLogicalTypeProvider(rt, p.FromLogicalType)
	case reflect.Ptr:
		if rt.Elem().Kind() != reflect.Struct {
			panic(fmt.Sprintf("beam.RegisterSchemaProvider: unsupported type kind for schema provider %v is a %v, must be interface, struct or *struct.", rt, rt.Kind()))
		}
		fallthrough
	case reflect.Struct:
		st, err := p.FromLogicalType(rt)
		if err != nil {
			panic(fmt.Sprintf("beam.RegisterSchemaProvider: schema type provider for %v, doesn't support that type", rt))
		}
		schema.RegisterLogicalType(schema.ToLogicalType(rt.Name(), rt, st))
	default:
		panic(fmt.Sprintf("beam.RegisterSchemaProvider: unsupported type kind for schema provider %v is a %v, must be interface, struct or *struct.", rt, rt.Kind()))
	}

	coder.RegisterSchemaProviders(rt, p.BuildEncoder, p.BuildDecoder)
}

// RegisterSchemaProviderWithURN is for internal use only. Users are recommended to use
// beam.RegisterSchemaProvider() instead.
// RegisterSchemaProviderWithURN registers a new schema provider for a new logical type defined
// in pkg/beam/model/pipeline_v1/schema.pb.go
//
// RegisterSchemaProviderWithURN must be called before beam.Init(), and conventionally
// is called in a package init() function.
func RegisterSchemaProviderWithURN(rt reflect.Type, provider any, urn string) {
	p := provider.(SchemaProvider)

View on GitHub (pinned to 12126d8942)