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.
243 lines
4.1 KiB
Go
243 lines
4.1 KiB
Go
package proto
|
|
|
|
import (
|
|
"encoding"
|
|
"fmt"
|
|
"io"
|
|
"net"
|
|
"strconv"
|
|
"time"
|
|
|
|
"github.com/hanzokv/go/v9/internal/util"
|
|
)
|
|
|
|
type writer interface {
|
|
io.Writer
|
|
io.ByteWriter
|
|
// WriteString implement io.StringWriter.
|
|
WriteString(s string) (n int, err error)
|
|
}
|
|
|
|
type Writer struct {
|
|
writer
|
|
|
|
lenBuf []byte
|
|
numBuf []byte
|
|
}
|
|
|
|
func NewWriter(wr writer) *Writer {
|
|
return &Writer{
|
|
writer: wr,
|
|
|
|
lenBuf: make([]byte, 64),
|
|
numBuf: make([]byte, 64),
|
|
}
|
|
}
|
|
|
|
func (w *Writer) WriteArgs(args []interface{}) error {
|
|
if err := w.WriteByte(RespArray); err != nil {
|
|
return err
|
|
}
|
|
|
|
if err := w.writeLen(len(args)); err != nil {
|
|
return err
|
|
}
|
|
|
|
for _, arg := range args {
|
|
if err := w.WriteArg(arg); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (w *Writer) writeLen(n int) error {
|
|
w.lenBuf = strconv.AppendUint(w.lenBuf[:0], uint64(n), 10)
|
|
w.lenBuf = append(w.lenBuf, '\r', '\n')
|
|
_, err := w.Write(w.lenBuf)
|
|
return err
|
|
}
|
|
|
|
func (w *Writer) WriteArg(v interface{}) error {
|
|
switch v := v.(type) {
|
|
case nil:
|
|
return w.string("")
|
|
case string:
|
|
return w.string(v)
|
|
case *string:
|
|
if v == nil {
|
|
return w.string("")
|
|
}
|
|
return w.string(*v)
|
|
case []byte:
|
|
return w.bytes(v)
|
|
case int:
|
|
return w.int(int64(v))
|
|
case *int:
|
|
if v == nil {
|
|
return w.int(0)
|
|
}
|
|
return w.int(int64(*v))
|
|
case int8:
|
|
return w.int(int64(v))
|
|
case *int8:
|
|
if v == nil {
|
|
return w.int(0)
|
|
}
|
|
return w.int(int64(*v))
|
|
case int16:
|
|
return w.int(int64(v))
|
|
case *int16:
|
|
if v == nil {
|
|
return w.int(0)
|
|
}
|
|
return w.int(int64(*v))
|
|
case int32:
|
|
return w.int(int64(v))
|
|
case *int32:
|
|
if v == nil {
|
|
return w.int(0)
|
|
}
|
|
return w.int(int64(*v))
|
|
case int64:
|
|
return w.int(v)
|
|
case *int64:
|
|
if v == nil {
|
|
return w.int(0)
|
|
}
|
|
return w.int(*v)
|
|
case uint:
|
|
return w.uint(uint64(v))
|
|
case *uint:
|
|
if v == nil {
|
|
return w.uint(0)
|
|
}
|
|
return w.uint(uint64(*v))
|
|
case uint8:
|
|
return w.uint(uint64(v))
|
|
case *uint8:
|
|
if v == nil {
|
|
return w.string("")
|
|
}
|
|
return w.uint(uint64(*v))
|
|
case uint16:
|
|
return w.uint(uint64(v))
|
|
case *uint16:
|
|
if v == nil {
|
|
return w.uint(0)
|
|
}
|
|
return w.uint(uint64(*v))
|
|
case uint32:
|
|
return w.uint(uint64(v))
|
|
case *uint32:
|
|
if v == nil {
|
|
return w.uint(0)
|
|
}
|
|
return w.uint(uint64(*v))
|
|
case uint64:
|
|
return w.uint(v)
|
|
case *uint64:
|
|
if v == nil {
|
|
return w.uint(0)
|
|
}
|
|
return w.uint(*v)
|
|
case float32:
|
|
return w.float(float64(v))
|
|
case *float32:
|
|
if v == nil {
|
|
return w.float(0)
|
|
}
|
|
return w.float(float64(*v))
|
|
case float64:
|
|
return w.float(v)
|
|
case *float64:
|
|
if v == nil {
|
|
return w.float(0)
|
|
}
|
|
return w.float(*v)
|
|
case bool:
|
|
if v {
|
|
return w.int(1)
|
|
}
|
|
return w.int(0)
|
|
case *bool:
|
|
if v == nil {
|
|
return w.int(0)
|
|
}
|
|
if *v {
|
|
return w.int(1)
|
|
}
|
|
return w.int(0)
|
|
case time.Time:
|
|
w.numBuf = v.AppendFormat(w.numBuf[:0], time.RFC3339Nano)
|
|
return w.bytes(w.numBuf)
|
|
case *time.Time:
|
|
if v == nil {
|
|
v = &time.Time{}
|
|
}
|
|
w.numBuf = v.AppendFormat(w.numBuf[:0], time.RFC3339Nano)
|
|
return w.bytes(w.numBuf)
|
|
case time.Duration:
|
|
return w.int(v.Nanoseconds())
|
|
case *time.Duration:
|
|
if v == nil {
|
|
return w.int(0)
|
|
}
|
|
return w.int(v.Nanoseconds())
|
|
case encoding.BinaryMarshaler:
|
|
b, err := v.MarshalBinary()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return w.bytes(b)
|
|
case net.IP:
|
|
return w.bytes(v)
|
|
default:
|
|
return fmt.Errorf(
|
|
"kv: can't marshal %T (implement encoding.BinaryMarshaler)", v)
|
|
}
|
|
}
|
|
|
|
func (w *Writer) bytes(b []byte) error {
|
|
if err := w.WriteByte(RespString); err != nil {
|
|
return err
|
|
}
|
|
|
|
if err := w.writeLen(len(b)); err != nil {
|
|
return err
|
|
}
|
|
|
|
if _, err := w.Write(b); err != nil {
|
|
return err
|
|
}
|
|
|
|
return w.crlf()
|
|
}
|
|
|
|
func (w *Writer) string(s string) error {
|
|
return w.bytes(util.StringToBytes(s))
|
|
}
|
|
|
|
func (w *Writer) uint(n uint64) error {
|
|
w.numBuf = strconv.AppendUint(w.numBuf[:0], n, 10)
|
|
return w.bytes(w.numBuf)
|
|
}
|
|
|
|
func (w *Writer) int(n int64) error {
|
|
w.numBuf = strconv.AppendInt(w.numBuf[:0], n, 10)
|
|
return w.bytes(w.numBuf)
|
|
}
|
|
|
|
func (w *Writer) float(f float64) error {
|
|
w.numBuf = strconv.AppendFloat(w.numBuf[:0], f, 'f', -1, 64)
|
|
return w.bytes(w.numBuf)
|
|
}
|
|
|
|
func (w *Writer) crlf() error {
|
|
if err := w.WriteByte('\r'); err != nil {
|
|
return err
|
|
}
|
|
return w.WriteByte('\n')
|
|
}
|