weaviate/weaviate · error

unsupported type %T

Error message

unsupported type %T

What it means

typedSliceToUntyped converts typed Go slices from an object property into []any for inverted-index processing. It only supports concrete slice types (string, int, bool, float64, uuid, etc.); a property whose value is a slice of another type reaches the default case and errors. This means an object contained a property array value of a type the inverted indexer does not recognize.

Source

Thrown at adapters/repos/db/inverted/objects.go:559

func typedSliceToUntyped(in any) ([]any, error) {
	switch typed := in.(type) {
	case []any:
		// nothing to do
		return typed, nil
	case []string:
		return convertToUntyped[string](typed), nil
	case []int:
		return convertToUntyped[int](typed), nil
	case []time.Time:
		return convertToUntyped[time.Time](typed), nil
	case []bool:
		return convertToUntyped[bool](typed), nil
	case []float64:
		return convertToUntyped[float64](typed), nil
	case []uuid.UUID:
		return convertToUntyped[uuid.UUID](typed), nil
	default:
		return nil, errors.Errorf("unsupported type %T", in)
	}
}

func convertToUntyped[T comparable](in []T) []any {
	out := make([]any, len(in))
	for i := range out {
		out[i] = in[i]
	}
	return out
}

// Indicates whether property should be indexed
// Index holds document ids with property of/containing particular value
// and number of its occurrences in that property
// (index created using bucket of StrategyMapCollection)
func HasSearchableIndex(prop *models.Property) bool {
	switch dt, _ := schema.AsPrimitive(prop.DataType); dt {
	case schema.DataTypeText, schema.DataTypeTextArray:

View on GitHub (pinned to 75aa4b6d11)

Solutions

1. Normalize the property value to a supported slice type ([]string, []int, []bool, []float64, []uuid.UUID) before writing the object
2. Fix the schema so the property uses a supported datatype for its contents
3. Identify the offending object type via the %T text in the error and convert the ingestion code accordingly
4. If it comes from a module/integration, update that module to emit supported types

Example fix

// before
counts := []int32{1, 2, 3}
props["counts"] = counts
// after
counts := []int32{1, 2, 3}
out := make([]int, len(counts))
for i, v := range counts { out[i] = int(v) }
props["counts"] = out

func isSupportedSlice(v any) bool {
    switch v.(type) {
    case []string, []int, []bool, []float64, []uuid.UUID, nil:
        return true
    default:
        return false
    }
}
// call before writing the object property

func normalizeSlice(in any) any {
    switch t := in.(type) {
    case []int32:
        out := make([]int, len(t))
        for i, v := range t { out[i] = int(v) }
        return out
    default:
        return in
    }
}

err := extendPropertiesWithArrayType(...)
if err != nil && strings.Contains(err.Error(), "unsupported type") {
    // inspect %T in message, convert the value, retry the batch item
}

When it happens

Trigger: Inserting/updating an object (extendPropertiesWithArrayType path) whose array property contains element types outside the supported set — e.g. []int8/[]int32, []float32, nested slices, or a custom type passed through module/extension code.

Common situations: Schema misconfiguration where a property datatype maps to an unsupported Go slice; custom code or a module supplying int32 arrays; importing data serialized from another system with narrower numeric types.

Related errors

• No properties provided, and no indexed properties found in c
• IndexPropertyLength cannot be changed when updating a schema
• IndexNullState cannot be changed when updating a schema
• could not find bucket for property %v
• failed to extract timestamp prop, unsupported type '%T' for

AI-assisted analysis of weaviate/weaviate@75aa4b6d11 (2026-09-04). Data as JSON: /api/errors/6e26652ae08eb702. Report an issue: GitHub.