Support Vector Similarity

redisearch/query.go

@@ -93,6 +93,8 @@ type Query struct {
 	SortBy        *SortingKey
 	HighlightOpts *HighlightOptions
 	SummarizeOpts *SummaryOptions
+	Params        map[string]interface{}
+	Dialect       int
 }
 
 // Paging represents the offset paging of a search result
@@ -227,6 +229,18 @@ func (q Query) serialize() redis.Args {
 			}
 		}
 	}
+
+	if q.Params != nil {
+		args = args.Add("PARAMS", len(q.Params) * 2)
+		for name, value := range q.Params {
+			args = args.Add(name, value)
+		}
+	}
+
+	if q.Dialect != 0 {
+		args = args.Add("DIALECT", q.Dialect)
+	}
+
 	return args
 }
 
@@ -370,6 +384,29 @@ func (q *Query) SummarizeOptions(opts SummaryOptions) *Query {
 	return q
 }
 
+// SetParams sets parameters that can be referenced in the query string by a $ , followed by the parameter name,
+// e.g., $user , and each such reference in the search query to a parameter name is substituted
+// by the corresponding parameter value.
+func (q *Query) SetParams(params map[string]interface{}) *Query {
+	q.Params = params
+	return q
+}
+
+// AddParam adds a new param to the parameters list
+func (q *Query) AddParam(name string, value interface{}) *Query {
+	if q.Params == nil {
+		q.Params = make(map[string]interface{})
+	}
+	q.Params[name] = value;
+	return q
+}
+
+// SetDialect can have one of 2 options - 1 or 2
+func (q *Query) SetDialect(dialect int) *Query {
+	q.Dialect = dialect
+	return q
+}
+
 // IndexOptions indexes multiple documents on the index, with optional Options passed to options
 func (i *Client) IndexOptions(opts IndexingOptions, docs ...Document) error {
 

redisearch/query_test.go

@@ -79,6 +79,8 @@ func TestQuery_serialize(t *testing.T) {
 		SortBy        *SortingKey
 		HighlightOpts *HighlightOptions
 		SummarizeOpts *SummaryOptions
+		Params        map[string]interface{}
+		Dialect       int
 	}
 	tests := []struct {
 		name   string
@@ -111,6 +113,8 @@ func TestQuery_serialize(t *testing.T) {
 			NumFragments: 3,
 			Separator:    "...",
 		}}, redis.Args{raw, "LIMIT", 0, 0, "SUMMARIZE", "FIELDS", 1, "test_field", "LEN", 20, "FRAGS", 3, "SEPARATOR", "..."}},
+		{"Params", fields{Raw: raw, Params: map[string]interface{}{"min": 1, "max": 2}}, redis.Args{raw, "LIMIT", 0, 0, "PARAMS", 4, "min", 1, "max", 2}},
+		{"Dialect", fields{Raw: raw, Dialect: 2}, redis.Args{raw, "LIMIT", 0, 0, "DIALECT", 2}},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
@@ -126,6 +130,8 @@ func TestQuery_serialize(t *testing.T) {
 				SortBy:        tt.fields.SortBy,
 				HighlightOpts: tt.fields.HighlightOpts,
 				SummarizeOpts: tt.fields.SummarizeOpts,
+				Params:        tt.fields.Params,
+				Dialect:       tt.fields.Dialect,
 			}
 			if g := q.serialize(); !reflect.DeepEqual(g, tt.want) {
 				t.Errorf("serialize() = %v, want %v", g, tt.want)

redisearch/schema.go

@@ -135,6 +135,9 @@ const (
 
 	// TagField is a field used for compact indexing of comma separated values
 	TagField
+
+	//VectorField allows vector similarity queries against the value in this attribute.
+	VectorField
 )
 
 // Phonetic Matchers
@@ -185,6 +188,20 @@ type GeoFieldOptions struct {
 	As      string
 }
 
+type algorithm string
+
+// Supported algorithms for Vector field
+const (
+	Flat algorithm = "FLAT"
+	HNSW algorithm = "HNSW"
+)
+
+// VectorFieldOptions Options for vector fields
+type VectorFieldOptions struct {
+	Algorithm  algorithm
+	Attributes map[string]interface{}
+}
+
 // NewTextField creates a new text field with the given weight
 func NewTextField(name string) Field {
 	return Field{
@@ -268,6 +285,15 @@ func NewGeoFieldOptions(name string, options GeoFieldOptions) Field {
 	return f
 }
 
+// NewVectorFieldOptions creates a new geo field with the given name and additional options
+func NewVectorFieldOptions(name string, options VectorFieldOptions) Field {
+	return Field{
+		Name:    name,
+		Type:    VectorField,
+		Options: options,
+	}
+}
+
 // Schema represents an index schema Schema, or how the index would
 // treat documents sent to it.
 type Schema struct {
@@ -417,6 +443,26 @@ func serializeField(f Field, args redis.Args) (argsOut redis.Args, err error) {
 				argsOut = append(argsOut, "NOINDEX")
 			}
 		}
+	case VectorField:
+		argsOut = append(argsOut, f.Name, "VECTOR")
+		if f.Options != nil {
+			opts, ok := f.Options.(VectorFieldOptions)
+			if !ok {
+				err = fmt.Errorf("Error on VectorField serialization")
+				return
+			}
+			if opts.Algorithm != "" {
+				argsOut = append(argsOut, opts.Algorithm)
+			}
+			if opts.Attributes != nil {
+				var flat []interface{}
+				for attrName, attrValue := range opts.Attributes {
+					flat = append(flat, attrName, attrValue)
+				}
+				argsOut = append(argsOut, len(flat))
+				argsOut = append(argsOut, flat...)
+			}
+		}
 	default:
 		err = fmt.Errorf("Unrecognized field type %v serialization", f.Type)
 		return

redisearch/schema_test.go

@@ -74,6 +74,7 @@ func TestSerializeSchema(t *testing.T) {
 		{"default-and-tag", args{NewSchema(DefaultOptions).AddField(NewTagField("tag-field")), redis.Args{}}, redis.Args{"SCHEMA", "tag-field", "TAG", "SEPARATOR", ","}, false},
 		{"default-and-tag-with-options", args{NewSchema(DefaultOptions).AddField(NewTagFieldOptions("tag-field", TagFieldOptions{Sortable: true, NoIndex: false, Separator: byte(','), As: "field"})), redis.Args{}}, redis.Args{"SCHEMA", "tag-field", "AS", "field", "TAG", "SEPARATOR", ",", "SORTABLE"}, false},
 		{"default-geo-with-options", args{NewSchema(DefaultOptions).AddField(NewGeoFieldOptions("location", GeoFieldOptions{As: "loc"})), redis.Args{}}, redis.Args{"SCHEMA", "location", "AS", "loc", "GEO"}, false},
+		{"default-vector", args{NewSchema(DefaultOptions).AddField(NewVectorFieldOptions("vec", VectorFieldOptions{Algorithm: Flat, Attributes: map[string]interface{}{"TYPE": "FLOAT32", "DIM": 128, "DISTANCE_METRIC": "L2"}})), redis.Args{}}, redis.Args{"SCHEMA", "vec", "VECTOR", Flat, 6, "TYPE", "FLOAT32", "DIM", 128, "DISTANCE_METRIC", "L2"}, false},
 		{"error-unsupported", args{NewSchema(DefaultOptions).AddField(Field{Type: 10}), redis.Args{}}, nil, true},
 	}
 	for _, tt := range tests {