mirror of
https://github.com/hanzokv/go.git
synced 2026-09-24 00:31:51 +00:00
zeekay
6994cf05aa
We do not use Redis. The client was a go-redis fork and still said so
everywhere: `package redis`, `redis.NewClient`, `redis://`, `extra/redisotel`.
Consumers wrote `redis.Client` against a Valkey-backed store called KV.
package redis -> package kv (93 decls)
redis.X -> kv.X (2,794 call sites)
"redis: …" errors -> "kv: …" (206)
extra/redis{otel,cmd,prometheus,census} -> extra/kv{otel,cmd,prometheus,census}
redis:// , rediss:// -> kv:// , kvs:// (ParseURL)
Redis*/*Redis* idents -> KV*/*KV*
REDIS_VERSION, REDIS_ENDPOINTS_CONFIG_PATH -> KV_*
I previously argued this rename was unsafe because much of it was "wire
contract". That was wrong, and the categorisation shows why: RESP command names
are GET/SET/HSET — they never contain the word. Of 5,771 occurrences only two
kinds were server-visible at all: the ParseURL scheme (we choose what we pass;
our configs already use kv://) and the CLIENT SETINFO lib-name label, which the
server merely records. Nothing here changes a byte of protocol.
Two things deliberately keep the old spelling:
RediSearch — names a specific external module the FT.* commands map to.
StoreDist — contains the letters by accident (sto-reDis-t), not the word.
Breaking for consumers by design: every import site must move redis.X -> kv.X.
Minor bump, never a major — this module stays v9 forever.
345 lines
9.0 KiB
Go
345 lines
9.0 KiB
Go
package kv_test
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"math/rand"
|
|
"time"
|
|
|
|
. "github.com/bsm/ginkgo/v2"
|
|
. "github.com/bsm/gomega"
|
|
"github.com/hanzokv/go/v9"
|
|
"github.com/hanzokv/go/v9/internal/proto"
|
|
)
|
|
|
|
func expectNil(err error) {
|
|
Expect(err).NotTo(HaveOccurred())
|
|
}
|
|
|
|
func expectTrue(t bool) {
|
|
expectEqual(t, true)
|
|
}
|
|
|
|
func expectEqual[T any, U any](a T, b U) {
|
|
Expect(a).To(BeEquivalentTo(b))
|
|
}
|
|
|
|
func generateRandomVector(dim int) kv.VectorValues {
|
|
rand.Seed(time.Now().UnixNano())
|
|
v := make([]float64, dim)
|
|
for i := range v {
|
|
v[i] = float64(rand.Intn(1000)) + rand.Float64()
|
|
}
|
|
return kv.VectorValues{Val: v}
|
|
}
|
|
|
|
var _ = Describe("KV VectorSet commands", Label("vectorset"), func() {
|
|
ctx := context.TODO()
|
|
|
|
setupKVClient := func(protocolVersion int) *kv.Client {
|
|
return kv.NewClient(&kv.Options{
|
|
Addr: "localhost:6379",
|
|
DB: 0,
|
|
Protocol: protocolVersion,
|
|
UnstableResp3: true,
|
|
})
|
|
}
|
|
|
|
protocols := []int{2, 3}
|
|
for _, protocol := range protocols {
|
|
protocol := protocol
|
|
|
|
Context(fmt.Sprintf("with protocol version %d", protocol), func() {
|
|
var client *kv.Client
|
|
|
|
BeforeEach(func() {
|
|
client = setupKVClient(protocol)
|
|
Expect(client.FlushAll(ctx).Err()).NotTo(HaveOccurred())
|
|
})
|
|
|
|
AfterEach(func() {
|
|
if client != nil {
|
|
client.FlushDB(ctx)
|
|
client.Close()
|
|
}
|
|
})
|
|
|
|
It("basic", func() {
|
|
SkipBeforeKVVersion(8.0, "KV 8.0 introduces support for VectorSet")
|
|
vecName := "basic"
|
|
val := &kv.VectorValues{
|
|
Val: []float64{1.5, 2.4, 3.3, 4.2},
|
|
}
|
|
ok, err := client.VAdd(ctx, vecName, "k1", val).Result()
|
|
expectNil(err)
|
|
expectTrue(ok)
|
|
|
|
fp32 := "\x8f\xc2\xf9\x3e\xcb\xbe\xe9\xbe\xb0\x1e\xca\x3f\x5e\x06\x9e\x3f"
|
|
val2 := &kv.VectorFP32{
|
|
Val: []byte(fp32),
|
|
}
|
|
ok, err = client.VAdd(ctx, vecName, "k2", val2).Result()
|
|
expectNil(err)
|
|
expectTrue(ok)
|
|
|
|
dim, err := client.VDim(ctx, vecName).Result()
|
|
expectNil(err)
|
|
expectEqual(dim, 4)
|
|
|
|
count, err := client.VCard(ctx, vecName).Result()
|
|
expectNil(err)
|
|
expectEqual(count, 2)
|
|
|
|
ok, err = client.VRem(ctx, vecName, "k1").Result()
|
|
expectNil(err)
|
|
expectTrue(ok)
|
|
|
|
count, err = client.VCard(ctx, vecName).Result()
|
|
expectNil(err)
|
|
expectEqual(count, 1)
|
|
})
|
|
|
|
It("basic similarity", func() {
|
|
SkipBeforeKVVersion(8.0, "KV 8.0 introduces support for VectorSet")
|
|
vecName := "basic_similarity"
|
|
|
|
ok, err := client.VAdd(ctx, vecName, "k1", &kv.VectorValues{
|
|
Val: []float64{1, 0, 0, 0},
|
|
}).Result()
|
|
expectNil(err)
|
|
expectTrue(ok)
|
|
ok, err = client.VAdd(ctx, vecName, "k2", &kv.VectorValues{
|
|
Val: []float64{0.99, 0.01, 0, 0},
|
|
}).Result()
|
|
expectNil(err)
|
|
expectTrue(ok)
|
|
ok, err = client.VAdd(ctx, vecName, "k3", &kv.VectorValues{
|
|
Val: []float64{0.1, 1, -1, 0.5},
|
|
}).Result()
|
|
expectNil(err)
|
|
expectTrue(ok)
|
|
|
|
sim, err := client.VSimWithScores(ctx, vecName, &kv.VectorValues{
|
|
Val: []float64{1, 0, 0, 0},
|
|
}).Result()
|
|
expectNil(err)
|
|
expectEqual(len(sim), 3)
|
|
simMap := make(map[string]float64)
|
|
for _, vi := range sim {
|
|
simMap[vi.Name] = vi.Score
|
|
}
|
|
expectTrue(simMap["k1"] > 0.99)
|
|
expectTrue(simMap["k2"] > 0.99)
|
|
expectTrue(simMap["k3"] < 0.8)
|
|
})
|
|
|
|
It("dimension operation", func() {
|
|
SkipBeforeKVVersion(8.0, "KV 8.0 introduces support for VectorSet")
|
|
vecName := "dimension_op"
|
|
originalDim := 100
|
|
reducedDim := 50
|
|
|
|
v1 := generateRandomVector(originalDim)
|
|
ok, err := client.VAddWithArgs(ctx, vecName, "k1", &v1, &kv.VAddArgs{
|
|
Reduce: int64(reducedDim),
|
|
}).Result()
|
|
expectNil(err)
|
|
expectTrue(ok)
|
|
|
|
info, err := client.VInfo(ctx, vecName).Result()
|
|
expectNil(err)
|
|
dim := info["vector-dim"].(int64)
|
|
oriDim := info["projection-input-dim"].(int64)
|
|
expectEqual(dim, reducedDim)
|
|
expectEqual(oriDim, originalDim)
|
|
|
|
wrongDim := 80
|
|
wrongV := generateRandomVector(wrongDim)
|
|
_, err = client.VAddWithArgs(ctx, vecName, "kw", &wrongV, &kv.VAddArgs{
|
|
Reduce: int64(reducedDim),
|
|
}).Result()
|
|
expectTrue(err != nil)
|
|
|
|
v2 := generateRandomVector(originalDim)
|
|
ok, err = client.VAddWithArgs(ctx, vecName, "k2", &v2, &kv.VAddArgs{
|
|
Reduce: int64(reducedDim),
|
|
}).Result()
|
|
expectNil(err)
|
|
expectTrue(ok)
|
|
})
|
|
|
|
It("remove", func() {
|
|
SkipBeforeKVVersion(8.0, "KV 8.0 introduces support for VectorSet")
|
|
vecName := "remove"
|
|
v1 := generateRandomVector(5)
|
|
ok, err := client.VAdd(ctx, vecName, "k1", &v1).Result()
|
|
expectNil(err)
|
|
expectTrue(ok)
|
|
|
|
exist, err := client.Exists(ctx, vecName).Result()
|
|
expectNil(err)
|
|
expectEqual(exist, 1)
|
|
|
|
ok, err = client.VRem(ctx, vecName, "k1").Result()
|
|
expectNil(err)
|
|
expectTrue(ok)
|
|
|
|
exist, err = client.Exists(ctx, vecName).Result()
|
|
expectNil(err)
|
|
expectEqual(exist, 0)
|
|
})
|
|
|
|
It("all operations", func() {
|
|
SkipBeforeKVVersion(8.0, "KV 8.0 introduces support for VectorSet")
|
|
vecName := "commands"
|
|
vals := []struct {
|
|
name string
|
|
v kv.VectorValues
|
|
attr string
|
|
}{
|
|
{
|
|
name: "k0",
|
|
v: kv.VectorValues{Val: []float64{1, 0, 0, 0}},
|
|
attr: `{"age": 25, "name": "Alice", "active": true, "scores": [85, 90, 95], "city": "New York"}`,
|
|
},
|
|
{
|
|
name: "k1",
|
|
v: kv.VectorValues{Val: []float64{0, 1, 0, 0}},
|
|
attr: `{"age": 30, "name": "Bob", "active": false, "scores": [70, 75, 80], "city": "Boston"}`,
|
|
},
|
|
{
|
|
name: "k2",
|
|
v: kv.VectorValues{Val: []float64{0, 0, 1, 0}},
|
|
attr: `{"age": 35, "name": "Charlie", "scores": [60, 65, 70], "city": "Seattle"}`,
|
|
},
|
|
{
|
|
name: "k3",
|
|
v: kv.VectorValues{Val: []float64{0, 0, 0, 1}},
|
|
},
|
|
{
|
|
name: "k4",
|
|
v: kv.VectorValues{Val: []float64{0.5, 0.5, 0, 0}},
|
|
attr: `invalid json`,
|
|
},
|
|
}
|
|
|
|
// If the key doesn't exist, return null error
|
|
_, err := client.VRandMember(ctx, vecName).Result()
|
|
expectEqual(err.Error(), proto.Nil.Error())
|
|
|
|
// If the key doesn't exist, return an empty array
|
|
res, err := client.VRandMemberCount(ctx, vecName, 3).Result()
|
|
expectNil(err)
|
|
expectEqual(len(res), 0)
|
|
|
|
for _, v := range vals {
|
|
ok, err := client.VAdd(ctx, vecName, v.name, &v.v).Result()
|
|
expectNil(err)
|
|
expectTrue(ok)
|
|
if len(v.attr) > 0 {
|
|
ok, err = client.VSetAttr(ctx, vecName, v.name, v.attr).Result()
|
|
expectNil(err)
|
|
expectTrue(ok)
|
|
}
|
|
}
|
|
|
|
// VGetAttr
|
|
attr, err := client.VGetAttr(ctx, vecName, vals[1].name).Result()
|
|
expectNil(err)
|
|
expectEqual(attr, vals[1].attr)
|
|
|
|
// VRandMember
|
|
_, err = client.VRandMember(ctx, vecName).Result()
|
|
expectNil(err)
|
|
|
|
res, err = client.VRandMemberCount(ctx, vecName, 3).Result()
|
|
expectNil(err)
|
|
expectEqual(len(res), 3)
|
|
|
|
res, err = client.VRandMemberCount(ctx, vecName, 10).Result()
|
|
expectNil(err)
|
|
expectEqual(len(res), len(vals))
|
|
|
|
if KVVersion >= 8.4 {
|
|
res, err = client.VRange(ctx, vecName, "[k1", "[k2", -1).Result()
|
|
expectNil(err)
|
|
expectEqual(len(res), 2)
|
|
|
|
res, err = client.VRange(ctx, vecName, "-", "[k2", -1).Result()
|
|
expectNil(err)
|
|
expectEqual(len(res), 3)
|
|
|
|
res, err = client.VRange(ctx, vecName, "(k1", "+", -1).Result()
|
|
expectNil(err)
|
|
expectEqual(len(res), 3)
|
|
|
|
res, err = client.VRange(ctx, vecName, "[k1", "+", 2).Result()
|
|
expectNil(err)
|
|
expectEqual(len(res), 2)
|
|
}
|
|
|
|
// test equality
|
|
sim, err := client.VSimWithArgs(ctx, vecName, &vals[0].v, &kv.VSimArgs{
|
|
Filter: `.age == 25`,
|
|
}).Result()
|
|
expectNil(err)
|
|
expectEqual(len(sim), 1)
|
|
expectEqual(sim[0], vals[0].name)
|
|
|
|
// test greater than
|
|
sim, err = client.VSimWithArgs(ctx, vecName, &vals[0].v, &kv.VSimArgs{
|
|
Filter: `.age > 25`,
|
|
}).Result()
|
|
expectNil(err)
|
|
expectEqual(len(sim), 2)
|
|
|
|
// test less than or equal
|
|
sim, err = client.VSimWithArgs(ctx, vecName, &vals[0].v, &kv.VSimArgs{
|
|
Filter: `.age <= 30`,
|
|
}).Result()
|
|
expectNil(err)
|
|
expectEqual(len(sim), 2)
|
|
|
|
// test string equality
|
|
sim, err = client.VSimWithArgs(ctx, vecName, &vals[0].v, &kv.VSimArgs{
|
|
Filter: `.name == "Alice"`,
|
|
}).Result()
|
|
expectNil(err)
|
|
expectEqual(len(sim), 1)
|
|
expectEqual(sim[0], vals[0].name)
|
|
|
|
// test string inequality
|
|
sim, err = client.VSimWithArgs(ctx, vecName, &vals[0].v, &kv.VSimArgs{
|
|
Filter: `.name != "Alice"`,
|
|
}).Result()
|
|
expectNil(err)
|
|
expectEqual(len(sim), 2)
|
|
|
|
// test bool
|
|
sim, err = client.VSimWithArgs(ctx, vecName, &vals[0].v, &kv.VSimArgs{
|
|
Filter: `.active`,
|
|
}).Result()
|
|
expectNil(err)
|
|
expectEqual(len(sim), 1)
|
|
expectEqual(sim[0], vals[0].name)
|
|
|
|
// test logical add
|
|
sim, err = client.VSimWithArgs(ctx, vecName, &vals[0].v, &kv.VSimArgs{
|
|
Filter: `.age > 20 and .age < 30`,
|
|
}).Result()
|
|
expectNil(err)
|
|
expectEqual(len(sim), 1)
|
|
expectEqual(sim[0], vals[0].name)
|
|
|
|
// test logical or
|
|
sim, err = client.VSimWithArgs(ctx, vecName, &vals[0].v, &kv.VSimArgs{
|
|
Filter: `.age < 30 or .age > 35`,
|
|
}).Result()
|
|
expectNil(err)
|
|
expectEqual(len(sim), 1)
|
|
expectEqual(sim[0], vals[0].name)
|
|
})
|
|
})
|
|
}
|
|
})
|