Make vectors arrays of 32-bit floats, not 64-bit floats.

Author: nicktobey

sql/core.go

@@ -325,15 +325,15 @@ func ConvertToBool(ctx *Context, v interface{}) (bool, error) {
 	}
 }
 
-func ConvertToVector(ctx context.Context, v interface{}) ([]float64, error) {
+func ConvertToVector(ctx context.Context, v interface{}) ([]float32, error) {
 	switch b := v.(type) {
-	case []float64:
+	case []float32:
 		return b, nil
 	case string:
 		var val interface{}
 		err := json.Unmarshal([]byte(b), &val)
 		if err != nil {
-			return nil, err
+			return nil, fmt.Errorf("can't convert JSON to vector: %w", err)
 		}
 		return convertJsonInterfaceToVector(val)
 	case JSONWrapper:
@@ -347,18 +347,25 @@ func ConvertToVector(ctx context.Context, v interface{}) ([]float64, error) {
 	}
 }
 
-func convertJsonInterfaceToVector(val interface{}) ([]float64, error) {
+func convertJsonInterfaceToVector(val interface{}) ([]float32, error) {
 	array, ok := val.([]interface{})
 	if !ok {
-		return nil, fmt.Errorf("can't convert JSON to vector; expected array, got %v", val)
+		return nil, fmt.Errorf("can't convert JSON to vector; expected array, got %T", val)
 	}
-	res := make([]float64, len(array))
+	res := make([]float32, len(array))
 	for i, elem := range array {
-		floatElem, ok := elem.(float64)
-		if !ok {
-			return nil, fmt.Errorf("can't convert JSON to vector; expected array of floats, got %v", elem)
+		switch v := elem.(type) {
+		case float32:
+			res[i] = v
+		case float64:
+			res[i] = float32(v)
+		case int64:
+			res[i] = float32(v)
+		case int32:
+			res[i] = float32(v)
+		default:
+			return nil, fmt.Errorf("can't convert JSON to vector; expected array of floats, but array contained %T", elem)
 		}
-		res[i] = floatElem
 	}
 	return res, nil
 }

sql/expression/function/vector/distance.go

@@ -25,7 +25,7 @@ import (
 
 type DistanceType interface {
 	String() string
-	Eval(left []float64, right []float64) (float64, error)
+	Eval(left []float32, right []float32) (float64, error)
 	CanEval(distanceType DistanceType) bool
 	FunctionName() string
 	Description() string
@@ -40,14 +40,14 @@ func (d DistanceL2Squared) String() string {
 	return "VEC_DISTANCE_L2_SQUARED"
 }
 
-func (d DistanceL2Squared) Eval(left []float64, right []float64) (float64, error) {
+func (d DistanceL2Squared) Eval(left []float32, right []float32) (float64, error) {
 	if len(left) != len(right) {
 		return 0, fmt.Errorf("attempting to find distance between vectors of different lengths: %d vs %d", len(left), len(right))
 	}
 	var total float64 = 0
 	for i, l := range left {
 		r := right[i]
-		total += (l - r) * (l - r)
+		total += float64(l-r) * float64(l-r)
 	}
 	return total, nil
 }

sql/types/vector.go

@@ -27,7 +27,7 @@ import (
 	"github.com/dolthub/go-mysql-server/sql"
 )
 
-var vectorValueType = reflect.TypeOf([]float64{})
+var vectorValueType = reflect.TypeOf([]float32{})
 
 // VectorType represents the VECTOR(N) type.
 // It stores a fixed-length array of N floating point numbers.
@@ -64,8 +64,8 @@ func (t VectorType) Compare(ctx context.Context, a interface{}, b interface{}) (
 		return 0, err
 	}
 
-	avec := av.([]float64)
-	bvec := bv.([]float64)
+	avec := av.([]float32)
+	bvec := bv.([]float32)
 
 	aBytes := make([]byte, 4)
 	bBytes := make([]byte, 4)
@@ -88,7 +88,16 @@ func (t VectorType) Convert(ctx context.Context, v interface{}) (interface{}, sq
 	}
 
 	switch val := v.(type) {
-	case []float64:
+	case []byte:
+		if len(val) != 4*t.Dimensions {
+			return nil, sql.OutOfRange, fmt.Errorf("cannot convert BINARY(%d) to VECTOR(%d), need BINARY(%d)", len(val), t.Dimensions, 4*t.Dimensions)
+		}
+		result := make([]float32, t.Dimensions)
+		for i := range result {
+			binary.Decode(val[4*i:4*(i+1)], binary.LittleEndian, &result[i])
+		}
+		return result, sql.InRange, nil
+	case []float32:
 		if len(val) != t.Dimensions {
 			return nil, sql.OutOfRange, fmt.Errorf("VECTOR dimension mismatch: expected %d, got %d", t.Dimensions, len(val))
 		}
@@ -97,26 +106,26 @@ func (t VectorType) Convert(ctx context.Context, v interface{}) (interface{}, sq
 		if len(val) != t.Dimensions {
 			return nil, sql.OutOfRange, fmt.Errorf("VECTOR dimension mismatch: expected %d, got %d", t.Dimensions, len(val))
 		}
-		result := make([]float64, t.Dimensions)
+		result := make([]float32, t.Dimensions)
 		for i, elem := range val {
 			switch e := elem.(type) {
 			case float64:
-				result[i] = e
+				result[i] = float32(e)
 			case float32:
-				result[i] = float64(e)
+				result[i] = e
 			case int:
-				result[i] = float64(e)
+				result[i] = float32(e)
 			case int64:
-				result[i] = float64(e)
+				result[i] = float32(e)
 			case int32:
-				result[i] = float64(e)
+				result[i] = float32(e)
 			default:
 				if str, ok := elem.(string); ok {
 					f, err := strconv.ParseFloat(str, 64)
 					if err != nil {
 						return nil, sql.OutOfRange, fmt.Errorf("invalid vector element: %v", elem)
 					}
-					result[i] = f
+					result[i] = float32(f)
 				} else {
 					return nil, sql.OutOfRange, fmt.Errorf("invalid vector element: %v", elem)
 				}
@@ -182,7 +191,7 @@ func (t VectorType) ValueType() reflect.Type {
 
 // Zero implements Type interface.
 func (t VectorType) Zero() interface{} {
-	return make([]float64, t.Dimensions)
+	return make([]float32, t.Dimensions)
 }
 
 // CollationCoercibility implements sql.CollationCoercible interface.