util/vector: remove unused error return argument from Encode

Release note: None

Author: yuzefovich

pkg/sql/backfill/backfill.go

@@ -1551,10 +1551,7 @@ func (ib *IndexBackfiller) BuildIndexEntriesChunk(
 			}
 
 			vectorValue := tree.MustBeDPGVector(ib.rowVals[vectorIndexHelper.vectorOrd]).T
-			encodedVector, err := vector.Encode([]byte{}, vectorValue)
-			if err != nil {
-				return nil, nil, memUsedPerChunk, err
-			}
+			encodedVector := vector.Encode([]byte{}, vectorValue)
 			ib.vectorEncodingHelper.QuantizedVecs[indexID] = tree.NewDBytes(tree.DBytes(encodedVector))
 			ib.vectorEncodingHelper.PartitionKeys[indexID] = tree.NewDInt(tree.DInt(cspann.RootKey))
 		}

pkg/sql/rowenc/index_encoding_test.go

@@ -1305,8 +1305,7 @@ func TestVectorEncoding(t *testing.T) {
 	tableDesc := desctestutils.TestingGetPublicTableDescriptor(kvDB, codec, "defaultdb", "prefix_cols")
 
 	testVector := vector.T{1, 2, 4}
-	encodedVector, err := vecencoding.EncodeUnquantizerVector([]byte{}, testVector)
-	require.NoError(t, err)
+	encodedVector := vecencoding.EncodeUnquantizerVector([]byte{}, testVector)
 
 	vh := VectorIndexEncodingHelper{
 		PartitionKeys: make(map[descpb.IndexID]tree.Datum),
@@ -1395,8 +1394,7 @@ func TestVectorCompositeEncoding(t *testing.T) {
 	tableDesc := desctestutils.TestingGetPublicTableDescriptor(kvDB, codec, "defaultdb", "prefix_cols")
 
 	testVector := vector.T{1, 2, 4}
-	encodedVector, err := vecencoding.EncodeUnquantizerVector([]byte{}, testVector)
-	require.NoError(t, err)
+	encodedVector := vecencoding.EncodeUnquantizerVector([]byte{}, testVector)
 
 	vh := VectorIndexEncodingHelper{
 		PartitionKeys: make(map[descpb.IndexID]tree.Datum),

pkg/sql/rowenc/valueside/array.go

@@ -353,10 +353,7 @@ func encodeArrayElement(b []byte, d tree.Datum) ([]byte, error) {
 		}
 		return encoding.EncodeUntaggedBytesValue(b, encoded), nil
 	case *tree.DPGVector:
-		encoded, err := vector.Encode(nil, t.T)
-		if err != nil {
-			return nil, err
-		}
+		encoded := vector.Encode(nil, t.T)
 		return encoding.EncodeUntaggedBytesValue(b, encoded), nil
 	case *tree.DLTree:
 		return encoding.EncodeUntaggedLTreeValue(b, t.LTree), nil

pkg/sql/rowenc/valueside/encode.go

@@ -108,10 +108,7 @@ func EncodeWithScratch(
 		}
 		return encoding.EncodeTSVectorValue(appendTo, uint32(colID), scratch), scratch, nil
 	case *tree.DPGVector:
-		scratch, err = vector.Encode(scratch[:0], t.T)
-		if err != nil {
-			return nil, nil, err
-		}
+		scratch = vector.Encode(scratch[:0], t.T)
 		return encoding.EncodePGVectorValue(appendTo, uint32(colID), scratch), scratch, nil
 	case *tree.DArray:
 		scratch, err = encodeArray(t, scratch[:0])

pkg/sql/rowenc/valueside/legacy.go

@@ -168,10 +168,7 @@ func MarshalLegacy(colType *types.T, val tree.Datum) (roachpb.Value, error) {
 		}
 	case types.PGVectorFamily:
 		if v, ok := val.(*tree.DPGVector); ok {
-			data, err := vector.Encode(nil, v.T)
-			if err != nil {
-				return r, err
-			}
+			data := vector.Encode(nil, v.T)
 			r.SetBytes(data)
 			return r, nil
 		}

pkg/sql/vecindex/vecencoding/encoding.go

@@ -199,9 +199,7 @@ func EncodeMetadataValue(metadata cspann.PartitionMetadata) []byte {
 	buf = encoding.EncodeUint64Ascending(buf, uint64(metadata.StateDetails.Source))
 	buf = encoding.EncodeUntaggedTimeValue(buf, metadata.StateDetails.Timestamp)
 
-	// vector.Encode never returns a non-nil error, so suppress return value.
-	buf, _ = vector.Encode(buf, metadata.Centroid)
-	return buf
+	return vector.Encode(buf, metadata.Centroid)
 }
 
 // EncodeRaBitQVector encodes a RaBitQ vector into the given byte slice.
@@ -222,7 +220,7 @@ func EncodeRaBitQVectorFromSet(
 
 // EncodeUnquantizerVector encodes an Unquantizer vector into the given byte
 // slice.
-func EncodeUnquantizerVector(appendTo []byte, v vector.T) ([]byte, error) {
+func EncodeUnquantizerVector(appendTo []byte, v vector.T) []byte {
 	// For backwards compatibility, encode a zero float32. Previously, the
 	// distance of the vector to the centroid was encoded, but that is no longer
 	// necessary.

pkg/sql/vecindex/vecencoding/encoding_test.go

@@ -90,9 +90,7 @@ func testEncodeDecodeRoundTripImpl(t *testing.T, rnd *rand.Rand, set vector.Set)
 		for i := range set.Count {
 			switch quantizedSet := quantizedSet.(type) {
 			case *quantize.UnQuantizedVectorSet:
-				var err error
-				buf, err = vecencoding.EncodeUnquantizerVector(buf, set.At(i))
-				require.NoError(t, err)
+				buf = vecencoding.EncodeUnquantizerVector(buf, set.At(i))
 			case *quantize.RaBitQuantizedVectorSet:
 				buf = vecencoding.EncodeRaBitQVectorFromSet(buf, quantizedSet, i)
 			}

pkg/sql/vecindex/vecstore/codec.go

@@ -70,7 +70,7 @@ func (sc *storeCodec) EncodeVector(w *workspace.T, v vector.T, centroid vector.T
 
 	switch t := sc.tmpVectorSet.(type) {
 	case *quantize.UnQuantizedVectorSet:
-		return vecencoding.EncodeUnquantizerVector([]byte{}, t.Vectors.At(0))
+		return vecencoding.EncodeUnquantizerVector([]byte{}, t.Vectors.At(0)), nil
 	case *quantize.RaBitQuantizedVectorSet:
 		return vecencoding.EncodeRaBitQVectorFromSet([]byte{}, t, 0), nil
 	default:

pkg/util/vector/vector.go

@@ -116,12 +116,12 @@ func (v T) Compare(v2 T) (int, error) {
 }
 
 // Encode encodes the vector as a byte array suitable for storing in KV.
-func Encode(appendTo []byte, t T) ([]byte, error) {
+func Encode(appendTo []byte, t T) []byte {
 	appendTo = encoding.EncodeUint32Ascending(appendTo, uint32(len(t)))
 	for i := range t {
 		appendTo = encoding.EncodeUntaggedFloat32Value(appendTo, t[i])
 	}
-	return appendTo, nil
+	return appendTo
 }
 
 // Decode decodes the byte array into a vector and returns any remaining bytes.

pkg/util/vector/vector_test.go

@@ -68,15 +68,13 @@ func TestRoundtripRandomPGVector(t *testing.T) {
 	extra := randutil.RandBytes(rng, 10)
 	for i := 0; i < 1000; i++ {
 		v := Random(rng, 1000 /* maxDim */)
-		encoded, err := Encode(nil, v)
-		assert.NoError(t, err)
+		encoded := Encode(nil, v)
 		encoded = append(encoded, extra...)
 		remaining, roundtripped, err := Decode(encoded)
 		assert.NoError(t, err)
 		assert.Equal(t, v.String(), roundtripped.String())
 		assert.Equal(t, extra, remaining)
-		reEncoded, err := Encode(nil, roundtripped)
-		assert.NoError(t, err)
+		reEncoded := Encode(nil, roundtripped)
 		assert.Equal(t, encoded, append(reEncoded, extra...))
 	}
 }