Merge branch 'master' into vv-9.7-master-sync

.github/wordlist.txt

@@ -54,6 +54,7 @@ stunnel
 SynDump
 TCP
 TLS
+UnstableResp
 uri
 URI
 url
@@ -62,3 +63,5 @@ RedisStack
 RedisGears
 RedisTimeseries
 RediSearch
+RawResult
+RawVal

.github/workflows/build.yml

@@ -39,7 +39,7 @@ jobs:
         run: make test
 
       - name: Upload to Codecov
-        uses: codecov/codecov-action@v4
+        uses: codecov/codecov-action@v5
         with:
           files: coverage.txt
           token: ${{ secrets.CODECOV_TOKEN }}

.github/workflows/spellcheck.yml

@@ -8,7 +8,7 @@ jobs:
       - name: Checkout
         uses: actions/checkout@v4
       - name: Check Spelling
-        uses: rojopolis/spellcheck-github-actions@0.40.0
+        uses: rojopolis/spellcheck-github-actions@0.45.0
         with:
           config_path: .github/spellcheck-settings.yml
           task_name: Markdown

README.md

@@ -186,6 +186,21 @@ rdb := redis.NewClient(&redis.Options{
 #### Unstable RESP3 Structures for RediSearch Commands
 When integrating Redis with application functionalities using RESP3, it's important to note that some response structures aren't final yet. This is especially true for more complex structures like search and query results. We recommend using RESP2 when using the search and query capabilities, but we plan to stabilize the RESP3-based API-s in the coming versions. You can find more guidance in the upcoming release notes.
 
+To enable unstable RESP3, set the option in your client configuration:
+
+```go
+redis.NewClient(&redis.Options{
+			UnstableResp3: true,
+		})
+```
+**Note:** When UnstableResp3 mode is enabled, it's necessary to use RawResult() and RawVal() to retrieve a raw data.
+          Since, raw response is the only option for unstable search commands Val() and Result() calls wouldn't have any affect on them:
+
+```go
+res1, err := client.FTSearchWithArgs(ctx, "txt", "foo bar", &redis.FTSearchOptions{}).RawResult()
+val1 := client.FTSearchWithArgs(ctx, "txt", "foo bar", &redis.FTSearchOptions{}).RawVal()
+```
+
 ## Contributing
 
 Please see [out contributing guidelines](CONTRIBUTING.md) to help us improve this library!

command.go

@@ -167,6 +167,8 @@ func (cmd *baseCmd) stringArg(pos int) string {
 	switch v := arg.(type) {
 	case string:
 		return v
+	case []byte:
+		return string(v)
 	default:
 		// TODO: consider using appendArg
 		return fmt.Sprint(v)
@@ -1403,27 +1405,63 @@ func (cmd *MapStringSliceInterfaceCmd) Val() map[string][]interface{} {
 }
 
 func (cmd *MapStringSliceInterfaceCmd) readReply(rd *proto.Reader) (err error) {
-	n, err := rd.ReadMapLen()
+	readType, err := rd.PeekReplyType()
 	if err != nil {
 		return err
 	}
-	cmd.val = make(map[string][]interface{}, n)
-	for i := 0; i < n; i++ {
-		k, err := rd.ReadString()
+
+	cmd.val = make(map[string][]interface{})
+
+	if readType == proto.RespMap {
+		n, err := rd.ReadMapLen()
 		if err != nil {
 			return err
 		}
-		nn, err := rd.ReadArrayLen()
+		for i := 0; i < n; i++ {
+			k, err := rd.ReadString()
+			if err != nil {
+				return err
+			}
+			nn, err := rd.ReadArrayLen()
+			if err != nil {
+				return err
+			}
+			cmd.val[k] = make([]interface{}, nn)
+			for j := 0; j < nn; j++ {
+				value, err := rd.ReadReply()
+				if err != nil {
+					return err
+				}
+				cmd.val[k][j] = value
+			}
+		}
+	} else if readType == proto.RespArray {
+		// RESP2 response
+		n, err := rd.ReadArrayLen()
 		if err != nil {
 			return err
 		}
-		cmd.val[k] = make([]interface{}, nn)
-		for j := 0; j < nn; j++ {
-			value, err := rd.ReadReply()
+
+		for i := 0; i < n; i++ {
+			// Each entry in this array is itself an array with key details
+			itemLen, err := rd.ReadArrayLen()
 			if err != nil {
 				return err
 			}
-			cmd.val[k][j] = value
+
+			key, err := rd.ReadString()
+			if err != nil {
+				return err
+			}
+			cmd.val[key] = make([]interface{}, 0, itemLen-1)
+			for j := 1; j < itemLen; j++ {
+				// Read the inner array for timestamp-value pairs
+				data, err := rd.ReadReply()
+				if err != nil {
+					return err
+				}
+				cmd.val[key] = append(cmd.val[key], data)
+			}
 		}
 	}
 

doctests/home_json_example_test.go

@@ -0,0 +1,199 @@
+// EXAMPLE: go_home_json
+// HIDE_START
+package example_commands_test
+
+// HIDE_END
+// STEP_START import
+import (
+	"context"
+	"fmt"
+	"sort"
+
+	"github.com/redis/go-redis/v9"
+)
+
+// STEP_END
+
+func ExampleClient_search_json() {
+	// STEP_START connect
+	ctx := context.Background()
+
+	rdb := redis.NewClient(&redis.Options{
+		Addr:     "localhost:6379",
+		Password: "", // no password docs
+		DB:       0,  // use default DB
+		Protocol: 2,
+	})
+	// STEP_END
+	// REMOVE_START
+	rdb.Del(ctx, "user:1", "user:2", "user:3")
+	rdb.FTDropIndex(ctx, "idx:users")
+	// REMOVE_END
+
+	// STEP_START create_data
+	user1 := map[string]interface{}{
+		"name":  "Paul John",
+		"email": "[email protected]",
+		"age":   42,
+		"city":  "London",
+	}
+
+	user2 := map[string]interface{}{
+		"name":  "Eden Zamir",
+		"email": "[email protected]",
+		"age":   29,
+		"city":  "Tel Aviv",
+	}
+
+	user3 := map[string]interface{}{
+		"name":  "Paul Zamir",
+		"email": "[email protected]",
+		"age":   35,
+		"city":  "Tel Aviv",
+	}
+	// STEP_END
+
+	// STEP_START make_index
+	_, err := rdb.FTCreate(
+		ctx,
+		"idx:users",
+		// Options:
+		&redis.FTCreateOptions{
+			OnJSON: true,
+			Prefix: []interface{}{"user:"},
+		},
+		// Index schema fields:
+		&redis.FieldSchema{
+			FieldName: "$.name",
+			As:        "name",
+			FieldType: redis.SearchFieldTypeText,
+		},
+		&redis.FieldSchema{
+			FieldName: "$.city",
+			As:        "city",
+			FieldType: redis.SearchFieldTypeTag,
+		},
+		&redis.FieldSchema{
+			FieldName: "$.age",
+			As:        "age",
+			FieldType: redis.SearchFieldTypeNumeric,
+		},
+	).Result()
+
+	if err != nil {
+		panic(err)
+	}
+	// STEP_END
+
+	// STEP_START add_data
+	_, err = rdb.JSONSet(ctx, "user:1", "$", user1).Result()
+
+	if err != nil {
+		panic(err)
+	}
+
+	_, err = rdb.JSONSet(ctx, "user:2", "$", user2).Result()
+
+	if err != nil {
+		panic(err)
+	}
+
+	_, err = rdb.JSONSet(ctx, "user:3", "$", user3).Result()
+
+	if err != nil {
+		panic(err)
+	}
+	// STEP_END
+
+	// STEP_START query1
+	findPaulResult, err := rdb.FTSearch(
+		ctx,
+		"idx:users",
+		"Paul @age:[30 40]",
+	).Result()
+
+	if err != nil {
+		panic(err)
+	}
+
+	fmt.Println(findPaulResult)
+	// >>> {1 [{user:3 <nil> <nil> <nil> map[$:{"age":35,"city":"Tel Aviv"...
+	// STEP_END
+
+	// STEP_START query2
+	citiesResult, err := rdb.FTSearchWithArgs(
+		ctx,
+		"idx:users",
+		"Paul",
+		&redis.FTSearchOptions{
+			Return: []redis.FTSearchReturn{
+				{
+					FieldName: "$.city",
+					As:        "city",
+				},
+			},
+		},
+	).Result()
+
+	if err != nil {
+		panic(err)
+	}
+
+	sort.Slice(citiesResult.Docs, func(i, j int) bool {
+		return citiesResult.Docs[i].Fields["city"] < citiesResult.Docs[j].Fields["city"]
+	})
+
+	for _, result := range citiesResult.Docs {
+		fmt.Println(result.Fields["city"])
+	}
+	// >>> London
+	// >>> Tel Aviv
+	// STEP_END
+
+	// STEP_START query3
+	aggOptions := redis.FTAggregateOptions{
+		GroupBy: []redis.FTAggregateGroupBy{
+			{
+				Fields: []interface{}{"@city"},
+				Reduce: []redis.FTAggregateReducer{
+					{
+						Reducer: redis.SearchCount,
+						As:      "count",
+					},
+				},
+			},
+		},
+	}
+
+	aggResult, err := rdb.FTAggregateWithArgs(
+		ctx,
+		"idx:users",
+		"*",
+		&aggOptions,
+	).Result()
+
+	if err != nil {
+		panic(err)
+	}
+
+	sort.Slice(aggResult.Rows, func(i, j int) bool {
+		return aggResult.Rows[i].Fields["city"].(string) <
+			aggResult.Rows[j].Fields["city"].(string)
+	})
+
+	for _, row := range aggResult.Rows {
+		fmt.Printf("%v - %v\n",
+			row.Fields["city"], row.Fields["count"],
+		)
+	}
+	// >>> City: London - 1
+	// >>> City: Tel Aviv - 2
+	// STEP_END
+
+	// Output:
+	// {1 [{user:3 <nil> <nil> <nil> map[$:{"age":35,"city":"Tel Aviv","email":"[email protected]","name":"Paul Zamir"}]}]}
+	// London
+	// Tel Aviv
+	// London - 1
+	// Tel Aviv - 2
+}