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.
97 lines
2.1 KiB
Go
97 lines
2.1 KiB
Go
package helper
|
|
|
|
import "testing"
|
|
|
|
// Golden values from KV DIGEST command:
|
|
// kv-cli SET testkey myvalue && kv-cli DIGEST testkey
|
|
// Returns: "5a32b091fa5dafe7" (hex) = 6499451353266237415 (decimal)
|
|
//
|
|
// KV source (t_string.c):
|
|
//
|
|
// hash = XXH3_64bits(o->ptr, sdslen(o->ptr)); // No seed parameter!
|
|
const (
|
|
goldenTestValue = "myvalue"
|
|
goldenKVDigest = uint64(0x5a32b091fa5dafe7) // 6499451353266237415
|
|
)
|
|
|
|
func TestDigestString_KVCompatibility(t *testing.T) {
|
|
digest := DigestString(goldenTestValue)
|
|
|
|
if digest != goldenKVDigest {
|
|
t.Errorf("DigestString(%q) = 0x%016x, want 0x%016x (KV DIGEST)",
|
|
goldenTestValue, digest, goldenKVDigest)
|
|
}
|
|
}
|
|
|
|
func TestDigestBytes_KVCompatibility(t *testing.T) {
|
|
digest := DigestBytes([]byte(goldenTestValue))
|
|
|
|
if digest != goldenKVDigest {
|
|
t.Errorf("DigestBytes(%q) = 0x%016x, want 0x%016x (KV DIGEST)",
|
|
goldenTestValue, digest, goldenKVDigest)
|
|
}
|
|
}
|
|
|
|
func TestDigestString_EqualsDigestBytes(t *testing.T) {
|
|
testCases := []string{
|
|
"",
|
|
"a",
|
|
"hello",
|
|
"hello world",
|
|
"The quick brown fox jumps over the lazy dog",
|
|
string(make([]byte, 1024)),
|
|
}
|
|
|
|
for _, s := range testCases {
|
|
stringDigest := DigestString(s)
|
|
bytesDigest := DigestBytes([]byte(s))
|
|
|
|
if stringDigest != bytesDigest {
|
|
t.Errorf("DigestString(%q) = 0x%016x, DigestBytes = 0x%016x, mismatch!",
|
|
s, stringDigest, bytesDigest)
|
|
}
|
|
}
|
|
}
|
|
|
|
// Benchmark to verify performance characteristics
|
|
func BenchmarkDigestString(b *testing.B) {
|
|
sizes := []struct {
|
|
name string
|
|
data string
|
|
}{
|
|
{"8B", "12345678"},
|
|
{"64B", "0123456789012345678901234567890123456789012345678901234567890123"},
|
|
{"1KB", string(make([]byte, 1024))},
|
|
}
|
|
|
|
for _, tc := range sizes {
|
|
b.Run(tc.name, func(b *testing.B) {
|
|
b.SetBytes(int64(len(tc.data)))
|
|
for i := 0; i < b.N; i++ {
|
|
_ = DigestString(tc.data)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func BenchmarkDigestBytes(b *testing.B) {
|
|
sizes := []struct {
|
|
name string
|
|
data []byte
|
|
}{
|
|
{"8B", make([]byte, 8)},
|
|
{"64B", make([]byte, 64)},
|
|
{"1KB", make([]byte, 1024)},
|
|
}
|
|
|
|
for _, tc := range sizes {
|
|
b.Run(tc.name, func(b *testing.B) {
|
|
b.SetBytes(int64(len(tc.data)))
|
|
for i := 0; i < b.N; i++ {
|
|
_ = DigestBytes(tc.data)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|