Redis rejson extension built upon go-redis
go get github.com/KromDaniel/rejonsongo get github.com/KromDaniel/rejonson/v7go get github.com/KromDaniel/rejonson/v8go get github.com/KromDaniel/rejonson/v9import (
"github.com/KromDaniel/rejonson"
"github.com/go-redis/redis"
)
func FunctionalApi(client *redis.Client) {
// all rejonson.JsonX functions accepts redis.Client or redis.Pipeline
// notice that some versions of go-redis also require context.Context (which is supported by rejonson)
jsonStringCmd := rejonson.JsonGet(client, "key")
if err := jsonStringCmd.Err(); err != nil {
panic(err)
}
pipeline := client.Pipeline()
rejonson.JsonGet(pipeline, "key")
cmds, err := pipeline.Exec()
// do something with cmds, err
}
func ExtendClient(client *redis.Client) *rejonson.Client {
// You can extend go-redis client to rejonson.Client
// that will have all JSON API as methods
rejonsonClient := rejonson.ExtendClient(client)
pingCmd := rejonsonClient.Ping()
jsonCmd := rejonsonClient.JsonDel("key")
return rejonsonClient
}Rejonson exports JsonX functions, all of them accept RedisProcessor as first parameter and context.Context (for go-redis versions >= 8) as second parameter, the other parameters are command specific
RedisProcessor is interface with the following definition:
type RedisProcessor interface {
Process(redis.Cmder) error
}type RedisProcessor interface {
Process(context.Context, redis.Cmder) error
}By default all *redis.Client, redis.Pipeliner, *redis.ClusterClient, *redis.SentinelClient implenets that interface, so you can pass any of them to the rejonson functional API
client := redis.NewClient(&redis.Options{ /*...*/ })
res := rejonson.JsonMGet(client, "key1", "key2", "$..a")
if res.Err() != nil {
// handle error
}
for _, value := range res.Val() {
// do something with value
}Extends go-redis client with all ReJSON abilities, so you can use directly the rejson client for all redis usage and commands.
// go redis client
goRedisClient := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
client := rejonson.ExtendClient(goRedisClient)
defer client.Close()
arr := []interface{}{"hello", "world", 1, map[string]interface{}{"key": 12}}
js, err := json.Marshal(arr)
if err != nil {
// handle
}
// redis "native" command
client.Set("go-redis-cmd", "hello", time.Second)
// rejson command
client.JsonSet("rejson-cmd", ".", string(js))
// int command
arrLen, err := client.JsonArrLen("rejson-cmd", ".").Result()
if err != nil {
// handle
}
fmt.Printf("Array length: %d", arrLen)
// Output: Array length: 4Client will also return extended Pipeline and TXPipeline
goRedisClient := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
client := rejonson.ExtendClient(goRedisClient)
pipeline := client.Pipeline()
pipeline.JsonSet("rejson-cmd-pipeline", ".", "[10]")
pipeline.JsonNumMultBy("rejson-cmd-pipeline", "[0]", 10)
pipeline.Set("go-redis-pipeline-command", "hello from go-redis", time.Second)
_, err := pipeline.Exec()
if err != nil {
// handle error
}
jsonString, err := client.JsonGet("rejson-cmd-pipeline").Result()
if err != nil {
// handle error
}
fmt.Printf("Array %s", jsonString)
// Output: Array [100]Rejonson implements all the methods as described at ReJson Commands except for JSON.DEBUG and JSON.RESP.
The args will be serialized to redis directly so make sure to read ReJSON command docs
All the rejson methods starts with the prefix of Json e.g JsonDel, JsonArrIndex, JsonMGet.
Each command returns specific go-redis.Cmder by the specific request.
Due to some ReJSON bug - #issue-76, some empty strings will be ignored.
Rejonson depends only on go-redis. The testing also depends on assert library
Rejonson tests must use real redis with ReJson module to run
It is recommended to run the tests when using rejonson.
The unit tests will make sure your go-redis version is compatible and your rejson plugin supports all the methods and working as expected.
The testing library depends on assert library
Apache 2.0
For any question or contribution, feel free to open an issue.