Method ConvertToType

server/types/type.go:512–553

ConvertToType implements the types.ExtendedType interface.

(ctx *sql.Context, typ sql.ExtendedType, val any)

// ConvertToType implements the types.ExtendedType interface.
func (t *DoltgresType) ConvertToType(ctx *sql.Context, typ sql.ExtendedType, val any) (any, sql.ConvertInRange, error) {
	dt, ok := typ.(*DoltgresType)
	if !ok {
		return nil, sql.InRange, errors.Errorf("expected DoltgresType, got %T", typ)
	}

	cast, err := GetAssignmentCast(ctx, dt, t)
	if err != nil {
		return nil, sql.InRange, err
	}
	if cast == nil {
		// In the case that we have an unknown type string literal, we attempt to parse it with the target type's
		// input function
		// TODO: this is probably not the best place to perform this conversion, it would probably be better as an
		//  analyzer step. This currently only takes place for foreign key checks and some index lookups, and could be
		//  generalized to many more places.
		if dt.ID.TypeName() == "unknown" {
			strVal, ok, err := sql.Unwrap[string](ctx, val)
			if err != nil {
				return nil, sql.InRange, err
			}
			if ok {
				converted, err := t.IoInput(ctx, strVal)
				if err != nil {
					return nil, sql.InRange, err
				}
				return converted, sql.InRange, nil
			}
		}
		return nil, sql.InRange, errors.Errorf("no assignment cast from %s to %s", dt.Name(), t.Name())
	}

	castResult, err := cast.Eval(ctx, val, dt, t)
	if err != nil && errors.Is(err, ErrCastOutOfRange) {
		// TODO: this could be either an overflow or an underflow, we should distinguish
		return castResult, sql.Overflow, nil
	} else if err != nil {
		return nil, sql.InRange, err
	}

	return castResult, sql.InRange, nil
}

// DomainUnderlyingBaseType returns an underlying base type of this domain type.
// It can be a nested domain type, so it recursively searches for a valid base type.