From a790394fb680d7b0eae1b2e78162cc282ef720ab Mon Sep 17 00:00:00 2001 From: Eric Chang Date: Fri, 25 Oct 2024 08:51:42 +0800 Subject: [PATCH 01/49] feat: wip: implement SearchCmdable --- rueidiscompat/adapter.go | 62 +++++++++++++++---------------- rueidiscompat/command.go | 79 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 110 insertions(+), 31 deletions(-) diff --git a/rueidiscompat/adapter.go b/rueidiscompat/adapter.go index d6ee60bd..e3e8dfb7 100644 --- a/rueidiscompat/adapter.go +++ b/rueidiscompat/adapter.go @@ -425,40 +425,40 @@ type CoreCmdable interface { ProbabilisticCmdable TimeseriesCmdable JSONCmdable - // TODO SearchCmdable + SearchCmdable } // TODO SearchCmdable -//type SearchCmdable interface { -// FT_List(ctx context.Context) *StringSliceCmd -// FTAggregate(ctx context.Context, index string, query string) *MapStringInterfaceCmd -// FTAggregateWithArgs(ctx context.Context, index string, query string, options *FTAggregateOptions) *AggregateCmd -// FTAliasAdd(ctx context.Context, index string, alias string) *StatusCmd -// FTAliasDel(ctx context.Context, alias string) *StatusCmd -// FTAliasUpdate(ctx context.Context, index string, alias string) *StatusCmd -// FTAlter(ctx context.Context, index string, skipInitalScan bool, definition []interface{}) *StatusCmd -// FTConfigGet(ctx context.Context, option string) *MapMapStringInterfaceCmd -// FTConfigSet(ctx context.Context, option string, value interface{}) *StatusCmd -// FTCreate(ctx context.Context, index string, options *FTCreateOptions, schema ...*FieldSchema) *StatusCmd -// FTCursorDel(ctx context.Context, index string, cursorId int) *StatusCmd -// FTCursorRead(ctx context.Context, index string, cursorId int, count int) *MapStringInterfaceCmd -// FTDictAdd(ctx context.Context, dict string, term ...interface{}) *IntCmd -// FTDictDel(ctx context.Context, dict string, term ...interface{}) *IntCmd -// FTDictDump(ctx context.Context, dict string) *StringSliceCmd -// FTDropIndex(ctx context.Context, index string) *StatusCmd -// FTDropIndexWithArgs(ctx context.Context, index string, options *FTDropIndexOptions) *StatusCmd -// FTExplain(ctx context.Context, index string, query string) *StringCmd -// FTExplainWithArgs(ctx context.Context, index string, query string, options *FTExplainOptions) *StringCmd -// FTInfo(ctx context.Context, index string) *FTInfoCmd -// FTSpellCheck(ctx context.Context, index string, query string) *FTSpellCheckCmd -// FTSpellCheckWithArgs(ctx context.Context, index string, query string, options *FTSpellCheckOptions) *FTSpellCheckCmd -// FTSearch(ctx context.Context, index string, query string) *FTSearchCmd -// FTSearchWithArgs(ctx context.Context, index string, query string, options *FTSearchOptions) *FTSearchCmd -// FTSynDump(ctx context.Context, index string) *FTSynDumpCmd -// FTSynUpdate(ctx context.Context, index string, synGroupId interface{}, terms []interface{}) *StatusCmd -// FTSynUpdateWithArgs(ctx context.Context, index string, synGroupId interface{}, options *FTSynUpdateOptions, terms []interface{}) *StatusCmd -// FTTagVals(ctx context.Context, index string, field string) *StringSliceCmd -//} +type SearchCmdable interface { + FT_List(ctx context.Context) *StringSliceCmd + FTAggregate(ctx context.Context, index string, query string) *MapStringInterfaceCmd + FTAggregateWithArgs(ctx context.Context, index string, query string, options *FTAggregateOptions) *AggregateCmd + FTAliasAdd(ctx context.Context, index string, alias string) *StatusCmd + FTAliasDel(ctx context.Context, alias string) *StatusCmd + FTAliasUpdate(ctx context.Context, index string, alias string) *StatusCmd + FTAlter(ctx context.Context, index string, skipInitalScan bool, definition []interface{}) *StatusCmd + FTConfigGet(ctx context.Context, option string) *MapMapStringInterfaceCmd + FTConfigSet(ctx context.Context, option string, value interface{}) *StatusCmd + FTCreate(ctx context.Context, index string, options *FTCreateOptions, schema ...*FieldSchema) *StatusCmd + FTCursorDel(ctx context.Context, index string, cursorId int) *StatusCmd + FTCursorRead(ctx context.Context, index string, cursorId int, count int) *MapStringInterfaceCmd + FTDictAdd(ctx context.Context, dict string, term ...interface{}) *IntCmd + FTDictDel(ctx context.Context, dict string, term ...interface{}) *IntCmd + FTDictDump(ctx context.Context, dict string) *StringSliceCmd + FTDropIndex(ctx context.Context, index string) *StatusCmd + FTDropIndexWithArgs(ctx context.Context, index string, options *FTDropIndexOptions) *StatusCmd + FTExplain(ctx context.Context, index string, query string) *StringCmd + FTExplainWithArgs(ctx context.Context, index string, query string, options *FTExplainOptions) *StringCmd + FTInfo(ctx context.Context, index string) *FTInfoCmd + FTSpellCheck(ctx context.Context, index string, query string) *FTSpellCheckCmd + FTSpellCheckWithArgs(ctx context.Context, index string, query string, options *FTSpellCheckOptions) *FTSpellCheckCmd + FTSearch(ctx context.Context, index string, query string) *FTSearchCmd + FTSearchWithArgs(ctx context.Context, index string, query string, options *FTSearchOptions) *FTSearchCmd + FTSynDump(ctx context.Context, index string) *FTSynDumpCmd + FTSynUpdate(ctx context.Context, index string, synGroupId interface{}, terms []interface{}) *StatusCmd + FTSynUpdateWithArgs(ctx context.Context, index string, synGroupId interface{}, options *FTSynUpdateOptions, terms []interface{}) *StatusCmd + FTTagVals(ctx context.Context, index string, field string) *StringSliceCmd +} // https://github.com/redis/go-redis/blob/af4872cbd0de349855ce3f0978929c2f56eb995f/probabilistic.go#L10 type ProbabilisticCmdable interface { diff --git a/rueidiscompat/command.go b/rueidiscompat/command.go index 699f8706..4fd00638 100644 --- a/rueidiscompat/command.go +++ b/rueidiscompat/command.go @@ -3348,3 +3348,82 @@ func newJSONSliceCmd(res rueidis.RedisResult) *JSONSliceCmd { cmd.from(res) return cmd } + +type MapMapStringInterfaceCmd struct { + // FIXME: add impl +} + +func (cmd *MapMapStringInterfaceCmd) from(res rueidis.RedisResult) { +} + +func newMapMapStringInterfaceCmd(res rueidis.RedisResult) *MapMapStringInterfaceCmd { + cmd := &MapMapStringInterfaceCmd{} + cmd.from(res) + return cmd +} + +type FTAggregateOptions struct { + // FIXME +} + +type AggregateCmd struct { + // FIXME +} + +type FTCreateOptions struct{} +type FieldSchema struct{} +type FTDropIndexOptions struct{} +type FTExplainOptions struct{} +type FTInfoCmd struct{} + +func (cmd *FTInfoCmd) from(res rueidis.RedisResult) { + // FIXME: impl +} + +func newFTInfoCmd(res rueidis.RedisResult) *FTInfoCmd { + cmd := &FTInfoCmd{} + cmd.from(res) + return cmd +} + +type FTSpellCheckOptions struct{} + +type FTSpellCheckCmd struct{} + +func (cmd *FTSpellCheckCmd) from(res rueidis.RedisResult) { + // FIXME: impl +} + +func newFTSpellCheckCmd(res rueidis.RedisResult) *FTSpellCheckCmd { + cmd := &FTSpellCheckCmd{} + cmd.from(res) + return cmd +} + +type FTSearchCmd struct{} + +func (cmd *FTSearchCmd) from(res rueidis.RedisResult) { + // FIXME: impl +} + +func newFTSearchCmd(res rueidis.RedisResult) *FTSearchCmd { + cmd := &FTSearchCmd{} + cmd.from(res) + return cmd +} + +type FTSearchOptions struct{} + +type FTSynDumpCmd struct{} + +func (cmd *FTSynDumpCmd) from(res rueidis.RedisResult) { + // FIXME: impl +} + +func newFTSynDumpCmd(res rueidis.RedisResult) *FTSynDumpCmd { + cmd := &FTSynDumpCmd{} + cmd.from(res) + return cmd +} + +type FTSynUpdateOptions struct{} From 06ad288f6849a0bc6336e6527e29db62a3f0fb98 Mon Sep 17 00:00:00 2001 From: Eric Chang Date: Tue, 29 Oct 2024 07:08:15 +0800 Subject: [PATCH 02/49] feat(RediSearch): wip --- rueidiscompat/adapter_test.go | 1309 ++++++++++++++++++++++++++++++++- rueidiscompat/command.go | 32 +- 2 files changed, 1338 insertions(+), 3 deletions(-) diff --git a/rueidiscompat/adapter_test.go b/rueidiscompat/adapter_test.go index ea0f1ac2..ea257072 100644 --- a/rueidiscompat/adapter_test.go +++ b/rueidiscompat/adapter_test.go @@ -11545,6 +11545,1296 @@ func testAdapterCache(resp3 bool) { }) }) }) + + Describe("RediSearch commands Resp 2", Label("search"), func() { + ctx := context.TODO() + + BeforeEach(func() { + Expect(adapter.FlushDB(ctx).Err()).NotTo(HaveOccurred()) + }) + + It("should FTCreate and FTSearch WithScores", Label("search", "ftcreate", "ftsearch"), func() { + // FIXME: FieldType + val, err := adapter.FTCreate(ctx, "txt", &FTCreateOptions{}, &FieldSchema{FieldName: "txt", FieldType: SearchFieldTypeText}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(val).To(BeEquivalentTo("OK")) + WaitForIndexing(clientresp2, "txt") + adapter.HSet(ctx, "doc1", "txt", "foo baz") + adapter.HSet(ctx, "doc2", "txt", "foo bar") + res, err := adapter.FTSearchWithArgs(ctx, "txt", "foo ~bar", &FTSearchOptions{WithScores: true}).Result() + + Expect(err).NotTo(HaveOccurred()) + Expect(res.Total).To(BeEquivalentTo(int64(2))) + for _, doc := range res.Docs { + Expect(*doc.Score).To(BeNumerically(">", 0)) + Expect(doc.ID).To(Or(Equal("doc1"), Equal("doc2"))) + } + }) + + It("should FTCreate and FTSearch stopwords", Label("search", "ftcreate", "ftsearch"), func() { + val, err := adapter.FTCreate(ctx, "txt", &FTCreateOptions{StopWords: []interface{}{"foo", "bar", "baz"}}, &FieldSchema{FieldName: "txt", FieldType: SearchFieldTypeText}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(val).To(BeEquivalentTo("OK")) + WaitForIndexing(clientresp2, "txt") + adapter.HSet(ctx, "doc1", "txt", "foo baz") + adapter.HSet(ctx, "doc2", "txt", "hello world") + res1, err := adapter.FTSearchWithArgs(ctx, "txt", "foo bar", &FTSearchOptions{NoContent: true}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res1.Total).To(BeEquivalentTo(int64(0))) + res2, err := adapter.FTSearchWithArgs(ctx, "txt", "foo bar hello world", &FTSearchOptions{NoContent: true}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res2.Total).To(BeEquivalentTo(int64(1))) + }) + + It("should FTCreate and FTSearch filters", Label("search", "ftcreate", "ftsearch"), func() { + val, err := adapter.FTCreate(ctx, "txt", &FTCreateOptions{}, &FieldSchema{FieldName: "txt", FieldType: SearchFieldTypeText}, &FieldSchema{FieldName: "num", FieldType: SearchFieldTypeNumeric}, &FieldSchema{FieldName: "loc", FieldType: SearchFieldTypeGeo}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(val).To(BeEquivalentTo("OK")) + WaitForIndexing(clientresp2, "txt") + adapter.HSet(ctx, "doc1", "txt", "foo bar", "num", 3.141, "loc", "-0.441,51.458") + adapter.HSet(ctx, "doc2", "txt", "foo baz", "num", 2, "loc", "-0.1,51.2") + res1, err := adapter.FTSearchWithArgs(ctx, "txt", "foo", &FTSearchOptions{Filters: []FTSearchFilter{{FieldName: "num", Min: 0, Max: 2}}, NoContent: true}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res1.Total).To(BeEquivalentTo(int64(1))) + Expect(res1.Docs[0].ID).To(BeEquivalentTo("doc2")) + res2, err := adapter.FTSearchWithArgs(ctx, "txt", "foo", &FTSearchOptions{Filters: []FTSearchFilter{{FieldName: "num", Min: 0, Max: "+inf"}}, NoContent: true}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res2.Total).To(BeEquivalentTo(int64(2))) + Expect(res2.Docs[0].ID).To(BeEquivalentTo("doc1")) + // Test Geo filter + geoFilter1 := FTSearchGeoFilter{FieldName: "loc", Longitude: -0.44, Latitude: 51.45, Radius: 10, Unit: "km"} + geoFilter2 := FTSearchGeoFilter{FieldName: "loc", Longitude: -0.44, Latitude: 51.45, Radius: 100, Unit: "km"} + res3, err := adapter.FTSearchWithArgs(ctx, "txt", "foo", &FTSearchOptions{GeoFilter: []FTSearchGeoFilter{geoFilter1}, NoContent: true}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res3.Total).To(BeEquivalentTo(int64(1))) + Expect(res3.Docs[0].ID).To(BeEquivalentTo("doc1")) + res4, err := adapter.FTSearchWithArgs(ctx, "txt", "foo", &FTSearchOptions{GeoFilter: []FTSearchGeoFilter{geoFilter2}, NoContent: true}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res4.Total).To(BeEquivalentTo(int64(2))) + docs := []interface{}{res4.Docs[0].ID, res4.Docs[1].ID} + Expect(docs).To(ContainElement("doc1")) + Expect(docs).To(ContainElement("doc2")) + + }) + + It("should FTCreate and FTSearch sortby", Label("search", "ftcreate", "ftsearch"), func() { + val, err := adapter.FTCreate(ctx, "num", &FTCreateOptions{}, &FieldSchema{FieldName: "txt", FieldType: SearchFieldTypeText}, &FieldSchema{FieldName: "num", FieldType: SearchFieldTypeNumeric, Sortable: true}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(val).To(BeEquivalentTo("OK")) + WaitForIndexing(clientresp2, "num") + adapter.HSet(ctx, "doc1", "txt", "foo bar", "num", 1) + adapter.HSet(ctx, "doc2", "txt", "foo baz", "num", 2) + adapter.HSet(ctx, "doc3", "txt", "foo qux", "num", 3) + + sortBy1 := FTSearchSortBy{FieldName: "num", Asc: true} + sortBy2 := FTSearchSortBy{FieldName: "num", Desc: true} + res1, err := adapter.FTSearchWithArgs(ctx, "num", "foo", &FTSearchOptions{NoContent: true, SortBy: []FTSearchSortBy{sortBy1}}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res1.Total).To(BeEquivalentTo(int64(3))) + Expect(res1.Docs[0].ID).To(BeEquivalentTo("doc1")) + Expect(res1.Docs[1].ID).To(BeEquivalentTo("doc2")) + Expect(res1.Docs[2].ID).To(BeEquivalentTo("doc3")) + + res2, err := adapter.FTSearchWithArgs(ctx, "num", "foo", &FTSearchOptions{NoContent: true, SortBy: []FTSearchSortBy{sortBy2}}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res2.Total).To(BeEquivalentTo(int64(3))) + Expect(res2.Docs[2].ID).To(BeEquivalentTo("doc1")) + Expect(res2.Docs[1].ID).To(BeEquivalentTo("doc2")) + Expect(res2.Docs[0].ID).To(BeEquivalentTo("doc3")) + + }) + + It("should FTCreate and FTSearch example", Label("search", "ftcreate", "ftsearch"), func() { + val, err := adapter.FTCreate(ctx, "txt", &FTCreateOptions{}, &FieldSchema{FieldName: "title", FieldType: SearchFieldTypeText, Weight: 5}, &FieldSchema{FieldName: "body", FieldType: SearchFieldTypeText}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(val).To(BeEquivalentTo("OK")) + WaitForIndexing(clientresp2, "txt") + adapter.HSet(ctx, "doc1", "title", "RediSearch", "body", "Redisearch impements a search engine on top of redis") + res1, err := adapter.FTSearchWithArgs(ctx, "txt", "search engine", &FTSearchOptions{NoContent: true, Verbatim: true, LimitOffset: 0, Limit: 5}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res1.Total).To(BeEquivalentTo(int64(1))) + + }) + + It("should FTCreate NoIndex", Label("search", "ftcreate", "ftsearch"), func() { + text1 := &FieldSchema{FieldName: "field", FieldType: SearchFieldTypeText} + text2 := &FieldSchema{FieldName: "text", FieldType: SearchFieldTypeText, NoIndex: true, Sortable: true} + num := &FieldSchema{FieldName: "numeric", FieldType: SearchFieldTypeNumeric, NoIndex: true, Sortable: true} + geo := &FieldSchema{FieldName: "geo", FieldType: SearchFieldTypeGeo, NoIndex: true, Sortable: true} + tag := &FieldSchema{FieldName: "tag", FieldType: SearchFieldTypeTag, NoIndex: true, Sortable: true} + val, err := adapter.FTCreate(ctx, "idx", &FTCreateOptions{}, text1, text2, num, geo, tag).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(val).To(BeEquivalentTo("OK")) + WaitForIndexing(clientresp2, "idx") + adapter.HSet(ctx, "doc1", "field", "aaa", "text", "1", "numeric", 1, "geo", "1,1", "tag", "1") + adapter.HSet(ctx, "doc2", "field", "aab", "text", "2", "numeric", 2, "geo", "2,2", "tag", "2") + res1, err := adapter.FTSearch(ctx, "idx", "@text:aa*").Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res1.Total).To(BeEquivalentTo(int64(0))) + res2, err := adapter.FTSearch(ctx, "idx", "@field:aa*").Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res2.Total).To(BeEquivalentTo(int64(2))) + res3, err := adapter.FTSearchWithArgs(ctx, "idx", "*", &FTSearchOptions{SortBy: []FTSearchSortBy{{FieldName: "text", Desc: true}}}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res3.Total).To(BeEquivalentTo(int64(2))) + Expect(res3.Docs[0].ID).To(BeEquivalentTo("doc2")) + res4, err := adapter.FTSearchWithArgs(ctx, "idx", "*", &FTSearchOptions{SortBy: []FTSearchSortBy{{FieldName: "text", Asc: true}}}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res4.Total).To(BeEquivalentTo(int64(2))) + Expect(res4.Docs[0].ID).To(BeEquivalentTo("doc1")) + res5, err := adapter.FTSearchWithArgs(ctx, "idx", "*", &FTSearchOptions{SortBy: []FTSearchSortBy{{FieldName: "numeric", Asc: true}}}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res5.Docs[0].ID).To(BeEquivalentTo("doc1")) + res6, err := adapter.FTSearchWithArgs(ctx, "idx", "*", &FTSearchOptions{SortBy: []FTSearchSortBy{{FieldName: "geo", Asc: true}}}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res6.Docs[0].ID).To(BeEquivalentTo("doc1")) + res7, err := adapter.FTSearchWithArgs(ctx, "idx", "*", &FTSearchOptions{SortBy: []FTSearchSortBy{{FieldName: "tag", Asc: true}}}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res7.Docs[0].ID).To(BeEquivalentTo("doc1")) + + }) + + It("should FTExplain", Label("search", "ftexplain"), func() { + text1 := &FieldSchema{FieldName: "f1", FieldType: SearchFieldTypeText} + text2 := &FieldSchema{FieldName: "f2", FieldType: SearchFieldTypeText} + text3 := &FieldSchema{FieldName: "f3", FieldType: SearchFieldTypeText} + val, err := adapter.FTCreate(ctx, "txt", &FTCreateOptions{}, text1, text2, text3).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(val).To(BeEquivalentTo("OK")) + WaitForIndexing(clientresp2, "txt") + res1, err := adapter.FTExplain(ctx, "txt", "@f3:f3_val @f2:f2_val @f1:f1_val").Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res1).ToNot(BeEmpty()) + + }) + + It("should FTAlias", Label("search", "ftexplain"), func() { + text1 := &FieldSchema{FieldName: "name", FieldType: SearchFieldTypeText} + text2 := &FieldSchema{FieldName: "name", FieldType: SearchFieldTypeText} + val1, err := adapter.FTCreate(ctx, "testAlias", &FTCreateOptions{Prefix: []interface{}{"index1:"}}, text1).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(val1).To(BeEquivalentTo("OK")) + WaitForIndexing(clientresp2, "testAlias") + val2, err := adapter.FTCreate(ctx, "testAlias2", &FTCreateOptions{Prefix: []interface{}{"index2:"}}, text2).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(val2).To(BeEquivalentTo("OK")) + WaitForIndexing(clientresp2, "testAlias2") + + adapter.HSet(ctx, "index1:lonestar", "name", "lonestar") + adapter.HSet(ctx, "index2:yogurt", "name", "yogurt") + + res1, err := adapter.FTSearch(ctx, "testAlias", "*").Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res1.Docs[0].ID).To(BeEquivalentTo("index1:lonestar")) + + aliasAddRes, err := adapter.FTAliasAdd(ctx, "testAlias", "mj23").Result() + Expect(err).NotTo(HaveOccurred()) + Expect(aliasAddRes).To(BeEquivalentTo("OK")) + + res1, err = adapter.FTSearch(ctx, "mj23", "*").Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res1.Docs[0].ID).To(BeEquivalentTo("index1:lonestar")) + + aliasUpdateRes, err := adapter.FTAliasUpdate(ctx, "testAlias2", "kb24").Result() + Expect(err).NotTo(HaveOccurred()) + Expect(aliasUpdateRes).To(BeEquivalentTo("OK")) + + res3, err := adapter.FTSearch(ctx, "kb24", "*").Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res3.Docs[0].ID).To(BeEquivalentTo("index2:yogurt")) + + aliasDelRes, err := adapter.FTAliasDel(ctx, "mj23").Result() + Expect(err).NotTo(HaveOccurred()) + Expect(aliasDelRes).To(BeEquivalentTo("OK")) + + }) + + It("should FTCreate and FTSearch textfield, sortable and nostem ", Label("search", "ftcreate", "ftsearch"), func() { + val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, &FieldSchema{FieldName: "txt", FieldType: SearchFieldTypeText, Sortable: true, NoStem: true}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(val).To(BeEquivalentTo("OK")) + WaitForIndexing(clientresp2, "idx1") + + resInfo, err := adapter.FTInfo(ctx, "idx1").Result() + Expect(err).NotTo(HaveOccurred()) + Expect(resInfo.Attributes[0].Sortable).To(BeTrue()) + Expect(resInfo.Attributes[0].NoStem).To(BeTrue()) + + }) + + It("should FTAlter", Label("search", "ftcreate", "ftsearch", "ftalter"), func() { + val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, &FieldSchema{FieldName: "txt", FieldType: SearchFieldTypeText}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(val).To(BeEquivalentTo("OK")) + WaitForIndexing(clientresp2, "idx1") + + resAlter, err := adapter.FTAlter(ctx, "idx1", false, []interface{}{"body", SearchFieldTypeText.String()}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(resAlter).To(BeEquivalentTo("OK")) + + adapter.HSet(ctx, "doc1", "title", "MyTitle", "body", "Some content only in the body") + res1, err := adapter.FTSearch(ctx, "idx1", "only in the body").Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res1.Total).To(BeEquivalentTo(int64(1))) + + }) + + It("should FTSpellCheck", Label("search", "ftcreate", "ftsearch", "ftspellcheck"), func() { + text1 := &FieldSchema{FieldName: "f1", FieldType: SearchFieldTypeText} + text2 := &FieldSchema{FieldName: "f2", FieldType: SearchFieldTypeText} + val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, text1, text2).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(val).To(BeEquivalentTo("OK")) + WaitForIndexing(clientresp2, "idx1") + + adapter.HSet(ctx, "doc1", "f1", "some valid content", "f2", "this is sample text") + adapter.HSet(ctx, "doc2", "f1", "very important", "f2", "lorem ipsum") + + resSpellCheck, err := adapter.FTSpellCheck(ctx, "idx1", "impornant").Result() + Expect(err).NotTo(HaveOccurred()) + Expect(resSpellCheck[0].Suggestions[0].Suggestion).To(BeEquivalentTo("important")) + + resSpellCheck2, err := adapter.FTSpellCheck(ctx, "idx1", "contnt").Result() + Expect(err).NotTo(HaveOccurred()) + Expect(resSpellCheck2[0].Suggestions[0].Suggestion).To(BeEquivalentTo("content")) + + // test spellcheck with Levenshtein distance + resSpellCheck3, err := adapter.FTSpellCheck(ctx, "idx1", "vlis").Result() + Expect(err).NotTo(HaveOccurred()) + Expect(resSpellCheck3[0].Term).To(BeEquivalentTo("vlis")) + + resSpellCheck4, err := adapter.FTSpellCheckWithArgs(ctx, "idx1", "vlis", &FTSpellCheckOptions{Distance: 2}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(resSpellCheck4[0].Suggestions[0].Suggestion).To(BeEquivalentTo("valid")) + + // test spellcheck include + resDictAdd, err := adapter.FTDictAdd(ctx, "dict", "lore", "lorem", "lorm").Result() + Expect(err).NotTo(HaveOccurred()) + Expect(resDictAdd).To(BeEquivalentTo(3)) + terms := &FTSpellCheckTerms{Inclusion: "INCLUDE", Dictionary: "dict"} + resSpellCheck5, err := adapter.FTSpellCheckWithArgs(ctx, "idx1", "lorm", &FTSpellCheckOptions{Terms: terms}).Result() + Expect(err).NotTo(HaveOccurred()) + lorm := resSpellCheck5[0].Suggestions + Expect(len(lorm)).To(BeEquivalentTo(3)) + Expect(lorm[0].Score).To(BeEquivalentTo(0.5)) + Expect(lorm[1].Score).To(BeEquivalentTo(0)) + Expect(lorm[2].Score).To(BeEquivalentTo(0)) + + terms2 := &FTSpellCheckTerms{Inclusion: "EXCLUDE", Dictionary: "dict"} + resSpellCheck6, err := adapter.FTSpellCheckWithArgs(ctx, "idx1", "lorm", &FTSpellCheckOptions{Terms: terms2}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(resSpellCheck6).To(BeEmpty()) + }) + + It("should FTDict opreations", Label("search", "ftdictdump", "ftdictdel", "ftdictadd"), func() { + text1 := &FieldSchema{FieldName: "f1", FieldType: SearchFieldTypeText} + text2 := &FieldSchema{FieldName: "f2", FieldType: SearchFieldTypeText} + val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, text1, text2).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(val).To(BeEquivalentTo("OK")) + WaitForIndexing(clientresp2, "idx1") + + resDictAdd, err := adapter.FTDictAdd(ctx, "custom_dict", "item1", "item2", "item3").Result() + Expect(err).NotTo(HaveOccurred()) + Expect(resDictAdd).To(BeEquivalentTo(3)) + + resDictDel, err := adapter.FTDictDel(ctx, "custom_dict", "item2").Result() + Expect(err).NotTo(HaveOccurred()) + Expect(resDictDel).To(BeEquivalentTo(1)) + + resDictDump, err := adapter.FTDictDump(ctx, "custom_dict").Result() + Expect(err).NotTo(HaveOccurred()) + Expect(resDictDump).To(BeEquivalentTo([]string{"item1", "item3"})) + + resDictDel2, err := adapter.FTDictDel(ctx, "custom_dict", "item1", "item3").Result() + Expect(err).NotTo(HaveOccurred()) + Expect(resDictDel2).To(BeEquivalentTo(2)) + }) + + It("should FTSearch phonetic matcher", Label("search", "ftsearch"), func() { + text1 := &FieldSchema{FieldName: "name", FieldType: SearchFieldTypeText} + val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, text1).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(val).To(BeEquivalentTo("OK")) + WaitForIndexing(clientresp2, "idx1") + + adapter.HSet(ctx, "doc1", "name", "Jon") + adapter.HSet(ctx, "doc2", "name", "John") + + res1, err := adapter.FTSearch(ctx, "idx1", "Jon").Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res1.Total).To(BeEquivalentTo(int64(1))) + Expect(res1.Docs[0].Fields["name"]).To(BeEquivalentTo("Jon")) + + adapter.FlushDB(ctx) + text2 := &FieldSchema{FieldName: "name", FieldType: SearchFieldTypeText, PhoneticMatcher: "dm:en"} + val2, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, text2).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(val2).To(BeEquivalentTo("OK")) + WaitForIndexing(clientresp2, "idx1") + + adapter.HSet(ctx, "doc1", "name", "Jon") + adapter.HSet(ctx, "doc2", "name", "John") + + res2, err := adapter.FTSearch(ctx, "idx1", "Jon").Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res2.Total).To(BeEquivalentTo(int64(2))) + names := []interface{}{res2.Docs[0].Fields["name"], res2.Docs[1].Fields["name"]} + Expect(names).To(ContainElement("Jon")) + Expect(names).To(ContainElement("John")) + }) + + It("should FTSearch WithScores", Label("search", "ftsearch"), func() { + text1 := &FieldSchema{FieldName: "description", FieldType: SearchFieldTypeText} + val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, text1).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(val).To(BeEquivalentTo("OK")) + WaitForIndexing(clientresp2, "idx1") + + adapter.HSet(ctx, "doc1", "description", "The quick brown fox jumps over the lazy dog") + adapter.HSet(ctx, "doc2", "description", "Quick alice was beginning to get very tired of sitting by her quick sister on the bank, and of having nothing to do.") + + res, err := adapter.FTSearchWithArgs(ctx, "idx1", "quick", &FTSearchOptions{WithScores: true}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(*res.Docs[0].Score).To(BeEquivalentTo(float64(1))) + + res, err = adapter.FTSearchWithArgs(ctx, "idx1", "quick", &FTSearchOptions{WithScores: true, Scorer: "TFIDF"}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(*res.Docs[0].Score).To(BeEquivalentTo(float64(1))) + + res, err = adapter.FTSearchWithArgs(ctx, "idx1", "quick", &FTSearchOptions{WithScores: true, Scorer: "TFIDF.DOCNORM"}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(*res.Docs[0].Score).To(BeEquivalentTo(0.14285714285714285)) + + res, err = adapter.FTSearchWithArgs(ctx, "idx1", "quick", &FTSearchOptions{WithScores: true, Scorer: "BM25"}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(*res.Docs[0].Score).To(BeNumerically("<=", 0.22471909420069797)) + + res, err = adapter.FTSearchWithArgs(ctx, "idx1", "quick", &FTSearchOptions{WithScores: true, Scorer: "DISMAX"}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(*res.Docs[0].Score).To(BeEquivalentTo(float64(2))) + + res, err = adapter.FTSearchWithArgs(ctx, "idx1", "quick", &FTSearchOptions{WithScores: true, Scorer: "DOCSCORE"}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(*res.Docs[0].Score).To(BeEquivalentTo(float64(1))) + + res, err = adapter.FTSearchWithArgs(ctx, "idx1", "quick", &FTSearchOptions{WithScores: true, Scorer: "HAMMING"}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(*res.Docs[0].Score).To(BeEquivalentTo(float64(0))) + }) + + It("should FTConfigSet and FTConfigGet ", Label("search", "ftconfigget", "ftconfigset", "NonRedisEnterprise"), func() { + val, err := adapter.FTConfigSet(ctx, "TIMEOUT", "100").Result() + Expect(err).NotTo(HaveOccurred()) + Expect(val).To(BeEquivalentTo("OK")) + + res, err := adapter.FTConfigGet(ctx, "*").Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res["TIMEOUT"]).To(BeEquivalentTo("100")) + + res, err = adapter.FTConfigGet(ctx, "TIMEOUT").Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res).To(BeEquivalentTo(map[string]interface{}{"TIMEOUT": "100"})) + + }) + + It("should FTAggregate GroupBy ", Label("search", "ftaggregate"), func() { + text1 := &FieldSchema{FieldName: "title", FieldType: SearchFieldTypeText} + text2 := &FieldSchema{FieldName: "body", FieldType: SearchFieldTypeText} + text3 := &FieldSchema{FieldName: "parent", FieldType: SearchFieldTypeText} + num := &FieldSchema{FieldName: "random_num", FieldType: SearchFieldTypeNumeric} + val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, text1, text2, text3, num).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(val).To(BeEquivalentTo("OK")) + WaitForIndexing(clientresp2, "idx1") + + adapter.HSet(ctx, "search", "title", "RediSearch", + "body", "Redisearch impements a search engine on top of redis", + "parent", "redis", + "random_num", 10) + adapter.HSet(ctx, "ai", "title", "RedisAI", + "body", "RedisAI executes Deep Learning/Machine Learning models and managing their data.", + "parent", "redis", + "random_num", 3) + adapter.HSet(ctx, "json", "title", "RedisJson", + "body", "RedisJSON implements ECMA-404 The JSON Data Interchange Standard as a native data type.", + "parent", "redis", + "random_num", 8) + + reducer := FTAggregateReducer{Reducer: SearchCount} + options := &FTAggregateOptions{GroupBy: []FTAggregateGroupBy{{Fields: []interface{}{"@parent"}, Reduce: []FTAggregateReducer{reducer}}}} + res, err := adapter.FTAggregateWithArgs(ctx, "idx1", "redis", options).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res.Rows[0].Fields["parent"]).To(BeEquivalentTo("redis")) + Expect(res.Rows[0].Fields["__generated_aliascount"]).To(BeEquivalentTo("3")) + + reducer = FTAggregateReducer{Reducer: SearchCountDistinct, Args: []interface{}{"@title"}} + options = &FTAggregateOptions{GroupBy: []FTAggregateGroupBy{{Fields: []interface{}{"@parent"}, Reduce: []FTAggregateReducer{reducer}}}} + res, err = adapter.FTAggregateWithArgs(ctx, "idx1", "redis", options).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res.Rows[0].Fields["parent"]).To(BeEquivalentTo("redis")) + Expect(res.Rows[0].Fields["__generated_aliascount_distincttitle"]).To(BeEquivalentTo("3")) + + reducer = FTAggregateReducer{Reducer: SearchSum, Args: []interface{}{"@random_num"}} + options = &FTAggregateOptions{GroupBy: []FTAggregateGroupBy{{Fields: []interface{}{"@parent"}, Reduce: []FTAggregateReducer{reducer}}}} + res, err = adapter.FTAggregateWithArgs(ctx, "idx1", "redis", options).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res.Rows[0].Fields["parent"]).To(BeEquivalentTo("redis")) + Expect(res.Rows[0].Fields["__generated_aliassumrandom_num"]).To(BeEquivalentTo("21")) + + reducer = FTAggregateReducer{Reducer: SearchMin, Args: []interface{}{"@random_num"}} + options = &FTAggregateOptions{GroupBy: []FTAggregateGroupBy{{Fields: []interface{}{"@parent"}, Reduce: []FTAggregateReducer{reducer}}}} + res, err = adapter.FTAggregateWithArgs(ctx, "idx1", "redis", options).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res.Rows[0].Fields["parent"]).To(BeEquivalentTo("redis")) + Expect(res.Rows[0].Fields["__generated_aliasminrandom_num"]).To(BeEquivalentTo("3")) + + reducer = FTAggregateReducer{Reducer: SearchMax, Args: []interface{}{"@random_num"}} + options = &FTAggregateOptions{GroupBy: []FTAggregateGroupBy{{Fields: []interface{}{"@parent"}, Reduce: []FTAggregateReducer{reducer}}}} + res, err = adapter.FTAggregateWithArgs(ctx, "idx1", "redis", options).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res.Rows[0].Fields["parent"]).To(BeEquivalentTo("redis")) + Expect(res.Rows[0].Fields["__generated_aliasmaxrandom_num"]).To(BeEquivalentTo("10")) + + reducer = FTAggregateReducer{Reducer: SearchAvg, Args: []interface{}{"@random_num"}} + options = &FTAggregateOptions{GroupBy: []FTAggregateGroupBy{{Fields: []interface{}{"@parent"}, Reduce: []FTAggregateReducer{reducer}}}} + res, err = adapter.FTAggregateWithArgs(ctx, "idx1", "redis", options).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res.Rows[0].Fields["parent"]).To(BeEquivalentTo("redis")) + Expect(res.Rows[0].Fields["__generated_aliasavgrandom_num"]).To(BeEquivalentTo("7")) + + reducer = FTAggregateReducer{Reducer: SearchStdDev, Args: []interface{}{"@random_num"}} + options = &FTAggregateOptions{GroupBy: []FTAggregateGroupBy{{Fields: []interface{}{"@parent"}, Reduce: []FTAggregateReducer{reducer}}}} + res, err = adapter.FTAggregateWithArgs(ctx, "idx1", "redis", options).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res.Rows[0].Fields["parent"]).To(BeEquivalentTo("redis")) + Expect(res.Rows[0].Fields["__generated_aliasstddevrandom_num"]).To(BeEquivalentTo("3.60555127546")) + + reducer = FTAggregateReducer{Reducer: SearchQuantile, Args: []interface{}{"@random_num", 0.5}} + options = &FTAggregateOptions{GroupBy: []FTAggregateGroupBy{{Fields: []interface{}{"@parent"}, Reduce: []FTAggregateReducer{reducer}}}} + res, err = adapter.FTAggregateWithArgs(ctx, "idx1", "redis", options).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res.Rows[0].Fields["parent"]).To(BeEquivalentTo("redis")) + Expect(res.Rows[0].Fields["__generated_aliasquantilerandom_num,0.5"]).To(BeEquivalentTo("8")) + + reducer = FTAggregateReducer{Reducer: SearchToList, Args: []interface{}{"@title"}} + options = &FTAggregateOptions{GroupBy: []FTAggregateGroupBy{{Fields: []interface{}{"@parent"}, Reduce: []FTAggregateReducer{reducer}}}} + res, err = adapter.FTAggregateWithArgs(ctx, "idx1", "redis", options).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res.Rows[0].Fields["parent"]).To(BeEquivalentTo("redis")) + Expect(res.Rows[0].Fields["__generated_aliastolisttitle"]).To(ContainElements("RediSearch", "RedisAI", "RedisJson")) + + reducer = FTAggregateReducer{Reducer: SearchFirstValue, Args: []interface{}{"@title"}, As: "first"} + options = &FTAggregateOptions{GroupBy: []FTAggregateGroupBy{{Fields: []interface{}{"@parent"}, Reduce: []FTAggregateReducer{reducer}}}} + res, err = adapter.FTAggregateWithArgs(ctx, "idx1", "redis", options).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res.Rows[0].Fields["parent"]).To(BeEquivalentTo("redis")) + Expect(res.Rows[0].Fields["first"]).To(Or(BeEquivalentTo("RediSearch"), BeEquivalentTo("RedisAI"), BeEquivalentTo("RedisJson"))) + + reducer = FTAggregateReducer{Reducer: SearchRandomSample, Args: []interface{}{"@title", 2}, As: "random"} + options = &FTAggregateOptions{GroupBy: []FTAggregateGroupBy{{Fields: []interface{}{"@parent"}, Reduce: []FTAggregateReducer{reducer}}}} + res, err = adapter.FTAggregateWithArgs(ctx, "idx1", "redis", options).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res.Rows[0].Fields["parent"]).To(BeEquivalentTo("redis")) + Expect(res.Rows[0].Fields["random"]).To(Or( + ContainElement("RediSearch"), + ContainElement("RedisAI"), + ContainElement("RedisJson"), + )) + + }) + + It("should FTAggregate sort and limit", Label("search", "ftaggregate"), func() { + text1 := &FieldSchema{FieldName: "t1", FieldType: SearchFieldTypeText} + text2 := &FieldSchema{FieldName: "t2", FieldType: SearchFieldTypeText} + val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, text1, text2).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(val).To(BeEquivalentTo("OK")) + WaitForIndexing(clientresp2, "idx1") + + adapter.HSet(ctx, "doc1", "t1", "a", "t2", "b") + adapter.HSet(ctx, "doc2", "t1", "b", "t2", "a") + + options := &FTAggregateOptions{SortBy: []FTAggregateSortBy{{FieldName: "@t2", Asc: true}, {FieldName: "@t1", Desc: true}}} + res, err := adapter.FTAggregateWithArgs(ctx, "idx1", "*", options).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res.Rows[0].Fields["t1"]).To(BeEquivalentTo("b")) + Expect(res.Rows[1].Fields["t1"]).To(BeEquivalentTo("a")) + Expect(res.Rows[0].Fields["t2"]).To(BeEquivalentTo("a")) + Expect(res.Rows[1].Fields["t2"]).To(BeEquivalentTo("b")) + + options = &FTAggregateOptions{SortBy: []FTAggregateSortBy{{FieldName: "@t1"}}} + res, err = adapter.FTAggregateWithArgs(ctx, "idx1", "*", options).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res.Rows[0].Fields["t1"]).To(BeEquivalentTo("a")) + Expect(res.Rows[1].Fields["t1"]).To(BeEquivalentTo("b")) + + options = &FTAggregateOptions{SortBy: []FTAggregateSortBy{{FieldName: "@t1"}}, SortByMax: 1} + res, err = adapter.FTAggregateWithArgs(ctx, "idx1", "*", options).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res.Rows[0].Fields["t1"]).To(BeEquivalentTo("a")) + + options = &FTAggregateOptions{SortBy: []FTAggregateSortBy{{FieldName: "@t1"}}, Limit: 1, LimitOffset: 1} + res, err = adapter.FTAggregateWithArgs(ctx, "idx1", "*", options).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res.Rows[0].Fields["t1"]).To(BeEquivalentTo("b")) + }) + + It("should FTAggregate load ", Label("search", "ftaggregate"), func() { + text1 := &FieldSchema{FieldName: "t1", FieldType: SearchFieldTypeText} + text2 := &FieldSchema{FieldName: "t2", FieldType: SearchFieldTypeText} + val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, text1, text2).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(val).To(BeEquivalentTo("OK")) + WaitForIndexing(clientresp2, "idx1") + + adapter.HSet(ctx, "doc1", "t1", "hello", "t2", "world") + + options := &FTAggregateOptions{Load: []FTAggregateLoad{{Field: "t1"}}} + res, err := adapter.FTAggregateWithArgs(ctx, "idx1", "*", options).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res.Rows[0].Fields["t1"]).To(BeEquivalentTo("hello")) + + options = &FTAggregateOptions{Load: []FTAggregateLoad{{Field: "t2"}}} + res, err = adapter.FTAggregateWithArgs(ctx, "idx1", "*", options).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res.Rows[0].Fields["t2"]).To(BeEquivalentTo("world")) + + options = &FTAggregateOptions{LoadAll: true} + res, err = adapter.FTAggregateWithArgs(ctx, "idx1", "*", options).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res.Rows[0].Fields["t1"]).To(BeEquivalentTo("hello")) + Expect(res.Rows[0].Fields["t2"]).To(BeEquivalentTo("world")) + }) + + It("should FTAggregate apply", Label("search", "ftaggregate"), func() { + text1 := &FieldSchema{FieldName: "PrimaryKey", FieldType: SearchFieldTypeText, Sortable: true} + num1 := &FieldSchema{FieldName: "CreatedDateTimeUTC", FieldType: SearchFieldTypeNumeric, Sortable: true} + val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, text1, num1).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(val).To(BeEquivalentTo("OK")) + WaitForIndexing(clientresp2, "idx1") + + adapter.HSet(ctx, "doc1", "PrimaryKey", "9::362330", "CreatedDateTimeUTC", "637387878524969984") + adapter.HSet(ctx, "doc2", "PrimaryKey", "9::362329", "CreatedDateTimeUTC", "637387875859270016") + + options := &FTAggregateOptions{Apply: []FTAggregateApply{{Field: "@CreatedDateTimeUTC * 10", As: "CreatedDateTimeUTC"}}} + res, err := adapter.FTAggregateWithArgs(ctx, "idx1", "*", options).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res.Rows[0].Fields["CreatedDateTimeUTC"]).To(Or(BeEquivalentTo("6373878785249699840"), BeEquivalentTo("6373878758592700416"))) + Expect(res.Rows[1].Fields["CreatedDateTimeUTC"]).To(Or(BeEquivalentTo("6373878785249699840"), BeEquivalentTo("6373878758592700416"))) + + }) + + It("should FTAggregate filter", Label("search", "ftaggregate"), func() { + text1 := &FieldSchema{FieldName: "name", FieldType: SearchFieldTypeText, Sortable: true} + num1 := &FieldSchema{FieldName: "age", FieldType: SearchFieldTypeNumeric, Sortable: true} + val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, text1, num1).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(val).To(BeEquivalentTo("OK")) + WaitForIndexing(clientresp2, "idx1") + + adapter.HSet(ctx, "doc1", "name", "bar", "age", "25") + adapter.HSet(ctx, "doc2", "name", "foo", "age", "19") + + for _, dlc := range []int{1, 2} { + options := &FTAggregateOptions{Filter: "@name=='foo' && @age < 20", DialectVersion: dlc} + res, err := adapter.FTAggregateWithArgs(ctx, "idx1", "*", options).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res.Total).To(Or(BeEquivalentTo(2), BeEquivalentTo(1))) + Expect(res.Rows[0].Fields["name"]).To(BeEquivalentTo("foo")) + + options = &FTAggregateOptions{Filter: "@age > 15", DialectVersion: dlc, SortBy: []FTAggregateSortBy{{FieldName: "@age"}}} + res, err = adapter.FTAggregateWithArgs(ctx, "idx1", "*", options).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res.Total).To(BeEquivalentTo(2)) + Expect(res.Rows[0].Fields["age"]).To(BeEquivalentTo("19")) + Expect(res.Rows[1].Fields["age"]).To(BeEquivalentTo("25")) + } + + }) + + It("should FTSearch SkipInitialScan", Label("search", "ftsearch"), func() { + adapter.HSet(ctx, "doc1", "foo", "bar") + + text1 := &FieldSchema{FieldName: "foo", FieldType: SearchFieldTypeText} + val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{SkipInitialScan: true}, text1).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(val).To(BeEquivalentTo("OK")) + WaitForIndexing(clientresp2, "idx1") + + res, err := adapter.FTSearch(ctx, "idx1", "@foo:bar").Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res.Total).To(BeEquivalentTo(int64(0))) + }) + + It("should FTCreate json", Label("search", "ftcreate"), func() { + + text1 := &FieldSchema{FieldName: "$.name", FieldType: SearchFieldTypeText} + val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{OnJSON: true, Prefix: []interface{}{"king:"}}, text1).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(val).To(BeEquivalentTo("OK")) + WaitForIndexing(clientresp2, "idx1") + + adapter.JSONSet(ctx, "king:1", "$", `{"name": "henry"}`) + adapter.JSONSet(ctx, "king:2", "$", `{"name": "james"}`) + + res, err := adapter.FTSearch(ctx, "idx1", "henry").Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res.Total).To(BeEquivalentTo(1)) + Expect(res.Docs[0].ID).To(BeEquivalentTo("king:1")) + Expect(res.Docs[0].Fields["$"]).To(BeEquivalentTo(`{"name":"henry"}`)) + }) + + It("should FTCreate json fields as names", Label("search", "ftcreate"), func() { + + text1 := &FieldSchema{FieldName: "$.name", FieldType: SearchFieldTypeText, As: "name"} + num1 := &FieldSchema{FieldName: "$.age", FieldType: SearchFieldTypeNumeric, As: "just_a_number"} + val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{OnJSON: true}, text1, num1).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(val).To(BeEquivalentTo("OK")) + WaitForIndexing(clientresp2, "idx1") + + adapter.JSONSet(ctx, "doc:1", "$", `{"name": "Jon", "age": 25}`) + + res, err := adapter.FTSearchWithArgs(ctx, "idx1", "Jon", &FTSearchOptions{Return: []FTSearchReturn{{FieldName: "name"}, {FieldName: "just_a_number"}}}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res.Total).To(BeEquivalentTo(1)) + Expect(res.Docs[0].ID).To(BeEquivalentTo("doc:1")) + Expect(res.Docs[0].Fields["name"]).To(BeEquivalentTo("Jon")) + Expect(res.Docs[0].Fields["just_a_number"]).To(BeEquivalentTo("25")) + }) + + It("should FTCreate CaseSensitive", Label("search", "ftcreate"), func() { + + tag1 := &FieldSchema{FieldName: "t", FieldType: SearchFieldTypeTag, CaseSensitive: false} + val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, tag1).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(val).To(BeEquivalentTo("OK")) + WaitForIndexing(client, "idx1") + + adapter.HSet(ctx, "1", "t", "HELLO") + adapter.HSet(ctx, "2", "t", "hello") + + res, err := adapter.FTSearch(ctx, "idx1", "@t:{HELLO}").Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res.Total).To(BeEquivalentTo(2)) + Expect(res.Docs[0].ID).To(BeEquivalentTo("1")) + Expect(res.Docs[1].ID).To(BeEquivalentTo("2")) + + resDrop, err := adapter.FTDropIndex(ctx, "idx1").Result() + Expect(err).NotTo(HaveOccurred()) + Expect(resDrop).To(BeEquivalentTo("OK")) + + tag2 := &FieldSchema{FieldName: "t", FieldType: SearchFieldTypeTag, CaseSensitive: true} + val, err = adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, tag2).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(val).To(BeEquivalentTo("OK")) + WaitForIndexing(client, "idx1") + + res, err = adapter.FTSearch(ctx, "idx1", "@t:{HELLO}").Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res.Total).To(BeEquivalentTo(1)) + Expect(res.Docs[0].ID).To(BeEquivalentTo("1")) + + }) + + It("should FTSearch ReturnFields", Label("search", "ftsearch"), func() { + resJson, err := adapter.JSONSet(ctx, "doc:1", "$", `{"t": "riceratops","t2": "telmatosaurus", "n": 9072, "flt": 97.2}`).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(resJson).To(BeEquivalentTo("OK")) + + text1 := &FieldSchema{FieldName: "$.t", FieldType: SearchFieldTypeText} + num1 := &FieldSchema{FieldName: "$.flt", FieldType: SearchFieldTypeNumeric} + val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{OnJSON: true}, text1, num1).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(val).To(BeEquivalentTo("OK")) + WaitForIndexing(client, "idx1") + + res, err := adapter.FTSearchWithArgs(ctx, "idx1", "*", &FTSearchOptions{Return: []FTSearchReturn{{FieldName: "$.t", As: "txt"}}}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res.Total).To(BeEquivalentTo(1)) + Expect(res.Docs[0].ID).To(BeEquivalentTo("doc:1")) + Expect(res.Docs[0].Fields["txt"]).To(BeEquivalentTo("riceratops")) + + res, err = adapter.FTSearchWithArgs(ctx, "idx1", "*", &FTSearchOptions{Return: []FTSearchReturn{{FieldName: "$.t2", As: "txt"}}}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res.Total).To(BeEquivalentTo(1)) + Expect(res.Docs[0].ID).To(BeEquivalentTo("doc:1")) + Expect(res.Docs[0].Fields["txt"]).To(BeEquivalentTo("telmatosaurus")) + }) + + It("should FTSynUpdate", Label("search", "ftsynupdate"), func() { + + text1 := &FieldSchema{FieldName: "title", FieldType: SearchFieldTypeText} + text2 := &FieldSchema{FieldName: "body", FieldType: SearchFieldTypeText} + val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{OnHash: true}, text1, text2).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(val).To(BeEquivalentTo("OK")) + WaitForIndexing(client, "idx1") + + resSynUpdate, err := adapter.FTSynUpdateWithArgs(ctx, "idx1", "id1", &FTSynUpdateOptions{SkipInitialScan: true}, []interface{}{"boy", "child", "offspring"}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(resSynUpdate).To(BeEquivalentTo("OK")) + adapter.HSet(ctx, "doc1", "title", "he is a baby", "body", "this is a test") + + resSynUpdate, err = adapter.FTSynUpdateWithArgs(ctx, "idx1", "id1", &FTSynUpdateOptions{SkipInitialScan: true}, []interface{}{"baby"}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(resSynUpdate).To(BeEquivalentTo("OK")) + adapter.HSet(ctx, "doc2", "title", "he is another baby", "body", "another test") + + res, err := adapter.FTSearchWithArgs(ctx, "idx1", "child", &FTSearchOptions{Expander: "SYNONYM"}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res.Docs[0].ID).To(BeEquivalentTo("doc2")) + Expect(res.Docs[0].Fields["title"]).To(BeEquivalentTo("he is another baby")) + Expect(res.Docs[0].Fields["body"]).To(BeEquivalentTo("another test")) + }) + + It("should FTSynDump", Label("search", "ftsyndump"), func() { + + text1 := &FieldSchema{FieldName: "title", FieldType: SearchFieldTypeText} + text2 := &FieldSchema{FieldName: "body", FieldType: SearchFieldTypeText} + val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{OnHash: true}, text1, text2).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(val).To(BeEquivalentTo("OK")) + WaitForIndexing(client, "idx1") + + resSynUpdate, err := adapter.FTSynUpdate(ctx, "idx1", "id1", []interface{}{"boy", "child", "offspring"}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(resSynUpdate).To(BeEquivalentTo("OK")) + + resSynUpdate, err = adapter.FTSynUpdate(ctx, "idx1", "id1", []interface{}{"baby", "child"}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(resSynUpdate).To(BeEquivalentTo("OK")) + + resSynUpdate, err = adapter.FTSynUpdate(ctx, "idx1", "id1", []interface{}{"tree", "wood"}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(resSynUpdate).To(BeEquivalentTo("OK")) + + resSynDump, err := adapter.FTSynDump(ctx, "idx1").Result() + Expect(err).NotTo(HaveOccurred()) + Expect(resSynDump[0].Term).To(BeEquivalentTo("baby")) + Expect(resSynDump[0].Synonyms).To(BeEquivalentTo([]string{"id1"})) + Expect(resSynDump[1].Term).To(BeEquivalentTo("wood")) + Expect(resSynDump[1].Synonyms).To(BeEquivalentTo([]string{"id1"})) + Expect(resSynDump[2].Term).To(BeEquivalentTo("boy")) + Expect(resSynDump[2].Synonyms).To(BeEquivalentTo([]string{"id1"})) + Expect(resSynDump[3].Term).To(BeEquivalentTo("tree")) + Expect(resSynDump[3].Synonyms).To(BeEquivalentTo([]string{"id1"})) + Expect(resSynDump[4].Term).To(BeEquivalentTo("child")) + Expect(resSynDump[4].Synonyms).To(Or(BeEquivalentTo([]string{"id1"}), BeEquivalentTo([]string{"id1", "id1"}))) + Expect(resSynDump[5].Term).To(BeEquivalentTo("offspring")) + Expect(resSynDump[5].Synonyms).To(BeEquivalentTo([]string{"id1"})) + + }) + + It("should FTCreate json with alias", Label("search", "ftcreate"), func() { + + text1 := &FieldSchema{FieldName: "$.name", FieldType: SearchFieldTypeText, As: "name"} + num1 := &FieldSchema{FieldName: "$.num", FieldType: SearchFieldTypeNumeric, As: "num"} + val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{OnJSON: true, Prefix: []interface{}{"king:"}}, text1, num1).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(val).To(BeEquivalentTo("OK")) + WaitForIndexing(client, "idx1") + + adapter.JSONSet(ctx, "king:1", "$", `{"name": "henry", "num": 42}`) + adapter.JSONSet(ctx, "king:2", "$", `{"name": "james", "num": 3.14}`) + + res, err := adapter.FTSearch(ctx, "idx1", "@name:henry").Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res.Total).To(BeEquivalentTo(1)) + Expect(res.Docs[0].ID).To(BeEquivalentTo("king:1")) + Expect(res.Docs[0].Fields["$"]).To(BeEquivalentTo(`{"name":"henry","num":42}`)) + + res, err = adapter.FTSearch(ctx, "idx1", "@num:[0 10]").Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res.Total).To(BeEquivalentTo(1)) + Expect(res.Docs[0].ID).To(BeEquivalentTo("king:2")) + Expect(res.Docs[0].Fields["$"]).To(BeEquivalentTo(`{"name":"james","num":3.14}`)) + }) + + It("should FTCreate json with multipath", Label("search", "ftcreate"), func() { + + tag1 := &FieldSchema{FieldName: "$..name", FieldType: SearchFieldTypeTag, As: "name"} + val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{OnJSON: true, Prefix: []interface{}{"king:"}}, tag1).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(val).To(BeEquivalentTo("OK")) + WaitForIndexing(client, "idx1") + + adapter.JSONSet(ctx, "king:1", "$", `{"name": "henry", "country": {"name": "england"}}`) + + res, err := adapter.FTSearch(ctx, "idx1", "@name:{england}").Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res.Total).To(BeEquivalentTo(1)) + Expect(res.Docs[0].ID).To(BeEquivalentTo("king:1")) + Expect(res.Docs[0].Fields["$"]).To(BeEquivalentTo(`{"name":"henry","country":{"name":"england"}}`)) + }) + + It("should FTCreate json with jsonpath", Label("search", "ftcreate"), func() { + + text1 := &FieldSchema{FieldName: `$["prod:name"]`, FieldType: SearchFieldTypeText, As: "name"} + text2 := &FieldSchema{FieldName: `$.prod:name`, FieldType: SearchFieldTypeText, As: "name_unsupported"} + val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{OnJSON: true}, text1, text2).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(val).To(BeEquivalentTo("OK")) + WaitForIndexing(client, "idx1") + + adapter.JSONSet(ctx, "doc:1", "$", `{"prod:name": "RediSearch"}`) + + res, err := adapter.FTSearch(ctx, "idx1", "@name:RediSearch").Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res.Total).To(BeEquivalentTo(1)) + Expect(res.Docs[0].ID).To(BeEquivalentTo("doc:1")) + Expect(res.Docs[0].Fields["$"]).To(BeEquivalentTo(`{"prod:name":"RediSearch"}`)) + + res, err = adapter.FTSearch(ctx, "idx1", "@name_unsupported:RediSearch").Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res.Total).To(BeEquivalentTo(1)) + + res, err = adapter.FTSearchWithArgs(ctx, "idx1", "@name:RediSearch", &FTSearchOptions{Return: []FTSearchReturn{{FieldName: "name"}}}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res.Total).To(BeEquivalentTo(1)) + Expect(res.Docs[0].ID).To(BeEquivalentTo("doc:1")) + Expect(res.Docs[0].Fields["name"]).To(BeEquivalentTo("RediSearch")) + + }) + + It("should FTCreate VECTOR", Label("search", "ftcreate"), func() { + hnswOptions := &FTHNSWOptions{Type: "FLOAT32", Dim: 2, DistanceMetric: "L2"} + val, err := adapter.FTCreate(ctx, "idx1", + &FTCreateOptions{}, + &FieldSchema{FieldName: "v", FieldType: SearchFieldTypeVector, VectorArgs: &FTVectorArgs{HNSWOptions: hnswOptions}}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(val).To(BeEquivalentTo("OK")) + WaitForIndexing(client, "idx1") + + adapter.HSet(ctx, "a", "v", "aaaaaaaa") + adapter.HSet(ctx, "b", "v", "aaaabaaa") + adapter.HSet(ctx, "c", "v", "aaaaabaa") + + searchOptions := &FTSearchOptions{ + Return: []FTSearchReturn{{FieldName: "__v_score"}}, + SortBy: []FTSearchSortBy{{FieldName: "__v_score", Asc: true}}, + DialectVersion: 2, + Params: map[string]interface{}{"vec": "aaaaaaaa"}, + } + res, err := adapter.FTSearchWithArgs(ctx, "idx1", "*=>[KNN 2 @v $vec]", searchOptions).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res.Docs[0].ID).To(BeEquivalentTo("a")) + Expect(res.Docs[0].Fields["__v_score"]).To(BeEquivalentTo("0")) + }) + + It("should FTCreate and FTSearch text params", Label("search", "ftcreate", "ftsearch"), func() { + val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, &FieldSchema{FieldName: "name", FieldType: SearchFieldTypeText}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(val).To(BeEquivalentTo("OK")) + WaitForIndexing(client, "idx1") + + adapter.HSet(ctx, "doc1", "name", "Alice") + adapter.HSet(ctx, "doc2", "name", "Bob") + adapter.HSet(ctx, "doc3", "name", "Carol") + + res1, err := adapter.FTSearchWithArgs(ctx, "idx1", "@name:($name1 | $name2 )", &FTSearchOptions{Params: map[string]interface{}{"name1": "Alice", "name2": "Bob"}, DialectVersion: 2}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res1.Total).To(BeEquivalentTo(int64(2))) + Expect(res1.Docs[0].ID).To(BeEquivalentTo("doc1")) + Expect(res1.Docs[1].ID).To(BeEquivalentTo("doc2")) + + }) + + It("should FTCreate and FTSearch numeric params", Label("search", "ftcreate", "ftsearch"), func() { + val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, &FieldSchema{FieldName: "numval", FieldType: SearchFieldTypeNumeric}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(val).To(BeEquivalentTo("OK")) + WaitForIndexing(client, "idx1") + + adapter.HSet(ctx, "doc1", "numval", 101) + adapter.HSet(ctx, "doc2", "numval", 102) + adapter.HSet(ctx, "doc3", "numval", 103) + + res1, err := adapter.FTSearchWithArgs(ctx, "idx1", "@numval:[$min $max]", &FTSearchOptions{Params: map[string]interface{}{"min": 101, "max": 102}, DialectVersion: 2}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res1.Total).To(BeEquivalentTo(int64(2))) + Expect(res1.Docs[0].ID).To(BeEquivalentTo("doc1")) + Expect(res1.Docs[1].ID).To(BeEquivalentTo("doc2")) + + }) + + It("should FTCreate and FTSearch geo params", Label("search", "ftcreate", "ftsearch"), func() { + val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, &FieldSchema{FieldName: "g", FieldType: SearchFieldTypeGeo}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(val).To(BeEquivalentTo("OK")) + WaitForIndexing(client, "idx1") + + adapter.HSet(ctx, "doc1", "g", "29.69465, 34.95126") + adapter.HSet(ctx, "doc2", "g", "29.69350, 34.94737") + adapter.HSet(ctx, "doc3", "g", "29.68746, 34.94882") + + res1, err := adapter.FTSearchWithArgs(ctx, "idx1", "@g:[$lon $lat $radius $units]", &FTSearchOptions{Params: map[string]interface{}{"lat": "34.95126", "lon": "29.69465", "radius": 1000, "units": "km"}, DialectVersion: 2}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res1.Total).To(BeEquivalentTo(int64(3))) + Expect(res1.Docs[0].ID).To(BeEquivalentTo("doc1")) + Expect(res1.Docs[1].ID).To(BeEquivalentTo("doc2")) + Expect(res1.Docs[2].ID).To(BeEquivalentTo("doc3")) + + }) + + It("should FTConfigSet and FTConfigGet dialect", Label("search", "ftconfigget", "ftconfigset", "NonRedisEnterprise"), func() { + res, err := adapter.FTConfigSet(ctx, "DEFAULT_DIALECT", "1").Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res).To(BeEquivalentTo("OK")) + + defDialect, err := adapter.FTConfigGet(ctx, "DEFAULT_DIALECT").Result() + Expect(err).NotTo(HaveOccurred()) + Expect(defDialect).To(BeEquivalentTo(map[string]interface{}{"DEFAULT_DIALECT": "1"})) + + res, err = adapter.FTConfigSet(ctx, "DEFAULT_DIALECT", "2").Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res).To(BeEquivalentTo("OK")) + + defDialect, err = adapter.FTConfigGet(ctx, "DEFAULT_DIALECT").Result() + Expect(err).NotTo(HaveOccurred()) + Expect(defDialect).To(BeEquivalentTo(map[string]interface{}{"DEFAULT_DIALECT": "2"})) + }) + + It("should FTCreate WithSuffixtrie", Label("search", "ftcreate", "ftinfo"), func() { + val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, &FieldSchema{FieldName: "txt", FieldType: SearchFieldTypeText}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(val).To(BeEquivalentTo("OK")) + WaitForIndexing(client, "idx1") + + res, err := adapter.FTInfo(ctx, "idx1").Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res.Attributes[0].Attribute).To(BeEquivalentTo("txt")) + + resDrop, err := adapter.FTDropIndex(ctx, "idx1").Result() + Expect(err).NotTo(HaveOccurred()) + Expect(resDrop).To(BeEquivalentTo("OK")) + + // create withsuffixtrie index - text field + val, err = adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, &FieldSchema{FieldName: "txt", FieldType: SearchFieldTypeText, WithSuffixtrie: true}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(val).To(BeEquivalentTo("OK")) + WaitForIndexing(client, "idx1") + + res, err = adapter.FTInfo(ctx, "idx1").Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res.Attributes[0].WithSuffixtrie).To(BeTrue()) + + resDrop, err = adapter.FTDropIndex(ctx, "idx1").Result() + Expect(err).NotTo(HaveOccurred()) + Expect(resDrop).To(BeEquivalentTo("OK")) + + // create withsuffixtrie index - tag field + val, err = adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, &FieldSchema{FieldName: "t", FieldType: SearchFieldTypeTag, WithSuffixtrie: true}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(val).To(BeEquivalentTo("OK")) + WaitForIndexing(client, "idx1") + + res, err = adapter.FTInfo(ctx, "idx1").Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res.Attributes[0].WithSuffixtrie).To(BeTrue()) + }) + + It("should test dialect 4", Label("search", "ftcreate", "ftsearch", "NonRedisEnterprise"), func() { + val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{ + Prefix: []interface{}{"resource:"}, + }, &FieldSchema{ + FieldName: "uuid", + FieldType: SearchFieldTypeTag, + }, &FieldSchema{ + FieldName: "tags", + FieldType: SearchFieldTypeTag, + }, &FieldSchema{ + FieldName: "description", + FieldType: SearchFieldTypeText, + }, &FieldSchema{ + FieldName: "rating", + FieldType: SearchFieldTypeNumeric, + }).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(val).To(BeEquivalentTo("OK")) + + adapter.HSet(ctx, "resource:1", map[string]interface{}{ + "uuid": "123e4567-e89b-12d3-a456-426614174000", + "tags": "finance|crypto|$btc|blockchain", + "description": "Analysis of blockchain technologies & Bitcoin's potential.", + "rating": 5, + }) + adapter.HSet(ctx, "resource:2", map[string]interface{}{ + "uuid": "987e6543-e21c-12d3-a456-426614174999", + "tags": "health|well-being|fitness|new-year's-resolutions", + "description": "Health trends for the new year, including fitness regimes.", + "rating": 4, + }) + + res, err := adapter.FTSearchWithArgs(ctx, "idx1", "@uuid:{$uuid}", + &FTSearchOptions{ + DialectVersion: 2, + Params: map[string]interface{}{"uuid": "123e4567-e89b-12d3-a456-426614174000"}, + }).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res.Total).To(BeEquivalentTo(int64(1))) + Expect(res.Docs[0].ID).To(BeEquivalentTo("resource:1")) + + res, err = adapter.FTSearchWithArgs(ctx, "idx1", "@uuid:{$uuid}", + &FTSearchOptions{ + DialectVersion: 4, + Params: map[string]interface{}{"uuid": "123e4567-e89b-12d3-a456-426614174000"}, + }).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res.Total).To(BeEquivalentTo(int64(1))) + Expect(res.Docs[0].ID).To(BeEquivalentTo("resource:1")) + + adapter.HSet(ctx, "test:1", map[string]interface{}{ + "uuid": "3d3586fe-0416-4572-8ce", + "email": "adriano@acme.com.ie", + "num": 5, + }) + + // Create the index + ftCreateOptions := &FTCreateOptions{ + Prefix: []interface{}{"test:"}, + } + schema := []*FieldSchema{ + { + FieldName: "uuid", + FieldType: SearchFieldTypeTag, + }, + { + FieldName: "email", + FieldType: SearchFieldTypeTag, + }, + { + FieldName: "num", + FieldType: SearchFieldTypeNumeric, + }, + } + + val, err = adapter.FTCreate(ctx, "idx_hash", ftCreateOptions, schema...).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(val).To(Equal("OK")) + + ftSearchOptions := &FTSearchOptions{ + DialectVersion: 4, + Params: map[string]interface{}{ + "uuid": "3d3586fe-0416-4572-8ce", + "email": "adriano@acme.com.ie", + }, + } + + res, err = adapter.FTSearchWithArgs(ctx, "idx_hash", "@uuid:{$uuid}", ftSearchOptions).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res.Docs[0].ID).To(BeEquivalentTo("test:1")) + Expect(res.Docs[0].Fields["uuid"]).To(BeEquivalentTo("3d3586fe-0416-4572-8ce")) + + res, err = adapter.FTSearchWithArgs(ctx, "idx_hash", "@email:{$email}", ftSearchOptions).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res.Docs[0].ID).To(BeEquivalentTo("test:1")) + Expect(res.Docs[0].Fields["email"]).To(BeEquivalentTo("adriano@acme.com.ie")) + + ftSearchOptions.Params = map[string]interface{}{"num": 5} + res, err = adapter.FTSearchWithArgs(ctx, "idx_hash", "@num:[5]", ftSearchOptions).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res.Docs[0].ID).To(BeEquivalentTo("test:1")) + Expect(res.Docs[0].Fields["num"]).To(BeEquivalentTo("5")) + }) + + It("should FTCreate GeoShape", Label("search", "ftcreate", "ftsearch"), func() { + val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, &FieldSchema{FieldName: "geom", FieldType: SearchFieldTypeGeoShape, GeoShapeFieldType: "FLAT"}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(val).To(BeEquivalentTo("OK")) + WaitForIndexing(client, "idx1") + + adapter.HSet(ctx, "small", "geom", "POLYGON((1 1, 1 100, 100 100, 100 1, 1 1))") + adapter.HSet(ctx, "large", "geom", "POLYGON((1 1, 1 200, 200 200, 200 1, 1 1))") + + res1, err := adapter.FTSearchWithArgs(ctx, "idx1", "@geom:[WITHIN $poly]", + &FTSearchOptions{ + DialectVersion: 3, + Params: map[string]interface{}{"poly": "POLYGON((0 0, 0 150, 150 150, 150 0, 0 0))"}, + }).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res1.Total).To(BeEquivalentTo(int64(1))) + Expect(res1.Docs[0].ID).To(BeEquivalentTo("small")) + + res2, err := adapter.FTSearchWithArgs(ctx, "idx1", "@geom:[CONTAINS $poly]", + &FTSearchOptions{ + DialectVersion: 3, + Params: map[string]interface{}{"poly": "POLYGON((2 2, 2 50, 50 50, 50 2, 2 2))"}, + }).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res2.Total).To(BeEquivalentTo(int64(2))) + }) + + It("should create search index with FLOAT16 and BFLOAT16 vectors", Label("search", "ftcreate", "NonRedisEnterprise"), func() { + val, err := adapter.FTCreate(ctx, "index", &FTCreateOptions{}, + &FieldSchema{FieldName: "float16", FieldType: SearchFieldTypeVector, VectorArgs: &FTVectorArgs{FlatOptions: &FTFlatOptions{Type: "FLOAT16", Dim: 768, DistanceMetric: "COSINE"}}}, + &FieldSchema{FieldName: "bfloat16", FieldType: SearchFieldTypeVector, VectorArgs: &FTVectorArgs{FlatOptions: &FTFlatOptions{Type: "BFLOAT16", Dim: 768, DistanceMetric: "COSINE"}}}, + ).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(val).To(BeEquivalentTo("OK")) + WaitForIndexing(client, "index") + }) + + It("should test geoshapes query intersects and disjoint", Label("NonRedisEnterprise"), func() { + _, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, &FieldSchema{ + FieldName: "g", + FieldType: SearchFieldTypeGeoShape, + GeoShapeFieldType: "FLAT", + }).Result() + Expect(err).NotTo(HaveOccurred()) + + adapter.HSet(ctx, "doc_point1", "g", "POINT (10 10)") + adapter.HSet(ctx, "doc_point2", "g", "POINT (50 50)") + adapter.HSet(ctx, "doc_polygon1", "g", "POLYGON ((20 20, 25 35, 35 25, 20 20))") + adapter.HSet(ctx, "doc_polygon2", "g", "POLYGON ((60 60, 65 75, 70 70, 65 55, 60 60))") + + intersection, err := adapter.FTSearchWithArgs(ctx, "idx1", "@g:[intersects $shape]", + &FTSearchOptions{ + DialectVersion: 3, + Params: map[string]interface{}{"shape": "POLYGON((15 15, 75 15, 50 70, 20 40, 15 15))"}, + }).Result() + Expect(err).NotTo(HaveOccurred()) + _assert_geosearch_result(&intersection, []string{"doc_point2", "doc_polygon1"}) + + disjunction, err := adapter.FTSearchWithArgs(ctx, "idx1", "@g:[disjoint $shape]", + &FTSearchOptions{ + DialectVersion: 3, + Params: map[string]interface{}{"shape": "POLYGON((15 15, 75 15, 50 70, 20 40, 15 15))"}, + }).Result() + Expect(err).NotTo(HaveOccurred()) + _assert_geosearch_result(&disjunction, []string{"doc_point1", "doc_polygon2"}) + }) + + It("should test geoshapes query contains and within", func() { + _, err := adapter.FTCreate(ctx, "idx2", &FTCreateOptions{}, &FieldSchema{ + FieldName: "g", + FieldType: SearchFieldTypeGeoShape, + GeoShapeFieldType: "FLAT", + }).Result() + Expect(err).NotTo(HaveOccurred()) + + adapter.HSet(ctx, "doc_point1", "g", "POINT (10 10)") + adapter.HSet(ctx, "doc_point2", "g", "POINT (50 50)") + adapter.HSet(ctx, "doc_polygon1", "g", "POLYGON ((20 20, 25 35, 35 25, 20 20))") + adapter.HSet(ctx, "doc_polygon2", "g", "POLYGON ((60 60, 65 75, 70 70, 65 55, 60 60))") + + containsA, err := adapter.FTSearchWithArgs(ctx, "idx2", "@g:[contains $shape]", + &FTSearchOptions{ + DialectVersion: 3, + Params: map[string]interface{}{"shape": "POINT(25 25)"}, + }).Result() + Expect(err).NotTo(HaveOccurred()) + _assert_geosearch_result(&containsA, []string{"doc_polygon1"}) + + containsB, err := adapter.FTSearchWithArgs(ctx, "idx2", "@g:[contains $shape]", + &FTSearchOptions{ + DialectVersion: 3, + Params: map[string]interface{}{"shape": "POLYGON((24 24, 24 26, 25 25, 24 24))"}, + }).Result() + Expect(err).NotTo(HaveOccurred()) + _assert_geosearch_result(&containsB, []string{"doc_polygon1"}) + + within, err := adapter.FTSearchWithArgs(ctx, "idx2", "@g:[within $shape]", + &FTSearchOptions{ + DialectVersion: 3, + Params: map[string]interface{}{"shape": "POLYGON((15 15, 75 15, 50 70, 20 40, 15 15))"}, + }).Result() + Expect(err).NotTo(HaveOccurred()) + _assert_geosearch_result(&within, []string{"doc_point2", "doc_polygon1"}) + }) + + It("should search missing fields", Label("search", "ftcreate", "ftsearch", "NonRedisEnterprise"), func() { + val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{Prefix: []interface{}{"property:"}}, + &FieldSchema{FieldName: "title", FieldType: SearchFieldTypeText, Sortable: true}, + &FieldSchema{FieldName: "features", FieldType: SearchFieldTypeTag, IndexMissing: true}, + &FieldSchema{FieldName: "description", FieldType: SearchFieldTypeText, IndexMissing: true}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(val).To(BeEquivalentTo("OK")) + WaitForIndexing(client, "idx1") + + adapter.HSet(ctx, "property:1", map[string]interface{}{ + "title": "Luxury Villa in Malibu", + "features": "pool,sea view,modern", + "description": "A stunning modern villa overlooking the Pacific Ocean.", + }) + + adapter.HSet(ctx, "property:2", map[string]interface{}{ + "title": "Downtown Flat", + "description": "Modern flat in central Paris with easy access to metro.", + }) + + adapter.HSet(ctx, "property:3", map[string]interface{}{ + "title": "Beachfront Bungalow", + "features": "beachfront,sun deck", + }) + + res, err := adapter.FTSearchWithArgs(ctx, "idx1", "ismissing(@features)", &FTSearchOptions{DialectVersion: 4, Return: []FTSearchReturn{{FieldName: "id"}}, NoContent: true}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res.Docs[0].ID).To(BeEquivalentTo("property:2")) + + res, err = adapter.FTSearchWithArgs(ctx, "idx1", "-ismissing(@features)", &FTSearchOptions{DialectVersion: 4, Return: []FTSearchReturn{{FieldName: "id"}}, NoContent: true}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res.Docs[0].ID).To(BeEquivalentTo("property:1")) + Expect(res.Docs[1].ID).To(BeEquivalentTo("property:3")) + + res, err = adapter.FTSearchWithArgs(ctx, "idx1", "ismissing(@description)", &FTSearchOptions{DialectVersion: 4, Return: []FTSearchReturn{{FieldName: "id"}}, NoContent: true}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res.Docs[0].ID).To(BeEquivalentTo("property:3")) + + res, err = adapter.FTSearchWithArgs(ctx, "idx1", "-ismissing(@description)", &FTSearchOptions{DialectVersion: 4, Return: []FTSearchReturn{{FieldName: "id"}}, NoContent: true}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res.Docs[0].ID).To(BeEquivalentTo("property:1")) + Expect(res.Docs[1].ID).To(BeEquivalentTo("property:2")) + }) + + It("should search empty fields", Label("search", "ftcreate", "ftsearch", "NonRedisEnterprise"), func() { + val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{Prefix: []interface{}{"property:"}}, + &FieldSchema{FieldName: "title", FieldType: SearchFieldTypeText, Sortable: true}, + &FieldSchema{FieldName: "features", FieldType: SearchFieldTypeTag, IndexEmpty: true}, + &FieldSchema{FieldName: "description", FieldType: SearchFieldTypeText, IndexEmpty: true}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(val).To(BeEquivalentTo("OK")) + WaitForIndexing(client, "idx1") + + adapter.HSet(ctx, "property:1", map[string]interface{}{ + "title": "Luxury Villa in Malibu", + "features": "pool,sea view,modern", + "description": "A stunning modern villa overlooking the Pacific Ocean.", + }) + + adapter.HSet(ctx, "property:2", map[string]interface{}{ + "title": "Downtown Flat", + "features": "", + "description": "Modern flat in central Paris with easy access to metro.", + }) + + adapter.HSet(ctx, "property:3", map[string]interface{}{ + "title": "Beachfront Bungalow", + "features": "beachfront,sun deck", + "description": "", + }) + + res, err := adapter.FTSearchWithArgs(ctx, "idx1", "@features:{\"\"}", &FTSearchOptions{DialectVersion: 4, Return: []FTSearchReturn{{FieldName: "id"}}, NoContent: true}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res.Docs[0].ID).To(BeEquivalentTo("property:2")) + + res, err = adapter.FTSearchWithArgs(ctx, "idx1", "-@features:{\"\"}", &FTSearchOptions{DialectVersion: 4, Return: []FTSearchReturn{{FieldName: "id"}}, NoContent: true}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res.Docs[0].ID).To(BeEquivalentTo("property:1")) + Expect(res.Docs[1].ID).To(BeEquivalentTo("property:3")) + + res, err = adapter.FTSearchWithArgs(ctx, "idx1", "@description:''", &FTSearchOptions{DialectVersion: 4, Return: []FTSearchReturn{{FieldName: "id"}}, NoContent: true}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res.Docs[0].ID).To(BeEquivalentTo("property:3")) + + res, err = adapter.FTSearchWithArgs(ctx, "idx1", "-@description:''", &FTSearchOptions{DialectVersion: 4, Return: []FTSearchReturn{{FieldName: "id"}}, NoContent: true}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res.Docs[0].ID).To(BeEquivalentTo("property:1")) + Expect(res.Docs[1].ID).To(BeEquivalentTo("property:2")) + }) + }) } func libCode(libName string) string { @@ -11555,14 +12845,14 @@ func libCodeWithConfig(libName string) string { lib := `#!js api_version=1.0 name=%s var last_update_field_name = "__last_update__" - + if (redis.config.last_update_field_name !== undefined) { if (typeof redis.config.last_update_field_name != 'string') { throw "last_update_field_name must be a string"; } last_update_field_name = redis.config.last_update_field_name } - + redis.registerFunction("hset", function(client, key, field, val){ // get the current time in ms var curr_time = client.call("time")[0]; @@ -11582,3 +12872,18 @@ func (s *numberStruct) MarshalBinary() ([]byte, error) { func (s *numberStruct) UnmarshalBinary(b []byte) error { return json.Unmarshal(b, s) } + +func WaitForIndexing(c rueidis.Client, index string) { + for { + res, err := c.FTInfo(context.Background(), index).Result() + Expect(err).NotTo(HaveOccurred()) + if c.Options().Protocol == 2 { + if res.Indexing == 0 { + return + } + time.Sleep(100 * time.Millisecond) + } else { + return + } + } +} diff --git a/rueidiscompat/command.go b/rueidiscompat/command.go index 4fd00638..e7b06c63 100644 --- a/rueidiscompat/command.go +++ b/rueidiscompat/command.go @@ -3349,11 +3349,36 @@ func newJSONSliceCmd(res rueidis.RedisResult) *JSONSliceCmd { return cmd } +type mapStringInterface map[string]any type MapMapStringInterfaceCmd struct { - // FIXME: add impl + baseCmd[map[string]mapStringInterface] } func (cmd *MapMapStringInterfaceCmd) from(res rueidis.RedisResult) { + // outerMap: map[string]mapStringInterface + outerMap, err := res.ToMap() + if err != nil { + cmd.SetErr(err) + return + } + cmd.val = make(map[string]mapStringInterface, len(outerMap)) + for k, v := range outerMap { + // _m: map[string]any + _m, err := v.ToMap() + if err != nil { + cmd.SetErr(err) + return + } + cmd.val[k] = make(map[string]any, len(_m)) + for _k, _v := range _m { + val, err := _v.ToAny() + if err != nil { + cmd.SetErr(err) + return + } + cmd.val[k][_k] = val + } + } } func newMapMapStringInterfaceCmd(res rueidis.RedisResult) *MapMapStringInterfaceCmd { @@ -3368,6 +3393,11 @@ type FTAggregateOptions struct { type AggregateCmd struct { // FIXME + baseCmd[map[string]any] +} + +func (cmd *AggregateCmd) from(res rueidis.RedisResult) { + } type FTCreateOptions struct{} From d1177232f404a612661d2e8562a602635a534aff Mon Sep 17 00:00:00 2001 From: Eric Chang Date: Tue, 29 Oct 2024 21:40:09 +0800 Subject: [PATCH 03/49] feat(RediSearch): wip: fixme: why not impl FTAggregate --- rueidiscompat/adapter.go | 61 +++++++++++ rueidiscompat/adapter_test.go | 186 ++++++++++++++++++++++++++++++++++ rueidiscompat/command.go | 55 +++++++++- rueidiscompat/pipeline.go | 6 ++ 4 files changed, 304 insertions(+), 4 deletions(-) diff --git a/rueidiscompat/adapter.go b/rueidiscompat/adapter.go index e3e8dfb7..d7abee88 100644 --- a/rueidiscompat/adapter.go +++ b/rueidiscompat/adapter.go @@ -4835,6 +4835,67 @@ func (c *Compat) Watch(ctx context.Context, fn func(Tx) error, keys ...string) e return fn(newTx(dc, cancel)) } +func (c *Compat) FT_List(ctx context.Context) *StringSliceCmd +func (c *Compat) FTAggregate(ctx context.Context, index string, query string) *MapStringInterfaceCmd { + return nil +} +func (c *Compat) FTAggregateWithArgs(ctx context.Context, index string, query string, options *FTAggregateOptions) *AggregateCmd { + return nil +} +func (c *Compat) FTAliasAdd(ctx context.Context, index string, alias string) *StatusCmd { return nil } +func (c *Compat) FTAliasDel(ctx context.Context, alias string) *StatusCmd { return nil } +func (c *Compat) FTAliasUpdate(ctx context.Context, index string, alias string) *StatusCmd { + return nil +} +func (c *Compat) FTAlter(ctx context.Context, index string, skipInitalScan bool, definition []interface{}) *StatusCmd { + return nil +} +func (c *Compat) FTConfigGet(ctx context.Context, option string) *MapMapStringInterfaceCmd { + return nil +} +func (c *Compat) FTConfigSet(ctx context.Context, option string, value interface{}) *StatusCmd { + return nil +} +func (c *Compat) FTCreate(ctx context.Context, index string, options *FTCreateOptions, schema ...*FieldSchema) *StatusCmd { + return nil +} +func (c *Compat) FTCursorDel(ctx context.Context, index string, cursorId int) *StatusCmd { return nil } +func (c *Compat) FTCursorRead(ctx context.Context, index string, cursorId int, count int) *MapStringInterfaceCmd { + return nil +} +func (c *Compat) FTDictAdd(ctx context.Context, dict string, term ...interface{}) *IntCmd { return nil } +func (c *Compat) FTDictDel(ctx context.Context, dict string, term ...interface{}) *IntCmd { return nil } +func (c *Compat) FTDictDump(ctx context.Context, dict string) *StringSliceCmd { return nil } +func (c *Compat) FTDropIndex(ctx context.Context, index string) *StatusCmd { return nil } +func (c *Compat) FTDropIndexWithArgs(ctx context.Context, index string, options *FTDropIndexOptions) *StatusCmd { + return nil +} +func (c *Compat) FTExplain(ctx context.Context, index string, query string) *StringCmd { return nil } +func (c *Compat) FTExplainWithArgs(ctx context.Context, index string, query string, options *FTExplainOptions) *StringCmd { + return nil +} +func (c *Compat) FTInfo(ctx context.Context, index string) *FTInfoCmd { return nil } +func (c *Compat) FTSpellCheck(ctx context.Context, index string, query string) *FTSpellCheckCmd { + return nil +} +func (c *Compat) FTSpellCheckWithArgs(ctx context.Context, index string, query string, options *FTSpellCheckOptions) *FTSpellCheckCmd { + return nil +} +func (c *Compat) FTSearch(ctx context.Context, index string, query string) *FTSearchCmd { return nil } +func (c *Compat) FTSearchWithArgs(ctx context.Context, index string, query string, options *FTSearchOptions) *FTSearchCmd { + return nil +} +func (c *Compat) FTSynDump(ctx context.Context, index string) *FTSynDumpCmd { return nil } +func (c *Compat) FTSynUpdate(ctx context.Context, index string, synGroupId interface{}, terms []interface{}) *StatusCmd { + return nil +} +func (c *Compat) FTSynUpdateWithArgs(ctx context.Context, index string, synGroupId interface{}, options *FTSynUpdateOptions, terms []interface{}) *StatusCmd { + return nil +} +func (c *Compat) FTTagVals(ctx context.Context, index string, field string) *StringSliceCmd { + return nil +} + func (c CacheCompat) BitCount(ctx context.Context, key string, bitCount *BitCount) *IntCmd { var resp rueidis.RedisResult if bitCount == nil { diff --git a/rueidiscompat/adapter_test.go b/rueidiscompat/adapter_test.go index ea257072..79456d24 100644 --- a/rueidiscompat/adapter_test.go +++ b/rueidiscompat/adapter_test.go @@ -12835,6 +12835,192 @@ func testAdapterCache(resp3 bool) { Expect(res.Docs[1].ID).To(BeEquivalentTo("property:2")) }) }) + + Describe("RediSearch commands Resp 3", Label("search"), func() { + ctx := context.TODO() + var client *redis.Client + var client2 *redis.Client + + BeforeEach(func() { + client = redis.NewClient(&redis.Options{Addr: ":6379", Protocol: 3, UnstableResp3: true}) + client2 = redis.NewClient(&redis.Options{Addr: ":6379", Protocol: 3}) + Expect(client.FlushDB(ctx).Err()).NotTo(HaveOccurred()) + }) + + AfterEach(func() { + Expect(client.Close()).NotTo(HaveOccurred()) + }) + + It("should handle FTAggregate with Unstable RESP3 Search Module and without stability", Label("search", "ftcreate", "ftaggregate"), func() { + text1 := &redis.FieldSchema{FieldName: "PrimaryKey", FieldType: redis.SearchFieldTypeText, Sortable: true} + num1 := &redis.FieldSchema{FieldName: "CreatedDateTimeUTC", FieldType: redis.SearchFieldTypeNumeric, Sortable: true} + val, err := client.FTCreate(ctx, "idx1", &redis.FTCreateOptions{}, text1, num1).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(val).To(BeEquivalentTo("OK")) + WaitForIndexing(client, "idx1") + + client.HSet(ctx, "doc1", "PrimaryKey", "9::362330", "CreatedDateTimeUTC", "637387878524969984") + client.HSet(ctx, "doc2", "PrimaryKey", "9::362329", "CreatedDateTimeUTC", "637387875859270016") + + options := &redis.FTAggregateOptions{Apply: []redis.FTAggregateApply{{Field: "@CreatedDateTimeUTC * 10", As: "CreatedDateTimeUTC"}}} + res, err := client.FTAggregateWithArgs(ctx, "idx1", "*", options).RawResult() + results := res.(map[interface{}]interface{})["results"].([]interface{}) + Expect(results[0].(map[interface{}]interface{})["extra_attributes"].(map[interface{}]interface{})["CreatedDateTimeUTC"]). + To(Or(BeEquivalentTo("6373878785249699840"), BeEquivalentTo("6373878758592700416"))) + Expect(results[1].(map[interface{}]interface{})["extra_attributes"].(map[interface{}]interface{})["CreatedDateTimeUTC"]). + To(Or(BeEquivalentTo("6373878785249699840"), BeEquivalentTo("6373878758592700416"))) + + rawVal := client.FTAggregateWithArgs(ctx, "idx1", "*", options).RawVal() + rawValResults := rawVal.(map[interface{}]interface{})["results"].([]interface{}) + Expect(err).NotTo(HaveOccurred()) + Expect(rawValResults[0]).To(Or(BeEquivalentTo(results[0]), BeEquivalentTo(results[1]))) + Expect(rawValResults[1]).To(Or(BeEquivalentTo(results[0]), BeEquivalentTo(results[1]))) + + // Test with UnstableResp3 false + Expect(func() { + options = &redis.FTAggregateOptions{Apply: []redis.FTAggregateApply{{Field: "@CreatedDateTimeUTC * 10", As: "CreatedDateTimeUTC"}}} + rawRes, _ := client2.FTAggregateWithArgs(ctx, "idx1", "*", options).RawResult() + rawVal = client2.FTAggregateWithArgs(ctx, "idx1", "*", options).RawVal() + Expect(rawRes).To(BeNil()) + Expect(rawVal).To(BeNil()) + }).Should(Panic()) + + }) + + It("should handle FTInfo with Unstable RESP3 Search Module and without stability", Label("search", "ftcreate", "ftinfo"), func() { + val, err := client.FTCreate(ctx, "idx1", &redis.FTCreateOptions{}, &redis.FieldSchema{FieldName: "txt", FieldType: redis.SearchFieldTypeText, Sortable: true, NoStem: true}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(val).To(BeEquivalentTo("OK")) + WaitForIndexing(client, "idx1") + + resInfo, err := client.FTInfo(ctx, "idx1").RawResult() + Expect(err).NotTo(HaveOccurred()) + attributes := resInfo.(map[interface{}]interface{})["attributes"].([]interface{}) + flags := attributes[0].(map[interface{}]interface{})["flags"].([]interface{}) + Expect(flags).To(ConsistOf("SORTABLE", "NOSTEM")) + + valInfo := client.FTInfo(ctx, "idx1").RawVal() + attributes = valInfo.(map[interface{}]interface{})["attributes"].([]interface{}) + flags = attributes[0].(map[interface{}]interface{})["flags"].([]interface{}) + Expect(flags).To(ConsistOf("SORTABLE", "NOSTEM")) + + // Test with UnstableResp3 false + Expect(func() { + rawResInfo, _ := client2.FTInfo(ctx, "idx1").RawResult() + rawValInfo := client2.FTInfo(ctx, "idx1").RawVal() + Expect(rawResInfo).To(BeNil()) + Expect(rawValInfo).To(BeNil()) + }).Should(Panic()) + }) + + It("should handle FTSpellCheck with Unstable RESP3 Search Module and without stability", Label("search", "ftcreate", "ftspellcheck"), func() { + text1 := &redis.FieldSchema{FieldName: "f1", FieldType: redis.SearchFieldTypeText} + text2 := &redis.FieldSchema{FieldName: "f2", FieldType: redis.SearchFieldTypeText} + val, err := client.FTCreate(ctx, "idx1", &redis.FTCreateOptions{}, text1, text2).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(val).To(BeEquivalentTo("OK")) + WaitForIndexing(client, "idx1") + + client.HSet(ctx, "doc1", "f1", "some valid content", "f2", "this is sample text") + client.HSet(ctx, "doc2", "f1", "very important", "f2", "lorem ipsum") + + resSpellCheck, err := client.FTSpellCheck(ctx, "idx1", "impornant").RawResult() + valSpellCheck := client.FTSpellCheck(ctx, "idx1", "impornant").RawVal() + Expect(err).NotTo(HaveOccurred()) + Expect(valSpellCheck).To(BeEquivalentTo(resSpellCheck)) + results := resSpellCheck.(map[interface{}]interface{})["results"].(map[interface{}]interface{}) + Expect(results["impornant"].([]interface{})[0].(map[interface{}]interface{})["important"]).To(BeEquivalentTo(0.5)) + + // Test with UnstableResp3 false + Expect(func() { + rawResSpellCheck, _ := client2.FTSpellCheck(ctx, "idx1", "impornant").RawResult() + rawValSpellCheck := client2.FTSpellCheck(ctx, "idx1", "impornant").RawVal() + Expect(rawResSpellCheck).To(BeNil()) + Expect(rawValSpellCheck).To(BeNil()) + }).Should(Panic()) + }) + + It("should handle FTSearch with Unstable RESP3 Search Module and without stability", Label("search", "ftcreate", "ftsearch"), func() { + val, err := client.FTCreate(ctx, "txt", &redis.FTCreateOptions{StopWords: []interface{}{"foo", "bar", "baz"}}, &redis.FieldSchema{FieldName: "txt", FieldType: redis.SearchFieldTypeText}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(val).To(BeEquivalentTo("OK")) + WaitForIndexing(client, "txt") + client.HSet(ctx, "doc1", "txt", "foo baz") + client.HSet(ctx, "doc2", "txt", "hello world") + res1, err := client.FTSearchWithArgs(ctx, "txt", "foo bar", &redis.FTSearchOptions{NoContent: true}).RawResult() + val1 := client.FTSearchWithArgs(ctx, "txt", "foo bar", &redis.FTSearchOptions{NoContent: true}).RawVal() + Expect(err).NotTo(HaveOccurred()) + Expect(val1).To(BeEquivalentTo(res1)) + totalResults := res1.(map[interface{}]interface{})["total_results"] + Expect(totalResults).To(BeEquivalentTo(int64(0))) + res2, err := client.FTSearchWithArgs(ctx, "txt", "foo bar hello world", &redis.FTSearchOptions{NoContent: true}).RawResult() + Expect(err).NotTo(HaveOccurred()) + totalResults2 := res2.(map[interface{}]interface{})["total_results"] + Expect(totalResults2).To(BeEquivalentTo(int64(1))) + + // Test with UnstableResp3 false + Expect(func() { + rawRes2, _ := client2.FTSearchWithArgs(ctx, "txt", "foo bar hello world", &redis.FTSearchOptions{NoContent: true}).RawResult() + rawVal2 := client2.FTSearchWithArgs(ctx, "txt", "foo bar hello world", &redis.FTSearchOptions{NoContent: true}).RawVal() + Expect(rawRes2).To(BeNil()) + Expect(rawVal2).To(BeNil()) + }).Should(Panic()) + }) + It("should handle FTSynDump with Unstable RESP3 Search Module and without stability", Label("search", "ftsyndump"), func() { + text1 := &redis.FieldSchema{FieldName: "title", FieldType: redis.SearchFieldTypeText} + text2 := &redis.FieldSchema{FieldName: "body", FieldType: redis.SearchFieldTypeText} + val, err := client.FTCreate(ctx, "idx1", &redis.FTCreateOptions{OnHash: true}, text1, text2).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(val).To(BeEquivalentTo("OK")) + WaitForIndexing(client, "idx1") + + resSynUpdate, err := client.FTSynUpdate(ctx, "idx1", "id1", []interface{}{"boy", "child", "offspring"}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(resSynUpdate).To(BeEquivalentTo("OK")) + + resSynUpdate, err = client.FTSynUpdate(ctx, "idx1", "id1", []interface{}{"baby", "child"}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(resSynUpdate).To(BeEquivalentTo("OK")) + + resSynUpdate, err = client.FTSynUpdate(ctx, "idx1", "id1", []interface{}{"tree", "wood"}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(resSynUpdate).To(BeEquivalentTo("OK")) + + resSynDump, err := client.FTSynDump(ctx, "idx1").RawResult() + valSynDump := client.FTSynDump(ctx, "idx1").RawVal() + Expect(err).NotTo(HaveOccurred()) + Expect(valSynDump).To(BeEquivalentTo(resSynDump)) + Expect(resSynDump.(map[interface{}]interface{})["baby"]).To(BeEquivalentTo([]interface{}{"id1"})) + + // Test with UnstableResp3 false + Expect(func() { + rawResSynDump, _ := client2.FTSynDump(ctx, "idx1").RawResult() + rawValSynDump := client2.FTSynDump(ctx, "idx1").RawVal() + Expect(rawResSynDump).To(BeNil()) + Expect(rawValSynDump).To(BeNil()) + }).Should(Panic()) + }) + + It("should test not affected Resp 3 Search method - FTExplain", Label("search", "ftexplain"), func() { + text1 := &redis.FieldSchema{FieldName: "f1", FieldType: redis.SearchFieldTypeText} + text2 := &redis.FieldSchema{FieldName: "f2", FieldType: redis.SearchFieldTypeText} + text3 := &redis.FieldSchema{FieldName: "f3", FieldType: redis.SearchFieldTypeText} + val, err := client.FTCreate(ctx, "txt", &redis.FTCreateOptions{}, text1, text2, text3).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(val).To(BeEquivalentTo("OK")) + WaitForIndexing(client, "txt") + res1, err := client.FTExplain(ctx, "txt", "@f3:f3_val @f2:f2_val @f1:f1_val").Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res1).ToNot(BeEmpty()) + + // Test with UnstableResp3 false + Expect(func() { + res2, err := client2.FTExplain(ctx, "txt", "@f3:f3_val @f2:f2_val @f1:f1_val").Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res2).ToNot(BeEmpty()) + }).ShouldNot(Panic()) + }) + }) } func libCode(libName string) string { diff --git a/rueidiscompat/command.go b/rueidiscompat/command.go index e7b06c63..4c223a25 100644 --- a/rueidiscompat/command.go +++ b/rueidiscompat/command.go @@ -3401,7 +3401,46 @@ func (cmd *AggregateCmd) from(res rueidis.RedisResult) { } type FTCreateOptions struct{} -type FieldSchema struct{} + +type SearchFieldType int + +const ( + SearchFieldTypeInvalid = SearchFieldType(iota) + SearchFieldTypeNumeric + SearchFieldTypeTag + SearchFieldTypeText + SearchFieldTypeGeo + SearchFieldTypeVector + SearchFieldTypeGeoShape +) + +func (t SearchFieldType) String() string { + switch t { + case SearchFieldTypeInvalid: + return "" + case SearchFieldTypeNumeric: + return "NUMERIC" + case SearchFieldTypeTag: + return "TAG" + case SearchFieldTypeText: + return "TEXT" + case SearchFieldTypeGeo: + return "GEO" + case SearchFieldTypeVector: + return "VECTOR" + case SearchFieldTypeGeoShape: + return "GEOSHAPE" + default: + return "TEXT" + } +} + +type FieldSchema struct { + FieldName string + // FIXME: + FieldType SearchFieldType +} + type FTDropIndexOptions struct{} type FTExplainOptions struct{} type FTInfoCmd struct{} @@ -3430,7 +3469,17 @@ func newFTSpellCheckCmd(res rueidis.RedisResult) *FTSpellCheckCmd { return cmd } -type FTSearchCmd struct{} +type FTSearchResult struct{} + +type FTSearchOptions struct { + WithScores bool +} + +type FTSearchCmd struct { + // FIXME: any ? + baseCmd[FTSearchResult] + options *FTSearchOptions +} func (cmd *FTSearchCmd) from(res rueidis.RedisResult) { // FIXME: impl @@ -3442,8 +3491,6 @@ func newFTSearchCmd(res rueidis.RedisResult) *FTSearchCmd { return cmd } -type FTSearchOptions struct{} - type FTSynDumpCmd struct{} func (cmd *FTSynDumpCmd) from(res rueidis.RedisResult) { diff --git a/rueidiscompat/pipeline.go b/rueidiscompat/pipeline.go index b985be56..d39e557f 100644 --- a/rueidiscompat/pipeline.go +++ b/rueidiscompat/pipeline.go @@ -97,6 +97,12 @@ type Pipeline struct { rets []Cmder } +var pp = Pipeline{} + +const a = 1 + +var b = 3 + func (c *Pipeline) Command(ctx context.Context) *CommandsInfoCmd { ret := c.comp.Command(ctx) c.rets = append(c.rets, ret) From 23456bb804fca4df242edaca5f5dcf03a47c22f8 Mon Sep 17 00:00:00 2001 From: Eric Chang Date: Thu, 31 Oct 2024 06:27:18 +0800 Subject: [PATCH 04/49] feat(RediSearch): wip: FTSpellCheckCmd --- rueidiscompat/command.go | 354 ++++++++++++++++++++++++++++++++++++-- rueidiscompat/pipeline.go | 4 - 2 files changed, 344 insertions(+), 14 deletions(-) diff --git a/rueidiscompat/command.go b/rueidiscompat/command.go index 4c223a25..911c9348 100644 --- a/rueidiscompat/command.go +++ b/rueidiscompat/command.go @@ -3387,8 +3387,56 @@ func newMapMapStringInterfaceCmd(res rueidis.RedisResult) *MapMapStringInterface return cmd } +// Each AggregateReducer have different args. +// Please follow https://redis.io/docs/interact/search-and-query/search/aggregations/#supported-groupby-reducers for more information. +type FTAggregateReducer struct { + Reducer SearchAggregator + Args []interface{} + As string +} + +type FTAggregateGroupBy struct { + Fields []interface{} + Reduce []FTAggregateReducer +} + +type FTAggregateSortBy struct { + FieldName string + Asc bool + Desc bool +} + +type FTAggregateApply struct { + Field string + As string +} + +type FTAggregateLoad struct { + Field string + As string +} + +type FTAggregateWithCursor struct { + Count int + MaxIdle int +} + type FTAggregateOptions struct { - // FIXME + Verbatim bool + LoadAll bool + Load []FTAggregateLoad + Timeout int + GroupBy []FTAggregateGroupBy + SortBy []FTAggregateSortBy + SortByMax int + Apply []FTAggregateApply + LimitOffset int + Limit int + Filter string + WithCursor bool + WithCursorOptions *FTAggregateWithCursor + Params map[string]interface{} + DialectVersion int } type AggregateCmd struct { @@ -3400,7 +3448,76 @@ func (cmd *AggregateCmd) from(res rueidis.RedisResult) { } -type FTCreateOptions struct{} +type FTCreateOptions struct { + OnHash bool + OnJSON bool + Prefix []any + Filter string + DefaultLanguage string + LanguageField string + Score float64 + ScoreField string + PayloadField string + MaxTextFields int + NoOffsets bool + Temporary int + NoHL bool + NoFields bool + NoFreqs bool + StopWords []any + SkipInitialScan bool +} + +type SearchAggregator int + +const ( + SearchInvalid = SearchAggregator(iota) + SearchAvg + SearchSum + SearchMin + SearchMax + SearchCount + SearchCountDistinct + SearchCountDistinctish + SearchStdDev + SearchQuantile + SearchToList + SearchFirstValue + SearchRandomSample +) + +func (a SearchAggregator) String() string { + switch a { + case SearchInvalid: + return "" + case SearchAvg: + return "AVG" + case SearchSum: + return "SUM" + case SearchMin: + return "MIN" + case SearchMax: + return "MAX" + case SearchCount: + return "COUNT" + case SearchCountDistinct: + return "COUNT_DISTINCT" + case SearchCountDistinctish: + return "COUNT_DISTINCTISH" + case SearchStdDev: + return "STDDEV" + case SearchQuantile: + return "QUANTILE" + case SearchToList: + return "TOLIST" + case SearchFirstValue: + return "FIRST_VALUE" + case SearchRandomSample: + return "RANDOM_SAMPLE" + default: + return "" + } +} type SearchFieldType int @@ -3436,14 +3553,171 @@ func (t SearchFieldType) String() string { } type FieldSchema struct { + FieldName string + As string + FieldType SearchFieldType + Sortable bool + UNF bool + NoStem bool + NoIndex bool + PhoneticMatcher string + Weight float64 + Separator string + CaseSensitive bool + WithSuffixtrie bool + VectorArgs *FTVectorArgs + GeoShapeFieldType string + IndexEmpty bool + IndexMissing bool +} + +type FTVectorArgs struct { + FlatOptions *FTFlatOptions + HNSWOptions *FTHNSWOptions +} + +type FTFlatOptions struct { + Type string + Dim int + DistanceMetric string + InitialCapacity int + BlockSize int +} + +type FTHNSWOptions struct { + Type string + Dim int + DistanceMetric string + InitialCapacity int + MaxEdgesPerNode int + MaxAllowedEdgesPerNode int + EFRunTime int + Epsilon float64 +} + +type SpellCheckTerms struct { + Include bool + Exclude bool + Dictionary string +} + +type FTSearchFilter struct { + FieldName any + Min any + Max any +} + +type FTSearchGeoFilter struct { + FieldName string + Longitude float64 + Latitude float64 + Radius float64 + Unit string +} + +type FTSearchReturn struct { FieldName string - // FIXME: - FieldType SearchFieldType + As string +} + +type FTSearchSortBy struct { + FieldName string + Asc bool + Desc bool } type FTDropIndexOptions struct{} type FTExplainOptions struct{} -type FTInfoCmd struct{} + +type IndexErrors struct { + IndexingFailures int + LastIndexingError string + LastIndexingErrorKey string +} + +type FTAttribute struct { + Identifier string + Attribute string + Type string + Weight float64 + Sortable bool + NoStem bool + NoIndex bool + UNF bool + PhoneticMatcher string + CaseSensitive bool + WithSuffixtrie bool +} + +type CursorStats struct { + GlobalIdle int + GlobalTotal int + IndexCapacity int + IndexTotal int +} + +type FieldStatistic struct { + Identifier string + Attribute string + IndexErrors IndexErrors +} + +type GCStats struct { + BytesCollected int + TotalMsRun int + TotalCycles int + AverageCycleTimeMs string + LastRunTimeMs int + GCNumericTreesMissed int + GCBlocksDenied int +} + +type IndexDefinition struct { + KeyType string + Prefixes []string + DefaultScore float64 +} + +type FTInfoResult struct { + IndexErrors IndexErrors + Attributes []FTAttribute + BytesPerRecordAvg string + Cleaning int + CursorStats CursorStats + DialectStats map[string]int + DocTableSizeMB float64 + FieldStatistics []FieldStatistic + GCStats GCStats + GeoshapesSzMB float64 + HashIndexingFailures int + IndexDefinition IndexDefinition + IndexName string + IndexOptions []string + Indexing int + InvertedSzMB float64 + KeyTableSizeMB float64 + MaxDocID int + NumDocs int + NumRecords int + NumTerms int + NumberOfUses int + OffsetBitsPerRecordAvg string + OffsetVectorsSzMB float64 + OffsetsPerTermAvg string + PercentIndexed float64 + RecordsPerDocAvg string + SortableValuesSizeMB float64 + TagOverheadSzMB float64 + TextOverheadSzMB float64 + TotalIndexMemorySzMB float64 + TotalIndexingTime int + TotalInvertedIndexBlocks int + VectorIndexSzMB float64 +} + +type FTInfoCmd struct { + baseCmd[FTInfoResult] +} func (cmd *FTInfoCmd) from(res rueidis.RedisResult) { // FIXME: impl @@ -3457,7 +3731,26 @@ func newFTInfoCmd(res rueidis.RedisResult) *FTInfoCmd { type FTSpellCheckOptions struct{} -type FTSpellCheckCmd struct{} +type SpellCheckResult struct { + Term string + Suggestions []SpellCheckSuggestion +} + +type SpellCheckSuggestion struct { + Score float64 + Suggestion string +} + +type FTSpellCheckCmd struct{ baseCmd[SpellCheckResult] } + +func (cmd *FTSpellCheckCmd) Val() []SpellCheckResult { + // fIXME: impl + return cmd.val.Suggestions +} + +func (cmd *FTSpellCheckCmd) Result() ([]SpellCheckResult, error) { + return cmd.Val(), cmd.err +} func (cmd *FTSpellCheckCmd) from(res rueidis.RedisResult) { // FIXME: impl @@ -3469,14 +3762,48 @@ func newFTSpellCheckCmd(res rueidis.RedisResult) *FTSpellCheckCmd { return cmd } -type FTSearchResult struct{} +type Document struct { + ID string + Score *float64 + Payload *string + SortKey *string + Fields map[string]string +} + +type FTSearchResult struct { + Total int + Docs []Document +} type FTSearchOptions struct { - WithScores bool + NoContent bool + Verbatim bool + NoStopWords bool + WithScores bool + WithPayloads bool + WithSortKeys bool + Filters []FTSearchFilter + GeoFilter []FTSearchGeoFilter + InKeys []interface{} + InFields []interface{} + Return []FTSearchReturn + Slop int + Timeout int + InOrder bool + Language string + Expander string + Scorer string + ExplainScore bool + Payload string + SortBy []FTSearchSortBy + SortByWithCount bool + LimitOffset int + Limit int + Params map[string]interface{} + DialectVersion int } type FTSearchCmd struct { - // FIXME: any ? baseCmd[FTSearchResult] options *FTSearchOptions } @@ -3491,6 +3818,10 @@ func newFTSearchCmd(res rueidis.RedisResult) *FTSearchCmd { return cmd } +type FTSynUpdateOptions struct { + SkipInitialScan bool +} + type FTSynDumpCmd struct{} func (cmd *FTSynDumpCmd) from(res rueidis.RedisResult) { @@ -3503,4 +3834,7 @@ func newFTSynDumpCmd(res rueidis.RedisResult) *FTSynDumpCmd { return cmd } -type FTSynUpdateOptions struct{} +type FTSynDumpResult struct { + Term string + Synonyms []string +} diff --git a/rueidiscompat/pipeline.go b/rueidiscompat/pipeline.go index d39e557f..431faa18 100644 --- a/rueidiscompat/pipeline.go +++ b/rueidiscompat/pipeline.go @@ -99,10 +99,6 @@ type Pipeline struct { var pp = Pipeline{} -const a = 1 - -var b = 3 - func (c *Pipeline) Command(ctx context.Context) *CommandsInfoCmd { ret := c.comp.Command(ctx) c.rets = append(c.rets, ret) From 8ad4582bf22ed2580432204d1d7b39b3d8417ffc Mon Sep 17 00:00:00 2001 From: Eric Chang Date: Thu, 31 Oct 2024 19:38:10 +0800 Subject: [PATCH 05/49] feat(RediSearch): wip: FTAggregate --- rueidiscompat/adapter_test.go | 64 ++++++++++++++++++++--------------- rueidiscompat/command.go | 28 ++++++++++++--- 2 files changed, 60 insertions(+), 32 deletions(-) diff --git a/rueidiscompat/adapter_test.go b/rueidiscompat/adapter_test.go index 79456d24..a97ba0bc 100644 --- a/rueidiscompat/adapter_test.go +++ b/rueidiscompat/adapter_test.go @@ -36,6 +36,7 @@ import ( "testing" "time" + "github.com/go-redis/redis" . "github.com/onsi/ginkgo/v2" . "github.com/onsi/gomega" @@ -12841,20 +12842,20 @@ func testAdapterCache(resp3 bool) { var client *redis.Client var client2 *redis.Client - BeforeEach(func() { - client = redis.NewClient(&redis.Options{Addr: ":6379", Protocol: 3, UnstableResp3: true}) - client2 = redis.NewClient(&redis.Options{Addr: ":6379", Protocol: 3}) - Expect(client.FlushDB(ctx).Err()).NotTo(HaveOccurred()) - }) + // BeforeEach(func() { + // client = redis.NewClient(&redis.Options{Addr: ":6379", Protocol: 3, UnstableResp3: true}) + // client2 = redis.NewClient(&redis.Options{Addr: ":6379", Protocol: 3}) + // Expect(client.FlushDB(ctx).Err()).NotTo(HaveOccurred()) + // }) AfterEach(func() { Expect(client.Close()).NotTo(HaveOccurred()) }) It("should handle FTAggregate with Unstable RESP3 Search Module and without stability", Label("search", "ftcreate", "ftaggregate"), func() { - text1 := &redis.FieldSchema{FieldName: "PrimaryKey", FieldType: redis.SearchFieldTypeText, Sortable: true} - num1 := &redis.FieldSchema{FieldName: "CreatedDateTimeUTC", FieldType: redis.SearchFieldTypeNumeric, Sortable: true} - val, err := client.FTCreate(ctx, "idx1", &redis.FTCreateOptions{}, text1, num1).Result() + text1 := &FieldSchema{FieldName: "PrimaryKey", FieldType: SearchFieldTypeText, Sortable: true} + num1 := &FieldSchema{FieldName: "CreatedDateTimeUTC", FieldType: SearchFieldTypeNumeric, Sortable: true} + val, err := client.FTCreate(ctx, "idx1", &FTCreateOptions{}, text1, num1).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) WaitForIndexing(client, "idx1") @@ -12862,7 +12863,7 @@ func testAdapterCache(resp3 bool) { client.HSet(ctx, "doc1", "PrimaryKey", "9::362330", "CreatedDateTimeUTC", "637387878524969984") client.HSet(ctx, "doc2", "PrimaryKey", "9::362329", "CreatedDateTimeUTC", "637387875859270016") - options := &redis.FTAggregateOptions{Apply: []redis.FTAggregateApply{{Field: "@CreatedDateTimeUTC * 10", As: "CreatedDateTimeUTC"}}} + options := &FTAggregateOptions{Apply: []FTAggregateApply{{Field: "@CreatedDateTimeUTC * 10", As: "CreatedDateTimeUTC"}}} res, err := client.FTAggregateWithArgs(ctx, "idx1", "*", options).RawResult() results := res.(map[interface{}]interface{})["results"].([]interface{}) Expect(results[0].(map[interface{}]interface{})["extra_attributes"].(map[interface{}]interface{})["CreatedDateTimeUTC"]). @@ -12878,7 +12879,7 @@ func testAdapterCache(resp3 bool) { // Test with UnstableResp3 false Expect(func() { - options = &redis.FTAggregateOptions{Apply: []redis.FTAggregateApply{{Field: "@CreatedDateTimeUTC * 10", As: "CreatedDateTimeUTC"}}} + options = &FTAggregateOptions{Apply: []FTAggregateApply{{Field: "@CreatedDateTimeUTC * 10", As: "CreatedDateTimeUTC"}}} rawRes, _ := client2.FTAggregateWithArgs(ctx, "idx1", "*", options).RawResult() rawVal = client2.FTAggregateWithArgs(ctx, "idx1", "*", options).RawVal() Expect(rawRes).To(BeNil()) @@ -12888,7 +12889,7 @@ func testAdapterCache(resp3 bool) { }) It("should handle FTInfo with Unstable RESP3 Search Module and without stability", Label("search", "ftcreate", "ftinfo"), func() { - val, err := client.FTCreate(ctx, "idx1", &redis.FTCreateOptions{}, &redis.FieldSchema{FieldName: "txt", FieldType: redis.SearchFieldTypeText, Sortable: true, NoStem: true}).Result() + val, err := client.FTCreate(ctx, "idx1", &FTCreateOptions{}, &FieldSchema{FieldName: "txt", FieldType: SearchFieldTypeText, Sortable: true, NoStem: true}).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) WaitForIndexing(client, "idx1") @@ -12914,9 +12915,9 @@ func testAdapterCache(resp3 bool) { }) It("should handle FTSpellCheck with Unstable RESP3 Search Module and without stability", Label("search", "ftcreate", "ftspellcheck"), func() { - text1 := &redis.FieldSchema{FieldName: "f1", FieldType: redis.SearchFieldTypeText} - text2 := &redis.FieldSchema{FieldName: "f2", FieldType: redis.SearchFieldTypeText} - val, err := client.FTCreate(ctx, "idx1", &redis.FTCreateOptions{}, text1, text2).Result() + text1 := &FieldSchema{FieldName: "f1", FieldType: SearchFieldTypeText} + text2 := &FieldSchema{FieldName: "f2", FieldType: SearchFieldTypeText} + val, err := client.FTCreate(ctx, "idx1", &FTCreateOptions{}, text1, text2).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) WaitForIndexing(client, "idx1") @@ -12941,35 +12942,35 @@ func testAdapterCache(resp3 bool) { }) It("should handle FTSearch with Unstable RESP3 Search Module and without stability", Label("search", "ftcreate", "ftsearch"), func() { - val, err := client.FTCreate(ctx, "txt", &redis.FTCreateOptions{StopWords: []interface{}{"foo", "bar", "baz"}}, &redis.FieldSchema{FieldName: "txt", FieldType: redis.SearchFieldTypeText}).Result() + val, err := client.FTCreate(ctx, "txt", &FTCreateOptions{StopWords: []interface{}{"foo", "bar", "baz"}}, &FieldSchema{FieldName: "txt", FieldType: SearchFieldTypeText}).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) WaitForIndexing(client, "txt") client.HSet(ctx, "doc1", "txt", "foo baz") client.HSet(ctx, "doc2", "txt", "hello world") - res1, err := client.FTSearchWithArgs(ctx, "txt", "foo bar", &redis.FTSearchOptions{NoContent: true}).RawResult() - val1 := client.FTSearchWithArgs(ctx, "txt", "foo bar", &redis.FTSearchOptions{NoContent: true}).RawVal() + res1, err := client.FTSearchWithArgs(ctx, "txt", "foo bar", &FTSearchOptions{NoContent: true}).RawResult() + val1 := client.FTSearchWithArgs(ctx, "txt", "foo bar", &FTSearchOptions{NoContent: true}).RawVal() Expect(err).NotTo(HaveOccurred()) Expect(val1).To(BeEquivalentTo(res1)) totalResults := res1.(map[interface{}]interface{})["total_results"] Expect(totalResults).To(BeEquivalentTo(int64(0))) - res2, err := client.FTSearchWithArgs(ctx, "txt", "foo bar hello world", &redis.FTSearchOptions{NoContent: true}).RawResult() + res2, err := client.FTSearchWithArgs(ctx, "txt", "foo bar hello world", &FTSearchOptions{NoContent: true}).RawResult() Expect(err).NotTo(HaveOccurred()) totalResults2 := res2.(map[interface{}]interface{})["total_results"] Expect(totalResults2).To(BeEquivalentTo(int64(1))) // Test with UnstableResp3 false Expect(func() { - rawRes2, _ := client2.FTSearchWithArgs(ctx, "txt", "foo bar hello world", &redis.FTSearchOptions{NoContent: true}).RawResult() - rawVal2 := client2.FTSearchWithArgs(ctx, "txt", "foo bar hello world", &redis.FTSearchOptions{NoContent: true}).RawVal() + rawRes2, _ := client2.FTSearchWithArgs(ctx, "txt", "foo bar hello world", &FTSearchOptions{NoContent: true}).RawResult() + rawVal2 := client2.FTSearchWithArgs(ctx, "txt", "foo bar hello world", &FTSearchOptions{NoContent: true}).RawVal() Expect(rawRes2).To(BeNil()) Expect(rawVal2).To(BeNil()) }).Should(Panic()) }) It("should handle FTSynDump with Unstable RESP3 Search Module and without stability", Label("search", "ftsyndump"), func() { - text1 := &redis.FieldSchema{FieldName: "title", FieldType: redis.SearchFieldTypeText} - text2 := &redis.FieldSchema{FieldName: "body", FieldType: redis.SearchFieldTypeText} - val, err := client.FTCreate(ctx, "idx1", &redis.FTCreateOptions{OnHash: true}, text1, text2).Result() + text1 := &FieldSchema{FieldName: "title", FieldType: SearchFieldTypeText} + text2 := &FieldSchema{FieldName: "body", FieldType: SearchFieldTypeText} + val, err := client.FTCreate(ctx, "idx1", &FTCreateOptions{OnHash: true}, text1, text2).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) WaitForIndexing(client, "idx1") @@ -13002,10 +13003,10 @@ func testAdapterCache(resp3 bool) { }) It("should test not affected Resp 3 Search method - FTExplain", Label("search", "ftexplain"), func() { - text1 := &redis.FieldSchema{FieldName: "f1", FieldType: redis.SearchFieldTypeText} - text2 := &redis.FieldSchema{FieldName: "f2", FieldType: redis.SearchFieldTypeText} - text3 := &redis.FieldSchema{FieldName: "f3", FieldType: redis.SearchFieldTypeText} - val, err := client.FTCreate(ctx, "txt", &redis.FTCreateOptions{}, text1, text2, text3).Result() + text1 := &FieldSchema{FieldName: "f1", FieldType: SearchFieldTypeText} + text2 := &FieldSchema{FieldName: "f2", FieldType: SearchFieldTypeText} + text3 := &FieldSchema{FieldName: "f3", FieldType: SearchFieldTypeText} + val, err := client.FTCreate(ctx, "txt", &FTCreateOptions{}, text1, text2, text3).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) WaitForIndexing(client, "txt") @@ -13073,3 +13074,12 @@ func WaitForIndexing(c rueidis.Client, index string) { } } } + +func _assert_geosearch_result(result *redis.FTSearchResult, expectedDocIDs []string) { + ids := make([]string, len(result.Docs)) + for i, doc := range result.Docs { + ids[i] = doc.ID + } + Expect(ids).To(ConsistOf(expectedDocIDs)) + Expect(result.Total).To(BeEquivalentTo(len(expectedDocIDs))) +} diff --git a/rueidiscompat/command.go b/rueidiscompat/command.go index 911c9348..75324724 100644 --- a/rueidiscompat/command.go +++ b/rueidiscompat/command.go @@ -3387,6 +3387,15 @@ func newMapMapStringInterfaceCmd(res rueidis.RedisResult) *MapMapStringInterface return cmd } +type FTAggregateResult struct { + Total int + Rows []AggregateRow +} + +type AggregateRow struct { + Fields map[string]any +} + // Each AggregateReducer have different args. // Please follow https://redis.io/docs/interact/search-and-query/search/aggregations/#supported-groupby-reducers for more information. type FTAggregateReducer struct { @@ -3440,8 +3449,7 @@ type FTAggregateOptions struct { } type AggregateCmd struct { - // FIXME - baseCmd[map[string]any] + baseCmd[FTAggregateResult] } func (cmd *AggregateCmd) from(res rueidis.RedisResult) { @@ -3729,7 +3737,17 @@ func newFTInfoCmd(res rueidis.RedisResult) *FTInfoCmd { return cmd } -type FTSpellCheckOptions struct{} +type FTSpellCheckOptions struct { + Distance int + Terms *FTSpellCheckTerms + Dialect int +} + +type FTSpellCheckTerms struct { + Inclusion string // Either "INCLUDE" or "EXCLUDE" + Dictionary string + Terms []interface{} +} type SpellCheckResult struct { Term string @@ -3744,8 +3762,8 @@ type SpellCheckSuggestion struct { type FTSpellCheckCmd struct{ baseCmd[SpellCheckResult] } func (cmd *FTSpellCheckCmd) Val() []SpellCheckResult { - // fIXME: impl - return cmd.val.Suggestions + // FIXME: impl + return []SpellCheckResult{} } func (cmd *FTSpellCheckCmd) Result() ([]SpellCheckResult, error) { From a9a41ce937d60a5e6c1fa9aa9fc18749beea82ad Mon Sep 17 00:00:00 2001 From: Eric Chang Date: Sat, 2 Nov 2024 20:00:58 +0800 Subject: [PATCH 06/49] feat: wip: implement SearchCmdable: FTAggregateWithArgs --- rueidiscompat/adapter.go | 47 ++++++++++++- rueidiscompat/adapter_test.go | 121 +++++++++++++++++----------------- rueidiscompat/command.go | 13 +++- 3 files changed, 115 insertions(+), 66 deletions(-) diff --git a/rueidiscompat/adapter.go b/rueidiscompat/adapter.go index d7abee88..e63f74ce 100644 --- a/rueidiscompat/adapter.go +++ b/rueidiscompat/adapter.go @@ -4835,13 +4835,54 @@ func (c *Compat) Watch(ctx context.Context, fn func(Tx) error, keys ...string) e return fn(newTx(dc, cancel)) } -func (c *Compat) FT_List(ctx context.Context) *StringSliceCmd +func (c *Compat) FT_List(ctx context.Context) *StringSliceCmd { + cmd := c.client.B().FtList().Build() + return newStringSliceCmd(c.client.Do(ctx, cmd)) +} + func (c *Compat) FTAggregate(ctx context.Context, index string, query string) *MapStringInterfaceCmd { - return nil + cmd := c.client.B().FtAggregate().Index(index).Query(query).Build() + return newMapStringInterfaceCmd(c.client.Do(ctx, cmd)) } + +// type FTAggregateOptions struct { +// Verbatim bool +// LoadAll bool +// Load []FTAggregateLoad +// Timeout int +// GroupBy []FTAggregateGroupBy +// SortBy []FTAggregateSortBy +// SortByMax int +// Apply []FTAggregateApply +// LimitOffset int +// Limit int +// Filter string +// WithCursor bool +// WithCursorOptions *FTAggregateWithCursor +// Params map[string]interface{} +// DialectVersion int +// } + func (c *Compat) FTAggregateWithArgs(ctx context.Context, index string, query string, options *FTAggregateOptions) *AggregateCmd { - return nil + _cmd := cmds.Incomplete(c.client.B().FtAggregate().Index(index).Query(query)) + if options != nil { + if options.Verbatim { + _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).Verbatim()) + } + if options.LoadAll { + _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).LoadAll()) + } else { + _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).Load(int64(len(options.Load)))) + // for _, l := range options.Load { + // // FIXME: where is AS ? + // // https://redis.io/docs/latest/commands/ft.aggregate/ + + // _cmd = cmds.Incomplete(cmds.FtAggregateOpLoadLoad(_cmd).Field()) + // } + } + } } + func (c *Compat) FTAliasAdd(ctx context.Context, index string, alias string) *StatusCmd { return nil } func (c *Compat) FTAliasDel(ctx context.Context, alias string) *StatusCmd { return nil } func (c *Compat) FTAliasUpdate(ctx context.Context, index string, alias string) *StatusCmd { diff --git a/rueidiscompat/adapter_test.go b/rueidiscompat/adapter_test.go index a97ba0bc..3e9c02c0 100644 --- a/rueidiscompat/adapter_test.go +++ b/rueidiscompat/adapter_test.go @@ -67,6 +67,7 @@ var ( adapterresp2 Cmdable adaptercluster2 Cmdable adapterresp3 Cmdable + adapter2resp3 Cmdable adaptercluster3 Cmdable ) @@ -83,6 +84,7 @@ var _ = BeforeSuite(func() { }) Expect(err).NotTo(HaveOccurred()) adapterresp3 = NewAdapter(clientresp3) + adapter2resp3 = NewAdapter(clientresp3) adaptercluster3 = NewAdapter(clusterresp3) clientresp2, err = rueidis.NewClient(rueidis.ClientOption{ InitAddress: []string{"127.0.0.1:6356"}, @@ -12336,7 +12338,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{OnJSON: true, Prefix: []interface{}{"king:"}}, text1, num1).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(client, "idx1") + WaitForIndexing(clientresp2, "idx1") adapter.JSONSet(ctx, "king:1", "$", `{"name": "henry", "num": 42}`) adapter.JSONSet(ctx, "king:2", "$", `{"name": "james", "num": 3.14}`) @@ -12429,7 +12431,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, &FieldSchema{FieldName: "name", FieldType: SearchFieldTypeText}).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(client, "idx1") + WaitForIndexing(clientresp3, "idx1") adapter.HSet(ctx, "doc1", "name", "Alice") adapter.HSet(ctx, "doc2", "name", "Bob") @@ -12447,7 +12449,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, &FieldSchema{FieldName: "numval", FieldType: SearchFieldTypeNumeric}).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(client, "idx1") + WaitForIndexing(clientresp3, "idx1") adapter.HSet(ctx, "doc1", "numval", 101) adapter.HSet(ctx, "doc2", "numval", 102) @@ -12465,7 +12467,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, &FieldSchema{FieldName: "g", FieldType: SearchFieldTypeGeo}).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(client, "idx1") + WaitForIndexing(clientresp3, "idx1") adapter.HSet(ctx, "doc1", "g", "29.69465, 34.95126") adapter.HSet(ctx, "doc2", "g", "29.69350, 34.94737") @@ -12502,7 +12504,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, &FieldSchema{FieldName: "txt", FieldType: SearchFieldTypeText}).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(client, "idx1") + WaitForIndexing(clientresp2, "idx1") res, err := adapter.FTInfo(ctx, "idx1").Result() Expect(err).NotTo(HaveOccurred()) @@ -12516,7 +12518,7 @@ func testAdapterCache(resp3 bool) { val, err = adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, &FieldSchema{FieldName: "txt", FieldType: SearchFieldTypeText, WithSuffixtrie: true}).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(client, "idx1") + WaitForIndexing(clientresp2, "idx1") res, err = adapter.FTInfo(ctx, "idx1").Result() Expect(err).NotTo(HaveOccurred()) @@ -12530,7 +12532,7 @@ func testAdapterCache(resp3 bool) { val, err = adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, &FieldSchema{FieldName: "t", FieldType: SearchFieldTypeTag, WithSuffixtrie: true}).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(client, "idx1") + WaitForIndexing(clientresp2, "idx1") res, err = adapter.FTInfo(ctx, "idx1").Result() Expect(err).NotTo(HaveOccurred()) @@ -12645,7 +12647,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, &FieldSchema{FieldName: "geom", FieldType: SearchFieldTypeGeoShape, GeoShapeFieldType: "FLAT"}).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(client, "idx1") + WaitForIndexing(clientresp2, "idx1") adapter.HSet(ctx, "small", "geom", "POLYGON((1 1, 1 100, 100 100, 100 1, 1 1))") adapter.HSet(ctx, "large", "geom", "POLYGON((1 1, 1 200, 200 200, 200 1, 1 1))") @@ -12675,7 +12677,7 @@ func testAdapterCache(resp3 bool) { ).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(client, "index") + WaitForIndexing(clientresp2, "index") }) It("should test geoshapes query intersects and disjoint", Label("NonRedisEnterprise"), func() { @@ -12753,7 +12755,7 @@ func testAdapterCache(resp3 bool) { &FieldSchema{FieldName: "description", FieldType: SearchFieldTypeText, IndexMissing: true}).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(client, "idx1") + WaitForIndexing(clientresp2, "idx1") adapter.HSet(ctx, "property:1", map[string]interface{}{ "title": "Luxury Villa in Malibu", @@ -12797,7 +12799,7 @@ func testAdapterCache(resp3 bool) { &FieldSchema{FieldName: "description", FieldType: SearchFieldTypeText, IndexEmpty: true}).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(client, "idx1") + WaitForIndexing(clientresp2, "idx1") adapter.HSet(ctx, "property:1", map[string]interface{}{ "title": "Luxury Villa in Malibu", @@ -12839,8 +12841,6 @@ func testAdapterCache(resp3 bool) { Describe("RediSearch commands Resp 3", Label("search"), func() { ctx := context.TODO() - var client *redis.Client - var client2 *redis.Client // BeforeEach(func() { // client = redis.NewClient(&redis.Options{Addr: ":6379", Protocol: 3, UnstableResp3: true}) @@ -12848,30 +12848,26 @@ func testAdapterCache(resp3 bool) { // Expect(client.FlushDB(ctx).Err()).NotTo(HaveOccurred()) // }) - AfterEach(func() { - Expect(client.Close()).NotTo(HaveOccurred()) - }) - It("should handle FTAggregate with Unstable RESP3 Search Module and without stability", Label("search", "ftcreate", "ftaggregate"), func() { text1 := &FieldSchema{FieldName: "PrimaryKey", FieldType: SearchFieldTypeText, Sortable: true} num1 := &FieldSchema{FieldName: "CreatedDateTimeUTC", FieldType: SearchFieldTypeNumeric, Sortable: true} - val, err := client.FTCreate(ctx, "idx1", &FTCreateOptions{}, text1, num1).Result() + val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, text1, num1).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(client, "idx1") + WaitForIndexing(clientresp3, "idx1") - client.HSet(ctx, "doc1", "PrimaryKey", "9::362330", "CreatedDateTimeUTC", "637387878524969984") - client.HSet(ctx, "doc2", "PrimaryKey", "9::362329", "CreatedDateTimeUTC", "637387875859270016") + adapter.HSet(ctx, "doc1", "PrimaryKey", "9::362330", "CreatedDateTimeUTC", "637387878524969984") + adapter.HSet(ctx, "doc2", "PrimaryKey", "9::362329", "CreatedDateTimeUTC", "637387875859270016") options := &FTAggregateOptions{Apply: []FTAggregateApply{{Field: "@CreatedDateTimeUTC * 10", As: "CreatedDateTimeUTC"}}} - res, err := client.FTAggregateWithArgs(ctx, "idx1", "*", options).RawResult() + res, err := adapter.FTAggregateWithArgs(ctx, "idx1", "*", options).RawResult() results := res.(map[interface{}]interface{})["results"].([]interface{}) Expect(results[0].(map[interface{}]interface{})["extra_attributes"].(map[interface{}]interface{})["CreatedDateTimeUTC"]). To(Or(BeEquivalentTo("6373878785249699840"), BeEquivalentTo("6373878758592700416"))) Expect(results[1].(map[interface{}]interface{})["extra_attributes"].(map[interface{}]interface{})["CreatedDateTimeUTC"]). To(Or(BeEquivalentTo("6373878785249699840"), BeEquivalentTo("6373878758592700416"))) - rawVal := client.FTAggregateWithArgs(ctx, "idx1", "*", options).RawVal() + rawVal := adapter.FTAggregateWithArgs(ctx, "idx1", "*", options).RawVal() rawValResults := rawVal.(map[interface{}]interface{})["results"].([]interface{}) Expect(err).NotTo(HaveOccurred()) Expect(rawValResults[0]).To(Or(BeEquivalentTo(results[0]), BeEquivalentTo(results[1]))) @@ -12880,8 +12876,8 @@ func testAdapterCache(resp3 bool) { // Test with UnstableResp3 false Expect(func() { options = &FTAggregateOptions{Apply: []FTAggregateApply{{Field: "@CreatedDateTimeUTC * 10", As: "CreatedDateTimeUTC"}}} - rawRes, _ := client2.FTAggregateWithArgs(ctx, "idx1", "*", options).RawResult() - rawVal = client2.FTAggregateWithArgs(ctx, "idx1", "*", options).RawVal() + rawRes, _ := adapter2resp3.FTAggregateWithArgs(ctx, "idx1", "*", options).RawResult() + rawVal = adapter2resp3.FTAggregateWithArgs(ctx, "idx1", "*", options).RawVal() Expect(rawRes).To(BeNil()) Expect(rawVal).To(BeNil()) }).Should(Panic()) @@ -12889,26 +12885,26 @@ func testAdapterCache(resp3 bool) { }) It("should handle FTInfo with Unstable RESP3 Search Module and without stability", Label("search", "ftcreate", "ftinfo"), func() { - val, err := client.FTCreate(ctx, "idx1", &FTCreateOptions{}, &FieldSchema{FieldName: "txt", FieldType: SearchFieldTypeText, Sortable: true, NoStem: true}).Result() + val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, &FieldSchema{FieldName: "txt", FieldType: SearchFieldTypeText, Sortable: true, NoStem: true}).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(client, "idx1") + WaitForIndexing(clientresp3, "idx1") - resInfo, err := client.FTInfo(ctx, "idx1").RawResult() + resInfo, err := adapter.FTInfo(ctx, "idx1").RawResult() Expect(err).NotTo(HaveOccurred()) attributes := resInfo.(map[interface{}]interface{})["attributes"].([]interface{}) flags := attributes[0].(map[interface{}]interface{})["flags"].([]interface{}) Expect(flags).To(ConsistOf("SORTABLE", "NOSTEM")) - valInfo := client.FTInfo(ctx, "idx1").RawVal() + valInfo := adapter.FTInfo(ctx, "idx1").RawVal() attributes = valInfo.(map[interface{}]interface{})["attributes"].([]interface{}) flags = attributes[0].(map[interface{}]interface{})["flags"].([]interface{}) Expect(flags).To(ConsistOf("SORTABLE", "NOSTEM")) // Test with UnstableResp3 false Expect(func() { - rawResInfo, _ := client2.FTInfo(ctx, "idx1").RawResult() - rawValInfo := client2.FTInfo(ctx, "idx1").RawVal() + rawResInfo, _ := adapter2resp3.FTInfo(ctx, "idx1").RawResult() + rawValInfo := adapter2resp3.FTInfo(ctx, "idx1").RawVal() Expect(rawResInfo).To(BeNil()) Expect(rawValInfo).To(BeNil()) }).Should(Panic()) @@ -12917,16 +12913,16 @@ func testAdapterCache(resp3 bool) { It("should handle FTSpellCheck with Unstable RESP3 Search Module and without stability", Label("search", "ftcreate", "ftspellcheck"), func() { text1 := &FieldSchema{FieldName: "f1", FieldType: SearchFieldTypeText} text2 := &FieldSchema{FieldName: "f2", FieldType: SearchFieldTypeText} - val, err := client.FTCreate(ctx, "idx1", &FTCreateOptions{}, text1, text2).Result() + val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, text1, text2).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(client, "idx1") + WaitForIndexing(adapter, "idx1") - client.HSet(ctx, "doc1", "f1", "some valid content", "f2", "this is sample text") - client.HSet(ctx, "doc2", "f1", "very important", "f2", "lorem ipsum") + adapter.HSet(ctx, "doc1", "f1", "some valid content", "f2", "this is sample text") + adapter.HSet(ctx, "doc2", "f1", "very important", "f2", "lorem ipsum") - resSpellCheck, err := client.FTSpellCheck(ctx, "idx1", "impornant").RawResult() - valSpellCheck := client.FTSpellCheck(ctx, "idx1", "impornant").RawVal() + resSpellCheck, err := adapter.FTSpellCheck(ctx, "idx1", "impornant").RawResult() + valSpellCheck := adapter.FTSpellCheck(ctx, "idx1", "impornant").RawVal() Expect(err).NotTo(HaveOccurred()) Expect(valSpellCheck).To(BeEquivalentTo(resSpellCheck)) results := resSpellCheck.(map[interface{}]interface{})["results"].(map[interface{}]interface{}) @@ -12934,35 +12930,35 @@ func testAdapterCache(resp3 bool) { // Test with UnstableResp3 false Expect(func() { - rawResSpellCheck, _ := client2.FTSpellCheck(ctx, "idx1", "impornant").RawResult() - rawValSpellCheck := client2.FTSpellCheck(ctx, "idx1", "impornant").RawVal() + rawResSpellCheck, _ := adapter2resp3.FTSpellCheck(ctx, "idx1", "impornant").RawResult() + rawValSpellCheck := adapter2resp3.FTSpellCheck(ctx, "idx1", "impornant").RawVal() Expect(rawResSpellCheck).To(BeNil()) Expect(rawValSpellCheck).To(BeNil()) }).Should(Panic()) }) It("should handle FTSearch with Unstable RESP3 Search Module and without stability", Label("search", "ftcreate", "ftsearch"), func() { - val, err := client.FTCreate(ctx, "txt", &FTCreateOptions{StopWords: []interface{}{"foo", "bar", "baz"}}, &FieldSchema{FieldName: "txt", FieldType: SearchFieldTypeText}).Result() + val, err := adapter.FTCreate(ctx, "txt", &FTCreateOptions{StopWords: []interface{}{"foo", "bar", "baz"}}, &FieldSchema{FieldName: "txt", FieldType: SearchFieldTypeText}).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(client, "txt") - client.HSet(ctx, "doc1", "txt", "foo baz") - client.HSet(ctx, "doc2", "txt", "hello world") - res1, err := client.FTSearchWithArgs(ctx, "txt", "foo bar", &FTSearchOptions{NoContent: true}).RawResult() - val1 := client.FTSearchWithArgs(ctx, "txt", "foo bar", &FTSearchOptions{NoContent: true}).RawVal() + WaitForIndexing(adapter, "txt") + adapter.HSet(ctx, "doc1", "txt", "foo baz") + adapter.HSet(ctx, "doc2", "txt", "hello world") + res1, err := adapter.FTSearchWithArgs(ctx, "txt", "foo bar", &FTSearchOptions{NoContent: true}).RawResult() + val1 := adapter.FTSearchWithArgs(ctx, "txt", "foo bar", &FTSearchOptions{NoContent: true}).RawVal() Expect(err).NotTo(HaveOccurred()) Expect(val1).To(BeEquivalentTo(res1)) totalResults := res1.(map[interface{}]interface{})["total_results"] Expect(totalResults).To(BeEquivalentTo(int64(0))) - res2, err := client.FTSearchWithArgs(ctx, "txt", "foo bar hello world", &FTSearchOptions{NoContent: true}).RawResult() + res2, err := adapter.FTSearchWithArgs(ctx, "txt", "foo bar hello world", &FTSearchOptions{NoContent: true}).RawResult() Expect(err).NotTo(HaveOccurred()) totalResults2 := res2.(map[interface{}]interface{})["total_results"] Expect(totalResults2).To(BeEquivalentTo(int64(1))) // Test with UnstableResp3 false Expect(func() { - rawRes2, _ := client2.FTSearchWithArgs(ctx, "txt", "foo bar hello world", &FTSearchOptions{NoContent: true}).RawResult() - rawVal2 := client2.FTSearchWithArgs(ctx, "txt", "foo bar hello world", &FTSearchOptions{NoContent: true}).RawVal() + rawRes2, _ := adapter2resp3.FTSearchWithArgs(ctx, "txt", "foo bar hello world", &FTSearchOptions{NoContent: true}).RawResult() + rawVal2 := adapter2resp3.FTSearchWithArgs(ctx, "txt", "foo bar hello world", &FTSearchOptions{NoContent: true}).RawVal() Expect(rawRes2).To(BeNil()) Expect(rawVal2).To(BeNil()) }).Should(Panic()) @@ -12970,33 +12966,33 @@ func testAdapterCache(resp3 bool) { It("should handle FTSynDump with Unstable RESP3 Search Module and without stability", Label("search", "ftsyndump"), func() { text1 := &FieldSchema{FieldName: "title", FieldType: SearchFieldTypeText} text2 := &FieldSchema{FieldName: "body", FieldType: SearchFieldTypeText} - val, err := client.FTCreate(ctx, "idx1", &FTCreateOptions{OnHash: true}, text1, text2).Result() + val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{OnHash: true}, text1, text2).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) WaitForIndexing(client, "idx1") - resSynUpdate, err := client.FTSynUpdate(ctx, "idx1", "id1", []interface{}{"boy", "child", "offspring"}).Result() + resSynUpdate, err := adapter.FTSynUpdate(ctx, "idx1", "id1", []interface{}{"boy", "child", "offspring"}).Result() Expect(err).NotTo(HaveOccurred()) Expect(resSynUpdate).To(BeEquivalentTo("OK")) - resSynUpdate, err = client.FTSynUpdate(ctx, "idx1", "id1", []interface{}{"baby", "child"}).Result() + resSynUpdate, err = adapter.FTSynUpdate(ctx, "idx1", "id1", []interface{}{"baby", "child"}).Result() Expect(err).NotTo(HaveOccurred()) Expect(resSynUpdate).To(BeEquivalentTo("OK")) - resSynUpdate, err = client.FTSynUpdate(ctx, "idx1", "id1", []interface{}{"tree", "wood"}).Result() + resSynUpdate, err = adapter.FTSynUpdate(ctx, "idx1", "id1", []interface{}{"tree", "wood"}).Result() Expect(err).NotTo(HaveOccurred()) Expect(resSynUpdate).To(BeEquivalentTo("OK")) - resSynDump, err := client.FTSynDump(ctx, "idx1").RawResult() - valSynDump := client.FTSynDump(ctx, "idx1").RawVal() + resSynDump, err := adapter.FTSynDump(ctx, "idx1").RawResult() + valSynDump := adapter.FTSynDump(ctx, "idx1").RawVal() Expect(err).NotTo(HaveOccurred()) Expect(valSynDump).To(BeEquivalentTo(resSynDump)) Expect(resSynDump.(map[interface{}]interface{})["baby"]).To(BeEquivalentTo([]interface{}{"id1"})) // Test with UnstableResp3 false Expect(func() { - rawResSynDump, _ := client2.FTSynDump(ctx, "idx1").RawResult() - rawValSynDump := client2.FTSynDump(ctx, "idx1").RawVal() + rawResSynDump, _ := adapter2resp3.FTSynDump(ctx, "idx1").RawResult() + rawValSynDump := adapter2resp3.FTSynDump(ctx, "idx1").RawVal() Expect(rawResSynDump).To(BeNil()) Expect(rawValSynDump).To(BeNil()) }).Should(Panic()) @@ -13006,17 +13002,17 @@ func testAdapterCache(resp3 bool) { text1 := &FieldSchema{FieldName: "f1", FieldType: SearchFieldTypeText} text2 := &FieldSchema{FieldName: "f2", FieldType: SearchFieldTypeText} text3 := &FieldSchema{FieldName: "f3", FieldType: SearchFieldTypeText} - val, err := client.FTCreate(ctx, "txt", &FTCreateOptions{}, text1, text2, text3).Result() + val, err := adapter.FTCreate(ctx, "txt", &FTCreateOptions{}, text1, text2, text3).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(client, "txt") - res1, err := client.FTExplain(ctx, "txt", "@f3:f3_val @f2:f2_val @f1:f1_val").Result() + WaitForIndexing(clientresp3, "txt") + res1, err := adapter.FTExplain(ctx, "txt", "@f3:f3_val @f2:f2_val @f1:f1_val").Result() Expect(err).NotTo(HaveOccurred()) Expect(res1).ToNot(BeEmpty()) // Test with UnstableResp3 false Expect(func() { - res2, err := client2.FTExplain(ctx, "txt", "@f3:f3_val @f2:f2_val @f1:f1_val").Result() + res2, err := adapter2resp3.FTExplain(ctx, "txt", "@f3:f3_val @f2:f2_val @f1:f1_val").Result() Expect(err).NotTo(HaveOccurred()) Expect(res2).ToNot(BeEmpty()) }).ShouldNot(Panic()) @@ -13061,10 +13057,11 @@ func (s *numberStruct) UnmarshalBinary(b []byte) error { } func WaitForIndexing(c rueidis.Client, index string) { + adapter := NewAdapter(c) for { - res, err := c.FTInfo(context.Background(), index).Result() + res, err := adapter.FTInfo(context.Background(), index).Result() Expect(err).NotTo(HaveOccurred()) - if c.Options().Protocol == 2 { + if adapter.Options().Protocol == 2 { if res.Indexing == 0 { return } diff --git a/rueidiscompat/command.go b/rueidiscompat/command.go index 75324724..6e60dfbb 100644 --- a/rueidiscompat/command.go +++ b/rueidiscompat/command.go @@ -3840,7 +3840,18 @@ type FTSynUpdateOptions struct { SkipInitialScan bool } -type FTSynDumpCmd struct{} +type FTSynDumpCmd struct { + baseCmd[[]FTSynDumpResult] + rawVal any +} + +func (cmd *FTSynDumpCmd) RawVal() any { + return cmd.rawVal +} + +func (cmd *FTSynDumpCmd) RawResult() (any, error) { + return cmd.rawVal, cmd.Err() +} func (cmd *FTSynDumpCmd) from(res rueidis.RedisResult) { // FIXME: impl From af0877fc93399f9be80cd06db88f9745f4dc266a Mon Sep 17 00:00:00 2001 From: Eric Chang Date: Fri, 8 Nov 2024 21:17:45 +0800 Subject: [PATCH 07/49] wip: ft aggregate: reduce --- rueidiscompat/adapter.go | 31 +++++++++++++++++++++++++------ 1 file changed, 25 insertions(+), 6 deletions(-) diff --git a/rueidiscompat/adapter.go b/rueidiscompat/adapter.go index e63f74ce..dc8454a2 100644 --- a/rueidiscompat/adapter.go +++ b/rueidiscompat/adapter.go @@ -4867,19 +4867,38 @@ func (c *Compat) FTAggregateWithArgs(ctx context.Context, index string, query st _cmd := cmds.Incomplete(c.client.B().FtAggregate().Index(index).Query(query)) if options != nil { if options.Verbatim { + // VERBATIM _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).Verbatim()) } if options.LoadAll { + // LOAD * _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).LoadAll()) } else { + // LOAD _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).Load(int64(len(options.Load)))) - // for _, l := range options.Load { - // // FIXME: where is AS ? - // // https://redis.io/docs/latest/commands/ft.aggregate/ - - // _cmd = cmds.Incomplete(cmds.FtAggregateOpLoadLoad(_cmd).Field()) - // } + fields := make([]string, 0, len(options.Load)) + for _, l := range options.Load { + fields = append(fields, l.Field) + } + _cmd = cmds.Incomplete(cmds.FtAggregateOpLoadLoad(_cmd).Field(fields...)) + } + // TIMEOUT + _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).Timeout(int64(options.Timeout))) + // GROUPBY + // [ GROUPBY nargs property [property ...] [ REDUCE function nargs arg [arg ...] [AS name] [ REDUCE function nargs arg [arg ...] [AS name] ...]] ...]] + // GroupBy: []FTAggregateGroupBy + // FTAggregateGroupBy: + // Fields []interface{} + // Reduce []FTAggregateReducer + for _, groupBy := range options.GroupBy { + _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd). + Groupby(int64(len(options.GroupBy))). + Property(argsToSlice(groupBy.Fields)...)) + // Reduce + // AS } + // SORTBY + _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).Groupby(int64(len(options.GroupBy)))) } } From 968c4233d9468bab9cc7c811e69b70d36b263810 Mon Sep 17 00:00:00 2001 From: Eric Chang Date: Sat, 9 Nov 2024 18:42:03 +0800 Subject: [PATCH 08/49] wip: ft aggregate: params --- rueidiscompat/adapter.go | 62 ++++++++++++++++++++++++++++++++++------ 1 file changed, 53 insertions(+), 9 deletions(-) diff --git a/rueidiscompat/adapter.go b/rueidiscompat/adapter.go index dc8454a2..8aae848f 100644 --- a/rueidiscompat/adapter.go +++ b/rueidiscompat/adapter.go @@ -4870,6 +4870,7 @@ func (c *Compat) FTAggregateWithArgs(ctx context.Context, index string, query st // VERBATIM _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).Verbatim()) } + // [LOAD count field [field ...]] if options.LoadAll { // LOAD * _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).LoadAll()) @@ -4882,23 +4883,66 @@ func (c *Compat) FTAggregateWithArgs(ctx context.Context, index string, query st } _cmd = cmds.Incomplete(cmds.FtAggregateOpLoadLoad(_cmd).Field(fields...)) } - // TIMEOUT + // [TIMEOUT timeout] _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).Timeout(int64(options.Timeout))) // GROUPBY - // [ GROUPBY nargs property [property ...] [ REDUCE function nargs arg [arg ...] [AS name] [ REDUCE function nargs arg [arg ...] [AS name] ...]] ...]] - // GroupBy: []FTAggregateGroupBy - // FTAggregateGroupBy: - // Fields []interface{} - // Reduce []FTAggregateReducer + // 0 + // [ + // GROUPBY nargs property [property ...] + // [ + // REDUCE function nargs arg [arg ...] [AS name] + // [ REDUCE function nargs arg [arg ...] [AS name] ...] + // ] ... + // ]] for _, groupBy := range options.GroupBy { _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd). Groupby(int64(len(options.GroupBy))). Property(argsToSlice(groupBy.Fields)...)) - // Reduce - // AS + for _, reduce := range groupBy.Reduce { + _cmd = cmds.Incomplete(cmds.FtAggregateOpGroupbyProperty(_cmd). + Reduce(reduce.Reducer.String()). + Nargs(int64(len(reduce.Args))). + Arg(argsToSlice(reduce.Args)...). + As(reduce.As)) + } } // SORTBY - _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).Groupby(int64(len(options.GroupBy)))) + // [ + // SORTBY nargs [ + // property ASC | DESC [ property ASC | DESC ...] + // ] [MAX num] [WITHCOUNT] + // + _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).Sortby(int64(len(options.SortBy)))) + for _, sortBy := range options.SortBy { + _cmd = cmds.Incomplete(cmds.FtAggregateOpSortbySortby(_cmd).Property(sortBy.FieldName)) + if sortBy.Desc == sortBy.Asc { + panic("sortBy should be either ASC or DESC") + } + if sortBy.Asc { + // ASC + _cmd = cmds.Incomplete(cmds.FtAggregateOpSortbyFieldsProperty(_cmd).Asc()) + continue + } else { + _cmd = cmds.Incomplete(cmds.FtAggregateOpSortbyFieldsProperty(_cmd).Desc()) + } + // DESC + } + // FIXME: go-redis doesn't provide WITHCOUNT option + _cmd = cmds.Incomplete(cmds.FtAggregateOpSortbySortby(_cmd).Max(int64(options.SortByMax))) + // [ APPLY expression AS name [ APPLY expression AS name ...]] + for _, apply := range options.Apply { + _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).Apply(apply.Field).As(apply.As)) + } + // [ LIMIT offset num] + _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).Limit().OffsetNum(int64(options.Limit), int64(options.LimitOffset))) + // [FILTER filter] + _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).Filter(options.Filter)) + // [ WITHCURSOR [COUNT read_size] [MAXIDLE idle_time]] + _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).Withcursor().Count(int64(options.WithCursorOptions.Count)).Maxidle(int64(options.WithCursorOptions.MaxIdle))) + // [ PARAMS nargs name value [ name value ...]] + _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).Params().Nargs(int64(len(options.Params)))) + // [ADDSCORES] + // [DIALECT dialect] } } From b09c97fc1d8cc3ee34ea14ca1c32e1e2c3c53b9d Mon Sep 17 00:00:00 2001 From: Eric Chang Date: Sat, 9 Nov 2024 20:31:10 +0800 Subject: [PATCH 09/49] feat: add ADDSCORES option to FT_AGGREGATE command --- hack/cmds/commands_search.json | 267 ++++++++----------------------- internal/cmds/gen_search.go | 137 ++++++++++++++++ internal/cmds/gen_search_test.go | 80 +++++---- 3 files changed, 256 insertions(+), 228 deletions(-) diff --git a/hack/cmds/commands_search.json b/hack/cmds/commands_search.json index a2c07161..aa8c39f7 100644 --- a/hack/cmds/commands_search.json +++ b/hack/cmds/commands_search.json @@ -14,10 +14,7 @@ "name": "data_type", "command": "ON", "type": "enum", - "enum": [ - "HASH", - "JSON" - ], + "enum": ["HASH", "JSON"], "optional": true }, { @@ -75,9 +72,7 @@ { "name": "maxtextfields", "type": "enum", - "enum": [ - "MAXTEXTFIELDS" - ], + "enum": ["MAXTEXTFIELDS"], "optional": true }, { @@ -89,33 +84,25 @@ { "name": "nooffsets", "type": "enum", - "enum": [ - "NOOFFSETS" - ], + "enum": ["NOOFFSETS"], "optional": true }, { "name": "nohl", "type": "enum", - "enum": [ - "NOHL" - ], + "enum": ["NOHL"], "optional": true }, { "name": "nofields", "type": "enum", - "enum": [ - "NOFIELDS" - ], + "enum": ["NOFIELDS"], "optional": true }, { "name": "nofreqs", "type": "enum", - "enum": [ - "NOFREQS" - ], + "enum": ["NOFREQS"], "optional": true }, { @@ -138,17 +125,13 @@ { "name": "skipinitialscan", "type": "enum", - "enum": [ - "SKIPINITIALSCAN" - ], + "enum": ["SKIPINITIALSCAN"], "optional": true }, { "name": "schema", "type": "enum", - "enum": [ - "SCHEMA" - ] + "enum": ["SCHEMA"] }, { "name": "field", @@ -168,13 +151,7 @@ { "name": "field_type", "type": "enum", - "enum": [ - "TEXT", - "TAG", - "NUMERIC", - "GEO", - "VECTOR" - ] + "enum": ["TEXT", "TAG", "NUMERIC", "GEO", "VECTOR"] }, { "name": "option", @@ -185,9 +162,7 @@ { "name": "withsuffixtrie", "type": "enum", - "enum": [ - "WITHSUFFIXTRIE" - ], + "enum": ["WITHSUFFIXTRIE"], "optional": true }, { @@ -198,16 +173,12 @@ { "name": "sortable", "type": "enum", - "enum": [ - "SORTABLE" - ] + "enum": ["SORTABLE"] }, { "name": "UNF", "type": "enum", - "enum": [ - "UNF" - ], + "enum": ["UNF"], "optional": true } ] @@ -216,17 +187,13 @@ "name": "noindex", "type": "enum", "optional": true, - "enum": [ - "NOINDEX" - ] + "enum": ["NOINDEX"] }, { "name": "NOSTEM", "type": "enum", "optional": true, - "enum": [ - "NOSTEM" - ] + "enum": ["NOSTEM"] }, { "name": "PHONETIC", @@ -250,9 +217,7 @@ "name": "CASESENSITIVE", "type": "enum", "optional": true, - "enum": [ - "CASESENSITIVE" - ] + "enum": ["CASESENSITIVE"] } ] } @@ -331,24 +296,18 @@ { "name": "skipinitialscan", "type": "enum", - "enum": [ - "SKIPINITIALSCAN" - ], + "enum": ["SKIPINITIALSCAN"], "optional": true }, { "name": "schema", "type": "enum", - "enum": [ - "SCHEMA" - ] + "enum": ["SCHEMA"] }, { "name": "add", "type": "enum", - "enum": [ - "ADD" - ] + "enum": ["ADD"] }, { "name": "field", @@ -373,9 +332,7 @@ { "name": "delete docs", "type": "enum", - "enum": [ - "DD" - ], + "enum": ["DD"], "optional": true } ], @@ -461,9 +418,7 @@ { "name": "increment score", "type": "enum", - "enum": [ - "INCR" - ], + "enum": ["INCR"], "optional": true }, { @@ -491,25 +446,19 @@ { "name": "fuzzy", "type": "enum", - "enum": [ - "FUZZY" - ], + "enum": ["FUZZY"], "optional": true }, { "name": "withscores", "type": "enum", - "enum": [ - "WITHSCORES" - ], + "enum": ["WITHSCORES"], "optional": true }, { "name": "withpayloads", "type": "enum", - "enum": [ - "WITHPAYLOADS" - ], + "enum": ["WITHPAYLOADS"], "optional": true }, { @@ -565,9 +514,7 @@ { "name": "skipinitialscan", "type": "enum", - "enum": [ - "SKIPINITIALSCAN" - ], + "enum": ["SKIPINITIALSCAN"], "optional": true }, { @@ -618,10 +565,7 @@ { "name": "inclusion", "type": "enum", - "enum": [ - "INCLUDE", - "EXCLUDE" - ] + "enum": ["INCLUDE", "EXCLUDE"] }, { "name": "dictionary", @@ -754,49 +698,37 @@ "name": "nocontent", "type": "enum", "optional": true, - "enum": [ - "NOCONTENT" - ] + "enum": ["NOCONTENT"] }, { "name": "verbatim", "type": "enum", "optional": true, - "enum": [ - "VERBATIM" - ] + "enum": ["VERBATIM"] }, { "name": "nostopwords", "type": "enum", "optional": true, - "enum": [ - "NOSTOPWORDS" - ] + "enum": ["NOSTOPWORDS"] }, { "name": "withscores", "type": "enum", "optional": true, - "enum": [ - "WITHSCORES" - ] + "enum": ["WITHSCORES"] }, { "name": "withpayloads", "type": "enum", "optional": true, - "enum": [ - "WITHPAYLOADS" - ] + "enum": ["WITHPAYLOADS"] }, { "name": "withsortkeys", "type": "enum", "optional": true, - "enum": [ - "WITHSORTKEYS" - ] + "enum": ["WITHSORTKEYS"] }, { "name": "filter", @@ -845,12 +777,7 @@ { "name": "radius_type", "type": "enum", - "enum": [ - "m", - "km", - "mi", - "ft" - ] + "enum": ["m", "km", "mi", "ft"] } ] }, @@ -925,9 +852,7 @@ { "name": "summarize", "type": "enum", - "enum": [ - "SUMMARIZE" - ] + "enum": ["SUMMARIZE"] }, { "name": "fields", @@ -974,9 +899,7 @@ { "name": "highlight", "type": "enum", - "enum": [ - "HIGHLIGHT" - ] + "enum": ["HIGHLIGHT"] }, { "name": "fields", @@ -1003,19 +926,11 @@ { "name": "tags", "type": "enum", - "enum": [ - "TAGS" - ] + "enum": ["TAGS"] }, { - "name": [ - "open", - "close" - ], - "type": [ - "string", - "string" - ] + "name": ["open", "close"], + "type": ["string", "string"] } ] } @@ -1037,9 +952,7 @@ "name": "tags", "type": "enum", "optional": true, - "enum": [ - "INORDER" - ] + "enum": ["INORDER"] }, { "name": "language", @@ -1063,9 +976,7 @@ "name": "explainscore", "type": "enum", "optional": true, - "enum": [ - "EXPLAINSCORE" - ] + "enum": ["EXPLAINSCORE"] }, { "name": "payload", @@ -1087,10 +998,7 @@ "name": "order", "type": "enum", "optional": true, - "enum": [ - "ASC", - "DESC" - ] + "enum": ["ASC", "DESC"] } ] }, @@ -1102,19 +1010,11 @@ { "name": "limit", "type": "enum", - "enum": [ - "LIMIT" - ] + "enum": ["LIMIT"] }, { - "name": [ - "offset", - "num" - ], - "type": [ - "integer", - "integer" - ] + "name": ["offset", "num"], + "type": ["integer", "integer"] } ] }, @@ -1125,23 +1025,15 @@ { "name": "params", "type": "enum", - "enum": [ - "PARAMS" - ] + "enum": ["PARAMS"] }, { "name": "NARGS", "type": "integer" }, { - "name": [ - "name", - "value" - ], - "type": [ - "string", - "string" - ], + "name": ["name", "value"], + "type": ["string", "string"], "multiple": true } ] @@ -1173,9 +1065,7 @@ "name": "verbatim", "type": "enum", "optional": true, - "enum": [ - "VERBATIM" - ] + "enum": ["VERBATIM"] }, { "name": "timeout", @@ -1194,9 +1084,7 @@ "name": "loadall", "type": "enum", "optional": true, - "enum": [ - "LOAD *" - ] + "enum": ["LOAD *"] }, { "name": "load", @@ -1268,10 +1156,7 @@ { "name": "order", "type": "enum", - "enum": [ - "ASC", - "DESC" - ], + "enum": ["ASC", "DESC"], "optional": true } ] @@ -1301,10 +1186,7 @@ { "name": "order", "type": "enum", - "enum": [ - "ASC", - "DESC" - ], + "enum": ["ASC", "DESC"], "optional": true } ] @@ -1343,19 +1225,11 @@ { "name": "limit", "type": "enum", - "enum": [ - "LIMIT" - ] + "enum": ["LIMIT"] }, { - "name": [ - "offset", - "num" - ], - "type": [ - "integer", - "integer" - ] + "name": ["offset", "num"], + "type": ["integer", "integer"] } ] }, @@ -1375,9 +1249,7 @@ { "name": "withcursor", "type": "enum", - "enum": [ - "WITHCURSOR" - ] + "enum": ["WITHCURSOR"] }, { "name": "read_size", @@ -1400,27 +1272,25 @@ { "name": "params", "type": "enum", - "enum": [ - "PARAMS" - ] + "enum": ["PARAMS"] }, { "name": "NARGS", "type": "integer" }, { - "name": [ - "name", - "value" - ], - "type": [ - "string", - "string" - ], + "name": ["name", "value"], + "type": ["string", "string"], "multiple": true } ] }, + { + "name": "addscores", + "type": "enum", + "enum": ["ADDSCORES"], + "optional": true + }, { "name": "dialect", "type": "integer", @@ -1441,17 +1311,12 @@ { "name": "querytype", "type": "enum", - "enum": [ - "SEARCH", - "AGGREGATE" - ] + "enum": ["SEARCH", "AGGREGATE"] }, { "name": "limited", "type": "enum", - "enum": [ - "LIMITED" - ], + "enum": ["LIMITED"], "optional": true }, { @@ -1500,4 +1365,4 @@ "since": "1.1.0", "group": "search" } -} \ No newline at end of file +} diff --git a/internal/cmds/gen_search.go b/internal/cmds/gen_search.go index c10dd499..bcc4b01e 100644 --- a/internal/cmds/gen_search.go +++ b/internal/cmds/gen_search.go @@ -17,6 +17,18 @@ func (c FtAggregate) Index(index string) FtAggregateIndex { return (FtAggregateIndex)(c) } +type FtAggregateAddscores Incomplete + +func (c FtAggregateAddscores) Dialect(dialect int64) FtAggregateDialect { + c.cs.s = append(c.cs.s, "DIALECT", strconv.FormatInt(dialect, 10)) + return (FtAggregateDialect)(c) +} + +func (c FtAggregateAddscores) Build() Completed { + c.cs.Build() + return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks} +} + type FtAggregateCursorCount Incomplete func (c FtAggregateCursorCount) Maxidle(idleTime int64) FtAggregateCursorMaxidle { @@ -29,6 +41,11 @@ func (c FtAggregateCursorCount) Params() FtAggregateParamsParams { return (FtAggregateParamsParams)(c) } +func (c FtAggregateCursorCount) Addscores() FtAggregateAddscores { + c.cs.s = append(c.cs.s, "ADDSCORES") + return (FtAggregateAddscores)(c) +} + func (c FtAggregateCursorCount) Dialect(dialect int64) FtAggregateDialect { c.cs.s = append(c.cs.s, "DIALECT", strconv.FormatInt(dialect, 10)) return (FtAggregateDialect)(c) @@ -46,6 +63,11 @@ func (c FtAggregateCursorMaxidle) Params() FtAggregateParamsParams { return (FtAggregateParamsParams)(c) } +func (c FtAggregateCursorMaxidle) Addscores() FtAggregateAddscores { + c.cs.s = append(c.cs.s, "ADDSCORES") + return (FtAggregateAddscores)(c) +} + func (c FtAggregateCursorMaxidle) Dialect(dialect int64) FtAggregateDialect { c.cs.s = append(c.cs.s, "DIALECT", strconv.FormatInt(dialect, 10)) return (FtAggregateDialect)(c) @@ -73,6 +95,11 @@ func (c FtAggregateCursorWithcursor) Params() FtAggregateParamsParams { return (FtAggregateParamsParams)(c) } +func (c FtAggregateCursorWithcursor) Addscores() FtAggregateAddscores { + c.cs.s = append(c.cs.s, "ADDSCORES") + return (FtAggregateAddscores)(c) +} + func (c FtAggregateCursorWithcursor) Dialect(dialect int64) FtAggregateDialect { c.cs.s = append(c.cs.s, "DIALECT", strconv.FormatInt(dialect, 10)) return (FtAggregateDialect)(c) @@ -151,6 +178,11 @@ func (c FtAggregateOpApplyAs) Params() FtAggregateParamsParams { return (FtAggregateParamsParams)(c) } +func (c FtAggregateOpApplyAs) Addscores() FtAggregateAddscores { + c.cs.s = append(c.cs.s, "ADDSCORES") + return (FtAggregateAddscores)(c) +} + func (c FtAggregateOpApplyAs) Dialect(dialect int64) FtAggregateDialect { c.cs.s = append(c.cs.s, "DIALECT", strconv.FormatInt(dialect, 10)) return (FtAggregateDialect)(c) @@ -208,6 +240,11 @@ func (c FtAggregateOpFilter) Params() FtAggregateParamsParams { return (FtAggregateParamsParams)(c) } +func (c FtAggregateOpFilter) Addscores() FtAggregateAddscores { + c.cs.s = append(c.cs.s, "ADDSCORES") + return (FtAggregateAddscores)(c) +} + func (c FtAggregateOpFilter) Dialect(dialect int64) FtAggregateDialect { c.cs.s = append(c.cs.s, "DIALECT", strconv.FormatInt(dialect, 10)) return (FtAggregateDialect)(c) @@ -275,6 +312,11 @@ func (c FtAggregateOpGroupbyGroupby) Params() FtAggregateParamsParams { return (FtAggregateParamsParams)(c) } +func (c FtAggregateOpGroupbyGroupby) Addscores() FtAggregateAddscores { + c.cs.s = append(c.cs.s, "ADDSCORES") + return (FtAggregateAddscores)(c) +} + func (c FtAggregateOpGroupbyGroupby) Dialect(dialect int64) FtAggregateDialect { c.cs.s = append(c.cs.s, "DIALECT", strconv.FormatInt(dialect, 10)) return (FtAggregateDialect)(c) @@ -342,6 +384,11 @@ func (c FtAggregateOpGroupbyProperty) Params() FtAggregateParamsParams { return (FtAggregateParamsParams)(c) } +func (c FtAggregateOpGroupbyProperty) Addscores() FtAggregateAddscores { + c.cs.s = append(c.cs.s, "ADDSCORES") + return (FtAggregateAddscores)(c) +} + func (c FtAggregateOpGroupbyProperty) Dialect(dialect int64) FtAggregateDialect { c.cs.s = append(c.cs.s, "DIALECT", strconv.FormatInt(dialect, 10)) return (FtAggregateDialect)(c) @@ -429,6 +476,11 @@ func (c FtAggregateOpGroupbyReduceArg) Params() FtAggregateParamsParams { return (FtAggregateParamsParams)(c) } +func (c FtAggregateOpGroupbyReduceArg) Addscores() FtAggregateAddscores { + c.cs.s = append(c.cs.s, "ADDSCORES") + return (FtAggregateAddscores)(c) +} + func (c FtAggregateOpGroupbyReduceArg) Dialect(dialect int64) FtAggregateDialect { c.cs.s = append(c.cs.s, "DIALECT", strconv.FormatInt(dialect, 10)) return (FtAggregateDialect)(c) @@ -506,6 +558,11 @@ func (c FtAggregateOpGroupbyReduceAs) Params() FtAggregateParamsParams { return (FtAggregateParamsParams)(c) } +func (c FtAggregateOpGroupbyReduceAs) Addscores() FtAggregateAddscores { + c.cs.s = append(c.cs.s, "ADDSCORES") + return (FtAggregateAddscores)(c) +} + func (c FtAggregateOpGroupbyReduceAs) Dialect(dialect int64) FtAggregateDialect { c.cs.s = append(c.cs.s, "DIALECT", strconv.FormatInt(dialect, 10)) return (FtAggregateDialect)(c) @@ -578,6 +635,11 @@ func (c FtAggregateOpGroupbyReduceBy) Params() FtAggregateParamsParams { return (FtAggregateParamsParams)(c) } +func (c FtAggregateOpGroupbyReduceBy) Addscores() FtAggregateAddscores { + c.cs.s = append(c.cs.s, "ADDSCORES") + return (FtAggregateAddscores)(c) +} + func (c FtAggregateOpGroupbyReduceBy) Dialect(dialect int64) FtAggregateDialect { c.cs.s = append(c.cs.s, "DIALECT", strconv.FormatInt(dialect, 10)) return (FtAggregateDialect)(c) @@ -665,6 +727,11 @@ func (c FtAggregateOpGroupbyReduceNargs) Params() FtAggregateParamsParams { return (FtAggregateParamsParams)(c) } +func (c FtAggregateOpGroupbyReduceNargs) Addscores() FtAggregateAddscores { + c.cs.s = append(c.cs.s, "ADDSCORES") + return (FtAggregateAddscores)(c) +} + func (c FtAggregateOpGroupbyReduceNargs) Dialect(dialect int64) FtAggregateDialect { c.cs.s = append(c.cs.s, "DIALECT", strconv.FormatInt(dialect, 10)) return (FtAggregateDialect)(c) @@ -727,6 +794,11 @@ func (c FtAggregateOpGroupbyReduceOrderAsc) Params() FtAggregateParamsParams { return (FtAggregateParamsParams)(c) } +func (c FtAggregateOpGroupbyReduceOrderAsc) Addscores() FtAggregateAddscores { + c.cs.s = append(c.cs.s, "ADDSCORES") + return (FtAggregateAddscores)(c) +} + func (c FtAggregateOpGroupbyReduceOrderAsc) Dialect(dialect int64) FtAggregateDialect { c.cs.s = append(c.cs.s, "DIALECT", strconv.FormatInt(dialect, 10)) return (FtAggregateDialect)(c) @@ -789,6 +861,11 @@ func (c FtAggregateOpGroupbyReduceOrderDesc) Params() FtAggregateParamsParams { return (FtAggregateParamsParams)(c) } +func (c FtAggregateOpGroupbyReduceOrderDesc) Addscores() FtAggregateAddscores { + c.cs.s = append(c.cs.s, "ADDSCORES") + return (FtAggregateAddscores)(c) +} + func (c FtAggregateOpGroupbyReduceOrderDesc) Dialect(dialect int64) FtAggregateDialect { c.cs.s = append(c.cs.s, "DIALECT", strconv.FormatInt(dialect, 10)) return (FtAggregateDialect)(c) @@ -860,6 +937,11 @@ func (c FtAggregateOpLimitOffsetNum) Params() FtAggregateParamsParams { return (FtAggregateParamsParams)(c) } +func (c FtAggregateOpLimitOffsetNum) Addscores() FtAggregateAddscores { + c.cs.s = append(c.cs.s, "ADDSCORES") + return (FtAggregateAddscores)(c) +} + func (c FtAggregateOpLimitOffsetNum) Dialect(dialect int64) FtAggregateDialect { c.cs.s = append(c.cs.s, "DIALECT", strconv.FormatInt(dialect, 10)) return (FtAggregateDialect)(c) @@ -922,6 +1004,11 @@ func (c FtAggregateOpLoadField) Params() FtAggregateParamsParams { return (FtAggregateParamsParams)(c) } +func (c FtAggregateOpLoadField) Addscores() FtAggregateAddscores { + c.cs.s = append(c.cs.s, "ADDSCORES") + return (FtAggregateAddscores)(c) +} + func (c FtAggregateOpLoadField) Dialect(dialect int64) FtAggregateDialect { c.cs.s = append(c.cs.s, "DIALECT", strconv.FormatInt(dialect, 10)) return (FtAggregateDialect)(c) @@ -986,6 +1073,11 @@ func (c FtAggregateOpLoadallLoadAll) Params() FtAggregateParamsParams { return (FtAggregateParamsParams)(c) } +func (c FtAggregateOpLoadallLoadAll) Addscores() FtAggregateAddscores { + c.cs.s = append(c.cs.s, "ADDSCORES") + return (FtAggregateAddscores)(c) +} + func (c FtAggregateOpLoadallLoadAll) Dialect(dialect int64) FtAggregateDialect { c.cs.s = append(c.cs.s, "DIALECT", strconv.FormatInt(dialect, 10)) return (FtAggregateDialect)(c) @@ -1053,6 +1145,11 @@ func (c FtAggregateOpSortbyFieldsOrderAsc) Params() FtAggregateParamsParams { return (FtAggregateParamsParams)(c) } +func (c FtAggregateOpSortbyFieldsOrderAsc) Addscores() FtAggregateAddscores { + c.cs.s = append(c.cs.s, "ADDSCORES") + return (FtAggregateAddscores)(c) +} + func (c FtAggregateOpSortbyFieldsOrderAsc) Dialect(dialect int64) FtAggregateDialect { c.cs.s = append(c.cs.s, "DIALECT", strconv.FormatInt(dialect, 10)) return (FtAggregateDialect)(c) @@ -1120,6 +1217,11 @@ func (c FtAggregateOpSortbyFieldsOrderDesc) Params() FtAggregateParamsParams { return (FtAggregateParamsParams)(c) } +func (c FtAggregateOpSortbyFieldsOrderDesc) Addscores() FtAggregateAddscores { + c.cs.s = append(c.cs.s, "ADDSCORES") + return (FtAggregateAddscores)(c) +} + func (c FtAggregateOpSortbyFieldsOrderDesc) Dialect(dialect int64) FtAggregateDialect { c.cs.s = append(c.cs.s, "DIALECT", strconv.FormatInt(dialect, 10)) return (FtAggregateDialect)(c) @@ -1197,6 +1299,11 @@ func (c FtAggregateOpSortbyFieldsProperty) Params() FtAggregateParamsParams { return (FtAggregateParamsParams)(c) } +func (c FtAggregateOpSortbyFieldsProperty) Addscores() FtAggregateAddscores { + c.cs.s = append(c.cs.s, "ADDSCORES") + return (FtAggregateAddscores)(c) +} + func (c FtAggregateOpSortbyFieldsProperty) Dialect(dialect int64) FtAggregateDialect { c.cs.s = append(c.cs.s, "DIALECT", strconv.FormatInt(dialect, 10)) return (FtAggregateDialect)(c) @@ -1254,6 +1361,11 @@ func (c FtAggregateOpSortbyMax) Params() FtAggregateParamsParams { return (FtAggregateParamsParams)(c) } +func (c FtAggregateOpSortbyMax) Addscores() FtAggregateAddscores { + c.cs.s = append(c.cs.s, "ADDSCORES") + return (FtAggregateAddscores)(c) +} + func (c FtAggregateOpSortbyMax) Dialect(dialect int64) FtAggregateDialect { c.cs.s = append(c.cs.s, "DIALECT", strconv.FormatInt(dialect, 10)) return (FtAggregateDialect)(c) @@ -1321,6 +1433,11 @@ func (c FtAggregateOpSortbySortby) Params() FtAggregateParamsParams { return (FtAggregateParamsParams)(c) } +func (c FtAggregateOpSortbySortby) Addscores() FtAggregateAddscores { + c.cs.s = append(c.cs.s, "ADDSCORES") + return (FtAggregateAddscores)(c) +} + func (c FtAggregateOpSortbySortby) Dialect(dialect int64) FtAggregateDialect { c.cs.s = append(c.cs.s, "DIALECT", strconv.FormatInt(dialect, 10)) return (FtAggregateDialect)(c) @@ -1338,6 +1455,11 @@ func (c FtAggregateParamsNameValue) NameValue(name string, value string) FtAggre return c } +func (c FtAggregateParamsNameValue) Addscores() FtAggregateAddscores { + c.cs.s = append(c.cs.s, "ADDSCORES") + return (FtAggregateAddscores)(c) +} + func (c FtAggregateParamsNameValue) Dialect(dialect int64) FtAggregateDialect { c.cs.s = append(c.cs.s, "DIALECT", strconv.FormatInt(dialect, 10)) return (FtAggregateDialect)(c) @@ -1418,6 +1540,11 @@ func (c FtAggregateQuery) Params() FtAggregateParamsParams { return (FtAggregateParamsParams)(c) } +func (c FtAggregateQuery) Addscores() FtAggregateAddscores { + c.cs.s = append(c.cs.s, "ADDSCORES") + return (FtAggregateAddscores)(c) +} + func (c FtAggregateQuery) Dialect(dialect int64) FtAggregateDialect { c.cs.s = append(c.cs.s, "DIALECT", strconv.FormatInt(dialect, 10)) return (FtAggregateDialect)(c) @@ -1475,6 +1602,11 @@ func (c FtAggregateTimeout) Params() FtAggregateParamsParams { return (FtAggregateParamsParams)(c) } +func (c FtAggregateTimeout) Addscores() FtAggregateAddscores { + c.cs.s = append(c.cs.s, "ADDSCORES") + return (FtAggregateAddscores)(c) +} + func (c FtAggregateTimeout) Dialect(dialect int64) FtAggregateDialect { c.cs.s = append(c.cs.s, "DIALECT", strconv.FormatInt(dialect, 10)) return (FtAggregateDialect)(c) @@ -1537,6 +1669,11 @@ func (c FtAggregateVerbatim) Params() FtAggregateParamsParams { return (FtAggregateParamsParams)(c) } +func (c FtAggregateVerbatim) Addscores() FtAggregateAddscores { + c.cs.s = append(c.cs.s, "ADDSCORES") + return (FtAggregateAddscores)(c) +} + func (c FtAggregateVerbatim) Dialect(dialect int64) FtAggregateDialect { c.cs.s = append(c.cs.s, "DIALECT", strconv.FormatInt(dialect, 10)) return (FtAggregateDialect)(c) diff --git a/internal/cmds/gen_search_test.go b/internal/cmds/gen_search_test.go index c923abc1..30c465ca 100644 --- a/internal/cmds/gen_search_test.go +++ b/internal/cmds/gen_search_test.go @@ -5,32 +5,41 @@ package cmds import "testing" func search0(s Builder) { + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Filter("1").Filter("1").Withcursor().Count(1).Maxidle(1).Addscores().Dialect(1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Filter("1").Filter("1").Withcursor().Count(1).Maxidle(1).Addscores().Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Filter("1").Filter("1").Withcursor().Count(1).Maxidle(1).Dialect(1).Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Filter("1").Filter("1").Withcursor().Count(1).Maxidle(1).Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Filter("1").Filter("1").Withcursor().Count(1).Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Filter("1").Filter("1").Withcursor().Count(1).Addscores().Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Filter("1").Filter("1").Withcursor().Count(1).Dialect(1).Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Filter("1").Filter("1").Withcursor().Count(1).Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Filter("1").Filter("1").Withcursor().Maxidle(1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Filter("1").Filter("1").Withcursor().Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Addscores().Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Filter("1").Filter("1").Withcursor().Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Dialect(1).Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Filter("1").Filter("1").Withcursor().Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Filter("1").Filter("1").Withcursor().Addscores().Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Filter("1").Filter("1").Withcursor().Dialect(1).Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Filter("1").Filter("1").Withcursor().Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Filter("1").Filter("1").Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Filter("1").Filter("1").Addscores().Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Filter("1").Filter("1").Dialect(1).Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Filter("1").Filter("1").Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Withcursor().Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Addscores().Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Dialect(1).Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Filter("1").Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Withcursor().Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Addscores().Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Dialect(1).Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Limit().OffsetNum(1, 1).Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Filter("1").Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Withcursor().Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Addscores().Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Dialect(1).Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Apply("1").As("1").Build() @@ -38,6 +47,7 @@ func search0(s Builder) { s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Filter("1").Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Withcursor().Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Addscores().Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Dialect(1).Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Desc().Max(1).Build() @@ -46,6 +56,7 @@ func search0(s Builder) { s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Desc().Filter("1").Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Desc().Withcursor().Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Desc().Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Desc().Addscores().Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Desc().Dialect(1).Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Desc().Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Property("1").Max(1).Build() @@ -54,6 +65,7 @@ func search0(s Builder) { s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Property("1").Filter("1").Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Property("1").Withcursor().Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Property("1").Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Property("1").Addscores().Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Property("1").Dialect(1).Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Property("1").Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Max(1).Build() @@ -62,6 +74,7 @@ func search0(s Builder) { s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Filter("1").Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Sortby(1).Withcursor().Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Sortby(1).Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Sortby(1).Addscores().Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Sortby(1).Dialect(1).Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Sortby(1).Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Apply("1").As("1").Build() @@ -69,6 +82,7 @@ func search0(s Builder) { s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Filter("1").Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Withcursor().Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Addscores().Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Dialect(1).Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Desc().Sortby(1).Build() @@ -77,6 +91,7 @@ func search0(s Builder) { s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Desc().Filter("1").Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Desc().Withcursor().Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Desc().Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Desc().Addscores().Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Desc().Dialect(1).Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Desc().Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Sortby(1).Build() @@ -85,16 +100,21 @@ func search0(s Builder) { s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Filter("1").Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Withcursor().Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Addscores().Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Dialect(1).Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").Asc().Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").Desc().Build() +} + +func search1(s Builder) { s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").Sortby(1).Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").Apply("1").As("1").Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").Limit().OffsetNum(1, 1).Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").Filter("1").Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").Withcursor().Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").Addscores().Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").Dialect(1).Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").By("1").Build() @@ -105,10 +125,8 @@ func search0(s Builder) { s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").Limit().OffsetNum(1, 1).Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").Filter("1").Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").Withcursor().Build() -} - -func search1(s Builder) { s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").Addscores().Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").Dialect(1).Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).As("1").Build() @@ -121,6 +139,7 @@ func search1(s Builder) { s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Filter("1").Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Withcursor().Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Addscores().Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Dialect(1).Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Sortby(1).Build() @@ -129,6 +148,7 @@ func search1(s Builder) { s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Filter("1").Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Withcursor().Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Addscores().Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Dialect(1).Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Reduce("1").Nargs(1).Build() @@ -138,6 +158,7 @@ func search1(s Builder) { s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Groupby(1).Filter("1").Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Groupby(1).Withcursor().Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Groupby(1).Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Groupby(1).Addscores().Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Groupby(1).Dialect(1).Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Groupby(1).Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Sortby(1).Build() @@ -146,6 +167,7 @@ func search1(s Builder) { s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Filter("1").Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Withcursor().Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Addscores().Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Dialect(1).Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Groupby(1).Build() @@ -155,6 +177,7 @@ func search1(s Builder) { s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Filter("1").Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().LoadAll().Withcursor().Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().LoadAll().Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().LoadAll().Addscores().Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().LoadAll().Dialect(1).Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().LoadAll().Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).Load(1).Field("1").Field("1").Build() @@ -165,6 +188,7 @@ func search1(s Builder) { s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).Filter("1").Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).Withcursor().Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).Addscores().Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).Dialect(1).Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).Build() s.FtAggregate().Index("1").Query("1").Verbatim().LoadAll().Build() @@ -176,6 +200,7 @@ func search1(s Builder) { s.FtAggregate().Index("1").Query("1").Verbatim().Filter("1").Build() s.FtAggregate().Index("1").Query("1").Verbatim().Withcursor().Build() s.FtAggregate().Index("1").Query("1").Verbatim().Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Addscores().Build() s.FtAggregate().Index("1").Query("1").Verbatim().Dialect(1).Build() s.FtAggregate().Index("1").Query("1").Verbatim().Build() s.FtAggregate().Index("1").Query("1").Timeout(1).Build() @@ -183,11 +208,15 @@ func search1(s Builder) { s.FtAggregate().Index("1").Query("1").Load(1).Field("1").Field("1").Build() s.FtAggregate().Index("1").Query("1").Groupby(1).Build() s.FtAggregate().Index("1").Query("1").Sortby(1).Build() +} + +func search2(s Builder) { s.FtAggregate().Index("1").Query("1").Apply("1").As("1").Build() s.FtAggregate().Index("1").Query("1").Limit().OffsetNum(1, 1).Build() s.FtAggregate().Index("1").Query("1").Filter("1").Build() s.FtAggregate().Index("1").Query("1").Withcursor().Build() s.FtAggregate().Index("1").Query("1").Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() + s.FtAggregate().Index("1").Query("1").Addscores().Build() s.FtAggregate().Index("1").Query("1").Dialect(1).Build() s.FtAggregate().Index("1").Query("1").Build() s.FtAliasadd().Alias("1").Index("1").Build() @@ -208,9 +237,6 @@ func search1(s Builder) { s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Nostem().Weight(1).Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Nostem().Separator("1").Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Nostem().Casesensitive().Build() -} - -func search2(s Builder) { s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Nostem().Noindex().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Nostem().Nostem().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Phonetic("1").Weight(1).Build() @@ -285,6 +311,9 @@ func search2(s Builder) { s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Geo().Phonetic("1").Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Geo().Weight(1).Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Geo().Separator("1").Build() +} + +func search3(s Builder) { s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Geo().Casesensitive().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Geo().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Vector("1", 1).Withsuffixtrie().Build() @@ -311,9 +340,6 @@ func search2(s Builder) { s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Schema().FieldName("1").As("1").Text().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() -} - -func search3(s Builder) { s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Schema().FieldName("1").As("1").Text().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() @@ -388,6 +414,9 @@ func search3(s Builder) { s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() +} + +func search4(s Builder) { s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() @@ -414,9 +443,6 @@ func search3(s Builder) { s.FtCreate().Index("1").OnHash().Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() s.FtCreate().Index("1").OnHash().Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() s.FtCreate().Index("1").OnHash().LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() -} - -func search4(s Builder) { s.FtCreate().Index("1").OnHash().Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() s.FtCreate().Index("1").OnHash().ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() s.FtCreate().Index("1").OnHash().PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() @@ -491,6 +517,9 @@ func search4(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Expander("1").Scorer("1").Explainscore().Payload("1").Sortby("1").Desc().Dialect(1).Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Expander("1").Scorer("1").Explainscore().Payload("1").Sortby("1").Desc().Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Expander("1").Scorer("1").Explainscore().Payload("1").Sortby("1").Limit().OffsetNum(1, 1).Build() +} + +func search5(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Expander("1").Scorer("1").Explainscore().Payload("1").Sortby("1").Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Expander("1").Scorer("1").Explainscore().Payload("1").Sortby("1").Dialect(1).Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Expander("1").Scorer("1").Explainscore().Payload("1").Sortby("1").Build() @@ -517,9 +546,6 @@ func search4(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Expander("1").Dialect(1).Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Expander("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Scorer("1").Build() -} - -func search5(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Explainscore().Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Payload("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Sortby("1").Build() @@ -594,6 +620,9 @@ func search5(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Sortby("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Limit().OffsetNum(1, 1).Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() +} + +func search6(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Dialect(1).Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Slop(1).Build() @@ -620,9 +649,6 @@ func search5(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Payload("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Sortby("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Limit().OffsetNum(1, 1).Build() -} - -func search6(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Dialect(1).Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Build() @@ -697,6 +723,9 @@ func search6(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").Identifier("1").Expander("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").Identifier("1").Scorer("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").Identifier("1").Explainscore().Build() +} + +func search7(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").Identifier("1").Payload("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").Identifier("1").Sortby("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").Identifier("1").Limit().OffsetNum(1, 1).Build() @@ -723,9 +752,6 @@ func search6(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Highlight().Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Slop(1).Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Timeout(1).Build() -} - -func search7(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Inorder().Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Language("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Expander("1").Build() @@ -800,6 +826,9 @@ func search7(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).Ft().Inorder().Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).Ft().Language("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).Ft().Expander("1").Build() +} + +func search8(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).Ft().Scorer("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).Ft().Explainscore().Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).Ft().Payload("1").Build() @@ -826,9 +855,6 @@ func search7(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Dialect(1).Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Build() -} - -func search8(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Inkeys("1").Key("1").Key("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Infields("1").Field("1").Field("1").Build() @@ -903,6 +929,9 @@ func search8(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Inorder().Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Language("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Expander("1").Build() +} + +func search9(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Scorer("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Explainscore().Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Payload("1").Build() @@ -929,9 +958,6 @@ func search8(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Scorer("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Explainscore().Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Payload("1").Build() -} - -func search9(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Sortby("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Limit().OffsetNum(1, 1).Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() From 1013f1c0789fffc7fea0cad3d9e3ff4df700aed4 Mon Sep 17 00:00:00 2001 From: Eric Chang Date: Sat, 9 Nov 2024 23:04:45 +0800 Subject: [PATCH 10/49] feat: FT_CREATE: add GEOSHAPE fieldType --- hack/cmds/commands_search.json | 2 +- internal/cmds/gen_search.go | 62 ++++++++++++++++++++++++++++++++ internal/cmds/gen_search_test.go | 51 ++++++++++++++++---------- 3 files changed, 96 insertions(+), 19 deletions(-) diff --git a/hack/cmds/commands_search.json b/hack/cmds/commands_search.json index aa8c39f7..cf391184 100644 --- a/hack/cmds/commands_search.json +++ b/hack/cmds/commands_search.json @@ -151,7 +151,7 @@ { "name": "field_type", "type": "enum", - "enum": ["TEXT", "TAG", "NUMERIC", "GEO", "VECTOR"] + "enum": ["TEXT", "TAG", "NUMERIC", "GEO", "VECTOR", "GEOSHAPE"] }, { "name": "option", diff --git a/internal/cmds/gen_search.go b/internal/cmds/gen_search.go index bcc4b01e..9bc4a6d1 100644 --- a/internal/cmds/gen_search.go +++ b/internal/cmds/gen_search.go @@ -1926,6 +1926,11 @@ func (c FtCreateFieldAs) Vector(algo string, nargs int64, args ...string) FtCrea return (FtCreateFieldFieldTypeVector)(c) } +func (c FtCreateFieldAs) Geoshape() FtCreateFieldFieldTypeGeoshape { + c.cs.s = append(c.cs.s, "GEOSHAPE") + return (FtCreateFieldFieldTypeGeoshape)(c) +} + type FtCreateFieldFieldName Incomplete func (c FtCreateFieldFieldName) As(alias string) FtCreateFieldAs { @@ -1959,6 +1964,11 @@ func (c FtCreateFieldFieldName) Vector(algo string, nargs int64, args ...string) return (FtCreateFieldFieldTypeVector)(c) } +func (c FtCreateFieldFieldName) Geoshape() FtCreateFieldFieldTypeGeoshape { + c.cs.s = append(c.cs.s, "GEOSHAPE") + return (FtCreateFieldFieldTypeGeoshape)(c) +} + type FtCreateFieldFieldTypeGeo Incomplete func (c FtCreateFieldFieldTypeGeo) Withsuffixtrie() FtCreateFieldOptionWithsuffixtrie { @@ -2011,6 +2021,58 @@ func (c FtCreateFieldFieldTypeGeo) Build() Completed { return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks} } +type FtCreateFieldFieldTypeGeoshape Incomplete + +func (c FtCreateFieldFieldTypeGeoshape) Withsuffixtrie() FtCreateFieldOptionWithsuffixtrie { + c.cs.s = append(c.cs.s, "WITHSUFFIXTRIE") + return (FtCreateFieldOptionWithsuffixtrie)(c) +} + +func (c FtCreateFieldFieldTypeGeoshape) Sortable() FtCreateFieldOptionSortableSortable { + c.cs.s = append(c.cs.s, "SORTABLE") + return (FtCreateFieldOptionSortableSortable)(c) +} + +func (c FtCreateFieldFieldTypeGeoshape) Noindex() FtCreateFieldOptionNoindex { + c.cs.s = append(c.cs.s, "NOINDEX") + return (FtCreateFieldOptionNoindex)(c) +} + +func (c FtCreateFieldFieldTypeGeoshape) Nostem() FtCreateFieldOptionNostem { + c.cs.s = append(c.cs.s, "NOSTEM") + return (FtCreateFieldOptionNostem)(c) +} + +func (c FtCreateFieldFieldTypeGeoshape) Phonetic(phonetic string) FtCreateFieldOptionPhonetic { + c.cs.s = append(c.cs.s, "PHONETIC", phonetic) + return (FtCreateFieldOptionPhonetic)(c) +} + +func (c FtCreateFieldFieldTypeGeoshape) Weight(weight float64) FtCreateFieldOptionWeight { + c.cs.s = append(c.cs.s, "WEIGHT", strconv.FormatFloat(weight, 'f', -1, 64)) + return (FtCreateFieldOptionWeight)(c) +} + +func (c FtCreateFieldFieldTypeGeoshape) Separator(separator string) FtCreateFieldOptionSeparator { + c.cs.s = append(c.cs.s, "SEPARATOR", separator) + return (FtCreateFieldOptionSeparator)(c) +} + +func (c FtCreateFieldFieldTypeGeoshape) Casesensitive() FtCreateFieldOptionCasesensitive { + c.cs.s = append(c.cs.s, "CASESENSITIVE") + return (FtCreateFieldOptionCasesensitive)(c) +} + +func (c FtCreateFieldFieldTypeGeoshape) FieldName(fieldName string) FtCreateFieldFieldName { + c.cs.s = append(c.cs.s, fieldName) + return (FtCreateFieldFieldName)(c) +} + +func (c FtCreateFieldFieldTypeGeoshape) Build() Completed { + c.cs.Build() + return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks} +} + type FtCreateFieldFieldTypeNumeric Incomplete func (c FtCreateFieldFieldTypeNumeric) Withsuffixtrie() FtCreateFieldOptionWithsuffixtrie { diff --git a/internal/cmds/gen_search_test.go b/internal/cmds/gen_search_test.go index 30c465ca..be4a74b6 100644 --- a/internal/cmds/gen_search_test.go +++ b/internal/cmds/gen_search_test.go @@ -325,11 +325,21 @@ func search3(s Builder) { s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Vector("1", 1).Separator("1").Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Vector("1", 1).Casesensitive().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Vector("1", 1).Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Geoshape().Withsuffixtrie().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Geoshape().Sortable().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Geoshape().Noindex().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Geoshape().Nostem().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Geoshape().Phonetic("1").Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Geoshape().Weight(1).Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Geoshape().Separator("1").Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Geoshape().Casesensitive().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Geoshape().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").Text().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").Tag().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").Numeric().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").Geo().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").Vector("1", 1).Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").Geoshape().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Schema().FieldName("1").As("1").Text().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Schema().FieldName("1").As("1").Text().Build() @@ -404,6 +414,9 @@ func search3(s Builder) { s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() +} + +func search4(s Builder) { s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() @@ -414,9 +427,6 @@ func search3(s Builder) { s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() -} - -func search4(s Builder) { s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() @@ -507,6 +517,9 @@ func search4(s Builder) { s.FtProfile().Index("1").Aggregate().Query("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Expander("1").Scorer("1").Explainscore().Payload("1").Sortby("1").Asc().Limit().OffsetNum(1, 1).Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Dialect(1).Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Expander("1").Scorer("1").Explainscore().Payload("1").Sortby("1").Asc().Limit().OffsetNum(1, 1).Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() +} + +func search5(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Expander("1").Scorer("1").Explainscore().Payload("1").Sortby("1").Asc().Limit().OffsetNum(1, 1).Dialect(1).Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Expander("1").Scorer("1").Explainscore().Payload("1").Sortby("1").Asc().Limit().OffsetNum(1, 1).Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Expander("1").Scorer("1").Explainscore().Payload("1").Sortby("1").Asc().Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() @@ -517,9 +530,6 @@ func search4(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Expander("1").Scorer("1").Explainscore().Payload("1").Sortby("1").Desc().Dialect(1).Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Expander("1").Scorer("1").Explainscore().Payload("1").Sortby("1").Desc().Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Expander("1").Scorer("1").Explainscore().Payload("1").Sortby("1").Limit().OffsetNum(1, 1).Build() -} - -func search5(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Expander("1").Scorer("1").Explainscore().Payload("1").Sortby("1").Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Expander("1").Scorer("1").Explainscore().Payload("1").Sortby("1").Dialect(1).Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Expander("1").Scorer("1").Explainscore().Payload("1").Sortby("1").Build() @@ -610,6 +620,9 @@ func search5(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Tags().OpenClose("1", "1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Slop(1).Build() +} + +func search6(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Timeout(1).Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Inorder().Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Language("1").Build() @@ -620,9 +633,6 @@ func search5(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Sortby("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Limit().OffsetNum(1, 1).Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() -} - -func search6(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Dialect(1).Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Slop(1).Build() @@ -713,6 +723,9 @@ func search6(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Limit().OffsetNum(1, 1).Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Dialect(1).Build() +} + +func search7(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").Identifier("1").Summarize().Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").Identifier("1").Highlight().Build() @@ -723,9 +736,6 @@ func search6(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").Identifier("1").Expander("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").Identifier("1").Scorer("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").Identifier("1").Explainscore().Build() -} - -func search7(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").Identifier("1").Payload("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").Identifier("1").Sortby("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").Identifier("1").Limit().OffsetNum(1, 1).Build() @@ -816,6 +826,9 @@ func search7(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).Mi().Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).Mi().Dialect(1).Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).Mi().Build() +} + +func search8(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).Ft().Inkeys("1").Key("1").Key("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).Ft().Infields("1").Field("1").Field("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).Ft().Return("1").Identifier("1").Build() @@ -826,9 +839,6 @@ func search7(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).Ft().Inorder().Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).Ft().Language("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).Ft().Expander("1").Build() -} - -func search8(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).Ft().Scorer("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).Ft().Explainscore().Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).Ft().Payload("1").Build() @@ -919,6 +929,9 @@ func search8(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withsortkeys().Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Filter("1").Min(1).Max(1).Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Build() +} + +func search9(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Inkeys("1").Key("1").Key("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Infields("1").Field("1").Field("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Return("1").Identifier("1").Build() @@ -929,9 +942,6 @@ func search8(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Inorder().Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Language("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Expander("1").Build() -} - -func search9(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Scorer("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Explainscore().Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Payload("1").Build() @@ -1022,6 +1032,9 @@ func search9(s Builder) { s.FtSpellcheck().Index("1").Query("1").TermsInclude().Dictionary("1").Build() s.FtSpellcheck().Index("1").Query("1").TermsExclude().Dictionary("1").Build() s.FtSpellcheck().Index("1").Query("1").Dialect(1).Build() +} + +func search10(s Builder) { s.FtSpellcheck().Index("1").Query("1").Build() s.FtSyndump().Index("1").Build() s.FtSynupdate().Index("1").SynonymGroupId("1").Skipinitialscan().Term("1").Term("1").Build() @@ -1041,6 +1054,7 @@ func TestCommand_InitSlot_search(t *testing.T) { t.Run("7", func(t *testing.T) { search7(s) }) t.Run("8", func(t *testing.T) { search8(s) }) t.Run("9", func(t *testing.T) { search9(s) }) + t.Run("10", func(t *testing.T) { search10(s) }) } func TestCommand_NoSlot_search(t *testing.T) { @@ -1055,4 +1069,5 @@ func TestCommand_NoSlot_search(t *testing.T) { t.Run("7", func(t *testing.T) { search7(s) }) t.Run("8", func(t *testing.T) { search8(s) }) t.Run("9", func(t *testing.T) { search9(s) }) + t.Run("10", func(t *testing.T) { search10(s) }) } From 8f5685195c7529e4faaf1d6de21fabe78a2d389b Mon Sep 17 00:00:00 2001 From: Eric Chang Date: Sun, 10 Nov 2024 10:55:59 +0800 Subject: [PATCH 11/49] wip: FT_EXPLAIN --- rueidiscompat/adapter.go | 345 ++++++++++++++++++++++++++++----------- rueidiscompat/command.go | 13 +- 2 files changed, 265 insertions(+), 93 deletions(-) diff --git a/rueidiscompat/adapter.go b/rueidiscompat/adapter.go index 8aae848f..e7f737db 100644 --- a/rueidiscompat/adapter.go +++ b/rueidiscompat/adapter.go @@ -4865,119 +4865,282 @@ func (c *Compat) FTAggregate(ctx context.Context, index string, query string) *M func (c *Compat) FTAggregateWithArgs(ctx context.Context, index string, query string, options *FTAggregateOptions) *AggregateCmd { _cmd := cmds.Incomplete(c.client.B().FtAggregate().Index(index).Query(query)) - if options != nil { - if options.Verbatim { - // VERBATIM - _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).Verbatim()) - } - // [LOAD count field [field ...]] - if options.LoadAll { - // LOAD * - _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).LoadAll()) - } else { - // LOAD - _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).Load(int64(len(options.Load)))) - fields := make([]string, 0, len(options.Load)) - for _, l := range options.Load { - fields = append(fields, l.Field) - } - _cmd = cmds.Incomplete(cmds.FtAggregateOpLoadLoad(_cmd).Field(fields...)) + if options == nil { + panic("options can not be nil") + } + if options.Verbatim { + // VERBATIM + _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).Verbatim()) + } + // [LOAD count field [field ...]] + if options.LoadAll { + // LOAD * + _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).LoadAll()) + } else { + // LOAD + _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).Load(int64(len(options.Load)))) + fields := make([]string, 0, len(options.Load)) + for _, l := range options.Load { + fields = append(fields, l.Field) } - // [TIMEOUT timeout] - _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).Timeout(int64(options.Timeout))) - // GROUPBY - // 0 - // [ - // GROUPBY nargs property [property ...] - // [ - // REDUCE function nargs arg [arg ...] [AS name] - // [ REDUCE function nargs arg [arg ...] [AS name] ...] - // ] ... - // ]] - for _, groupBy := range options.GroupBy { - _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd). - Groupby(int64(len(options.GroupBy))). - Property(argsToSlice(groupBy.Fields)...)) - for _, reduce := range groupBy.Reduce { - _cmd = cmds.Incomplete(cmds.FtAggregateOpGroupbyProperty(_cmd). - Reduce(reduce.Reducer.String()). - Nargs(int64(len(reduce.Args))). - Arg(argsToSlice(reduce.Args)...). - As(reduce.As)) - } + _cmd = cmds.Incomplete(cmds.FtAggregateOpLoadLoad(_cmd).Field(fields...)) + } + // [TIMEOUT timeout] + _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).Timeout(int64(options.Timeout))) + // GROUPBY + // 0 + // [ + // GROUPBY nargs property [property ...] + // [ + // REDUCE function nargs arg [arg ...] [AS name] + // [ REDUCE function nargs arg [arg ...] [AS name] ...] + // ] ... + // ]] + for _, groupBy := range options.GroupBy { + _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd). + Groupby(int64(len(options.GroupBy))). + Property(argsToSlice(groupBy.Fields)...)) + for _, reduce := range groupBy.Reduce { + _cmd = cmds.Incomplete(cmds.FtAggregateOpGroupbyProperty(_cmd). + Reduce(reduce.Reducer.String()). + Nargs(int64(len(reduce.Args))). + Arg(argsToSlice(reduce.Args)...). + As(reduce.As)) } - // SORTBY - // [ - // SORTBY nargs [ - // property ASC | DESC [ property ASC | DESC ...] - // ] [MAX num] [WITHCOUNT] - // - _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).Sortby(int64(len(options.SortBy)))) - for _, sortBy := range options.SortBy { - _cmd = cmds.Incomplete(cmds.FtAggregateOpSortbySortby(_cmd).Property(sortBy.FieldName)) - if sortBy.Desc == sortBy.Asc { - panic("sortBy should be either ASC or DESC") - } - if sortBy.Asc { - // ASC - _cmd = cmds.Incomplete(cmds.FtAggregateOpSortbyFieldsProperty(_cmd).Asc()) - continue - } else { - _cmd = cmds.Incomplete(cmds.FtAggregateOpSortbyFieldsProperty(_cmd).Desc()) - } - // DESC + } + // SORTBY + // [ + // SORTBY nargs [ + // property ASC | DESC [ property ASC | DESC ...] + // ] [MAX num] [WITHCOUNT] + // + _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).Sortby(int64(len(options.SortBy)))) + for _, sortBy := range options.SortBy { + _cmd = cmds.Incomplete(cmds.FtAggregateOpSortbySortby(_cmd).Property(sortBy.FieldName)) + if sortBy.Desc == sortBy.Asc { + panic("sortBy should be either ASC or DESC") } - // FIXME: go-redis doesn't provide WITHCOUNT option - _cmd = cmds.Incomplete(cmds.FtAggregateOpSortbySortby(_cmd).Max(int64(options.SortByMax))) - // [ APPLY expression AS name [ APPLY expression AS name ...]] - for _, apply := range options.Apply { - _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).Apply(apply.Field).As(apply.As)) + if sortBy.Asc { + // ASC + _cmd = cmds.Incomplete(cmds.FtAggregateOpSortbyFieldsProperty(_cmd).Asc()) + continue + } else { + _cmd = cmds.Incomplete(cmds.FtAggregateOpSortbyFieldsProperty(_cmd).Desc()) } - // [ LIMIT offset num] - _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).Limit().OffsetNum(int64(options.Limit), int64(options.LimitOffset))) - // [FILTER filter] - _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).Filter(options.Filter)) - // [ WITHCURSOR [COUNT read_size] [MAXIDLE idle_time]] - _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).Withcursor().Count(int64(options.WithCursorOptions.Count)).Maxidle(int64(options.WithCursorOptions.MaxIdle))) - // [ PARAMS nargs name value [ name value ...]] - _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).Params().Nargs(int64(len(options.Params)))) - // [ADDSCORES] - // [DIALECT dialect] - } + // DESC + } + // FIXME: go-redis doesn't provide WITHCOUNT option + _cmd = cmds.Incomplete(cmds.FtAggregateOpSortbySortby(_cmd).Max(int64(options.SortByMax))) + // [ APPLY expression AS name [ APPLY expression AS name ...]] + for _, apply := range options.Apply { + _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).Apply(apply.Field).As(apply.As)) + } + // [ LIMIT offset num] + _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).Limit().OffsetNum(int64(options.Limit), int64(options.LimitOffset))) + // [FILTER filter] + _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).Filter(options.Filter)) + // [ WITHCURSOR [COUNT read_size] [MAXIDLE idle_time]] + _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).Withcursor().Count(int64(options.WithCursorOptions.Count)).Maxidle(int64(options.WithCursorOptions.MaxIdle))) + // [ PARAMS nargs name value [ name value ...]] + _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).Params().Nargs(int64(len(options.Params))).NameValue()) + for name, val := range options.Params { + _cmd = cmds.Incomplete(cmds.FtAggregateParamsNameValue(_cmd).NameValue(name, str(val))) + } + // [ADDSCORES]: NOTE: go-redis doesn't implement this option. + // [DIALECT dialect] + _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).Dialect(int64(options.DialectVersion))) + cmd := cmds.FtAggregateQuery(_cmd).Build() + return newAggregateCmd(c.client.Do(ctx, cmd)) +} + +func (c *Compat) FTAliasAdd(ctx context.Context, index string, alias string) *StatusCmd { + cmd := c.client.B().FtAliasadd().Alias(alias).Index(index).Build() + return newStatusCmd(c.client.Do(ctx, cmd)) +} + +func (c *Compat) FTAliasDel(ctx context.Context, alias string) *StatusCmd { + cmd := c.client.B().FtAliasdel().Alias(alias).Build() + return newStatusCmd(c.client.Do(ctx, cmd)) } -func (c *Compat) FTAliasAdd(ctx context.Context, index string, alias string) *StatusCmd { return nil } -func (c *Compat) FTAliasDel(ctx context.Context, alias string) *StatusCmd { return nil } func (c *Compat) FTAliasUpdate(ctx context.Context, index string, alias string) *StatusCmd { - return nil + cmd := c.client.B().FtAliasupdate().Alias(alias).Index(index).Build() + return newStatusCmd(c.client.Do(ctx, cmd)) } + func (c *Compat) FTAlter(ctx context.Context, index string, skipInitalScan bool, definition []interface{}) *StatusCmd { - return nil + _cmd := cmds.Incomplete(c.client.B().FtAlter().Index(index)) + if skipInitalScan { + _cmd = cmds.Incomplete(cmds.FtAlterIndex(_cmd).Skipinitialscan()) + } + if len(definition) != 2 { + panic("definition should contain attribute and options") + } + cmd := cmds.FtAlterIndex(_cmd).Schema().Add().Field(str(definition[0])).Options(str(definition[1])).Build() + return newStatusCmd(c.client.Do(ctx, cmd)) } + func (c *Compat) FTConfigGet(ctx context.Context, option string) *MapMapStringInterfaceCmd { - return nil + cmd := c.client.B().FtConfigGet().Option(option).Build() + return newMapMapStringInterfaceCmd(c.client.Do(ctx, cmd)) } + func (c *Compat) FTConfigSet(ctx context.Context, option string, value interface{}) *StatusCmd { - return nil + cmd := c.client.B().FtConfigSet().Option(option).Value(str(value)).Build() + return newStatusCmd(c.client.Do(ctx, cmd)) } + +// OnHash bool +// +// OnJSON bool +// Prefix []any +// Filter string +// DefaultLanguage string +// LanguageField string +// Score float64 +// ScoreField string +// PayloadField string +// MaxTextFields int +// NoOffsets bool +// Temporary int +// NoHL bool +// NoFields bool +// NoFreqs bool +// StopWords []any +// SkipInitialScan bool func (c *Compat) FTCreate(ctx context.Context, index string, options *FTCreateOptions, schema ...*FieldSchema) *StatusCmd { - return nil + _cmd := cmds.Incomplete(c.client.B().FtCreate().Index(index)) + if options.OnHash { + _cmd = cmds.Incomplete(cmds.FtCreateIndex(_cmd).OnHash()) + } + if options.OnJSON { + _cmd = cmds.Incomplete(cmds.FtCreateIndex(_cmd).OnJson()) + } + _cmd = cmds.Incomplete(cmds.FtCreateIndex(_cmd).Prefix(int64(len(options.Prefix))).Prefix(argsToSlice(options.Prefix)...)) + _cmd = cmds.Incomplete( + cmds.FtCreateIndex(_cmd). + Filter(options.Filter). + Language(options.DefaultLanguage). + LanguageField(options.LanguageField). + Score(options.Score). + ScoreField(options.ScoreField). + PayloadField(options.PayloadField)) + // in go-reids, FTCreateOptions.MaxTextFields should be bool, not int + if options.MaxTextFields > 0 { + _cmd = cmds.Incomplete(cmds.FtCreateIndex(_cmd).Maxtextfields()) + } + if options.NoOffsets { + _cmd = cmds.Incomplete(cmds.FtCreateIndex(_cmd).Nooffsets()) + } + _cmd = cmds.Incomplete(cmds.FtCreateIndex(_cmd).Temporary(float64(options.Temporary))) + if options.NoHL { + _cmd = cmds.Incomplete(cmds.FtCreateIndex(_cmd).Nohl()) + } + if options.NoFields { + _cmd = cmds.Incomplete(cmds.FtCreateIndex(_cmd).Nofields()) + } + if options.NoFreqs { + _cmd = cmds.Incomplete(cmds.FtCreateIndex(_cmd).Nofreqs()) + } + _cmd = cmds.Incomplete(cmds.FtCreateIndex(_cmd).Stopwords(int64(len(options.StopWords))).Stopword(argsToSlice(options.StopWords)...)) + if options.SkipInitialScan { + _cmd = cmds.Incomplete(cmds.FtCreateIndex(_cmd).Skipinitialscan()) + } + // schema + // if (len(schema) != 1) { + // panic("can only have one FieldSchema") + // } + _cmd = cmds.Incomplete(cmds.FtCreateIndex(_cmd).Schema()) + for _, sc := range schema { + _cmd = cmds.Incomplete(cmds.FtCreateSchema(_cmd).FieldName(sc.FieldName).As(sc.As)) + switch sc.FieldType { + case SearchFieldTypeGeo: + _cmd = cmds.Incomplete(cmds.FtCreateFieldAs(_cmd).Geo()) + case SearchFieldTypeGeoShape: + _cmd = cmds.Incomplete(cmds.FtCreateFieldAs(_cmd).Geoshape()) + case SearchFieldTypeNumeric: + _cmd = cmds.Incomplete(cmds.FtCreateFieldAs(_cmd).Numeric()) + case SearchFieldTypeTag: + case SearchFieldTypeText: + _cmd = cmds.Incomplete(cmds.FtCreateFieldAs(_cmd).Tag()) + case SearchFieldTypeVector: + // FIXME: implement this + break + // if (sc.VectorArgs.FlatOptions == sc.VectorArgs.HNSWOptions) { + // panic("Vector index algorithm should be either FLAT or HNSW") + // } + // if (sc.VectorArgs.FlatOptions!= nil) { + // // (algo string, nargs int64, args ...string) + // _cmd = cmds.Incomplete(cmds.FtCreateFieldAs(_cmd).Vector("FLAT",sc.VectorArgs.FlatOptions.)) + // } else { + + // } + default: + panic(fmt.Sprintf("unexpected SearchFieldType: %s", sc.FieldType.String())) + } + } + // FIXME: handle index properly + cmd := cmds.FtCreateSkipinitialscan(_cmd).Schema().FieldName("xx").Geo().Build() + return newStatusCmd(c.client.Do(ctx, cmd)) } -func (c *Compat) FTCursorDel(ctx context.Context, index string, cursorId int) *StatusCmd { return nil } + +func (c *Compat) FTCursorDel(ctx context.Context, index string, cursorId int) *StatusCmd { + cmd := c.client.B().FtCursorDel().Index(index).CursorId(int64(cursorId)).Build() + return newStatusCmd(c.client.Do(ctx, cmd)) +} + func (c *Compat) FTCursorRead(ctx context.Context, index string, cursorId int, count int) *MapStringInterfaceCmd { - return nil + cmd := c.client.B().FtCursorRead().Index(index).CursorId(int64(cursorId)).Count(int64(count)).Build() + return newMapStringInterfaceCmd(c.client.Do(ctx, cmd)) +} + +func (c *Compat) FTDictAdd(ctx context.Context, dict string, term ...interface{}) *IntCmd { + cmd := c.client.B().FtDictadd().Dict(dict).Term(argsToSlice(term)...).Build() + return newIntCmd(c.client.Do(ctx, cmd)) +} + +func (c *Compat) FTDictDel(ctx context.Context, dict string, term ...interface{}) *IntCmd { + cmd := c.client.B().FtDictdel().Dict(dict).Term(argsToSlice(term)...).Build() + return newIntCmd(c.client.Do(ctx, cmd)) +} + +func (c *Compat) FTDictDump(ctx context.Context, dict string) *StringSliceCmd { + cmd := c.client.B().FtDictdump().Dict(dict).Build() + return newStringSliceCmd(c.client.Do(ctx, cmd)) } -func (c *Compat) FTDictAdd(ctx context.Context, dict string, term ...interface{}) *IntCmd { return nil } -func (c *Compat) FTDictDel(ctx context.Context, dict string, term ...interface{}) *IntCmd { return nil } -func (c *Compat) FTDictDump(ctx context.Context, dict string) *StringSliceCmd { return nil } -func (c *Compat) FTDropIndex(ctx context.Context, index string) *StatusCmd { return nil } + +func (c *Compat) FTDropIndex(ctx context.Context, index string) *StatusCmd { + cmd := c.client.B().FtDropindex().Index(index).Build() + return newStatusCmd(c.client.Do(ctx, cmd)) +} + func (c *Compat) FTDropIndexWithArgs(ctx context.Context, index string, options *FTDropIndexOptions) *StatusCmd { - return nil + _cmd := cmds.Incomplete(c.client.B().FtDropindex().Index(index)) + if options.DeleteDocs { + _cmd = cmds.Incomplete(cmds.FtDropindexIndex(_cmd).Dd()) + } + cmd := cmds.FtDropindexIndex(_cmd).Build() + return newStatusCmd(c.client.Do(ctx, cmd)) } -func (c *Compat) FTExplain(ctx context.Context, index string, query string) *StringCmd { return nil } + +func (c *Compat) FTExplain(ctx context.Context, index string, query string) *StringCmd { + cmd := c.client.B().FtExplain().Index(index).Query(query).Build() + return newStringCmd(c.client.Do(ctx, cmd)) +} + func (c *Compat) FTExplainWithArgs(ctx context.Context, index string, query string, options *FTExplainOptions) *StringCmd { - return nil + _cmd := cmds.Incomplete(c.client.B().FtExplain().Index(index).Query(query)) + if options != nil { + dialectVersion, err := strconv.ParseInt(options.Dialect, 10, 64) + if err != nil { + panic(fmt.Errorf("failed to parse dialect version: %v", err)) + } + _cmd = cmds.Incomplete(cmds.FtExplainQuery(_cmd).Dialect(dialectVersion)) + } + cmd := cmds.FtExplainQuery(_cmd).Build() + return newStringCmd(c.client.Do(ctx, cmd)) } + func (c *Compat) FTInfo(ctx context.Context, index string) *FTInfoCmd { return nil } func (c *Compat) FTSpellCheck(ctx context.Context, index string, query string) *FTSpellCheckCmd { return nil diff --git a/rueidiscompat/command.go b/rueidiscompat/command.go index 6e60dfbb..da3a2a59 100644 --- a/rueidiscompat/command.go +++ b/rueidiscompat/command.go @@ -3452,6 +3452,10 @@ type AggregateCmd struct { baseCmd[FTAggregateResult] } +func newAggregateCmd(res rueidis.RedisResult) *AggregateCmd { + return nil +} + func (cmd *AggregateCmd) from(res rueidis.RedisResult) { } @@ -3634,8 +3638,13 @@ type FTSearchSortBy struct { Desc bool } -type FTDropIndexOptions struct{} -type FTExplainOptions struct{} +type FTDropIndexOptions struct { + DeleteDocs bool +} + +type FTExplainOptions struct { + Dialect string +} type IndexErrors struct { IndexingFailures int From f1521877c801be0a1041a19e4e346eeea3c4e630 Mon Sep 17 00:00:00 2001 From: Eric Chang Date: Sun, 10 Nov 2024 12:59:54 +0800 Subject: [PATCH 12/49] wip: FT_SEARCH: filter --- rueidiscompat/adapter.go | 113 +++++++++++++++++++++++++++++++++++++-- 1 file changed, 108 insertions(+), 5 deletions(-) diff --git a/rueidiscompat/adapter.go b/rueidiscompat/adapter.go index e7f737db..35135f94 100644 --- a/rueidiscompat/adapter.go +++ b/rueidiscompat/adapter.go @@ -5141,17 +5141,120 @@ func (c *Compat) FTExplainWithArgs(ctx context.Context, index string, query stri return newStringCmd(c.client.Do(ctx, cmd)) } -func (c *Compat) FTInfo(ctx context.Context, index string) *FTInfoCmd { return nil } +func (c *Compat) FTInfo(ctx context.Context, index string) *FTInfoCmd { + cmd := c.client.B().FtInfo().Index(index).Build() + return newFTInfoCmd(c.client.Do(ctx, cmd)) +} + func (c *Compat) FTSpellCheck(ctx context.Context, index string, query string) *FTSpellCheckCmd { - return nil + cmd := c.client.B().FtSpellcheck().Index(index).Query(query).Build() + return newFTSpellCheckCmd(c.client.Do(ctx, cmd)) } + func (c *Compat) FTSpellCheckWithArgs(ctx context.Context, index string, query string, options *FTSpellCheckOptions) *FTSpellCheckCmd { - return nil -} -func (c *Compat) FTSearch(ctx context.Context, index string, query string) *FTSearchCmd { return nil } + _cmd := cmds.Incomplete(c.client.B().FtSpellcheck().Index(index).Query(query)) + _cmd = cmds.Incomplete(cmds.FtSpellcheckQuery(_cmd).Distance(int64(options.Distance))) + if options.Terms != nil { + if options.Terms.Inclusion != "INCLUDE" || options.Terms.Inclusion != "EXCLUDE" { + panic("Inclusion should be either INCLUDE or EXCLUDE") + } + if options.Terms.Inclusion == "INCLUDE" { + _cmd = cmds.Incomplete(cmds.FtSpellcheckQuery(_cmd).TermsInclude().Dictionary(options.Terms.Dictionary).Terms(argsToSlice(options.Terms.Terms)...)) + } else { + _cmd = cmds.Incomplete(cmds.FtSpellcheckQuery(_cmd).TermsExclude().Dictionary(options.Terms.Dictionary).Terms(argsToSlice(options.Terms.Terms)...)) + } + } + cmd := cmds.FtSpellcheckQuery(_cmd).Dialect(int64(options.Dialect)).Build() + return newFTSpellCheckCmd(c.client.Do(ctx, cmd)) +} + +func (c *Compat) FTSearch(ctx context.Context, index string, query string) *FTSearchCmd { + cmd := c.client.B().FtSearch().Index(index).Query(query).Build() + return newFTSearchCmd(c.client.Do(ctx, cmd)) +} + +// type FTSearchOptions struct { +// NoContent bool +// Verbatim bool +// NoStopWords bool +// WithScores bool +// WithPayloads bool +// WithSortKeys bool +// Filters []FTSearchFilter +// GeoFilter []FTSearchGeoFilter +// InKeys []interface{} +// InFields []interface{} +// Return []FTSearchReturn +// Slop int +// Timeout int +// InOrder bool +// Language string +// Expander string +// Scorer string +// ExplainScore bool +// Payload string +// SortBy []FTSearchSortBy +// SortByWithCount bool +// LimitOffset int +// Limit int +// Params map[string]interface{} +// DialectVersion int +// } func (c *Compat) FTSearchWithArgs(ctx context.Context, index string, query string, options *FTSearchOptions) *FTSearchCmd { + _cmd := cmds.Incomplete(c.client.B().FtSearch().Index(index).Query(query)) + // NoContent bool + if options == nil { + panic("options can not be nil") + } + if options.NoContent { + _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Nocontent()) + } + // Verbatim bool + if options.Verbatim { + _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Verbatim()) + } + // NoStopWords bool + if options.NoStopWords { + _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Nostopwords()) + } + // WithScores bool + if options.WithScores { + _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Withscores()) + } + // WithPayloads bool + if options.WithPayloads { + _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Withpayloads()) + } + // WithSortKeys bool + if options.WithSortKeys { + _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Withsortkeys()) + } + // Filters []FTSearchFilter + for _, filter := range options.Filters { + // _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Filter(options.)) + } + // GeoFilter []FTSearchGeoFilter + // InKeys []interface{} + // InFields []interface{} + // Return []FTSearchReturn + // Slop int + // Timeout int + // InOrder bool + // Language string + // Expander string + // Scorer string + // ExplainScore bool + // Payload string + // SortBy []FTSearchSortBy + // SortByWithCount bool + // LimitOffset int + // Limit int + // Params map[string]interface{} + // DialectVersion int + return newFTSearchCmd(c.client.Do(ctx, cmd)) return nil } + func (c *Compat) FTSynDump(ctx context.Context, index string) *FTSynDumpCmd { return nil } func (c *Compat) FTSynUpdate(ctx context.Context, index string, synGroupId interface{}, terms []interface{}) *StatusCmd { return nil From 3dd39d77b63d6c997076d96f32fa41c68465bf24 Mon Sep 17 00:00:00 2001 From: Eric Chang Date: Sun, 10 Nov 2024 19:46:14 +0800 Subject: [PATCH 13/49] feat: FT_SEARCH: add WITHCOUNT option --- hack/cmds/commands_search.json | 6 +++++ internal/cmds/gen_search.go | 37 ++++++++++++++++++++++++++++ internal/cmds/gen_search_test.go | 42 ++++++++++++++++++-------------- 3 files changed, 67 insertions(+), 18 deletions(-) diff --git a/hack/cmds/commands_search.json b/hack/cmds/commands_search.json index cf391184..6d62890f 100644 --- a/hack/cmds/commands_search.json +++ b/hack/cmds/commands_search.json @@ -999,6 +999,12 @@ "type": "enum", "optional": true, "enum": ["ASC", "DESC"] + }, + { + "name": "withcount", + "type": "enum", + "optional": true, + "enum": ["WITHCOUNT"] } ] }, diff --git a/internal/cmds/gen_search.go b/internal/cmds/gen_search.go index 9bc4a6d1..633b6df3 100644 --- a/internal/cmds/gen_search.go +++ b/internal/cmds/gen_search.go @@ -5894,6 +5894,11 @@ func (c FtSearchSlop) Build() Completed { type FtSearchSortbyOrderAsc Incomplete +func (c FtSearchSortbyOrderAsc) Withcount() FtSearchSortbyWithcount { + c.cs.s = append(c.cs.s, "WITHCOUNT") + return (FtSearchSortbyWithcount)(c) +} + func (c FtSearchSortbyOrderAsc) Limit() FtSearchLimitLimit { c.cs.s = append(c.cs.s, "LIMIT") return (FtSearchLimitLimit)(c) @@ -5916,6 +5921,11 @@ func (c FtSearchSortbyOrderAsc) Build() Completed { type FtSearchSortbyOrderDesc Incomplete +func (c FtSearchSortbyOrderDesc) Withcount() FtSearchSortbyWithcount { + c.cs.s = append(c.cs.s, "WITHCOUNT") + return (FtSearchSortbyWithcount)(c) +} + func (c FtSearchSortbyOrderDesc) Limit() FtSearchLimitLimit { c.cs.s = append(c.cs.s, "LIMIT") return (FtSearchLimitLimit)(c) @@ -5948,6 +5958,11 @@ func (c FtSearchSortbySortby) Desc() FtSearchSortbyOrderDesc { return (FtSearchSortbyOrderDesc)(c) } +func (c FtSearchSortbySortby) Withcount() FtSearchSortbyWithcount { + c.cs.s = append(c.cs.s, "WITHCOUNT") + return (FtSearchSortbyWithcount)(c) +} + func (c FtSearchSortbySortby) Limit() FtSearchLimitLimit { c.cs.s = append(c.cs.s, "LIMIT") return (FtSearchLimitLimit)(c) @@ -5968,6 +5983,28 @@ func (c FtSearchSortbySortby) Build() Completed { return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks} } +type FtSearchSortbyWithcount Incomplete + +func (c FtSearchSortbyWithcount) Limit() FtSearchLimitLimit { + c.cs.s = append(c.cs.s, "LIMIT") + return (FtSearchLimitLimit)(c) +} + +func (c FtSearchSortbyWithcount) Params() FtSearchParamsParams { + c.cs.s = append(c.cs.s, "PARAMS") + return (FtSearchParamsParams)(c) +} + +func (c FtSearchSortbyWithcount) Dialect(dialect int64) FtSearchDialect { + c.cs.s = append(c.cs.s, "DIALECT", strconv.FormatInt(dialect, 10)) + return (FtSearchDialect)(c) +} + +func (c FtSearchSortbyWithcount) Build() Completed { + c.cs.Build() + return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks} +} + type FtSearchSummarizeFieldsField Incomplete func (c FtSearchSummarizeFieldsField) Field(field ...string) FtSearchSummarizeFieldsField { diff --git a/internal/cmds/gen_search_test.go b/internal/cmds/gen_search_test.go index be4a74b6..a2be4025 100644 --- a/internal/cmds/gen_search_test.go +++ b/internal/cmds/gen_search_test.go @@ -515,20 +515,26 @@ func search4(s Builder) { s.FtProfile().Index("1").Search().Query("1").Build() s.FtProfile().Index("1").Aggregate().Limited().Query("1").Build() s.FtProfile().Index("1").Aggregate().Query("1").Build() - s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Expander("1").Scorer("1").Explainscore().Payload("1").Sortby("1").Asc().Limit().OffsetNum(1, 1).Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Dialect(1).Build() - s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Expander("1").Scorer("1").Explainscore().Payload("1").Sortby("1").Asc().Limit().OffsetNum(1, 1).Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() + s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Expander("1").Scorer("1").Explainscore().Payload("1").Sortby("1").Asc().Withcount().Limit().OffsetNum(1, 1).Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Dialect(1).Build() + s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Expander("1").Scorer("1").Explainscore().Payload("1").Sortby("1").Asc().Withcount().Limit().OffsetNum(1, 1).Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() } func search5(s Builder) { - s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Expander("1").Scorer("1").Explainscore().Payload("1").Sortby("1").Asc().Limit().OffsetNum(1, 1).Dialect(1).Build() + s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Expander("1").Scorer("1").Explainscore().Payload("1").Sortby("1").Asc().Withcount().Limit().OffsetNum(1, 1).Dialect(1).Build() + s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Expander("1").Scorer("1").Explainscore().Payload("1").Sortby("1").Asc().Withcount().Limit().OffsetNum(1, 1).Build() + s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Expander("1").Scorer("1").Explainscore().Payload("1").Sortby("1").Asc().Withcount().Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() + s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Expander("1").Scorer("1").Explainscore().Payload("1").Sortby("1").Asc().Withcount().Dialect(1).Build() + s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Expander("1").Scorer("1").Explainscore().Payload("1").Sortby("1").Asc().Withcount().Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Expander("1").Scorer("1").Explainscore().Payload("1").Sortby("1").Asc().Limit().OffsetNum(1, 1).Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Expander("1").Scorer("1").Explainscore().Payload("1").Sortby("1").Asc().Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Expander("1").Scorer("1").Explainscore().Payload("1").Sortby("1").Asc().Dialect(1).Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Expander("1").Scorer("1").Explainscore().Payload("1").Sortby("1").Asc().Build() + s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Expander("1").Scorer("1").Explainscore().Payload("1").Sortby("1").Desc().Withcount().Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Expander("1").Scorer("1").Explainscore().Payload("1").Sortby("1").Desc().Limit().OffsetNum(1, 1).Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Expander("1").Scorer("1").Explainscore().Payload("1").Sortby("1").Desc().Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Expander("1").Scorer("1").Explainscore().Payload("1").Sortby("1").Desc().Dialect(1).Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Expander("1").Scorer("1").Explainscore().Payload("1").Sortby("1").Desc().Build() + s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Expander("1").Scorer("1").Explainscore().Payload("1").Sortby("1").Withcount().Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Expander("1").Scorer("1").Explainscore().Payload("1").Sortby("1").Limit().OffsetNum(1, 1).Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Expander("1").Scorer("1").Explainscore().Payload("1").Sortby("1").Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Expander("1").Scorer("1").Explainscore().Payload("1").Sortby("1").Dialect(1).Build() @@ -614,15 +620,15 @@ func search5(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Explainscore().Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Payload("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Sortby("1").Build() +} + +func search6(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Limit().OffsetNum(1, 1).Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Dialect(1).Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Tags().OpenClose("1", "1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Slop(1).Build() -} - -func search6(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Timeout(1).Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Inorder().Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Language("1").Build() @@ -717,15 +723,15 @@ func search6(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Language("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Expander("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Scorer("1").Build() +} + +func search7(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Explainscore().Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Payload("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Sortby("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Limit().OffsetNum(1, 1).Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Dialect(1).Build() -} - -func search7(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").Identifier("1").Summarize().Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").Identifier("1").Highlight().Build() @@ -820,15 +826,15 @@ func search7(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).Mi().Expander("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).Mi().Scorer("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).Mi().Explainscore().Build() +} + +func search8(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).Mi().Payload("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).Mi().Sortby("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).Mi().Limit().OffsetNum(1, 1).Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).Mi().Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).Mi().Dialect(1).Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).Mi().Build() -} - -func search8(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).Ft().Inkeys("1").Key("1").Key("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).Ft().Infields("1").Field("1").Field("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).Ft().Return("1").Identifier("1").Build() @@ -923,15 +929,15 @@ func search8(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Sortby("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Limit().OffsetNum(1, 1).Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() +} + +func search9(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Dialect(1).Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withpayloads().Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withsortkeys().Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Filter("1").Min(1).Max(1).Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Build() -} - -func search9(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Inkeys("1").Key("1").Key("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Infields("1").Field("1").Field("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Return("1").Identifier("1").Build() @@ -1026,15 +1032,15 @@ func search9(s Builder) { s.FtSpellcheck().Index("1").Query("1").Distance(1).TermsInclude().Dictionary("1").Terms("1").Terms("1").Build() s.FtSpellcheck().Index("1").Query("1").Distance(1).TermsInclude().Dictionary("1").Dialect(1).Build() s.FtSpellcheck().Index("1").Query("1").Distance(1).TermsInclude().Dictionary("1").Build() +} + +func search10(s Builder) { s.FtSpellcheck().Index("1").Query("1").Distance(1).TermsExclude().Dictionary("1").Build() s.FtSpellcheck().Index("1").Query("1").Distance(1).Dialect(1).Build() s.FtSpellcheck().Index("1").Query("1").Distance(1).Build() s.FtSpellcheck().Index("1").Query("1").TermsInclude().Dictionary("1").Build() s.FtSpellcheck().Index("1").Query("1").TermsExclude().Dictionary("1").Build() s.FtSpellcheck().Index("1").Query("1").Dialect(1).Build() -} - -func search10(s Builder) { s.FtSpellcheck().Index("1").Query("1").Build() s.FtSyndump().Index("1").Build() s.FtSynupdate().Index("1").SynonymGroupId("1").Skipinitialscan().Term("1").Term("1").Build() From fb2a44a803efc84d573a84e79ae4ca79daf927a7 Mon Sep 17 00:00:00 2001 From: Eric Chang Date: Sun, 10 Nov 2024 19:53:09 +0800 Subject: [PATCH 14/49] feat: FT_SEARCH --- rueidiscompat/adapter.go | 137 +++++++++++++++++++++++++-------------- 1 file changed, 89 insertions(+), 48 deletions(-) diff --git a/rueidiscompat/adapter.go b/rueidiscompat/adapter.go index 35135f94..029dd44b 100644 --- a/rueidiscompat/adapter.go +++ b/rueidiscompat/adapter.go @@ -5173,33 +5173,6 @@ func (c *Compat) FTSearch(ctx context.Context, index string, query string) *FTSe return newFTSearchCmd(c.client.Do(ctx, cmd)) } -// type FTSearchOptions struct { -// NoContent bool -// Verbatim bool -// NoStopWords bool -// WithScores bool -// WithPayloads bool -// WithSortKeys bool -// Filters []FTSearchFilter -// GeoFilter []FTSearchGeoFilter -// InKeys []interface{} -// InFields []interface{} -// Return []FTSearchReturn -// Slop int -// Timeout int -// InOrder bool -// Language string -// Expander string -// Scorer string -// ExplainScore bool -// Payload string -// SortBy []FTSearchSortBy -// SortByWithCount bool -// LimitOffset int -// Limit int -// Params map[string]interface{} -// DialectVersion int -// } func (c *Compat) FTSearchWithArgs(ctx context.Context, index string, query string, options *FTSearchOptions) *FTSearchCmd { _cmd := cmds.Incomplete(c.client.B().FtSearch().Index(index).Query(query)) // NoContent bool @@ -5231,28 +5204,96 @@ func (c *Compat) FTSearchWithArgs(ctx context.Context, index string, query strin } // Filters []FTSearchFilter for _, filter := range options.Filters { - // _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Filter(options.)) - } - // GeoFilter []FTSearchGeoFilter - // InKeys []interface{} - // InFields []interface{} - // Return []FTSearchReturn - // Slop int - // Timeout int - // InOrder bool - // Language string - // Expander string - // Scorer string - // ExplainScore bool - // Payload string - // SortBy []FTSearchSortBy - // SortByWithCount bool - // LimitOffset int - // Limit int - // Params map[string]interface{} - // DialectVersion int + min, err := strconv.ParseFloat(str(filter.Min), 64) + if err != nil { + panic(fmt.Sprintf("failed to parse min %v to float64", filter.Min)) + } + max, err := strconv.ParseFloat(str(filter.Max), 64) + if err != nil { + panic(fmt.Sprintf("failed to parse max %v to float64", filter.Max)) + } + _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Filter(str(filter.FieldName)).Min(min).Max(max)) + } + // GEOFILTER + for _, filter := range options.GeoFilter { + _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Geofilter(filter.FieldName).Lon(filter.Longitude).Lat(filter.Latitude).Radius(filter.Radius)) + switch filter.Unit { + case "m": + _cmd = cmds.Incomplete(cmds.FtSearchGeoFilterRadius(_cmd).M()) + case "km": + _cmd = cmds.Incomplete(cmds.FtSearchGeoFilterRadius(_cmd).M()) + case "mi": + _cmd = cmds.Incomplete(cmds.FtSearchGeoFilterRadius(_cmd).Mi()) + case "ft": + _cmd = cmds.Incomplete(cmds.FtSearchGeoFilterRadius(_cmd).Ft()) + default: + panic(fmt.Sprint("invalid unit, want m | km | mi | ft, got %v", filter.Unit)) + } + } + // [INKEYS count key [key ...]] + _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Inkeys(str(len(options.InKeys))).Key(argsToSlice(options.InKeys)...)) + // [ INFIELDS count field [field ...]] + _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Infields(str(len(options.InKeys))).Field(argsToSlice(options.InFields)...)) + // [RETURN count identifier [AS property] [ identifier [AS property] ...]] + _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Return(str(len(options.Return)))) + for _, re := range options.Return { + _cmd = cmds.Incomplete(cmds.FtSearchReturnReturn(_cmd).Identifier(re.FieldName).As(re.As)) + } + // NOTE: go-redis doesn't implement SUMMARIZE option + // [SUMMARIZE [ FIELDS count field [field ...]] [FRAGS num] [LEN fragsize] [SEPARATOR separator]] + // [SLOP slop] + _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Slop(int64(options.Slop))) + // [TIMEOUT timeout] + _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Timeout(int64(options.Timeout))) + // [INORDER] + if options.InOrder { + _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Inorder()) + } + // [LANGUAGE language] + _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Language(options.Language)) + // [EXPANDER expander] + _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Expander(options.Expander)) + // [SCORER scorer] + _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Scorer(options.Scorer)) + // [EXPLAINSCORE] + if options.ExplainScore { + _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Explainscore()) + } + // [PAYLOAD payload] + _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Payload(options.Payload)) + // [SORTBY sortby [ ASC | DESC] [WITHCOUNT]] + if len(options.SortBy) != 1 { + panic(fmt.Sprintf("options.SortBy can only have 1 element, got %v", len(options.SortBy))) + } + sortBy := options.SortBy[0] + _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Sortby(sortBy.FieldName)) + if sortBy.Asc == sortBy.Desc && sortBy.Asc { + panic("options.SortBy[0] should specify either ASC or DESC") + } + if sortBy.Asc { + _cmd = cmds.Incomplete(cmds.FtSearchSortbySortby(_cmd).Asc()) + } else { + _cmd = cmds.Incomplete(cmds.FtSearchSortbySortby(_cmd).Desc()) + } + // WITHCOUNT + if options.SortByWithCount { + _cmd = cmds.Incomplete(cmds.FtSearchSortbySortby(_cmd).Withcount()) + } + // [LIMIT offset num] + _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Limit().OffsetNum(int64(options.Limit), int64(options.LimitOffset))) + // [PARAMS nargs name value [ name value ...]] + if options.Params != nil { + _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Params().Nargs(int64(len(options.Params)))) + for name, val := range options.Params { + _cmd = cmds.Incomplete(cmds.FtSearchParamsNargs(_cmd).NameValue().NameValue(name, str(val))) + } + } + // [DIALECT dialect] + if options.DialectVersion > 0 { + _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Dialect(int64(options.DialectVersion))) + } + cmd := cmds.FtSearchQuery(_cmd).Build() return newFTSearchCmd(c.client.Do(ctx, cmd)) - return nil } func (c *Compat) FTSynDump(ctx context.Context, index string) *FTSynDumpCmd { return nil } From 8696ed17badc81e6f977075cf3a8b7144eea6dbe Mon Sep 17 00:00:00 2001 From: Eric Chang Date: Wed, 13 Nov 2024 21:02:46 +0800 Subject: [PATCH 15/49] feat(rueidiscompat/SearchCmdable): done --- rueidiscompat/adapter.go | 4 +- rueidiscompat/adapter_test.go | 105 +++++++++++---------- rueidiscompat/command.go | 13 ++- rueidiscompat/pipeline.go | 167 ++++++++++++++++++++++++++++++++++ 4 files changed, 232 insertions(+), 57 deletions(-) diff --git a/rueidiscompat/adapter.go b/rueidiscompat/adapter.go index 029dd44b..1e74f112 100644 --- a/rueidiscompat/adapter.go +++ b/rueidiscompat/adapter.go @@ -5155,7 +5155,7 @@ func (c *Compat) FTSpellCheckWithArgs(ctx context.Context, index string, query s _cmd := cmds.Incomplete(c.client.B().FtSpellcheck().Index(index).Query(query)) _cmd = cmds.Incomplete(cmds.FtSpellcheckQuery(_cmd).Distance(int64(options.Distance))) if options.Terms != nil { - if options.Terms.Inclusion != "INCLUDE" || options.Terms.Inclusion != "EXCLUDE" { + if options.Terms.Inclusion != "INCLUDE" && options.Terms.Inclusion != "EXCLUDE" { panic("Inclusion should be either INCLUDE or EXCLUDE") } if options.Terms.Inclusion == "INCLUDE" { @@ -5227,7 +5227,7 @@ func (c *Compat) FTSearchWithArgs(ctx context.Context, index string, query strin case "ft": _cmd = cmds.Incomplete(cmds.FtSearchGeoFilterRadius(_cmd).Ft()) default: - panic(fmt.Sprint("invalid unit, want m | km | mi | ft, got %v", filter.Unit)) + panic(fmt.Sprintf("invalid unit, want m | km | mi | ft, got %v", filter.Unit)) } } // [INKEYS count key [key ...]] diff --git a/rueidiscompat/adapter_test.go b/rueidiscompat/adapter_test.go index 3e9c02c0..36c38031 100644 --- a/rueidiscompat/adapter_test.go +++ b/rueidiscompat/adapter_test.go @@ -36,7 +36,6 @@ import ( "testing" "time" - "github.com/go-redis/redis" . "github.com/onsi/ginkgo/v2" . "github.com/onsi/gomega" @@ -11561,7 +11560,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "txt", &FTCreateOptions{}, &FieldSchema{FieldName: "txt", FieldType: SearchFieldTypeText}).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "txt") + WaitForIndexing(clientresp2, "txt", 2) adapter.HSet(ctx, "doc1", "txt", "foo baz") adapter.HSet(ctx, "doc2", "txt", "foo bar") res, err := adapter.FTSearchWithArgs(ctx, "txt", "foo ~bar", &FTSearchOptions{WithScores: true}).Result() @@ -11578,7 +11577,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "txt", &FTCreateOptions{StopWords: []interface{}{"foo", "bar", "baz"}}, &FieldSchema{FieldName: "txt", FieldType: SearchFieldTypeText}).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "txt") + WaitForIndexing(clientresp2, "txt", 2) adapter.HSet(ctx, "doc1", "txt", "foo baz") adapter.HSet(ctx, "doc2", "txt", "hello world") res1, err := adapter.FTSearchWithArgs(ctx, "txt", "foo bar", &FTSearchOptions{NoContent: true}).Result() @@ -11593,7 +11592,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "txt", &FTCreateOptions{}, &FieldSchema{FieldName: "txt", FieldType: SearchFieldTypeText}, &FieldSchema{FieldName: "num", FieldType: SearchFieldTypeNumeric}, &FieldSchema{FieldName: "loc", FieldType: SearchFieldTypeGeo}).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "txt") + WaitForIndexing(clientresp2, "txt", 2) adapter.HSet(ctx, "doc1", "txt", "foo bar", "num", 3.141, "loc", "-0.441,51.458") adapter.HSet(ctx, "doc2", "txt", "foo baz", "num", 2, "loc", "-0.1,51.2") res1, err := adapter.FTSearchWithArgs(ctx, "txt", "foo", &FTSearchOptions{Filters: []FTSearchFilter{{FieldName: "num", Min: 0, Max: 2}}, NoContent: true}).Result() @@ -11624,7 +11623,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "num", &FTCreateOptions{}, &FieldSchema{FieldName: "txt", FieldType: SearchFieldTypeText}, &FieldSchema{FieldName: "num", FieldType: SearchFieldTypeNumeric, Sortable: true}).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "num") + WaitForIndexing(clientresp2, "num", 2) adapter.HSet(ctx, "doc1", "txt", "foo bar", "num", 1) adapter.HSet(ctx, "doc2", "txt", "foo baz", "num", 2) adapter.HSet(ctx, "doc3", "txt", "foo qux", "num", 3) @@ -11651,7 +11650,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "txt", &FTCreateOptions{}, &FieldSchema{FieldName: "title", FieldType: SearchFieldTypeText, Weight: 5}, &FieldSchema{FieldName: "body", FieldType: SearchFieldTypeText}).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "txt") + WaitForIndexing(clientresp2, "txt", 2) adapter.HSet(ctx, "doc1", "title", "RediSearch", "body", "Redisearch impements a search engine on top of redis") res1, err := adapter.FTSearchWithArgs(ctx, "txt", "search engine", &FTSearchOptions{NoContent: true, Verbatim: true, LimitOffset: 0, Limit: 5}).Result() Expect(err).NotTo(HaveOccurred()) @@ -11668,7 +11667,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx", &FTCreateOptions{}, text1, text2, num, geo, tag).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "idx") + WaitForIndexing(clientresp2, "idx", 2) adapter.HSet(ctx, "doc1", "field", "aaa", "text", "1", "numeric", 1, "geo", "1,1", "tag", "1") adapter.HSet(ctx, "doc2", "field", "aab", "text", "2", "numeric", 2, "geo", "2,2", "tag", "2") res1, err := adapter.FTSearch(ctx, "idx", "@text:aa*").Result() @@ -11704,7 +11703,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "txt", &FTCreateOptions{}, text1, text2, text3).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "txt") + WaitForIndexing(clientresp2, "txt", 2) res1, err := adapter.FTExplain(ctx, "txt", "@f3:f3_val @f2:f2_val @f1:f1_val").Result() Expect(err).NotTo(HaveOccurred()) Expect(res1).ToNot(BeEmpty()) @@ -11717,11 +11716,11 @@ func testAdapterCache(resp3 bool) { val1, err := adapter.FTCreate(ctx, "testAlias", &FTCreateOptions{Prefix: []interface{}{"index1:"}}, text1).Result() Expect(err).NotTo(HaveOccurred()) Expect(val1).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "testAlias") + WaitForIndexing(clientresp2, "testAlias", 2) val2, err := adapter.FTCreate(ctx, "testAlias2", &FTCreateOptions{Prefix: []interface{}{"index2:"}}, text2).Result() Expect(err).NotTo(HaveOccurred()) Expect(val2).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "testAlias2") + WaitForIndexing(clientresp2, "testAlias2", 2) adapter.HSet(ctx, "index1:lonestar", "name", "lonestar") adapter.HSet(ctx, "index2:yogurt", "name", "yogurt") @@ -11756,7 +11755,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, &FieldSchema{FieldName: "txt", FieldType: SearchFieldTypeText, Sortable: true, NoStem: true}).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "idx1") + WaitForIndexing(clientresp2, "idx1", 2) resInfo, err := adapter.FTInfo(ctx, "idx1").Result() Expect(err).NotTo(HaveOccurred()) @@ -11769,7 +11768,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, &FieldSchema{FieldName: "txt", FieldType: SearchFieldTypeText}).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "idx1") + WaitForIndexing(clientresp2, "idx1", 2) resAlter, err := adapter.FTAlter(ctx, "idx1", false, []interface{}{"body", SearchFieldTypeText.String()}).Result() Expect(err).NotTo(HaveOccurred()) @@ -11788,7 +11787,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, text1, text2).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "idx1") + WaitForIndexing(clientresp2, "idx1", 2) adapter.HSet(ctx, "doc1", "f1", "some valid content", "f2", "this is sample text") adapter.HSet(ctx, "doc2", "f1", "very important", "f2", "lorem ipsum") @@ -11835,7 +11834,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, text1, text2).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "idx1") + WaitForIndexing(clientresp2, "idx1", 2) resDictAdd, err := adapter.FTDictAdd(ctx, "custom_dict", "item1", "item2", "item3").Result() Expect(err).NotTo(HaveOccurred()) @@ -11859,7 +11858,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, text1).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "idx1") + WaitForIndexing(clientresp2, "idx1", 2) adapter.HSet(ctx, "doc1", "name", "Jon") adapter.HSet(ctx, "doc2", "name", "John") @@ -11874,7 +11873,7 @@ func testAdapterCache(resp3 bool) { val2, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, text2).Result() Expect(err).NotTo(HaveOccurred()) Expect(val2).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "idx1") + WaitForIndexing(clientresp2, "idx1", 2) adapter.HSet(ctx, "doc1", "name", "Jon") adapter.HSet(ctx, "doc2", "name", "John") @@ -11892,7 +11891,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, text1).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "idx1") + WaitForIndexing(clientresp2, "idx1", 2) adapter.HSet(ctx, "doc1", "description", "The quick brown fox jumps over the lazy dog") adapter.HSet(ctx, "doc2", "description", "Quick alice was beginning to get very tired of sitting by her quick sister on the bank, and of having nothing to do.") @@ -11949,7 +11948,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, text1, text2, text3, num).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "idx1") + WaitForIndexing(clientresp2, "idx1", 2) adapter.HSet(ctx, "search", "title", "RediSearch", "body", "Redisearch impements a search engine on top of redis", @@ -12053,7 +12052,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, text1, text2).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "idx1") + WaitForIndexing(clientresp2, "idx1", 2) adapter.HSet(ctx, "doc1", "t1", "a", "t2", "b") adapter.HSet(ctx, "doc2", "t1", "b", "t2", "a") @@ -12089,7 +12088,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, text1, text2).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "idx1") + WaitForIndexing(clientresp2, "idx1", 2) adapter.HSet(ctx, "doc1", "t1", "hello", "t2", "world") @@ -12116,7 +12115,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, text1, num1).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "idx1") + WaitForIndexing(clientresp2, "idx1", 2) adapter.HSet(ctx, "doc1", "PrimaryKey", "9::362330", "CreatedDateTimeUTC", "637387878524969984") adapter.HSet(ctx, "doc2", "PrimaryKey", "9::362329", "CreatedDateTimeUTC", "637387875859270016") @@ -12135,7 +12134,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, text1, num1).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "idx1") + WaitForIndexing(clientresp2, "idx1", 2) adapter.HSet(ctx, "doc1", "name", "bar", "age", "25") adapter.HSet(ctx, "doc2", "name", "foo", "age", "19") @@ -12164,7 +12163,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{SkipInitialScan: true}, text1).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "idx1") + WaitForIndexing(clientresp2, "idx1", 2) res, err := adapter.FTSearch(ctx, "idx1", "@foo:bar").Result() Expect(err).NotTo(HaveOccurred()) @@ -12177,7 +12176,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{OnJSON: true, Prefix: []interface{}{"king:"}}, text1).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "idx1") + WaitForIndexing(clientresp2, "idx1", 2) adapter.JSONSet(ctx, "king:1", "$", `{"name": "henry"}`) adapter.JSONSet(ctx, "king:2", "$", `{"name": "james"}`) @@ -12196,7 +12195,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{OnJSON: true}, text1, num1).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "idx1") + WaitForIndexing(clientresp2, "idx1", 2) adapter.JSONSet(ctx, "doc:1", "$", `{"name": "Jon", "age": 25}`) @@ -12214,7 +12213,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, tag1).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(client, "idx1") + WaitForIndexing(clientresp2, "idx1", 2) adapter.HSet(ctx, "1", "t", "HELLO") adapter.HSet(ctx, "2", "t", "hello") @@ -12233,7 +12232,7 @@ func testAdapterCache(resp3 bool) { val, err = adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, tag2).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(client, "idx1") + WaitForIndexing(clientresp2, "idx1", 2) res, err = adapter.FTSearch(ctx, "idx1", "@t:{HELLO}").Result() Expect(err).NotTo(HaveOccurred()) @@ -12252,7 +12251,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{OnJSON: true}, text1, num1).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(client, "idx1") + WaitForIndexing(clientresp2, "idx1", 2) res, err := adapter.FTSearchWithArgs(ctx, "idx1", "*", &FTSearchOptions{Return: []FTSearchReturn{{FieldName: "$.t", As: "txt"}}}).Result() Expect(err).NotTo(HaveOccurred()) @@ -12274,7 +12273,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{OnHash: true}, text1, text2).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(client, "idx1") + WaitForIndexing(clientresp2, "idx1", 2) resSynUpdate, err := adapter.FTSynUpdateWithArgs(ctx, "idx1", "id1", &FTSynUpdateOptions{SkipInitialScan: true}, []interface{}{"boy", "child", "offspring"}).Result() Expect(err).NotTo(HaveOccurred()) @@ -12300,7 +12299,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{OnHash: true}, text1, text2).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(client, "idx1") + WaitForIndexing(clientresp2, "idx1", 2) resSynUpdate, err := adapter.FTSynUpdate(ctx, "idx1", "id1", []interface{}{"boy", "child", "offspring"}).Result() Expect(err).NotTo(HaveOccurred()) @@ -12338,7 +12337,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{OnJSON: true, Prefix: []interface{}{"king:"}}, text1, num1).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "idx1") + WaitForIndexing(clientresp2, "idx1", 2) adapter.JSONSet(ctx, "king:1", "$", `{"name": "henry", "num": 42}`) adapter.JSONSet(ctx, "king:2", "$", `{"name": "james", "num": 3.14}`) @@ -12362,7 +12361,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{OnJSON: true, Prefix: []interface{}{"king:"}}, tag1).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(client, "idx1") + WaitForIndexing(clientresp2, "idx1", 2) adapter.JSONSet(ctx, "king:1", "$", `{"name": "henry", "country": {"name": "england"}}`) @@ -12380,7 +12379,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{OnJSON: true}, text1, text2).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(client, "idx1") + WaitForIndexing(clientresp2, "idx1", 2) adapter.JSONSet(ctx, "doc:1", "$", `{"prod:name": "RediSearch"}`) @@ -12409,7 +12408,7 @@ func testAdapterCache(resp3 bool) { &FieldSchema{FieldName: "v", FieldType: SearchFieldTypeVector, VectorArgs: &FTVectorArgs{HNSWOptions: hnswOptions}}).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(client, "idx1") + WaitForIndexing(clientresp2, "idx1", 2) adapter.HSet(ctx, "a", "v", "aaaaaaaa") adapter.HSet(ctx, "b", "v", "aaaabaaa") @@ -12431,7 +12430,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, &FieldSchema{FieldName: "name", FieldType: SearchFieldTypeText}).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp3, "idx1") + WaitForIndexing(clientresp2, "idx1", 2) adapter.HSet(ctx, "doc1", "name", "Alice") adapter.HSet(ctx, "doc2", "name", "Bob") @@ -12449,7 +12448,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, &FieldSchema{FieldName: "numval", FieldType: SearchFieldTypeNumeric}).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp3, "idx1") + WaitForIndexing(clientresp2, "idx1", 2) adapter.HSet(ctx, "doc1", "numval", 101) adapter.HSet(ctx, "doc2", "numval", 102) @@ -12467,7 +12466,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, &FieldSchema{FieldName: "g", FieldType: SearchFieldTypeGeo}).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp3, "idx1") + WaitForIndexing(clientresp2, "idx1", 2) adapter.HSet(ctx, "doc1", "g", "29.69465, 34.95126") adapter.HSet(ctx, "doc2", "g", "29.69350, 34.94737") @@ -12504,7 +12503,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, &FieldSchema{FieldName: "txt", FieldType: SearchFieldTypeText}).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "idx1") + WaitForIndexing(clientresp2, "idx1", 2) res, err := adapter.FTInfo(ctx, "idx1").Result() Expect(err).NotTo(HaveOccurred()) @@ -12518,7 +12517,7 @@ func testAdapterCache(resp3 bool) { val, err = adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, &FieldSchema{FieldName: "txt", FieldType: SearchFieldTypeText, WithSuffixtrie: true}).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "idx1") + WaitForIndexing(clientresp2, "idx1", 2) res, err = adapter.FTInfo(ctx, "idx1").Result() Expect(err).NotTo(HaveOccurred()) @@ -12532,7 +12531,7 @@ func testAdapterCache(resp3 bool) { val, err = adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, &FieldSchema{FieldName: "t", FieldType: SearchFieldTypeTag, WithSuffixtrie: true}).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "idx1") + WaitForIndexing(clientresp2, "idx1", 2) res, err = adapter.FTInfo(ctx, "idx1").Result() Expect(err).NotTo(HaveOccurred()) @@ -12647,7 +12646,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, &FieldSchema{FieldName: "geom", FieldType: SearchFieldTypeGeoShape, GeoShapeFieldType: "FLAT"}).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "idx1") + WaitForIndexing(clientresp2, "idx1", 2) adapter.HSet(ctx, "small", "geom", "POLYGON((1 1, 1 100, 100 100, 100 1, 1 1))") adapter.HSet(ctx, "large", "geom", "POLYGON((1 1, 1 200, 200 200, 200 1, 1 1))") @@ -12677,7 +12676,7 @@ func testAdapterCache(resp3 bool) { ).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "index") + WaitForIndexing(clientresp2, "index", 2) }) It("should test geoshapes query intersects and disjoint", Label("NonRedisEnterprise"), func() { @@ -12755,7 +12754,7 @@ func testAdapterCache(resp3 bool) { &FieldSchema{FieldName: "description", FieldType: SearchFieldTypeText, IndexMissing: true}).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "idx1") + WaitForIndexing(clientresp2, "idx1", 2) adapter.HSet(ctx, "property:1", map[string]interface{}{ "title": "Luxury Villa in Malibu", @@ -12799,7 +12798,7 @@ func testAdapterCache(resp3 bool) { &FieldSchema{FieldName: "description", FieldType: SearchFieldTypeText, IndexEmpty: true}).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "idx1") + WaitForIndexing(clientresp2, "idx1", 2) adapter.HSet(ctx, "property:1", map[string]interface{}{ "title": "Luxury Villa in Malibu", @@ -12854,7 +12853,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, text1, num1).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp3, "idx1") + WaitForIndexing(clientresp3, "idx1", 3) adapter.HSet(ctx, "doc1", "PrimaryKey", "9::362330", "CreatedDateTimeUTC", "637387878524969984") adapter.HSet(ctx, "doc2", "PrimaryKey", "9::362329", "CreatedDateTimeUTC", "637387875859270016") @@ -12888,7 +12887,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, &FieldSchema{FieldName: "txt", FieldType: SearchFieldTypeText, Sortable: true, NoStem: true}).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp3, "idx1") + WaitForIndexing(clientresp3, "idx1", 3) resInfo, err := adapter.FTInfo(ctx, "idx1").RawResult() Expect(err).NotTo(HaveOccurred()) @@ -12916,7 +12915,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, text1, text2).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(adapter, "idx1") + WaitForIndexing(clientresp3, "idx1", 3) adapter.HSet(ctx, "doc1", "f1", "some valid content", "f2", "this is sample text") adapter.HSet(ctx, "doc2", "f1", "very important", "f2", "lorem ipsum") @@ -12941,7 +12940,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "txt", &FTCreateOptions{StopWords: []interface{}{"foo", "bar", "baz"}}, &FieldSchema{FieldName: "txt", FieldType: SearchFieldTypeText}).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(adapter, "txt") + WaitForIndexing(clientresp3, "txt", 3) adapter.HSet(ctx, "doc1", "txt", "foo baz") adapter.HSet(ctx, "doc2", "txt", "hello world") res1, err := adapter.FTSearchWithArgs(ctx, "txt", "foo bar", &FTSearchOptions{NoContent: true}).RawResult() @@ -12969,7 +12968,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{OnHash: true}, text1, text2).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(client, "idx1") + WaitForIndexing(clientresp3, "idx1", 3) resSynUpdate, err := adapter.FTSynUpdate(ctx, "idx1", "id1", []interface{}{"boy", "child", "offspring"}).Result() Expect(err).NotTo(HaveOccurred()) @@ -13005,7 +13004,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "txt", &FTCreateOptions{}, text1, text2, text3).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp3, "txt") + WaitForIndexing(clientresp3, "txt", 3) res1, err := adapter.FTExplain(ctx, "txt", "@f3:f3_val @f2:f2_val @f1:f1_val").Result() Expect(err).NotTo(HaveOccurred()) Expect(res1).ToNot(BeEmpty()) @@ -13056,12 +13055,12 @@ func (s *numberStruct) UnmarshalBinary(b []byte) error { return json.Unmarshal(b, s) } -func WaitForIndexing(c rueidis.Client, index string) { +func WaitForIndexing(c rueidis.Client, index string, protocolVersion int) { adapter := NewAdapter(c) for { res, err := adapter.FTInfo(context.Background(), index).Result() Expect(err).NotTo(HaveOccurred()) - if adapter.Options().Protocol == 2 { + if protocolVersion == 2 { if res.Indexing == 0 { return } @@ -13072,7 +13071,7 @@ func WaitForIndexing(c rueidis.Client, index string) { } } -func _assert_geosearch_result(result *redis.FTSearchResult, expectedDocIDs []string) { +func _assert_geosearch_result(result *FTSearchResult, expectedDocIDs []string) { ids := make([]string, len(result.Docs)) for i, doc := range result.Docs { ids[i] = doc.ID diff --git a/rueidiscompat/command.go b/rueidiscompat/command.go index da3a2a59..35441914 100644 --- a/rueidiscompat/command.go +++ b/rueidiscompat/command.go @@ -45,8 +45,9 @@ type Cmder interface { } type baseCmd[T any] struct { - err error - val T + err error + val T + rawVal any } func (cmd *baseCmd[T]) SetVal(val T) { @@ -57,6 +58,10 @@ func (cmd *baseCmd[T]) Val() T { return cmd.val } +func (cmd *baseCmd[T]) RawVal() any { + return cmd.rawVal +} + func (cmd *baseCmd[T]) SetErr(err error) { cmd.err = err } @@ -69,6 +74,10 @@ func (cmd *baseCmd[T]) Result() (T, error) { return cmd.Val(), cmd.Err() } +func (cmd *baseCmd[T]) RawResult() (any, error) { + return cmd.RawVal(), cmd.Err() +} + type Cmd struct { baseCmd[any] } diff --git a/rueidiscompat/pipeline.go b/rueidiscompat/pipeline.go index 431faa18..439d974a 100644 --- a/rueidiscompat/pipeline.go +++ b/rueidiscompat/pipeline.go @@ -2847,6 +2847,173 @@ func (c *Pipeline) JSONType(ctx context.Context, key, path string) *JSONSliceCmd return ret } +func (c *Pipeline) FT_List(ctx context.Context) *StringSliceCmd { + ret := c.comp.FT_List(ctx) + c.rets = append(c.rets, ret) + return ret +} +func (c *Pipeline) FTAggregate(ctx context.Context, index string, query string) *MapStringInterfaceCmd { + ret := c.comp.FTAggregate(ctx, index, query) + c.rets = append(c.rets, ret) + return ret +} + +func (c *Pipeline) FTAggregateWithArgs(ctx context.Context, index string, query string, options *FTAggregateOptions) *AggregateCmd { + ret := c.comp.FTAggregateWithArgs(ctx, index, query, options) + c.rets = append(c.rets, ret) + return ret +} + +func (c *Pipeline) FTAliasAdd(ctx context.Context, index string, alias string) *StatusCmd { + ret := c.comp.FTAliasAdd(ctx, index, alias) + c.rets = append(c.rets, ret) + return ret +} + +func (c *Pipeline) FTAliasDel(ctx context.Context, alias string) *StatusCmd { + ret := c.comp.FTAliasDel(ctx, alias) + c.rets = append(c.rets, ret) + return ret +} + +func (c *Pipeline) FTAliasUpdate(ctx context.Context, index string, alias string) *StatusCmd { + ret := c.comp.FTAliasUpdate(ctx, index, alias) + c.rets = append(c.rets, ret) + return ret +} + +func (c *Pipeline) FTAlter(ctx context.Context, index string, skipInitalScan bool, definition []interface{}) *StatusCmd { + ret := c.comp.FTAlter(ctx, index, skipInitalScan, definition) + c.rets = append(c.rets, ret) + return ret +} + +func (c *Pipeline) FTConfigGet(ctx context.Context, option string) *MapMapStringInterfaceCmd { + ret := c.comp.FTConfigGet(ctx, option) + c.rets = append(c.rets, ret) + return ret +} + +func (c *Pipeline) FTConfigSet(ctx context.Context, option string, value interface{}) *StatusCmd { + ret := c.comp.FTConfigSet(ctx, option, value) + c.rets = append(c.rets, ret) + return ret +} + +func (c *Pipeline) FTCreate(ctx context.Context, index string, options *FTCreateOptions, schema ...*FieldSchema) *StatusCmd { + ret := c.comp.FTCreate(ctx, index, options, schema...) + c.rets = append(c.rets, ret) + return ret +} + +func (c *Pipeline) FTCursorDel(ctx context.Context, index string, cursorId int) *StatusCmd { + ret := c.comp.FTCursorDel(ctx, index, cursorId) + c.rets = append(c.rets, ret) + return ret +} + +func (c *Pipeline) FTCursorRead(ctx context.Context, index string, cursorId int, count int) *MapStringInterfaceCmd { + ret := c.comp.FTCursorRead(ctx, index, cursorId, count) + c.rets = append(c.rets, ret) + return ret +} + +func (c *Pipeline) FTDictAdd(ctx context.Context, dict string, term ...interface{}) *IntCmd { + ret := c.comp.FTDictAdd(ctx, dict, term...) + c.rets = append(c.rets, ret) + return ret +} + +func (c *Pipeline) FTDictDel(ctx context.Context, dict string, term ...interface{}) *IntCmd { + ret := c.comp.FTDictDel(ctx, dict, term...) + c.rets = append(c.rets, ret) + return ret +} + +func (c *Pipeline) FTDictDump(ctx context.Context, dict string) *StringSliceCmd { + ret := c.comp.FTDictDump(ctx, dict) + c.rets = append(c.rets, ret) + return ret +} + +func (c *Pipeline) FTDropIndex(ctx context.Context, index string) *StatusCmd { + ret := c.comp.FTDropIndex(ctx, index) + c.rets = append(c.rets, ret) + return ret +} + +func (c *Pipeline) FTDropIndexWithArgs(ctx context.Context, index string, options *FTDropIndexOptions) *StatusCmd { + ret := c.comp.FTDropIndexWithArgs(ctx, index, options) + c.rets = append(c.rets, ret) + return ret +} + +func (c *Pipeline) FTExplain(ctx context.Context, index string, query string) *StringCmd { + ret := c.comp.FTExplain(ctx, index, query) + c.rets = append(c.rets, ret) + return ret +} + +func (c *Pipeline) FTExplainWithArgs(ctx context.Context, index string, query string, options *FTExplainOptions) *StringCmd { + ret := c.comp.FTExplainWithArgs(ctx, index, query, options) + c.rets = append(c.rets, ret) + return ret +} + +func (c *Pipeline) FTInfo(ctx context.Context, index string) *FTInfoCmd { + ret := c.comp.FTInfo(ctx, index) + c.rets = append(c.rets, ret) + return ret +} + +func (c *Pipeline) FTSpellCheck(ctx context.Context, index string, query string) *FTSpellCheckCmd { + ret := c.comp.FTSpellCheck(ctx, index, query) + c.rets = append(c.rets, ret) + return ret +} + +func (c *Pipeline) FTSpellCheckWithArgs(ctx context.Context, index string, query string, options *FTSpellCheckOptions) *FTSpellCheckCmd { + ret := c.comp.FTSpellCheckWithArgs(ctx, index, query, options) + c.rets = append(c.rets, ret) + return ret +} + +func (c *Pipeline) FTSearch(ctx context.Context, index string, query string) *FTSearchCmd { + ret := c.comp.FTSearch(ctx, index, query) + c.rets = append(c.rets, ret) + return ret +} + +func (c *Pipeline) FTSearchWithArgs(ctx context.Context, index string, query string, options *FTSearchOptions) *FTSearchCmd { + ret := c.comp.FTSearchWithArgs(ctx, index, query, options) + c.rets = append(c.rets, ret) + return ret +} + +func (c *Pipeline) FTSynDump(ctx context.Context, index string) *FTSynDumpCmd { + ret := c.comp.FTSynDump(ctx, index) + c.rets = append(c.rets, ret) + return ret +} + +func (c *Pipeline) FTSynUpdate(ctx context.Context, index string, synGroupId interface{}, terms []interface{}) *StatusCmd { + ret := c.comp.FTSynUpdate(ctx, index, synGroupId, terms) + c.rets = append(c.rets, ret) + return ret +} + +func (c *Pipeline) FTSynUpdateWithArgs(ctx context.Context, index string, synGroupId interface{}, options *FTSynUpdateOptions, terms []interface{}) *StatusCmd { + ret := c.comp.FTSynUpdateWithArgs(ctx, index, synGroupId, options, terms) + c.rets = append(c.rets, ret) + return ret +} + +func (c *Pipeline) FTTagVals(ctx context.Context, index string, field string) *StringSliceCmd { + ret := c.comp.FTTagVals(ctx, index, field) + c.rets = append(c.rets, ret) + return ret +} + // Len returns the number of queued commands. func (c *Pipeline) Len() int { return len(c.comp.client.(*proxy).cmds) From d9b842d40c959379de3649d7768ddd208a1519bb Mon Sep 17 00:00:00 2001 From: Eric Chang Date: Sat, 16 Nov 2024 11:35:59 +0800 Subject: [PATCH 16/49] feat(rueidiscompat/SearchCmdable): wip: fix teste --- rueidiscompat/adapter.go | 109 +++++++++++++++++++++------------- rueidiscompat/adapter_test.go | 2 +- 2 files changed, 70 insertions(+), 41 deletions(-) diff --git a/rueidiscompat/adapter.go b/rueidiscompat/adapter.go index 1e74f112..91f35a13 100644 --- a/rueidiscompat/adapter.go +++ b/rueidiscompat/adapter.go @@ -5010,46 +5010,74 @@ func (c *Compat) FTConfigSet(ctx context.Context, option string, value interface // SkipInitialScan bool func (c *Compat) FTCreate(ctx context.Context, index string, options *FTCreateOptions, schema ...*FieldSchema) *StatusCmd { _cmd := cmds.Incomplete(c.client.B().FtCreate().Index(index)) - if options.OnHash { - _cmd = cmds.Incomplete(cmds.FtCreateIndex(_cmd).OnHash()) - } - if options.OnJSON { - _cmd = cmds.Incomplete(cmds.FtCreateIndex(_cmd).OnJson()) - } - _cmd = cmds.Incomplete(cmds.FtCreateIndex(_cmd).Prefix(int64(len(options.Prefix))).Prefix(argsToSlice(options.Prefix)...)) - _cmd = cmds.Incomplete( - cmds.FtCreateIndex(_cmd). - Filter(options.Filter). - Language(options.DefaultLanguage). - LanguageField(options.LanguageField). - Score(options.Score). - ScoreField(options.ScoreField). - PayloadField(options.PayloadField)) - // in go-reids, FTCreateOptions.MaxTextFields should be bool, not int - if options.MaxTextFields > 0 { - _cmd = cmds.Incomplete(cmds.FtCreateIndex(_cmd).Maxtextfields()) - } - if options.NoOffsets { - _cmd = cmds.Incomplete(cmds.FtCreateIndex(_cmd).Nooffsets()) - } - _cmd = cmds.Incomplete(cmds.FtCreateIndex(_cmd).Temporary(float64(options.Temporary))) - if options.NoHL { - _cmd = cmds.Incomplete(cmds.FtCreateIndex(_cmd).Nohl()) - } - if options.NoFields { - _cmd = cmds.Incomplete(cmds.FtCreateIndex(_cmd).Nofields()) - } - if options.NoFreqs { - _cmd = cmds.Incomplete(cmds.FtCreateIndex(_cmd).Nofreqs()) - } - _cmd = cmds.Incomplete(cmds.FtCreateIndex(_cmd).Stopwords(int64(len(options.StopWords))).Stopword(argsToSlice(options.StopWords)...)) - if options.SkipInitialScan { - _cmd = cmds.Incomplete(cmds.FtCreateIndex(_cmd).Skipinitialscan()) - } - // schema - // if (len(schema) != 1) { - // panic("can only have one FieldSchema") - // } + if options != nil { + // [ON HASH | JSON] + if options.OnHash { + _cmd = cmds.Incomplete(cmds.FtCreateIndex(_cmd).OnHash()) + } + if options.OnJSON { + _cmd = cmds.Incomplete(cmds.FtCreateIndex(_cmd).OnJson()) + } + // [PREFIX count prefix [prefix ...]] + _cmd = cmds.Incomplete(cmds.FtCreateIndex(_cmd).Prefix(int64(len(options.Prefix))).Prefix(argsToSlice(options.Prefix)...)) + // [FILTER {filter}] + if options.Filter != "" { + _cmd = cmds.Incomplete(cmds.FtCreateIndex(_cmd).Filter(options.Filter)) + } + // [LANGUAGE default_lang] + if options.DefaultLanguage != "" { + _cmd = cmds.Incomplete(cmds.FtCreateIndex(_cmd).Language(options.DefaultLanguage)) + } + // [LANGUAGE_FIELD lang_attribute] + if options.LanguageField != "" { + _cmd = cmds.Incomplete(cmds.FtCreateIndex(_cmd).LanguageField(options.LanguageField)) + } + // [SCORE default_score] + if options.Score != 0 { + _cmd = cmds.Incomplete(cmds.FtCreateIndex(_cmd).Score(options.Score)) + } + // [SCORE_FIELD score_attribute] + if options.ScoreField != "" { + _cmd = cmds.Incomplete(cmds.FtCreateIndex(_cmd).ScoreField(options.ScoreField)) + } + // [PAYLOAD_FIELD payload_attribute] + _cmd = cmds.Incomplete(cmds.FtCreateIndex(_cmd).PayloadField(options.PayloadField)) + // [MAXTEXTFIELDS] + // FIXME: in go-reids, FTCreateOptions.MaxTextFields should be bool, not int + if options.MaxTextFields > 0 { + _cmd = cmds.Incomplete(cmds.FtCreateIndex(_cmd).Maxtextfields()) + } + // [TEMPORARY seconds] + // FIXME: reudis: Temporary should not be float64 + // TRY FT.CREATE myindex2 ON JSON PREFIX 1 doc: TEMPORARY 1.1 SCHEMA $.name AS name TEXT + if options.Temporary > 0 { + _cmd = cmds.Incomplete(cmds.FtCreateIndex(_cmd).Temporary(float64(options.Temporary))) + } + // [NOOFFSETS] + if options.NoOffsets { + _cmd = cmds.Incomplete(cmds.FtCreateIndex(_cmd).Nooffsets()) + } + // [NOHL] + if options.NoHL { + _cmd = cmds.Incomplete(cmds.FtCreateIndex(_cmd).Nohl()) + } + // [NOFIELDS] + if options.NoFields { + _cmd = cmds.Incomplete(cmds.FtCreateIndex(_cmd).Nofields()) + } + // [NOFREQS] + if options.NoFreqs { + _cmd = cmds.Incomplete(cmds.FtCreateIndex(_cmd).Nofreqs()) + } + // [STOPWORDS count [stopword ...]] + if len(options.StopWords) > 0 { + _cmd = cmds.Incomplete(cmds.FtCreateIndex(_cmd).Stopwords(int64(len(options.StopWords))).Stopword(argsToSlice(options.StopWords)...)) + } + // [SKIPINITIALSCAN] + if options.SkipInitialScan { + _cmd = cmds.Incomplete(cmds.FtCreateIndex(_cmd).Skipinitialscan()) + } + } _cmd = cmds.Incomplete(cmds.FtCreateIndex(_cmd).Schema()) for _, sc := range schema { _cmd = cmds.Incomplete(cmds.FtCreateSchema(_cmd).FieldName(sc.FieldName).As(sc.As)) @@ -5081,6 +5109,7 @@ func (c *Compat) FTCreate(ctx context.Context, index string, options *FTCreateOp } // FIXME: handle index properly cmd := cmds.FtCreateSkipinitialscan(_cmd).Schema().FieldName("xx").Geo().Build() + fmt.Print(cmd.Commands()) return newStatusCmd(c.client.Do(ctx, cmd)) } diff --git a/rueidiscompat/adapter_test.go b/rueidiscompat/adapter_test.go index 36c38031..2d4ad363 100644 --- a/rueidiscompat/adapter_test.go +++ b/rueidiscompat/adapter_test.go @@ -11555,7 +11555,7 @@ func testAdapterCache(resp3 bool) { Expect(adapter.FlushDB(ctx).Err()).NotTo(HaveOccurred()) }) - It("should FTCreate and FTSearch WithScores", Label("search", "ftcreate", "ftsearch"), func() { + FIt("should FTCreate and FTSearch WithScores", Label("search", "ftcreate", "ftsearch"), func() { // FIXME: FieldType val, err := adapter.FTCreate(ctx, "txt", &FTCreateOptions{}, &FieldSchema{FieldName: "txt", FieldType: SearchFieldTypeText}).Result() Expect(err).NotTo(HaveOccurred()) From 9bdbdc116740e810c9976ec17914045befa23da3 Mon Sep 17 00:00:00 2001 From: Eric Chang Date: Mon, 18 Nov 2024 20:22:01 +0800 Subject: [PATCH 17/49] fix(FTSearchCmd): impl FTSearchCmd.from --- rueidiscompat/adapter.go | 125 +++++++++++++++++++++++++-------------- rueidiscompat/command.go | 107 ++++++++++++++++++++++++++++++++- 2 files changed, 185 insertions(+), 47 deletions(-) diff --git a/rueidiscompat/adapter.go b/rueidiscompat/adapter.go index 91f35a13..c71f3585 100644 --- a/rueidiscompat/adapter.go +++ b/rueidiscompat/adapter.go @@ -5041,7 +5041,9 @@ func (c *Compat) FTCreate(ctx context.Context, index string, options *FTCreateOp _cmd = cmds.Incomplete(cmds.FtCreateIndex(_cmd).ScoreField(options.ScoreField)) } // [PAYLOAD_FIELD payload_attribute] - _cmd = cmds.Incomplete(cmds.FtCreateIndex(_cmd).PayloadField(options.PayloadField)) + if options.PayloadField != "" { + _cmd = cmds.Incomplete(cmds.FtCreateIndex(_cmd).PayloadField(options.PayloadField)) + } // [MAXTEXTFIELDS] // FIXME: in go-reids, FTCreateOptions.MaxTextFields should be bool, not int if options.MaxTextFields > 0 { @@ -5080,7 +5082,10 @@ func (c *Compat) FTCreate(ctx context.Context, index string, options *FTCreateOp } _cmd = cmds.Incomplete(cmds.FtCreateIndex(_cmd).Schema()) for _, sc := range schema { - _cmd = cmds.Incomplete(cmds.FtCreateSchema(_cmd).FieldName(sc.FieldName).As(sc.As)) + _cmd = cmds.Incomplete(cmds.FtCreateSchema(_cmd).FieldName(sc.FieldName)) + if sc.As != "" { + _cmd = cmds.Incomplete(cmds.FtCreateFieldFieldName(_cmd).As(sc.As)) + } switch sc.FieldType { case SearchFieldTypeGeo: _cmd = cmds.Incomplete(cmds.FtCreateFieldAs(_cmd).Geo()) @@ -5089,8 +5094,9 @@ func (c *Compat) FTCreate(ctx context.Context, index string, options *FTCreateOp case SearchFieldTypeNumeric: _cmd = cmds.Incomplete(cmds.FtCreateFieldAs(_cmd).Numeric()) case SearchFieldTypeTag: - case SearchFieldTypeText: _cmd = cmds.Incomplete(cmds.FtCreateFieldAs(_cmd).Tag()) + case SearchFieldTypeText: + _cmd = cmds.Incomplete(cmds.FtCreateFieldAs(_cmd).Text()) case SearchFieldTypeVector: // FIXME: implement this break @@ -5106,10 +5112,18 @@ func (c *Compat) FTCreate(ctx context.Context, index string, options *FTCreateOp default: panic(fmt.Sprintf("unexpected SearchFieldType: %s", sc.FieldType.String())) } + if sc.Sortable { + _cmd = cmds.Incomplete(cmds.FtCreateFieldFieldTypeText(_cmd).Sortable()) + } + if sc.UNF { + _cmd = cmds.Incomplete(cmds.FtCreateFieldOptionSortableSortable(_cmd).Unf()) + } + if sc.NoIndex { + _cmd = cmds.Incomplete(cmds.FtCreateFieldFieldTypeText(_cmd).Noindex()) + } } // FIXME: handle index properly - cmd := cmds.FtCreateSkipinitialscan(_cmd).Schema().FieldName("xx").Geo().Build() - fmt.Print(cmd.Commands()) + cmd := cmds.FtCreateFieldFieldTypeText(_cmd).Build() return newStatusCmd(c.client.Do(ctx, cmd)) } @@ -5199,39 +5213,40 @@ func (c *Compat) FTSpellCheckWithArgs(ctx context.Context, index string, query s func (c *Compat) FTSearch(ctx context.Context, index string, query string) *FTSearchCmd { cmd := c.client.B().FtSearch().Index(index).Query(query).Build() - return newFTSearchCmd(c.client.Do(ctx, cmd)) + return newFTSearchCmd(c.client.Do(ctx, cmd), nil) } +// Ref: https://github.com/redis/go-redis/blob/930d904205691ff06104fcc3ac108177077def35/search_commands.go#L1688 func (c *Compat) FTSearchWithArgs(ctx context.Context, index string, query string, options *FTSearchOptions) *FTSearchCmd { _cmd := cmds.Incomplete(c.client.B().FtSearch().Index(index).Query(query)) - // NoContent bool if options == nil { panic("options can not be nil") } + // [NOCONTENT] if options.NoContent { _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Nocontent()) } - // Verbatim bool + // [VERBATIM] if options.Verbatim { _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Verbatim()) } - // NoStopWords bool + // [NOSTOPWORDS] if options.NoStopWords { _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Nostopwords()) } - // WithScores bool + // [WITHSCORES] if options.WithScores { _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Withscores()) } - // WithPayloads bool + // [WITHPAYLOADS] if options.WithPayloads { _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Withpayloads()) } - // WithSortKeys bool + // [WITHSORTKEYS] if options.WithSortKeys { _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Withsortkeys()) } - // Filters []FTSearchFilter + // [FILTER numeric_field min max [ FILTER numeric_field min max ...]] for _, filter := range options.Filters { min, err := strconv.ParseFloat(str(filter.Min), 64) if err != nil { @@ -5243,7 +5258,7 @@ func (c *Compat) FTSearchWithArgs(ctx context.Context, index string, query strin } _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Filter(str(filter.FieldName)).Min(min).Max(max)) } - // GEOFILTER + // [GEOFILTER geo_field lon lat radius m | km | mi | ft [ GEOFILTER geo_field lon lat radius m | km | mi | ft ...]] for _, filter := range options.GeoFilter { _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Geofilter(filter.FieldName).Lon(filter.Longitude).Lat(filter.Latitude).Radius(filter.Radius)) switch filter.Unit { @@ -5260,56 +5275,77 @@ func (c *Compat) FTSearchWithArgs(ctx context.Context, index string, query strin } } // [INKEYS count key [key ...]] - _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Inkeys(str(len(options.InKeys))).Key(argsToSlice(options.InKeys)...)) + if len(options.InKeys) > 0 { + _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Inkeys(str(len(options.InKeys))).Key(argsToSlice(options.InKeys)...)) + } // [ INFIELDS count field [field ...]] - _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Infields(str(len(options.InKeys))).Field(argsToSlice(options.InFields)...)) + if len(options.InFields) > 0 { + _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Infields(str(len(options.InFields))).Field(argsToSlice(options.InFields)...)) + } // [RETURN count identifier [AS property] [ identifier [AS property] ...]] - _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Return(str(len(options.Return)))) - for _, re := range options.Return { - _cmd = cmds.Incomplete(cmds.FtSearchReturnReturn(_cmd).Identifier(re.FieldName).As(re.As)) + if len(options.Return) > 0 { + _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Return(str(len(options.Return)))) + for _, re := range options.Return { + _cmd = cmds.Incomplete(cmds.FtSearchReturnReturn(_cmd).Identifier(re.FieldName).As(re.As)) + } } - // NOTE: go-redis doesn't implement SUMMARIZE option + // FIXME: go-redis doesn't implement SUMMARIZE option // [SUMMARIZE [ FIELDS count field [field ...]] [FRAGS num] [LEN fragsize] [SEPARATOR separator]] // [SLOP slop] - _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Slop(int64(options.Slop))) + if options.Slop > 0 { + _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Slop(int64(options.Slop))) + } // [TIMEOUT timeout] - _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Timeout(int64(options.Timeout))) + if options.Timeout > 0 { + _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Timeout(int64(options.Timeout))) + } // [INORDER] if options.InOrder { _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Inorder()) } // [LANGUAGE language] - _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Language(options.Language)) + if options.Language != "" { + _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Language(options.Language)) + } // [EXPANDER expander] - _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Expander(options.Expander)) + if options.Expander != "" { + _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Expander(options.Expander)) + } // [SCORER scorer] - _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Scorer(options.Scorer)) + if options.Scorer != "" { + _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Scorer(options.Scorer)) + } // [EXPLAINSCORE] if options.ExplainScore { _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Explainscore()) } // [PAYLOAD payload] - _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Payload(options.Payload)) - // [SORTBY sortby [ ASC | DESC] [WITHCOUNT]] - if len(options.SortBy) != 1 { - panic(fmt.Sprintf("options.SortBy can only have 1 element, got %v", len(options.SortBy))) + if options.Payload != "" { + _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Payload(options.Payload)) } - sortBy := options.SortBy[0] - _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Sortby(sortBy.FieldName)) - if sortBy.Asc == sortBy.Desc && sortBy.Asc { - panic("options.SortBy[0] should specify either ASC or DESC") - } - if sortBy.Asc { - _cmd = cmds.Incomplete(cmds.FtSearchSortbySortby(_cmd).Asc()) - } else { - _cmd = cmds.Incomplete(cmds.FtSearchSortbySortby(_cmd).Desc()) - } - // WITHCOUNT - if options.SortByWithCount { - _cmd = cmds.Incomplete(cmds.FtSearchSortbySortby(_cmd).Withcount()) + // [SORTBY sortby [ ASC | DESC] [WITHCOUNT]] + if options.SortBy != nil { + if len(options.SortBy) != 1 { + panic(fmt.Sprintf("options.SortBy can only have 1 element, got %v", len(options.SortBy))) + } + sortBy := options.SortBy[0] + _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Sortby(sortBy.FieldName)) + if sortBy.Asc == sortBy.Desc && sortBy.Asc { + panic("options.SortBy[0] should specify either ASC or DESC") + } + if sortBy.Asc { + _cmd = cmds.Incomplete(cmds.FtSearchSortbySortby(_cmd).Asc()) + } else { + _cmd = cmds.Incomplete(cmds.FtSearchSortbySortby(_cmd).Desc()) + } + if options.SortByWithCount { + _cmd = cmds.Incomplete(cmds.FtSearchSortbySortby(_cmd).Withcount()) + } } // [LIMIT offset num] - _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Limit().OffsetNum(int64(options.Limit), int64(options.LimitOffset))) + if options.LimitOffset >= 0 && options.Limit > 0 { + _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Limit().OffsetNum(int64(options.Limit), int64(options.LimitOffset))) + } // [PARAMS nargs name value [ name value ...]] if options.Params != nil { _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Params().Nargs(int64(len(options.Params)))) @@ -5322,7 +5358,8 @@ func (c *Compat) FTSearchWithArgs(ctx context.Context, index string, query strin _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Dialect(int64(options.DialectVersion))) } cmd := cmds.FtSearchQuery(_cmd).Build() - return newFTSearchCmd(c.client.Do(ctx, cmd)) + fmt.Print(cmd.Commands()) + return newFTSearchCmd(c.client.Do(ctx, cmd), options) } func (c *Compat) FTSynDump(ctx context.Context, index string) *FTSynDumpCmd { return nil } diff --git a/rueidiscompat/command.go b/rueidiscompat/command.go index 35441914..7ab2cfad 100644 --- a/rueidiscompat/command.go +++ b/rueidiscompat/command.go @@ -3844,12 +3844,113 @@ type FTSearchCmd struct { options *FTSearchOptions } +// Ref: https://redis.io/docs/latest/commands/ft.search/ func (cmd *FTSearchCmd) from(res rueidis.RedisResult) { - // FIXME: impl + if err := res.Error(); err != nil { + cmd.SetErr(err) + return + } + m, err := res.ToMap() + if err != nil { + cmd.SetErr(err) + return + } + resultsMsg, ok := m["results"] + if !ok { + cmd.SetErr(fmt.Errorf(`result map should contain key "results"`)) + } + resultsArr, err := resultsMsg.ToArray() + if err != nil { + cmd.SetErr(err) + return + } + fmt.Println("Hello") + ftSearchResult := FTSearchResult{Total: len(resultsArr)} + for _, result := range resultsArr { + // result: arr: id, doc2, score, 3, "extra_attributes": [foo, bar] + resultMap, err := result.ToMap() + if err != nil { + cmd.SetErr(err) + return + } + fmt.Println("resultMap", result.String()) + doc := Document{} + for k, v := range resultMap { + switch k { + case "id": + idStr, err := v.ToString() + if err != nil { + cmd.SetErr(err) + return + } + doc.ID = idStr + case "extra_attributes": + // doc.ID = resultArr[i+1].String() + strMap, err := v.AsStrMap() + if err != nil { + cmd.SetErr(err) + return + } + doc.Fields = strMap + // docs[d].Doc, _ = record.values[j+1].AsStrMap() + case "score": + score, err := v.AsFloat64() + if err != nil { + cmd.SetErr(err) + return + } + doc.Score = &score + case "payload": + if !v.IsNil() { + payload, err := v.ToString() + if err != nil { + cmd.SetErr(err) + return + } + doc.Payload = &payload + } + case "sortkey": + if !v.IsNil() { + sortKey, err := v.ToString() + if err != nil { + cmd.SetErr(err) + return + } + doc.SortKey = &sortKey + } + } + // FIXME: withpayload + ftSearchResult.Docs = append(ftSearchResult.Docs, doc) + fmt.Println("got doc", doc) + } + cmd.SetVal(ftSearchResult) + + _r, _ := json.MarshalIndent(ftSearchResult, "", "\t") + fmt.Print(string(_r)) + + fmt.Printf("rueidisresult %#v\n", res.String()) + + // attributes: string + // total_results: integer + // format: string + // results + // warning + + // + // if len(m) == 0 { + // cmd.SetErr(fmt.Errorf("got %d, wanted 4", len(m))) + // } + // result := FTSearchResult{} + // result = + // val := make([]FTSearchResult, 0, len(arr)) + + if cmd.options.DialectVersion == 3 { + + } } -func newFTSearchCmd(res rueidis.RedisResult) *FTSearchCmd { - cmd := &FTSearchCmd{} +func newFTSearchCmd(res rueidis.RedisResult, options *FTSearchOptions) *FTSearchCmd { + cmd := &FTSearchCmd{options: options} cmd.from(res) return cmd } From 9726d8b1df0db96ce14bd97d358bf678345051d1 Mon Sep 17 00:00:00 2001 From: Eric Chang Date: Mon, 18 Nov 2024 21:26:16 +0800 Subject: [PATCH 18/49] fix(FTSearchCmd): fix FTSearchWithArgs: geofilter --- rueidiscompat/adapter.go | 2 +- rueidiscompat/command.go | 29 ++++++----------------------- 2 files changed, 7 insertions(+), 24 deletions(-) diff --git a/rueidiscompat/adapter.go b/rueidiscompat/adapter.go index c71f3585..ccafdba0 100644 --- a/rueidiscompat/adapter.go +++ b/rueidiscompat/adapter.go @@ -5265,7 +5265,7 @@ func (c *Compat) FTSearchWithArgs(ctx context.Context, index string, query strin case "m": _cmd = cmds.Incomplete(cmds.FtSearchGeoFilterRadius(_cmd).M()) case "km": - _cmd = cmds.Incomplete(cmds.FtSearchGeoFilterRadius(_cmd).M()) + _cmd = cmds.Incomplete(cmds.FtSearchGeoFilterRadius(_cmd).Km()) case "mi": _cmd = cmds.Incomplete(cmds.FtSearchGeoFilterRadius(_cmd).Mi()) case "ft": diff --git a/rueidiscompat/command.go b/rueidiscompat/command.go index 7ab2cfad..6977237a 100644 --- a/rueidiscompat/command.go +++ b/rueidiscompat/command.go @@ -3846,6 +3846,8 @@ type FTSearchCmd struct { // Ref: https://redis.io/docs/latest/commands/ft.search/ func (cmd *FTSearchCmd) from(res rueidis.RedisResult) { + fmt.Printf("rueidisresult %#v\n", res.String()) + if err := res.Error(); err != nil { cmd.SetErr(err) return @@ -3864,8 +3866,7 @@ func (cmd *FTSearchCmd) from(res rueidis.RedisResult) { cmd.SetErr(err) return } - fmt.Println("Hello") - ftSearchResult := FTSearchResult{Total: len(resultsArr)} + ftSearchResult := FTSearchResult{Total: len(resultsArr), Docs: make([]Document, 0, len(resultsArr))} for _, result := range resultsArr { // result: arr: id, doc2, score, 3, "extra_attributes": [foo, bar] resultMap, err := result.ToMap() @@ -3918,35 +3919,17 @@ func (cmd *FTSearchCmd) from(res rueidis.RedisResult) { } doc.SortKey = &sortKey } + } } - // FIXME: withpayload + ftSearchResult.Docs = append(ftSearchResult.Docs, doc) - fmt.Println("got doc", doc) } + cmd.SetVal(ftSearchResult) _r, _ := json.MarshalIndent(ftSearchResult, "", "\t") fmt.Print(string(_r)) - fmt.Printf("rueidisresult %#v\n", res.String()) - - // attributes: string - // total_results: integer - // format: string - // results - // warning - - // - // if len(m) == 0 { - // cmd.SetErr(fmt.Errorf("got %d, wanted 4", len(m))) - // } - // result := FTSearchResult{} - // result = - // val := make([]FTSearchResult, 0, len(arr)) - - if cmd.options.DialectVersion == 3 { - - } } func newFTSearchCmd(res rueidis.RedisResult, options *FTSearchOptions) *FTSearchCmd { From e0228728031f449d5838f5d0a24b9d5d97b4d0db Mon Sep 17 00:00:00 2001 From: Eric Chang Date: Tue, 19 Nov 2024 07:39:03 +0800 Subject: [PATCH 19/49] feat(hack/cmds/commands_search.json): FT.CREATE: add WITHSUFFIXTRIE, INDEXEMPTY, INDEXMISSING options --- hack/cmds/commands_search.json | 24 ++- internal/cmds/gen_search.go | 334 ++++++++++++++++++++++++++++--- internal/cmds/gen_search_test.go | 215 ++++++++++++-------- 3 files changed, 456 insertions(+), 117 deletions(-) diff --git a/hack/cmds/commands_search.json b/hack/cmds/commands_search.json index 6d62890f..c7c67b18 100644 --- a/hack/cmds/commands_search.json +++ b/hack/cmds/commands_search.json @@ -159,12 +159,6 @@ "optional": true, "multiple": true, "block": [ - { - "name": "withsuffixtrie", - "type": "enum", - "enum": ["WITHSUFFIXTRIE"], - "optional": true - }, { "name": "sortable", "type": "block", @@ -218,6 +212,24 @@ "type": "enum", "optional": true, "enum": ["CASESENSITIVE"] + }, + { + "name": "WITHSUFFIXTRIE", + "type": "enum", + "optional": true, + "enum": ["WITHSUFFIXTRIE"] + }, + { + "name": "INDEXEMPTY", + "type": "enum", + "optional": true, + "enum": ["INDEXEMPTY"] + }, + { + "name": "INDEXMISSING", + "type": "enum", + "optional": true, + "enum": ["INDEXMISSING"] } ] } diff --git a/internal/cmds/gen_search.go b/internal/cmds/gen_search.go index 633b6df3..3c2e21d1 100644 --- a/internal/cmds/gen_search.go +++ b/internal/cmds/gen_search.go @@ -1971,11 +1971,6 @@ func (c FtCreateFieldFieldName) Geoshape() FtCreateFieldFieldTypeGeoshape { type FtCreateFieldFieldTypeGeo Incomplete -func (c FtCreateFieldFieldTypeGeo) Withsuffixtrie() FtCreateFieldOptionWithsuffixtrie { - c.cs.s = append(c.cs.s, "WITHSUFFIXTRIE") - return (FtCreateFieldOptionWithsuffixtrie)(c) -} - func (c FtCreateFieldFieldTypeGeo) Sortable() FtCreateFieldOptionSortableSortable { c.cs.s = append(c.cs.s, "SORTABLE") return (FtCreateFieldOptionSortableSortable)(c) @@ -2011,6 +2006,21 @@ func (c FtCreateFieldFieldTypeGeo) Casesensitive() FtCreateFieldOptionCasesensit return (FtCreateFieldOptionCasesensitive)(c) } +func (c FtCreateFieldFieldTypeGeo) Withsuffixtrie() FtCreateFieldOptionWithsuffixtrie { + c.cs.s = append(c.cs.s, "WITHSUFFIXTRIE") + return (FtCreateFieldOptionWithsuffixtrie)(c) +} + +func (c FtCreateFieldFieldTypeGeo) Indexempty() FtCreateFieldOptionIndexempty { + c.cs.s = append(c.cs.s, "INDEXEMPTY") + return (FtCreateFieldOptionIndexempty)(c) +} + +func (c FtCreateFieldFieldTypeGeo) Indexmissing() FtCreateFieldOptionIndexmissing { + c.cs.s = append(c.cs.s, "INDEXMISSING") + return (FtCreateFieldOptionIndexmissing)(c) +} + func (c FtCreateFieldFieldTypeGeo) FieldName(fieldName string) FtCreateFieldFieldName { c.cs.s = append(c.cs.s, fieldName) return (FtCreateFieldFieldName)(c) @@ -2023,11 +2033,6 @@ func (c FtCreateFieldFieldTypeGeo) Build() Completed { type FtCreateFieldFieldTypeGeoshape Incomplete -func (c FtCreateFieldFieldTypeGeoshape) Withsuffixtrie() FtCreateFieldOptionWithsuffixtrie { - c.cs.s = append(c.cs.s, "WITHSUFFIXTRIE") - return (FtCreateFieldOptionWithsuffixtrie)(c) -} - func (c FtCreateFieldFieldTypeGeoshape) Sortable() FtCreateFieldOptionSortableSortable { c.cs.s = append(c.cs.s, "SORTABLE") return (FtCreateFieldOptionSortableSortable)(c) @@ -2063,6 +2068,21 @@ func (c FtCreateFieldFieldTypeGeoshape) Casesensitive() FtCreateFieldOptionCases return (FtCreateFieldOptionCasesensitive)(c) } +func (c FtCreateFieldFieldTypeGeoshape) Withsuffixtrie() FtCreateFieldOptionWithsuffixtrie { + c.cs.s = append(c.cs.s, "WITHSUFFIXTRIE") + return (FtCreateFieldOptionWithsuffixtrie)(c) +} + +func (c FtCreateFieldFieldTypeGeoshape) Indexempty() FtCreateFieldOptionIndexempty { + c.cs.s = append(c.cs.s, "INDEXEMPTY") + return (FtCreateFieldOptionIndexempty)(c) +} + +func (c FtCreateFieldFieldTypeGeoshape) Indexmissing() FtCreateFieldOptionIndexmissing { + c.cs.s = append(c.cs.s, "INDEXMISSING") + return (FtCreateFieldOptionIndexmissing)(c) +} + func (c FtCreateFieldFieldTypeGeoshape) FieldName(fieldName string) FtCreateFieldFieldName { c.cs.s = append(c.cs.s, fieldName) return (FtCreateFieldFieldName)(c) @@ -2075,11 +2095,6 @@ func (c FtCreateFieldFieldTypeGeoshape) Build() Completed { type FtCreateFieldFieldTypeNumeric Incomplete -func (c FtCreateFieldFieldTypeNumeric) Withsuffixtrie() FtCreateFieldOptionWithsuffixtrie { - c.cs.s = append(c.cs.s, "WITHSUFFIXTRIE") - return (FtCreateFieldOptionWithsuffixtrie)(c) -} - func (c FtCreateFieldFieldTypeNumeric) Sortable() FtCreateFieldOptionSortableSortable { c.cs.s = append(c.cs.s, "SORTABLE") return (FtCreateFieldOptionSortableSortable)(c) @@ -2115,6 +2130,21 @@ func (c FtCreateFieldFieldTypeNumeric) Casesensitive() FtCreateFieldOptionCasese return (FtCreateFieldOptionCasesensitive)(c) } +func (c FtCreateFieldFieldTypeNumeric) Withsuffixtrie() FtCreateFieldOptionWithsuffixtrie { + c.cs.s = append(c.cs.s, "WITHSUFFIXTRIE") + return (FtCreateFieldOptionWithsuffixtrie)(c) +} + +func (c FtCreateFieldFieldTypeNumeric) Indexempty() FtCreateFieldOptionIndexempty { + c.cs.s = append(c.cs.s, "INDEXEMPTY") + return (FtCreateFieldOptionIndexempty)(c) +} + +func (c FtCreateFieldFieldTypeNumeric) Indexmissing() FtCreateFieldOptionIndexmissing { + c.cs.s = append(c.cs.s, "INDEXMISSING") + return (FtCreateFieldOptionIndexmissing)(c) +} + func (c FtCreateFieldFieldTypeNumeric) FieldName(fieldName string) FtCreateFieldFieldName { c.cs.s = append(c.cs.s, fieldName) return (FtCreateFieldFieldName)(c) @@ -2127,11 +2157,6 @@ func (c FtCreateFieldFieldTypeNumeric) Build() Completed { type FtCreateFieldFieldTypeTag Incomplete -func (c FtCreateFieldFieldTypeTag) Withsuffixtrie() FtCreateFieldOptionWithsuffixtrie { - c.cs.s = append(c.cs.s, "WITHSUFFIXTRIE") - return (FtCreateFieldOptionWithsuffixtrie)(c) -} - func (c FtCreateFieldFieldTypeTag) Sortable() FtCreateFieldOptionSortableSortable { c.cs.s = append(c.cs.s, "SORTABLE") return (FtCreateFieldOptionSortableSortable)(c) @@ -2167,6 +2192,21 @@ func (c FtCreateFieldFieldTypeTag) Casesensitive() FtCreateFieldOptionCasesensit return (FtCreateFieldOptionCasesensitive)(c) } +func (c FtCreateFieldFieldTypeTag) Withsuffixtrie() FtCreateFieldOptionWithsuffixtrie { + c.cs.s = append(c.cs.s, "WITHSUFFIXTRIE") + return (FtCreateFieldOptionWithsuffixtrie)(c) +} + +func (c FtCreateFieldFieldTypeTag) Indexempty() FtCreateFieldOptionIndexempty { + c.cs.s = append(c.cs.s, "INDEXEMPTY") + return (FtCreateFieldOptionIndexempty)(c) +} + +func (c FtCreateFieldFieldTypeTag) Indexmissing() FtCreateFieldOptionIndexmissing { + c.cs.s = append(c.cs.s, "INDEXMISSING") + return (FtCreateFieldOptionIndexmissing)(c) +} + func (c FtCreateFieldFieldTypeTag) FieldName(fieldName string) FtCreateFieldFieldName { c.cs.s = append(c.cs.s, fieldName) return (FtCreateFieldFieldName)(c) @@ -2179,11 +2219,6 @@ func (c FtCreateFieldFieldTypeTag) Build() Completed { type FtCreateFieldFieldTypeText Incomplete -func (c FtCreateFieldFieldTypeText) Withsuffixtrie() FtCreateFieldOptionWithsuffixtrie { - c.cs.s = append(c.cs.s, "WITHSUFFIXTRIE") - return (FtCreateFieldOptionWithsuffixtrie)(c) -} - func (c FtCreateFieldFieldTypeText) Sortable() FtCreateFieldOptionSortableSortable { c.cs.s = append(c.cs.s, "SORTABLE") return (FtCreateFieldOptionSortableSortable)(c) @@ -2219,6 +2254,21 @@ func (c FtCreateFieldFieldTypeText) Casesensitive() FtCreateFieldOptionCasesensi return (FtCreateFieldOptionCasesensitive)(c) } +func (c FtCreateFieldFieldTypeText) Withsuffixtrie() FtCreateFieldOptionWithsuffixtrie { + c.cs.s = append(c.cs.s, "WITHSUFFIXTRIE") + return (FtCreateFieldOptionWithsuffixtrie)(c) +} + +func (c FtCreateFieldFieldTypeText) Indexempty() FtCreateFieldOptionIndexempty { + c.cs.s = append(c.cs.s, "INDEXEMPTY") + return (FtCreateFieldOptionIndexempty)(c) +} + +func (c FtCreateFieldFieldTypeText) Indexmissing() FtCreateFieldOptionIndexmissing { + c.cs.s = append(c.cs.s, "INDEXMISSING") + return (FtCreateFieldOptionIndexmissing)(c) +} + func (c FtCreateFieldFieldTypeText) FieldName(fieldName string) FtCreateFieldFieldName { c.cs.s = append(c.cs.s, fieldName) return (FtCreateFieldFieldName)(c) @@ -2231,11 +2281,6 @@ func (c FtCreateFieldFieldTypeText) Build() Completed { type FtCreateFieldFieldTypeVector Incomplete -func (c FtCreateFieldFieldTypeVector) Withsuffixtrie() FtCreateFieldOptionWithsuffixtrie { - c.cs.s = append(c.cs.s, "WITHSUFFIXTRIE") - return (FtCreateFieldOptionWithsuffixtrie)(c) -} - func (c FtCreateFieldFieldTypeVector) Sortable() FtCreateFieldOptionSortableSortable { c.cs.s = append(c.cs.s, "SORTABLE") return (FtCreateFieldOptionSortableSortable)(c) @@ -2271,6 +2316,21 @@ func (c FtCreateFieldFieldTypeVector) Casesensitive() FtCreateFieldOptionCasesen return (FtCreateFieldOptionCasesensitive)(c) } +func (c FtCreateFieldFieldTypeVector) Withsuffixtrie() FtCreateFieldOptionWithsuffixtrie { + c.cs.s = append(c.cs.s, "WITHSUFFIXTRIE") + return (FtCreateFieldOptionWithsuffixtrie)(c) +} + +func (c FtCreateFieldFieldTypeVector) Indexempty() FtCreateFieldOptionIndexempty { + c.cs.s = append(c.cs.s, "INDEXEMPTY") + return (FtCreateFieldOptionIndexempty)(c) +} + +func (c FtCreateFieldFieldTypeVector) Indexmissing() FtCreateFieldOptionIndexmissing { + c.cs.s = append(c.cs.s, "INDEXMISSING") + return (FtCreateFieldOptionIndexmissing)(c) +} + func (c FtCreateFieldFieldTypeVector) FieldName(fieldName string) FtCreateFieldFieldName { c.cs.s = append(c.cs.s, fieldName) return (FtCreateFieldFieldName)(c) @@ -2288,6 +2348,16 @@ func (c FtCreateFieldOptionCasesensitive) Withsuffixtrie() FtCreateFieldOptionWi return (FtCreateFieldOptionWithsuffixtrie)(c) } +func (c FtCreateFieldOptionCasesensitive) Indexempty() FtCreateFieldOptionIndexempty { + c.cs.s = append(c.cs.s, "INDEXEMPTY") + return (FtCreateFieldOptionIndexempty)(c) +} + +func (c FtCreateFieldOptionCasesensitive) Indexmissing() FtCreateFieldOptionIndexmissing { + c.cs.s = append(c.cs.s, "INDEXMISSING") + return (FtCreateFieldOptionIndexmissing)(c) +} + func (c FtCreateFieldOptionCasesensitive) Sortable() FtCreateFieldOptionSortableSortable { c.cs.s = append(c.cs.s, "SORTABLE") return (FtCreateFieldOptionSortableSortable)(c) @@ -2333,6 +2403,130 @@ func (c FtCreateFieldOptionCasesensitive) Build() Completed { return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks} } +type FtCreateFieldOptionIndexempty Incomplete + +func (c FtCreateFieldOptionIndexempty) Indexmissing() FtCreateFieldOptionIndexmissing { + c.cs.s = append(c.cs.s, "INDEXMISSING") + return (FtCreateFieldOptionIndexmissing)(c) +} + +func (c FtCreateFieldOptionIndexempty) Sortable() FtCreateFieldOptionSortableSortable { + c.cs.s = append(c.cs.s, "SORTABLE") + return (FtCreateFieldOptionSortableSortable)(c) +} + +func (c FtCreateFieldOptionIndexempty) Noindex() FtCreateFieldOptionNoindex { + c.cs.s = append(c.cs.s, "NOINDEX") + return (FtCreateFieldOptionNoindex)(c) +} + +func (c FtCreateFieldOptionIndexempty) Nostem() FtCreateFieldOptionNostem { + c.cs.s = append(c.cs.s, "NOSTEM") + return (FtCreateFieldOptionNostem)(c) +} + +func (c FtCreateFieldOptionIndexempty) Phonetic(phonetic string) FtCreateFieldOptionPhonetic { + c.cs.s = append(c.cs.s, "PHONETIC", phonetic) + return (FtCreateFieldOptionPhonetic)(c) +} + +func (c FtCreateFieldOptionIndexempty) Weight(weight float64) FtCreateFieldOptionWeight { + c.cs.s = append(c.cs.s, "WEIGHT", strconv.FormatFloat(weight, 'f', -1, 64)) + return (FtCreateFieldOptionWeight)(c) +} + +func (c FtCreateFieldOptionIndexempty) Separator(separator string) FtCreateFieldOptionSeparator { + c.cs.s = append(c.cs.s, "SEPARATOR", separator) + return (FtCreateFieldOptionSeparator)(c) +} + +func (c FtCreateFieldOptionIndexempty) Casesensitive() FtCreateFieldOptionCasesensitive { + c.cs.s = append(c.cs.s, "CASESENSITIVE") + return (FtCreateFieldOptionCasesensitive)(c) +} + +func (c FtCreateFieldOptionIndexempty) Withsuffixtrie() FtCreateFieldOptionWithsuffixtrie { + c.cs.s = append(c.cs.s, "WITHSUFFIXTRIE") + return (FtCreateFieldOptionWithsuffixtrie)(c) +} + +func (c FtCreateFieldOptionIndexempty) Indexempty() FtCreateFieldOptionIndexempty { + c.cs.s = append(c.cs.s, "INDEXEMPTY") + return c +} + +func (c FtCreateFieldOptionIndexempty) FieldName(fieldName string) FtCreateFieldFieldName { + c.cs.s = append(c.cs.s, fieldName) + return (FtCreateFieldFieldName)(c) +} + +func (c FtCreateFieldOptionIndexempty) Build() Completed { + c.cs.Build() + return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks} +} + +type FtCreateFieldOptionIndexmissing Incomplete + +func (c FtCreateFieldOptionIndexmissing) Sortable() FtCreateFieldOptionSortableSortable { + c.cs.s = append(c.cs.s, "SORTABLE") + return (FtCreateFieldOptionSortableSortable)(c) +} + +func (c FtCreateFieldOptionIndexmissing) Noindex() FtCreateFieldOptionNoindex { + c.cs.s = append(c.cs.s, "NOINDEX") + return (FtCreateFieldOptionNoindex)(c) +} + +func (c FtCreateFieldOptionIndexmissing) Nostem() FtCreateFieldOptionNostem { + c.cs.s = append(c.cs.s, "NOSTEM") + return (FtCreateFieldOptionNostem)(c) +} + +func (c FtCreateFieldOptionIndexmissing) Phonetic(phonetic string) FtCreateFieldOptionPhonetic { + c.cs.s = append(c.cs.s, "PHONETIC", phonetic) + return (FtCreateFieldOptionPhonetic)(c) +} + +func (c FtCreateFieldOptionIndexmissing) Weight(weight float64) FtCreateFieldOptionWeight { + c.cs.s = append(c.cs.s, "WEIGHT", strconv.FormatFloat(weight, 'f', -1, 64)) + return (FtCreateFieldOptionWeight)(c) +} + +func (c FtCreateFieldOptionIndexmissing) Separator(separator string) FtCreateFieldOptionSeparator { + c.cs.s = append(c.cs.s, "SEPARATOR", separator) + return (FtCreateFieldOptionSeparator)(c) +} + +func (c FtCreateFieldOptionIndexmissing) Casesensitive() FtCreateFieldOptionCasesensitive { + c.cs.s = append(c.cs.s, "CASESENSITIVE") + return (FtCreateFieldOptionCasesensitive)(c) +} + +func (c FtCreateFieldOptionIndexmissing) Withsuffixtrie() FtCreateFieldOptionWithsuffixtrie { + c.cs.s = append(c.cs.s, "WITHSUFFIXTRIE") + return (FtCreateFieldOptionWithsuffixtrie)(c) +} + +func (c FtCreateFieldOptionIndexmissing) Indexempty() FtCreateFieldOptionIndexempty { + c.cs.s = append(c.cs.s, "INDEXEMPTY") + return (FtCreateFieldOptionIndexempty)(c) +} + +func (c FtCreateFieldOptionIndexmissing) Indexmissing() FtCreateFieldOptionIndexmissing { + c.cs.s = append(c.cs.s, "INDEXMISSING") + return c +} + +func (c FtCreateFieldOptionIndexmissing) FieldName(fieldName string) FtCreateFieldFieldName { + c.cs.s = append(c.cs.s, fieldName) + return (FtCreateFieldFieldName)(c) +} + +func (c FtCreateFieldOptionIndexmissing) Build() Completed { + c.cs.Build() + return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks} +} + type FtCreateFieldOptionNoindex Incomplete func (c FtCreateFieldOptionNoindex) Nostem() FtCreateFieldOptionNostem { @@ -2365,6 +2559,16 @@ func (c FtCreateFieldOptionNoindex) Withsuffixtrie() FtCreateFieldOptionWithsuff return (FtCreateFieldOptionWithsuffixtrie)(c) } +func (c FtCreateFieldOptionNoindex) Indexempty() FtCreateFieldOptionIndexempty { + c.cs.s = append(c.cs.s, "INDEXEMPTY") + return (FtCreateFieldOptionIndexempty)(c) +} + +func (c FtCreateFieldOptionNoindex) Indexmissing() FtCreateFieldOptionIndexmissing { + c.cs.s = append(c.cs.s, "INDEXMISSING") + return (FtCreateFieldOptionIndexmissing)(c) +} + func (c FtCreateFieldOptionNoindex) Sortable() FtCreateFieldOptionSortableSortable { c.cs.s = append(c.cs.s, "SORTABLE") return (FtCreateFieldOptionSortableSortable)(c) @@ -2412,6 +2616,16 @@ func (c FtCreateFieldOptionNostem) Withsuffixtrie() FtCreateFieldOptionWithsuffi return (FtCreateFieldOptionWithsuffixtrie)(c) } +func (c FtCreateFieldOptionNostem) Indexempty() FtCreateFieldOptionIndexempty { + c.cs.s = append(c.cs.s, "INDEXEMPTY") + return (FtCreateFieldOptionIndexempty)(c) +} + +func (c FtCreateFieldOptionNostem) Indexmissing() FtCreateFieldOptionIndexmissing { + c.cs.s = append(c.cs.s, "INDEXMISSING") + return (FtCreateFieldOptionIndexmissing)(c) +} + func (c FtCreateFieldOptionNostem) Sortable() FtCreateFieldOptionSortableSortable { c.cs.s = append(c.cs.s, "SORTABLE") return (FtCreateFieldOptionSortableSortable)(c) @@ -2459,6 +2673,16 @@ func (c FtCreateFieldOptionPhonetic) Withsuffixtrie() FtCreateFieldOptionWithsuf return (FtCreateFieldOptionWithsuffixtrie)(c) } +func (c FtCreateFieldOptionPhonetic) Indexempty() FtCreateFieldOptionIndexempty { + c.cs.s = append(c.cs.s, "INDEXEMPTY") + return (FtCreateFieldOptionIndexempty)(c) +} + +func (c FtCreateFieldOptionPhonetic) Indexmissing() FtCreateFieldOptionIndexmissing { + c.cs.s = append(c.cs.s, "INDEXMISSING") + return (FtCreateFieldOptionIndexmissing)(c) +} + func (c FtCreateFieldOptionPhonetic) Sortable() FtCreateFieldOptionSortableSortable { c.cs.s = append(c.cs.s, "SORTABLE") return (FtCreateFieldOptionSortableSortable)(c) @@ -2501,6 +2725,16 @@ func (c FtCreateFieldOptionSeparator) Withsuffixtrie() FtCreateFieldOptionWithsu return (FtCreateFieldOptionWithsuffixtrie)(c) } +func (c FtCreateFieldOptionSeparator) Indexempty() FtCreateFieldOptionIndexempty { + c.cs.s = append(c.cs.s, "INDEXEMPTY") + return (FtCreateFieldOptionIndexempty)(c) +} + +func (c FtCreateFieldOptionSeparator) Indexmissing() FtCreateFieldOptionIndexmissing { + c.cs.s = append(c.cs.s, "INDEXMISSING") + return (FtCreateFieldOptionIndexmissing)(c) +} + func (c FtCreateFieldOptionSeparator) Sortable() FtCreateFieldOptionSortableSortable { c.cs.s = append(c.cs.s, "SORTABLE") return (FtCreateFieldOptionSortableSortable)(c) @@ -2583,6 +2817,16 @@ func (c FtCreateFieldOptionSortableSortable) Withsuffixtrie() FtCreateFieldOptio return (FtCreateFieldOptionWithsuffixtrie)(c) } +func (c FtCreateFieldOptionSortableSortable) Indexempty() FtCreateFieldOptionIndexempty { + c.cs.s = append(c.cs.s, "INDEXEMPTY") + return (FtCreateFieldOptionIndexempty)(c) +} + +func (c FtCreateFieldOptionSortableSortable) Indexmissing() FtCreateFieldOptionIndexmissing { + c.cs.s = append(c.cs.s, "INDEXMISSING") + return (FtCreateFieldOptionIndexmissing)(c) +} + func (c FtCreateFieldOptionSortableSortable) Sortable() FtCreateFieldOptionSortableSortable { c.cs.s = append(c.cs.s, "SORTABLE") return c @@ -2635,6 +2879,16 @@ func (c FtCreateFieldOptionSortableUnf) Withsuffixtrie() FtCreateFieldOptionWith return (FtCreateFieldOptionWithsuffixtrie)(c) } +func (c FtCreateFieldOptionSortableUnf) Indexempty() FtCreateFieldOptionIndexempty { + c.cs.s = append(c.cs.s, "INDEXEMPTY") + return (FtCreateFieldOptionIndexempty)(c) +} + +func (c FtCreateFieldOptionSortableUnf) Indexmissing() FtCreateFieldOptionIndexmissing { + c.cs.s = append(c.cs.s, "INDEXMISSING") + return (FtCreateFieldOptionIndexmissing)(c) +} + func (c FtCreateFieldOptionSortableUnf) Sortable() FtCreateFieldOptionSortableSortable { c.cs.s = append(c.cs.s, "SORTABLE") return (FtCreateFieldOptionSortableSortable)(c) @@ -2667,6 +2921,16 @@ func (c FtCreateFieldOptionWeight) Withsuffixtrie() FtCreateFieldOptionWithsuffi return (FtCreateFieldOptionWithsuffixtrie)(c) } +func (c FtCreateFieldOptionWeight) Indexempty() FtCreateFieldOptionIndexempty { + c.cs.s = append(c.cs.s, "INDEXEMPTY") + return (FtCreateFieldOptionIndexempty)(c) +} + +func (c FtCreateFieldOptionWeight) Indexmissing() FtCreateFieldOptionIndexmissing { + c.cs.s = append(c.cs.s, "INDEXMISSING") + return (FtCreateFieldOptionIndexmissing)(c) +} + func (c FtCreateFieldOptionWeight) Sortable() FtCreateFieldOptionSortableSortable { c.cs.s = append(c.cs.s, "SORTABLE") return (FtCreateFieldOptionSortableSortable)(c) @@ -2704,6 +2968,16 @@ func (c FtCreateFieldOptionWeight) Build() Completed { type FtCreateFieldOptionWithsuffixtrie Incomplete +func (c FtCreateFieldOptionWithsuffixtrie) Indexempty() FtCreateFieldOptionIndexempty { + c.cs.s = append(c.cs.s, "INDEXEMPTY") + return (FtCreateFieldOptionIndexempty)(c) +} + +func (c FtCreateFieldOptionWithsuffixtrie) Indexmissing() FtCreateFieldOptionIndexmissing { + c.cs.s = append(c.cs.s, "INDEXMISSING") + return (FtCreateFieldOptionIndexmissing)(c) +} + func (c FtCreateFieldOptionWithsuffixtrie) Sortable() FtCreateFieldOptionSortableSortable { c.cs.s = append(c.cs.s, "SORTABLE") return (FtCreateFieldOptionSortableSortable)(c) diff --git a/internal/cmds/gen_search_test.go b/internal/cmds/gen_search_test.go index a2be4025..f30af599 100644 --- a/internal/cmds/gen_search_test.go +++ b/internal/cmds/gen_search_test.go @@ -227,66 +227,111 @@ func search2(s Builder) { s.FtConfigGet().Option("1").Build() s.FtConfigHelp().Option("1").Build() s.FtConfigSet().Option("1").Value("1").Build() - s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Build() - s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Phonetic("1").Build() - s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Weight(1).Build() - s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Separator("1").Build() - s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Casesensitive().Build() - s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Noindex().Build() - s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Nostem().Phonetic("1").Build() - s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Nostem().Weight(1).Build() - s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Nostem().Separator("1").Build() - s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Nostem().Casesensitive().Build() - s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Nostem().Noindex().Build() - s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Nostem().Nostem().Build() - s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Phonetic("1").Weight(1).Build() - s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Phonetic("1").Separator("1").Build() - s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Phonetic("1").Casesensitive().Build() - s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Phonetic("1").Noindex().Build() - s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Phonetic("1").Nostem().Build() - s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Phonetic("1").Phonetic("1").Build() - s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Weight(1).Separator("1").Build() - s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Weight(1).Casesensitive().Build() - s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Weight(1).Noindex().Build() - s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Weight(1).Nostem().Build() - s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Weight(1).Phonetic("1").Build() - s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Weight(1).Weight(1).Build() - s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Separator("1").Casesensitive().Build() - s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Separator("1").Noindex().Build() - s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Separator("1").Nostem().Build() - s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Separator("1").Phonetic("1").Build() - s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Separator("1").Weight(1).Build() - s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Separator("1").Separator("1").Build() - s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Casesensitive().Build() - s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Sortable().Unf().Nostem().Build() - s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Sortable().Unf().Phonetic("1").Build() - s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Sortable().Unf().Weight(1).Build() - s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Sortable().Unf().Separator("1").Build() - s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Sortable().Unf().Casesensitive().Build() - s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Sortable().Unf().Build() - s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Sortable().Noindex().Build() - s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Sortable().Nostem().Build() - s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Sortable().Phonetic("1").Build() - s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Sortable().Weight(1).Build() - s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Sortable().Separator("1").Build() - s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Sortable().Casesensitive().Build() - s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Sortable().Sortable().Build() - s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Noindex().Build() - s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Nostem().Build() - s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Phonetic("1").Build() - s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Weight(1).Build() - s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Separator("1").Build() - s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Casesensitive().Build() - s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Withsuffixtrie().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Withsuffixtrie().Build() - s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Noindex().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Nostem().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Phonetic("1").Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Weight(1).Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Separator("1").Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Casesensitive().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Withsuffixtrie().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexempty().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexmissing().Noindex().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexmissing().Nostem().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexmissing().Phonetic("1").Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexmissing().Weight(1).Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexmissing().Separator("1").Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexmissing().Casesensitive().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexmissing().Withsuffixtrie().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexmissing().Indexempty().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexmissing().Indexmissing().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Noindex().Nostem().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Noindex().Phonetic("1").Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Noindex().Weight(1).Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Noindex().Separator("1").Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Noindex().Casesensitive().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Noindex().Withsuffixtrie().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Noindex().Indexempty().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Noindex().Indexmissing().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Noindex().Noindex().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Nostem().Phonetic("1").Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Nostem().Weight(1).Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Nostem().Separator("1").Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Nostem().Casesensitive().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Nostem().Withsuffixtrie().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Nostem().Indexempty().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Nostem().Indexmissing().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Nostem().Noindex().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Nostem().Nostem().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Phonetic("1").Weight(1).Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Phonetic("1").Separator("1").Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Phonetic("1").Casesensitive().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Phonetic("1").Withsuffixtrie().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Phonetic("1").Indexempty().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Phonetic("1").Indexmissing().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Phonetic("1").Noindex().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Phonetic("1").Nostem().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Phonetic("1").Phonetic("1").Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Weight(1).Separator("1").Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Weight(1).Casesensitive().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Weight(1).Withsuffixtrie().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Weight(1).Indexempty().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Weight(1).Indexmissing().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Weight(1).Noindex().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Weight(1).Nostem().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Weight(1).Phonetic("1").Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Weight(1).Weight(1).Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Separator("1").Casesensitive().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Separator("1").Withsuffixtrie().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Separator("1").Indexempty().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Separator("1").Indexmissing().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Separator("1").Noindex().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Separator("1").Nostem().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Separator("1").Phonetic("1").Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Separator("1").Weight(1).Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Separator("1").Separator("1").Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Casesensitive().Withsuffixtrie().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Casesensitive().Indexempty().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Casesensitive().Indexmissing().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Casesensitive().Noindex().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Casesensitive().Nostem().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Casesensitive().Phonetic("1").Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Casesensitive().Weight(1).Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Casesensitive().Separator("1").Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Casesensitive().Casesensitive().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Withsuffixtrie().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Nostem().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Phonetic("1").Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Weight(1).Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Separator("1").Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Casesensitive().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Withsuffixtrie().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Indexempty().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Indexmissing().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Noindex().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Nostem().Build() +} + +func search3(s Builder) { + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Phonetic("1").Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Weight(1).Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Separator("1").Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Casesensitive().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Withsuffixtrie().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Indexempty().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Indexmissing().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Sortable().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Noindex().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Nostem().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Phonetic("1").Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Weight(1).Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Separator("1").Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Casesensitive().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Withsuffixtrie().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Indexempty().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Indexmissing().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() - s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Tag().Withsuffixtrie().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Tag().Sortable().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Tag().Noindex().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Tag().Nostem().Build() @@ -294,8 +339,10 @@ func search2(s Builder) { s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Tag().Weight(1).Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Tag().Separator("1").Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Tag().Casesensitive().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Tag().Withsuffixtrie().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Tag().Indexempty().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Tag().Indexmissing().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Tag().Build() - s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Numeric().Withsuffixtrie().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Numeric().Sortable().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Numeric().Noindex().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Numeric().Nostem().Build() @@ -303,20 +350,21 @@ func search2(s Builder) { s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Numeric().Weight(1).Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Numeric().Separator("1").Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Numeric().Casesensitive().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Numeric().Withsuffixtrie().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Numeric().Indexempty().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Numeric().Indexmissing().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Numeric().Build() - s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Geo().Withsuffixtrie().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Geo().Sortable().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Geo().Noindex().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Geo().Nostem().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Geo().Phonetic("1").Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Geo().Weight(1).Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Geo().Separator("1").Build() -} - -func search3(s Builder) { s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Geo().Casesensitive().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Geo().Withsuffixtrie().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Geo().Indexempty().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Geo().Indexmissing().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Geo().Build() - s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Vector("1", 1).Withsuffixtrie().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Vector("1", 1).Sortable().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Vector("1", 1).Noindex().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Vector("1", 1).Nostem().Build() @@ -324,8 +372,10 @@ func search3(s Builder) { s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Vector("1", 1).Weight(1).Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Vector("1", 1).Separator("1").Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Vector("1", 1).Casesensitive().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Vector("1", 1).Withsuffixtrie().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Vector("1", 1).Indexempty().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Vector("1", 1).Indexmissing().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Vector("1", 1).Build() - s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Geoshape().Withsuffixtrie().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Geoshape().Sortable().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Geoshape().Noindex().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Geoshape().Nostem().Build() @@ -333,6 +383,9 @@ func search3(s Builder) { s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Geoshape().Weight(1).Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Geoshape().Separator("1").Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Geoshape().Casesensitive().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Geoshape().Withsuffixtrie().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Geoshape().Indexempty().Build() + s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Geoshape().Indexmissing().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Geoshape().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").Text().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").Tag().Build() @@ -361,6 +414,9 @@ func search3(s Builder) { s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() +} + +func search4(s Builder) { s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Schema().FieldName("1").As("1").Text().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() @@ -414,9 +470,6 @@ func search3(s Builder) { s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() -} - -func search4(s Builder) { s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() @@ -464,6 +517,9 @@ func search4(s Builder) { s.FtCreate().Index("1").OnHash().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() s.FtCreate().Index("1").OnHash().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() s.FtCreate().Index("1").OnHash().Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() +} + +func search5(s Builder) { s.FtCreate().Index("1").OnHash().Schema().FieldName("1").As("1").Text().Build() s.FtCreate().Index("1").OnJson().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() s.FtCreate().Index("1").OnJson().Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() @@ -517,9 +573,6 @@ func search4(s Builder) { s.FtProfile().Index("1").Aggregate().Query("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Expander("1").Scorer("1").Explainscore().Payload("1").Sortby("1").Asc().Withcount().Limit().OffsetNum(1, 1).Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Dialect(1).Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Expander("1").Scorer("1").Explainscore().Payload("1").Sortby("1").Asc().Withcount().Limit().OffsetNum(1, 1).Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() -} - -func search5(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Expander("1").Scorer("1").Explainscore().Payload("1").Sortby("1").Asc().Withcount().Limit().OffsetNum(1, 1).Dialect(1).Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Expander("1").Scorer("1").Explainscore().Payload("1").Sortby("1").Asc().Withcount().Limit().OffsetNum(1, 1).Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Expander("1").Scorer("1").Explainscore().Payload("1").Sortby("1").Asc().Withcount().Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() @@ -567,6 +620,9 @@ func search5(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Sortby("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Limit().OffsetNum(1, 1).Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() +} + +func search6(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Dialect(1).Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Expander("1").Build() @@ -620,9 +676,6 @@ func search5(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Explainscore().Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Payload("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Sortby("1").Build() -} - -func search6(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Limit().OffsetNum(1, 1).Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Dialect(1).Build() @@ -670,6 +723,9 @@ func search6(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Separator("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Highlight().Build() +} + +func search7(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Slop(1).Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Timeout(1).Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Inorder().Build() @@ -723,9 +779,6 @@ func search6(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Language("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Expander("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Scorer("1").Build() -} - -func search7(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Explainscore().Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Payload("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Sortby("1").Build() @@ -773,6 +826,9 @@ func search7(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Expander("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Scorer("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Explainscore().Build() +} + +func search8(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Payload("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Sortby("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Limit().OffsetNum(1, 1).Build() @@ -826,9 +882,6 @@ func search7(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).Mi().Expander("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).Mi().Scorer("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).Mi().Explainscore().Build() -} - -func search8(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).Mi().Payload("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).Mi().Sortby("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).Mi().Limit().OffsetNum(1, 1).Build() @@ -876,6 +929,9 @@ func search8(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Infields("1").Field("1").Field("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Return("1").Identifier("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Summarize().Build() +} + +func search9(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Highlight().Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Slop(1).Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Timeout(1).Build() @@ -929,9 +985,6 @@ func search8(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Sortby("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Limit().OffsetNum(1, 1).Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() -} - -func search9(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Dialect(1).Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withpayloads().Build() @@ -979,6 +1032,9 @@ func search9(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Dialect(1).Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Build() +} + +func search10(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Nostopwords().Build() s.FtSearch().Index("1").Query("1").Nocontent().Withscores().Build() s.FtSearch().Index("1").Query("1").Nocontent().Withpayloads().Build() @@ -1032,9 +1088,6 @@ func search9(s Builder) { s.FtSpellcheck().Index("1").Query("1").Distance(1).TermsInclude().Dictionary("1").Terms("1").Terms("1").Build() s.FtSpellcheck().Index("1").Query("1").Distance(1).TermsInclude().Dictionary("1").Dialect(1).Build() s.FtSpellcheck().Index("1").Query("1").Distance(1).TermsInclude().Dictionary("1").Build() -} - -func search10(s Builder) { s.FtSpellcheck().Index("1").Query("1").Distance(1).TermsExclude().Dictionary("1").Build() s.FtSpellcheck().Index("1").Query("1").Distance(1).Dialect(1).Build() s.FtSpellcheck().Index("1").Query("1").Distance(1).Build() From f29e8eff7e64c694f90e0daa32616bc55ada72d6 Mon Sep 17 00:00:00 2001 From: Eric Chang Date: Tue, 19 Nov 2024 07:39:35 +0800 Subject: [PATCH 20/49] fix(FTCreateCmd): fix failed tests --- rueidiscompat/adapter.go | 50 ++++++++++++++++++++++++++--------- rueidiscompat/adapter_test.go | 4 +-- rueidiscompat/command.go | 11 +++++++- 3 files changed, 50 insertions(+), 15 deletions(-) diff --git a/rueidiscompat/adapter.go b/rueidiscompat/adapter.go index ccafdba0..d727aec9 100644 --- a/rueidiscompat/adapter.go +++ b/rueidiscompat/adapter.go @@ -5081,34 +5081,37 @@ func (c *Compat) FTCreate(ctx context.Context, index string, options *FTCreateOp } } _cmd = cmds.Incomplete(cmds.FtCreateIndex(_cmd).Schema()) + // SCHEMA field_name [AS alias] TEXT | TAG | NUMERIC | GEO | VECTOR | GEOSHAPE [ SORTABLE [UNF]] + // [NOINDEX] [ field_name [AS alias] TEXT | TAG | NUMERIC | GEO | VECTOR | GEOSHAPE [ SORTABLE [UNF]] [NOINDEX] ...] + for _, sc := range schema { _cmd = cmds.Incomplete(cmds.FtCreateSchema(_cmd).FieldName(sc.FieldName)) if sc.As != "" { _cmd = cmds.Incomplete(cmds.FtCreateFieldFieldName(_cmd).As(sc.As)) } switch sc.FieldType { - case SearchFieldTypeGeo: - _cmd = cmds.Incomplete(cmds.FtCreateFieldAs(_cmd).Geo()) - case SearchFieldTypeGeoShape: - _cmd = cmds.Incomplete(cmds.FtCreateFieldAs(_cmd).Geoshape()) case SearchFieldTypeNumeric: _cmd = cmds.Incomplete(cmds.FtCreateFieldAs(_cmd).Numeric()) case SearchFieldTypeTag: _cmd = cmds.Incomplete(cmds.FtCreateFieldAs(_cmd).Tag()) case SearchFieldTypeText: _cmd = cmds.Incomplete(cmds.FtCreateFieldAs(_cmd).Text()) + case SearchFieldTypeGeo: + _cmd = cmds.Incomplete(cmds.FtCreateFieldAs(_cmd).Geo()) case SearchFieldTypeVector: // FIXME: implement this break // if (sc.VectorArgs.FlatOptions == sc.VectorArgs.HNSWOptions) { - // panic("Vector index algorithm should be either FLAT or HNSW") - // } - // if (sc.VectorArgs.FlatOptions!= nil) { - // // (algo string, nargs int64, args ...string) - // _cmd = cmds.Incomplete(cmds.FtCreateFieldAs(_cmd).Vector("FLAT",sc.VectorArgs.FlatOptions.)) - // } else { - - // } + // panic("Vector index algorithm should be either FLAT or HNSW") + // } + // if (sc.VectorArgs.FlatOptions!= nil) { + // // (algo string, nargs int64, args ...string) + // _cmd = cmds.Incomplete(cmds.FtCreateFieldAs(_cmd).Vector("FLAT",sc.VectorArgs.FlatOptions.)) + // } else { + + // } + case SearchFieldTypeGeoShape: + _cmd = cmds.Incomplete(cmds.FtCreateFieldAs(_cmd).Geoshape()) default: panic(fmt.Sprintf("unexpected SearchFieldType: %s", sc.FieldType.String())) } @@ -5121,7 +5124,30 @@ func (c *Compat) FTCreate(ctx context.Context, index string, options *FTCreateOp if sc.NoIndex { _cmd = cmds.Incomplete(cmds.FtCreateFieldFieldTypeText(_cmd).Noindex()) } + // FIXME: redis doc: PHONETIC not in EBNF definition + if sc.PhoneticMatcher != "" { + _cmd = cmds.Incomplete(cmds.FtCreateFieldFieldTypeText(_cmd).Phonetic(sc.PhoneticMatcher)) + } + if sc.Weight > 0 { + _cmd = cmds.Incomplete(cmds.FtCreateFieldFieldTypeText(_cmd).Weight(sc.Weight)) + } + if sc.Separator != "" { + _cmd = cmds.Incomplete(cmds.FtCreateFieldFieldTypeText(_cmd).Separator(sc.Separator)) + } + if sc.CaseSensitive { + _cmd = cmds.Incomplete(cmds.FtCreateFieldFieldTypeText(_cmd).Casesensitive()) + } + if sc.WithSuffixtrie { + _cmd = cmds.Incomplete(cmds.FtCreateFieldFieldTypeText(_cmd).Withsuffixtrie()) + } + if sc.IndexEmpty { + _cmd = cmds.Incomplete(cmds.FtCreateFieldFieldTypeText(_cmd).Indexempty()) + } + if sc.IndexMissing { + _cmd = cmds.Incomplete(cmds.FtCreateFieldFieldTypeText(_cmd).Casesensitive()) + } } + // FIXME: handle index properly cmd := cmds.FtCreateFieldFieldTypeText(_cmd).Build() return newStatusCmd(c.client.Do(ctx, cmd)) diff --git a/rueidiscompat/adapter_test.go b/rueidiscompat/adapter_test.go index 2d4ad363..d682dcdd 100644 --- a/rueidiscompat/adapter_test.go +++ b/rueidiscompat/adapter_test.go @@ -11555,7 +11555,7 @@ func testAdapterCache(resp3 bool) { Expect(adapter.FlushDB(ctx).Err()).NotTo(HaveOccurred()) }) - FIt("should FTCreate and FTSearch WithScores", Label("search", "ftcreate", "ftsearch"), func() { + It("should FTCreate and FTSearch WithScores", Label("search", "ftcreate", "ftsearch"), func() { // FIXME: FieldType val, err := adapter.FTCreate(ctx, "txt", &FTCreateOptions{}, &FieldSchema{FieldName: "txt", FieldType: SearchFieldTypeText}).Result() Expect(err).NotTo(HaveOccurred()) @@ -11940,7 +11940,7 @@ func testAdapterCache(resp3 bool) { }) - It("should FTAggregate GroupBy ", Label("search", "ftaggregate"), func() { + FIt("should FTAggregate GroupBy ", Label("search", "ftaggregate"), func() { text1 := &FieldSchema{FieldName: "title", FieldType: SearchFieldTypeText} text2 := &FieldSchema{FieldName: "body", FieldType: SearchFieldTypeText} text3 := &FieldSchema{FieldName: "parent", FieldType: SearchFieldTypeText} diff --git a/rueidiscompat/command.go b/rueidiscompat/command.go index 6977237a..606f562a 100644 --- a/rueidiscompat/command.go +++ b/rueidiscompat/command.go @@ -3857,6 +3857,15 @@ func (cmd *FTSearchCmd) from(res rueidis.RedisResult) { cmd.SetErr(err) return } + totalResultsMsg, ok := m["total_results"] + if !ok { + cmd.SetErr(fmt.Errorf(`result map should contain key "total_results"`)) + } + totalResults, err := totalResultsMsg.AsInt64() + if err != nil { + cmd.SetErr(err) + return + } resultsMsg, ok := m["results"] if !ok { cmd.SetErr(fmt.Errorf(`result map should contain key "results"`)) @@ -3866,7 +3875,7 @@ func (cmd *FTSearchCmd) from(res rueidis.RedisResult) { cmd.SetErr(err) return } - ftSearchResult := FTSearchResult{Total: len(resultsArr), Docs: make([]Document, 0, len(resultsArr))} + ftSearchResult := FTSearchResult{Total: int(totalResults), Docs: make([]Document, 0, len(resultsArr))} for _, result := range resultsArr { // result: arr: id, doc2, score, 3, "extra_attributes": [foo, bar] resultMap, err := result.ToMap() From c69f492a70027c924bedf9fbfd439ab22b54cfbf Mon Sep 17 00:00:00 2001 From: Eric Chang Date: Tue, 19 Nov 2024 20:53:05 +0800 Subject: [PATCH 21/49] feat(hack/cmds/commands_search.json): FT.AGGREGATE: add missing WITHCOUNT option --- hack/cmds/commands_search.json | 6 + internal/cmds/gen_search.go | 87 +++++++ internal/cmds/gen_search_test.go | 407 ++++++++++++++++--------------- 3 files changed, 301 insertions(+), 199 deletions(-) diff --git a/hack/cmds/commands_search.json b/hack/cmds/commands_search.json index c7c67b18..aa144e56 100644 --- a/hack/cmds/commands_search.json +++ b/hack/cmds/commands_search.json @@ -1214,6 +1214,12 @@ "type": "integer", "command": "MAX", "optional": true + }, + { + "name": "withcount", + "type": "enum", + "enum": ["WITHCOUNT"], + "optional": true } ] }, diff --git a/internal/cmds/gen_search.go b/internal/cmds/gen_search.go index 3c2e21d1..f34933a5 100644 --- a/internal/cmds/gen_search.go +++ b/internal/cmds/gen_search.go @@ -1100,6 +1100,11 @@ func (c FtAggregateOpSortbyFieldsOrderAsc) Max(num int64) FtAggregateOpSortbyMax return (FtAggregateOpSortbyMax)(c) } +func (c FtAggregateOpSortbyFieldsOrderAsc) Withcount() FtAggregateOpSortbyWithcount { + c.cs.s = append(c.cs.s, "WITHCOUNT") + return (FtAggregateOpSortbyWithcount)(c) +} + func (c FtAggregateOpSortbyFieldsOrderAsc) Apply(expression string) FtAggregateOpApplyApply { c.cs.s = append(c.cs.s, "APPLY", expression) return (FtAggregateOpApplyApply)(c) @@ -1172,6 +1177,11 @@ func (c FtAggregateOpSortbyFieldsOrderDesc) Max(num int64) FtAggregateOpSortbyMa return (FtAggregateOpSortbyMax)(c) } +func (c FtAggregateOpSortbyFieldsOrderDesc) Withcount() FtAggregateOpSortbyWithcount { + c.cs.s = append(c.cs.s, "WITHCOUNT") + return (FtAggregateOpSortbyWithcount)(c) +} + func (c FtAggregateOpSortbyFieldsOrderDesc) Apply(expression string) FtAggregateOpApplyApply { c.cs.s = append(c.cs.s, "APPLY", expression) return (FtAggregateOpApplyApply)(c) @@ -1254,6 +1264,11 @@ func (c FtAggregateOpSortbyFieldsProperty) Max(num int64) FtAggregateOpSortbyMax return (FtAggregateOpSortbyMax)(c) } +func (c FtAggregateOpSortbyFieldsProperty) Withcount() FtAggregateOpSortbyWithcount { + c.cs.s = append(c.cs.s, "WITHCOUNT") + return (FtAggregateOpSortbyWithcount)(c) +} + func (c FtAggregateOpSortbyFieldsProperty) Apply(expression string) FtAggregateOpApplyApply { c.cs.s = append(c.cs.s, "APPLY", expression) return (FtAggregateOpApplyApply)(c) @@ -1316,6 +1331,11 @@ func (c FtAggregateOpSortbyFieldsProperty) Build() Completed { type FtAggregateOpSortbyMax Incomplete +func (c FtAggregateOpSortbyMax) Withcount() FtAggregateOpSortbyWithcount { + c.cs.s = append(c.cs.s, "WITHCOUNT") + return (FtAggregateOpSortbyWithcount)(c) +} + func (c FtAggregateOpSortbyMax) Apply(expression string) FtAggregateOpApplyApply { c.cs.s = append(c.cs.s, "APPLY", expression) return (FtAggregateOpApplyApply)(c) @@ -1388,6 +1408,11 @@ func (c FtAggregateOpSortbySortby) Max(num int64) FtAggregateOpSortbyMax { return (FtAggregateOpSortbyMax)(c) } +func (c FtAggregateOpSortbySortby) Withcount() FtAggregateOpSortbyWithcount { + c.cs.s = append(c.cs.s, "WITHCOUNT") + return (FtAggregateOpSortbyWithcount)(c) +} + func (c FtAggregateOpSortbySortby) Apply(expression string) FtAggregateOpApplyApply { c.cs.s = append(c.cs.s, "APPLY", expression) return (FtAggregateOpApplyApply)(c) @@ -1448,6 +1473,68 @@ func (c FtAggregateOpSortbySortby) Build() Completed { return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks} } +type FtAggregateOpSortbyWithcount Incomplete + +func (c FtAggregateOpSortbyWithcount) Apply(expression string) FtAggregateOpApplyApply { + c.cs.s = append(c.cs.s, "APPLY", expression) + return (FtAggregateOpApplyApply)(c) +} + +func (c FtAggregateOpSortbyWithcount) Limit() FtAggregateOpLimitLimit { + c.cs.s = append(c.cs.s, "LIMIT") + return (FtAggregateOpLimitLimit)(c) +} + +func (c FtAggregateOpSortbyWithcount) Filter(filter string) FtAggregateOpFilter { + c.cs.s = append(c.cs.s, "FILTER", filter) + return (FtAggregateOpFilter)(c) +} + +func (c FtAggregateOpSortbyWithcount) LoadAll() FtAggregateOpLoadallLoadAll { + c.cs.s = append(c.cs.s, "LOAD", "*") + return (FtAggregateOpLoadallLoadAll)(c) +} + +func (c FtAggregateOpSortbyWithcount) Load(count int64) FtAggregateOpLoadLoad { + c.cs.s = append(c.cs.s, "LOAD", strconv.FormatInt(count, 10)) + return (FtAggregateOpLoadLoad)(c) +} + +func (c FtAggregateOpSortbyWithcount) Groupby(nargs int64) FtAggregateOpGroupbyGroupby { + c.cs.s = append(c.cs.s, "GROUPBY", strconv.FormatInt(nargs, 10)) + return (FtAggregateOpGroupbyGroupby)(c) +} + +func (c FtAggregateOpSortbyWithcount) Sortby(nargs int64) FtAggregateOpSortbySortby { + c.cs.s = append(c.cs.s, "SORTBY", strconv.FormatInt(nargs, 10)) + return (FtAggregateOpSortbySortby)(c) +} + +func (c FtAggregateOpSortbyWithcount) Withcursor() FtAggregateCursorWithcursor { + c.cs.s = append(c.cs.s, "WITHCURSOR") + return (FtAggregateCursorWithcursor)(c) +} + +func (c FtAggregateOpSortbyWithcount) Params() FtAggregateParamsParams { + c.cs.s = append(c.cs.s, "PARAMS") + return (FtAggregateParamsParams)(c) +} + +func (c FtAggregateOpSortbyWithcount) Addscores() FtAggregateAddscores { + c.cs.s = append(c.cs.s, "ADDSCORES") + return (FtAggregateAddscores)(c) +} + +func (c FtAggregateOpSortbyWithcount) Dialect(dialect int64) FtAggregateDialect { + c.cs.s = append(c.cs.s, "DIALECT", strconv.FormatInt(dialect, 10)) + return (FtAggregateDialect)(c) +} + +func (c FtAggregateOpSortbyWithcount) Build() Completed { + c.cs.Build() + return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks} +} + type FtAggregateParamsNameValue Incomplete func (c FtAggregateParamsNameValue) NameValue(name string, value string) FtAggregateParamsNameValue { diff --git a/internal/cmds/gen_search_test.go b/internal/cmds/gen_search_test.go index f30af599..1f795e9d 100644 --- a/internal/cmds/gen_search_test.go +++ b/internal/cmds/gen_search_test.go @@ -5,181 +5,190 @@ package cmds import "testing" func search0(s Builder) { - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Filter("1").Filter("1").Withcursor().Count(1).Maxidle(1).Addscores().Dialect(1).Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Filter("1").Filter("1").Withcursor().Count(1).Maxidle(1).Addscores().Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Filter("1").Filter("1").Withcursor().Count(1).Maxidle(1).Dialect(1).Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Filter("1").Filter("1").Withcursor().Count(1).Maxidle(1).Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Filter("1").Filter("1").Withcursor().Count(1).Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Filter("1").Filter("1").Withcursor().Count(1).Addscores().Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Filter("1").Filter("1").Withcursor().Count(1).Dialect(1).Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Filter("1").Filter("1").Withcursor().Count(1).Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Filter("1").Filter("1").Withcursor().Maxidle(1).Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Filter("1").Filter("1").Withcursor().Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Addscores().Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Filter("1").Filter("1").Withcursor().Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Dialect(1).Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Filter("1").Filter("1").Withcursor().Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Filter("1").Filter("1").Withcursor().Addscores().Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Filter("1").Filter("1").Withcursor().Dialect(1).Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Filter("1").Filter("1").Withcursor().Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Filter("1").Filter("1").Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Filter("1").Filter("1").Addscores().Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Filter("1").Filter("1").Dialect(1).Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Filter("1").Filter("1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Withcursor().Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Addscores().Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Dialect(1).Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Filter("1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Withcursor().Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Addscores().Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Dialect(1).Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Limit().OffsetNum(1, 1).Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Filter("1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Withcursor().Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Addscores().Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Dialect(1).Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Apply("1").As("1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Limit().OffsetNum(1, 1).Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Filter("1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Withcursor().Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Addscores().Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Dialect(1).Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Desc().Max(1).Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Desc().Apply("1").As("1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Desc().Limit().OffsetNum(1, 1).Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Desc().Filter("1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Desc().Withcursor().Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Desc().Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Desc().Addscores().Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Desc().Dialect(1).Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Desc().Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Property("1").Max(1).Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Property("1").Apply("1").As("1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Property("1").Limit().OffsetNum(1, 1).Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Property("1").Filter("1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Property("1").Withcursor().Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Property("1").Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Property("1").Addscores().Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Property("1").Dialect(1).Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Property("1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Max(1).Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Apply("1").As("1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Limit().OffsetNum(1, 1).Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Filter("1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Sortby(1).Withcursor().Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Sortby(1).Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Sortby(1).Addscores().Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Sortby(1).Dialect(1).Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Sortby(1).Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Apply("1").As("1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Limit().OffsetNum(1, 1).Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Filter("1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Withcursor().Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Addscores().Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Dialect(1).Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Desc().Sortby(1).Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Desc().Apply("1").As("1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Desc().Limit().OffsetNum(1, 1).Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Desc().Filter("1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Desc().Withcursor().Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Desc().Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Desc().Addscores().Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Desc().Dialect(1).Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Desc().Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Sortby(1).Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Apply("1").As("1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Limit().OffsetNum(1, 1).Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Filter("1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Withcursor().Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Addscores().Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Dialect(1).Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").Asc().Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").Desc().Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Filter("1").Filter("1").Withcursor().Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Filter("1").Filter("1").Addscores().Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Filter("1").Filter("1").Dialect(1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Filter("1").Filter("1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Withcursor().Count(1).Maxidle(1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Withcursor().Count(1).Addscores().Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Withcursor().Count(1).Dialect(1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Withcursor().Count(1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Withcursor().Maxidle(1).Addscores().Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Withcursor().Maxidle(1).Dialect(1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Withcursor().Maxidle(1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Withcursor().Addscores().Dialect(1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Withcursor().Addscores().Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Withcursor().Dialect(1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Withcursor().Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Addscores().Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Dialect(1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Limit().OffsetNum(1, 1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Filter("1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Withcursor().Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Addscores().Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Dialect(1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Addscores().Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Dialect(1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Withcount().Limit().OffsetNum(1, 1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Withcount().Filter("1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Withcount().Withcursor().Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Withcount().Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Withcount().Addscores().Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Withcount().Dialect(1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Withcount().Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Limit().OffsetNum(1, 1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Filter("1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Withcursor().Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Addscores().Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Dialect(1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Max(1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Withcount().Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Apply("1").As("1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Limit().OffsetNum(1, 1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Filter("1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Withcursor().Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Addscores().Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Dialect(1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Asc().Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Desc().Max(1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Desc().Withcount().Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Desc().Apply("1").As("1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Desc().Limit().OffsetNum(1, 1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Desc().Filter("1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Desc().Withcursor().Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Desc().Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Desc().Addscores().Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Desc().Dialect(1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Desc().Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Property("1").Max(1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Property("1").Withcount().Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Property("1").Apply("1").As("1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Property("1").Limit().OffsetNum(1, 1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Property("1").Filter("1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Property("1").Withcursor().Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Property("1").Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Property("1").Addscores().Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Property("1").Dialect(1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Property("1").Property("1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Max(1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Withcount().Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Apply("1").As("1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Limit().OffsetNum(1, 1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Filter("1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Sortby(1).Withcursor().Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Sortby(1).Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Sortby(1).Addscores().Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Sortby(1).Dialect(1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Sortby(1).Sortby(1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Apply("1").As("1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Limit().OffsetNum(1, 1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Filter("1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Withcursor().Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Addscores().Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Dialect(1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Desc().Sortby(1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Desc().Apply("1").As("1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Desc().Limit().OffsetNum(1, 1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Desc().Filter("1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Desc().Withcursor().Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Desc().Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Desc().Addscores().Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Desc().Dialect(1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Desc().Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Sortby(1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Apply("1").As("1").Build() } func search1(s Builder) { - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").Sortby(1).Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").Apply("1").As("1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").Limit().OffsetNum(1, 1).Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").Filter("1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").Withcursor().Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").Addscores().Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").Dialect(1).Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").By("1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").Asc().Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").Desc().Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").Sortby(1).Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").Apply("1").As("1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").Limit().OffsetNum(1, 1).Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").Filter("1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").Withcursor().Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").Addscores().Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").Dialect(1).Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).As("1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).By("1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Asc().Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Desc().Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Sortby(1).Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Apply("1").As("1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Limit().OffsetNum(1, 1).Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Filter("1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Withcursor().Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Addscores().Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Dialect(1).Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Sortby(1).Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Apply("1").As("1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Limit().OffsetNum(1, 1).Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Filter("1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Withcursor().Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Addscores().Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Dialect(1).Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Reduce("1").Nargs(1).Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Groupby(1).Sortby(1).Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Groupby(1).Apply("1").As("1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Groupby(1).Limit().OffsetNum(1, 1).Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Groupby(1).Filter("1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Groupby(1).Withcursor().Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Groupby(1).Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Groupby(1).Addscores().Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Groupby(1).Dialect(1).Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Groupby(1).Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Sortby(1).Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Apply("1").As("1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Limit().OffsetNum(1, 1).Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Filter("1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Withcursor().Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Addscores().Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Dialect(1).Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Groupby(1).Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Sortby(1).Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Apply("1").As("1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Limit().OffsetNum(1, 1).Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Filter("1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().LoadAll().Withcursor().Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().LoadAll().Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().LoadAll().Addscores().Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().LoadAll().Dialect(1).Build() - s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().LoadAll().Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Limit().OffsetNum(1, 1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Filter("1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Withcursor().Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Addscores().Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Dialect(1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").Asc().Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").Desc().Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").Sortby(1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").Apply("1").As("1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").Limit().OffsetNum(1, 1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").Filter("1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").Withcursor().Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").Addscores().Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").Dialect(1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").By("1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").Asc().Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").Desc().Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").Sortby(1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").Apply("1").As("1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").Limit().OffsetNum(1, 1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").Filter("1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").Withcursor().Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").Addscores().Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").Dialect(1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).As("1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).By("1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Asc().Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Desc().Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Sortby(1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Apply("1").As("1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Limit().OffsetNum(1, 1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Filter("1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Withcursor().Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Addscores().Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Dialect(1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Sortby(1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Apply("1").As("1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Limit().OffsetNum(1, 1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Filter("1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Withcursor().Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Addscores().Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Dialect(1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Reduce("1").Nargs(1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Groupby(1).Sortby(1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Groupby(1).Apply("1").As("1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Groupby(1).Limit().OffsetNum(1, 1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Groupby(1).Filter("1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Groupby(1).Withcursor().Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Groupby(1).Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Groupby(1).Addscores().Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Groupby(1).Dialect(1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Groupby(1).Groupby(1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Sortby(1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Apply("1").As("1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Limit().OffsetNum(1, 1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Filter("1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Withcursor().Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Addscores().Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Dialect(1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").Load(1).Field("1").Field("1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Groupby(1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Sortby(1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Apply("1").As("1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Limit().OffsetNum(1, 1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().Filter("1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().LoadAll().Withcursor().Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().LoadAll().Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().LoadAll().Addscores().Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().LoadAll().Dialect(1).Build() + s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).LoadAll().Load(1).Field("1").Field("1").Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Groupby(1).Property("1").Property("1").Reduce("1").Nargs(1).Arg("1").Arg("1").As("1").By("1").Asc().Sortby(1).Property("1").Asc().Property("1").Asc().Max(1).Withcount().Apply("1").As("1").Apply("1").As("1").Limit().OffsetNum(1, 1).Filter("1").LoadAll().LoadAll().Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).Load(1).Field("1").Field("1").Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).Groupby(1).Build() s.FtAggregate().Index("1").Query("1").Verbatim().Timeout(1).Sortby(1).Build() @@ -199,6 +208,9 @@ func search1(s Builder) { s.FtAggregate().Index("1").Query("1").Verbatim().Limit().OffsetNum(1, 1).Build() s.FtAggregate().Index("1").Query("1").Verbatim().Filter("1").Build() s.FtAggregate().Index("1").Query("1").Verbatim().Withcursor().Build() +} + +func search2(s Builder) { s.FtAggregate().Index("1").Query("1").Verbatim().Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() s.FtAggregate().Index("1").Query("1").Verbatim().Addscores().Build() s.FtAggregate().Index("1").Query("1").Verbatim().Dialect(1).Build() @@ -208,9 +220,6 @@ func search1(s Builder) { s.FtAggregate().Index("1").Query("1").Load(1).Field("1").Field("1").Build() s.FtAggregate().Index("1").Query("1").Groupby(1).Build() s.FtAggregate().Index("1").Query("1").Sortby(1).Build() -} - -func search2(s Builder) { s.FtAggregate().Index("1").Query("1").Apply("1").As("1").Build() s.FtAggregate().Index("1").Query("1").Limit().OffsetNum(1, 1).Build() s.FtAggregate().Index("1").Query("1").Filter("1").Build() @@ -302,6 +311,9 @@ func search2(s Builder) { s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Withsuffixtrie().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Nostem().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Phonetic("1").Build() +} + +func search3(s Builder) { s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Weight(1).Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Separator("1").Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Casesensitive().Build() @@ -311,9 +323,6 @@ func search2(s Builder) { s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Unf().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Noindex().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Nostem().Build() -} - -func search3(s Builder) { s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Phonetic("1").Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Weight(1).Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Sortable().Unf().Noindex().Nostem().Phonetic("1").Weight(1).Separator("1").Casesensitive().Withsuffixtrie().Indexempty().Indexmissing().Sortable().Separator("1").Build() @@ -405,6 +414,9 @@ func search3(s Builder) { s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Schema().FieldName("1").As("1").Text().Build() +} + +func search4(s Builder) { s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() @@ -414,9 +426,6 @@ func search3(s Builder) { s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() -} - -func search4(s Builder) { s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Schema().FieldName("1").As("1").Text().Build() s.FtCreate().Index("1").OnHash().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() @@ -508,6 +517,9 @@ func search4(s Builder) { s.FtCreate().Index("1").OnHash().LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() s.FtCreate().Index("1").OnHash().Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() s.FtCreate().Index("1").OnHash().ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() +} + +func search5(s Builder) { s.FtCreate().Index("1").OnHash().PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() s.FtCreate().Index("1").OnHash().Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() s.FtCreate().Index("1").OnHash().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() @@ -517,9 +529,6 @@ func search4(s Builder) { s.FtCreate().Index("1").OnHash().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() s.FtCreate().Index("1").OnHash().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() s.FtCreate().Index("1").OnHash().Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() -} - -func search5(s Builder) { s.FtCreate().Index("1").OnHash().Schema().FieldName("1").As("1").Text().Build() s.FtCreate().Index("1").OnJson().Prefix(1).Prefix("1").Prefix("1").Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() s.FtCreate().Index("1").OnJson().Filter("1").Language("1").LanguageField("1").Score(1).ScoreField("1").PayloadField("1").Maxtextfields().Temporary(1).Nooffsets().Nohl().Nofields().Nofreqs().Stopwords(1).Stopword("1").Stopword("1").Skipinitialscan().Schema().FieldName("1").As("1").Text().Build() @@ -611,6 +620,9 @@ func search5(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Expander("1").Payload("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Expander("1").Sortby("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Expander("1").Limit().OffsetNum(1, 1).Build() +} + +func search6(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Expander("1").Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Expander("1").Dialect(1).Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Expander("1").Build() @@ -620,9 +632,6 @@ func search5(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Sortby("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Limit().OffsetNum(1, 1).Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() -} - -func search6(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Dialect(1).Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Language("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Separator("1").Highlight().Fields("1").Field("1").Field("1").Tags().OpenClose("1", "1").Slop(1).Timeout(1).Inorder().Expander("1").Build() @@ -714,6 +723,9 @@ func search6(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Language("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Expander("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Scorer("1").Build() +} + +func search7(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Explainscore().Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Payload("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Sortby("1").Build() @@ -723,9 +735,6 @@ func search6(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Len(1).Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Separator("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Highlight().Build() -} - -func search7(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Slop(1).Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Timeout(1).Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Return("1").Identifier("1").As("1").Identifier("1").As("1").Summarize().Fields("1").Field("1").Field("1").Frags(1).Inorder().Build() @@ -817,6 +826,9 @@ func search7(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Dialect(1).Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Infields("1").Field("1").Field("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Return("1").Identifier("1").Build() +} + +func search8(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Summarize().Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Highlight().Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Slop(1).Build() @@ -826,9 +838,6 @@ func search7(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Expander("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Scorer("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Explainscore().Build() -} - -func search8(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Payload("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Sortby("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Geofilter("1").Lon(1).Lat(1).Radius(1).M().Geofilter("1").Lon(1).Lat(1).Radius(1).M().Inkeys("1").Key("1").Key("1").Limit().OffsetNum(1, 1).Build() @@ -920,6 +929,9 @@ func search8(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Explainscore().Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Payload("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Sortby("1").Build() +} + +func search9(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Limit().OffsetNum(1, 1).Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Filter("1").Min(1).Max(1).Filter("1").Min(1).Max(1).Dialect(1).Build() @@ -929,9 +941,6 @@ func search8(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Infields("1").Field("1").Field("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Return("1").Identifier("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Summarize().Build() -} - -func search9(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Highlight().Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Slop(1).Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Nostopwords().Withscores().Withpayloads().Withsortkeys().Timeout(1).Build() @@ -1023,6 +1032,9 @@ func search9(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Timeout(1).Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Inorder().Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Language("1").Build() +} + +func search10(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Expander("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Scorer("1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Explainscore().Build() @@ -1032,9 +1044,6 @@ func search9(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Params().Nargs(1).NameValue().NameValue("1", "1").NameValue("1", "1").Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Dialect(1).Build() s.FtSearch().Index("1").Query("1").Nocontent().Verbatim().Build() -} - -func search10(s Builder) { s.FtSearch().Index("1").Query("1").Nocontent().Nostopwords().Build() s.FtSearch().Index("1").Query("1").Nocontent().Withscores().Build() s.FtSearch().Index("1").Query("1").Nocontent().Withpayloads().Build() From 45da2f16742e44fa5cd7a2dd50a3e6a30cac112d Mon Sep 17 00:00:00 2001 From: Eric Chang Date: Wed, 20 Nov 2024 07:08:55 +0800 Subject: [PATCH 22/49] fix(FTAggregate): fix sortby limit test case --- rueidiscompat/adapter.go | 212 ++++++++++++++++++---------------- rueidiscompat/adapter_test.go | 4 +- rueidiscompat/command.go | 88 +++++++++++++- 3 files changed, 198 insertions(+), 106 deletions(-) diff --git a/rueidiscompat/adapter.go b/rueidiscompat/adapter.go index d727aec9..064aa0a6 100644 --- a/rueidiscompat/adapter.go +++ b/rueidiscompat/adapter.go @@ -4845,110 +4845,122 @@ func (c *Compat) FTAggregate(ctx context.Context, index string, query string) *M return newMapStringInterfaceCmd(c.client.Do(ctx, cmd)) } -// type FTAggregateOptions struct { -// Verbatim bool -// LoadAll bool -// Load []FTAggregateLoad -// Timeout int -// GroupBy []FTAggregateGroupBy -// SortBy []FTAggregateSortBy -// SortByMax int -// Apply []FTAggregateApply -// LimitOffset int -// Limit int -// Filter string -// WithCursor bool -// WithCursorOptions *FTAggregateWithCursor -// Params map[string]interface{} -// DialectVersion int -// } - +// FTAggregateWithArgs aligns with go-redis' implementation. +// see: go-redis v9.7.0: https://github.com/redis/go-redis/blob/ed37c33a9037483ad2a6b1042e5eb6df89009a1c/search_commands.go#L671 func (c *Compat) FTAggregateWithArgs(ctx context.Context, index string, query string, options *FTAggregateOptions) *AggregateCmd { _cmd := cmds.Incomplete(c.client.B().FtAggregate().Index(index).Query(query)) - if options == nil { - panic("options can not be nil") - } - if options.Verbatim { - // VERBATIM - _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).Verbatim()) - } - // [LOAD count field [field ...]] - if options.LoadAll { - // LOAD * - _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).LoadAll()) - } else { - // LOAD - _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).Load(int64(len(options.Load)))) - fields := make([]string, 0, len(options.Load)) - for _, l := range options.Load { - fields = append(fields, l.Field) + if options != nil { + // [VERBATIM] + if options.Verbatim { + _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).Verbatim()) + } + // [LOAD count field [field ...]] + if options.LoadAll { + // LOAD * + _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).LoadAll()) + } else { + // LOAD + _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).Load(int64(len(options.Load)))) + fields := make([]string, 0, len(options.Load)) + for _, l := range options.Load { + fields = append(fields, l.Field) + } + _cmd = cmds.Incomplete(cmds.FtAggregateOpLoadLoad(_cmd).Field(fields...)) + } + // [TIMEOUT timeout] + if options.Timeout > 0 { + _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).Timeout(int64(options.Timeout))) + } + // [ GROUPBY nargs property [property ...] [ REDUCE function nargs arg [arg ...] [AS name] [ REDUCE function nargs arg [arg ...] [AS name] ...]] ...]] + if options.GroupBy != nil { + for _, groupBy := range options.GroupBy { + _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd). + Groupby(int64(len(options.GroupBy))). + Property(argsToSlice(groupBy.Fields)...)) + for _, reduce := range groupBy.Reduce { + _cmd = cmds.Incomplete(cmds.FtAggregateOpGroupbyProperty(_cmd). + Reduce(reduce.Reducer.String()). + Nargs(int64(len(reduce.Args))). + Arg(argsToSlice(reduce.Args)...)) + if reduce.As != "" { + _cmd = cmds.Incomplete(cmds.FtAggregateOpGroupbyReduceArg(_cmd).As(reduce.As)) + } + } + } } - _cmd = cmds.Incomplete(cmds.FtAggregateOpLoadLoad(_cmd).Field(fields...)) - } - // [TIMEOUT timeout] - _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).Timeout(int64(options.Timeout))) - // GROUPBY - // 0 - // [ - // GROUPBY nargs property [property ...] - // [ - // REDUCE function nargs arg [arg ...] [AS name] - // [ REDUCE function nargs arg [arg ...] [AS name] ...] - // ] ... - // ]] - for _, groupBy := range options.GroupBy { - _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd). - Groupby(int64(len(options.GroupBy))). - Property(argsToSlice(groupBy.Fields)...)) - for _, reduce := range groupBy.Reduce { - _cmd = cmds.Incomplete(cmds.FtAggregateOpGroupbyProperty(_cmd). - Reduce(reduce.Reducer.String()). - Nargs(int64(len(reduce.Args))). - Arg(argsToSlice(reduce.Args)...). - As(reduce.As)) - } - } - // SORTBY - // [ - // SORTBY nargs [ - // property ASC | DESC [ property ASC | DESC ...] - // ] [MAX num] [WITHCOUNT] - // - _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).Sortby(int64(len(options.SortBy)))) - for _, sortBy := range options.SortBy { - _cmd = cmds.Incomplete(cmds.FtAggregateOpSortbySortby(_cmd).Property(sortBy.FieldName)) - if sortBy.Desc == sortBy.Asc { - panic("sortBy should be either ASC or DESC") + // [ SORTBY nargs [ property ASC | DESC [ property ASC | DESC ...]] [MAX num] [WITHCOUNT] + if options.SortBy != nil { + var numOfArgs int64 = 0 + // count number of args to be passed in to cmds.FtAggregateQuery(_cmd).Sortby() + for _, sortBy := range options.SortBy { + numOfArgs++ + if sortBy.Asc && sortBy.Desc { + panic("FT.AGGREGATE: ASC and DESC are mutually exclusive") + } + if sortBy.Asc || sortBy.Desc { + numOfArgs++ + } + } + _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).Sortby(numOfArgs)) + for _, sortBy := range options.SortBy { + _cmd = cmds.Incomplete(cmds.FtAggregateOpSortbySortby(_cmd).Property(sortBy.FieldName)) + if sortBy.Asc && sortBy.Desc { + panic("FT.AGGREGATE: ASC and DESC are mutually exclusive") + } + if sortBy.Asc { + // ASC + _cmd = cmds.Incomplete(cmds.FtAggregateOpSortbyFieldsProperty(_cmd).Asc()) + } + if sortBy.Desc { + // DESC + _cmd = cmds.Incomplete(cmds.FtAggregateOpSortbyFieldsProperty(_cmd).Desc()) + } + } } - if sortBy.Asc { - // ASC - _cmd = cmds.Incomplete(cmds.FtAggregateOpSortbyFieldsProperty(_cmd).Asc()) - continue - } else { - _cmd = cmds.Incomplete(cmds.FtAggregateOpSortbyFieldsProperty(_cmd).Desc()) - } - // DESC - } - // FIXME: go-redis doesn't provide WITHCOUNT option - _cmd = cmds.Incomplete(cmds.FtAggregateOpSortbySortby(_cmd).Max(int64(options.SortByMax))) - // [ APPLY expression AS name [ APPLY expression AS name ...]] - for _, apply := range options.Apply { - _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).Apply(apply.Field).As(apply.As)) - } - // [ LIMIT offset num] - _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).Limit().OffsetNum(int64(options.Limit), int64(options.LimitOffset))) - // [FILTER filter] - _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).Filter(options.Filter)) - // [ WITHCURSOR [COUNT read_size] [MAXIDLE idle_time]] - _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).Withcursor().Count(int64(options.WithCursorOptions.Count)).Maxidle(int64(options.WithCursorOptions.MaxIdle))) - // [ PARAMS nargs name value [ name value ...]] - _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).Params().Nargs(int64(len(options.Params))).NameValue()) - for name, val := range options.Params { - _cmd = cmds.Incomplete(cmds.FtAggregateParamsNameValue(_cmd).NameValue(name, str(val))) - } - // [ADDSCORES]: NOTE: go-redis doesn't implement this option. - // [DIALECT dialect] - _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).Dialect(int64(options.DialectVersion))) + if options.SortByMax > 0 { + _cmd = cmds.Incomplete(cmds.FtAggregateOpSortbySortby(_cmd).Max(int64(options.SortByMax))) + } + // FIXME: go-redis doesn't provide WITHCOUNT option + + // [ APPLY expression AS name [ APPLY expression AS name ...]] + if options.Apply != nil { + for _, apply := range options.Apply { + _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).Apply(apply.Field).As(apply.As)) + } + } + // [ LIMIT offset num] + if options.LimitOffset > 0 { + _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).Limit().OffsetNum(int64(options.Limit), int64(options.LimitOffset))) + } + // [FILTER filter] + if options.Filter != "" { + _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).Filter(options.Filter)) + } + // [ WITHCURSOR [COUNT read_size] [MAXIDLE idle_time]] + if options.WithCursor { + _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).Withcursor()) + if options.WithCursorOptions != nil { + if options.WithCursorOptions.Count > 0 { + _cmd = cmds.Incomplete(cmds.FtAggregateCursorWithcursor(_cmd).Count(int64(options.WithCursorOptions.Count))) + } + if options.WithCursorOptions.MaxIdle > 0 { + _cmd = cmds.Incomplete(cmds.FtAggregateCursorWithcursor(_cmd).Maxidle(int64(options.WithCursorOptions.MaxIdle))) + } + } + } + // [ PARAMS nargs name value [ name value ...]] + if options.Params != nil { + _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).Params().Nargs(int64(len(options.Params) * 2)).NameValue()) + for name, val := range options.Params { + _cmd = cmds.Incomplete(cmds.FtAggregateParamsNameValue(_cmd).NameValue(name, str(val))) + } + } + // [ADDSCORES]: NOTE: go-redis doesn't implement this option. + // [DIALECT dialect] + if options.DialectVersion > 0 { + _cmd = cmds.Incomplete(cmds.FtAggregateQuery(_cmd).Dialect(int64(options.DialectVersion))) + } + } cmd := cmds.FtAggregateQuery(_cmd).Build() return newAggregateCmd(c.client.Do(ctx, cmd)) } diff --git a/rueidiscompat/adapter_test.go b/rueidiscompat/adapter_test.go index d682dcdd..effc77bb 100644 --- a/rueidiscompat/adapter_test.go +++ b/rueidiscompat/adapter_test.go @@ -11940,7 +11940,7 @@ func testAdapterCache(resp3 bool) { }) - FIt("should FTAggregate GroupBy ", Label("search", "ftaggregate"), func() { + It("should FTAggregate GroupBy ", Label("search", "ftaggregate"), func() { text1 := &FieldSchema{FieldName: "title", FieldType: SearchFieldTypeText} text2 := &FieldSchema{FieldName: "body", FieldType: SearchFieldTypeText} text3 := &FieldSchema{FieldName: "parent", FieldType: SearchFieldTypeText} @@ -12046,7 +12046,7 @@ func testAdapterCache(resp3 bool) { }) - It("should FTAggregate sort and limit", Label("search", "ftaggregate"), func() { + FIt("should FTAggregate sort and limit", Label("search", "ftaggregate"), func() { text1 := &FieldSchema{FieldName: "t1", FieldType: SearchFieldTypeText} text2 := &FieldSchema{FieldName: "t2", FieldType: SearchFieldTypeText} val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, text1, text2).Result() diff --git a/rueidiscompat/command.go b/rueidiscompat/command.go index 606f562a..fe5be7dc 100644 --- a/rueidiscompat/command.go +++ b/rueidiscompat/command.go @@ -3461,12 +3461,92 @@ type AggregateCmd struct { baseCmd[FTAggregateResult] } -func newAggregateCmd(res rueidis.RedisResult) *AggregateCmd { - return nil -} - func (cmd *AggregateCmd) from(res rueidis.RedisResult) { + fmt.Printf("rueidisresult %#v\n", res.String()) + if err := res.Error(); err != nil { + cmd.SetErr(err) + return + } + m, err := res.ToMap() + if err != nil { + cmd.SetErr(err) + return + } + totalResultsMsg, ok := m["total_results"] + if !ok { + cmd.SetErr(fmt.Errorf(`result map should contain key "total_results"`)) + } + totalResults, err := totalResultsMsg.AsInt64() + if err != nil { + cmd.SetErr(err) + return + } + resultsMsg, ok := m["results"] + if !ok { + cmd.SetErr(fmt.Errorf(`result map should contain key "results"`)) + } + resultsArr, err := resultsMsg.ToArray() + if err != nil { + cmd.SetErr(err) + return + } + ftAggregateResult := FTAggregateResult{Total: int(totalResults), Rows: make([]AggregateRow, 0, len(resultsArr))} + for _, result := range resultsArr { + resultMap, err := result.ToMap() + if err != nil { + cmd.SetErr(err) + return + } + fmt.Println("resultMap", result.String()) + // FIXME: unknown length? + row := AggregateRow{Fields: make(map[string]any)} + for k, v := range resultMap { + switch k { + case "extra_attributes": + // simple string + _m, err := v.AsMap() + if err != nil { + cmd.SetErr(err) + return + } + for _k, _v := range _m { + anyVal, err := _v.ToAny() + if err != nil { + cmd.SetErr(err) + return + } + row.Fields[_k] = anyVal + } + case "values": + // FIXME: do we have this? + continue + default: + fmt.Println("xxx got v", v.String()) + // case "id": + // idStr, err := v.ToString() + // if err != nil { + // cmd.SetErr(err) + // return + // } + // row. = idStr + } + } + + ftAggregateResult.Rows = append(ftAggregateResult.Rows, row) + } + + cmd.SetVal(ftAggregateResult) + + _r, _ := json.MarshalIndent(ftAggregateResult, "", "\t") + fmt.Print(string(_r)) + +} + +func newAggregateCmd(res rueidis.RedisResult) *AggregateCmd { + cmd := &AggregateCmd{} + cmd.from(res) + return cmd } type FTCreateOptions struct { From ae41893badc8abe9492ccbfe5cf29ad70d5ca687 Mon Sep 17 00:00:00 2001 From: Eric Chang Date: Wed, 20 Nov 2024 08:49:45 +0800 Subject: [PATCH 23/49] fix(FT.SEARCH): fix tests --- rueidiscompat/adapter.go | 275 ++++++++++++++++++---------------- rueidiscompat/adapter_test.go | 4 +- 2 files changed, 147 insertions(+), 132 deletions(-) diff --git a/rueidiscompat/adapter.go b/rueidiscompat/adapter.go index 064aa0a6..d16dff88 100644 --- a/rueidiscompat/adapter.go +++ b/rueidiscompat/adapter.go @@ -5254,146 +5254,161 @@ func (c *Compat) FTSearch(ctx context.Context, index string, query string) *FTSe return newFTSearchCmd(c.client.Do(ctx, cmd), nil) } -// Ref: https://github.com/redis/go-redis/blob/930d904205691ff06104fcc3ac108177077def35/search_commands.go#L1688 +// FTSearchWithArgs - Executes a search query on an index with additional options. +// The 'index' parameter specifies the index to search, the 'query' parameter specifies the search query, +// and the 'options' parameter specifies additional options for the search. +// For more information, please refer to the Redis documentation: +// [FT.SEARCH]: (https://redis.io/commands/ft.search/) +// FTSearchWithArgs Aligns with go-redis v9.7.0. +// Ref: https://github.com/redis/go-redis/blob/ed37c33a9037483ad2a6b1042e5eb6df89009a1c/search_commands.go#L1802 func (c *Compat) FTSearchWithArgs(ctx context.Context, index string, query string, options *FTSearchOptions) *FTSearchCmd { _cmd := cmds.Incomplete(c.client.B().FtSearch().Index(index).Query(query)) - if options == nil { - panic("options can not be nil") - } - // [NOCONTENT] - if options.NoContent { - _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Nocontent()) - } - // [VERBATIM] - if options.Verbatim { - _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Verbatim()) - } - // [NOSTOPWORDS] - if options.NoStopWords { - _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Nostopwords()) - } - // [WITHSCORES] - if options.WithScores { - _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Withscores()) - } - // [WITHPAYLOADS] - if options.WithPayloads { - _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Withpayloads()) - } - // [WITHSORTKEYS] - if options.WithSortKeys { - _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Withsortkeys()) - } - // [FILTER numeric_field min max [ FILTER numeric_field min max ...]] - for _, filter := range options.Filters { - min, err := strconv.ParseFloat(str(filter.Min), 64) - if err != nil { - panic(fmt.Sprintf("failed to parse min %v to float64", filter.Min)) + if options != nil { + // [NOCONTENT] + if options.NoContent { + _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Nocontent()) } - max, err := strconv.ParseFloat(str(filter.Max), 64) - if err != nil { - panic(fmt.Sprintf("failed to parse max %v to float64", filter.Max)) - } - _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Filter(str(filter.FieldName)).Min(min).Max(max)) - } - // [GEOFILTER geo_field lon lat radius m | km | mi | ft [ GEOFILTER geo_field lon lat radius m | km | mi | ft ...]] - for _, filter := range options.GeoFilter { - _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Geofilter(filter.FieldName).Lon(filter.Longitude).Lat(filter.Latitude).Radius(filter.Radius)) - switch filter.Unit { - case "m": - _cmd = cmds.Incomplete(cmds.FtSearchGeoFilterRadius(_cmd).M()) - case "km": - _cmd = cmds.Incomplete(cmds.FtSearchGeoFilterRadius(_cmd).Km()) - case "mi": - _cmd = cmds.Incomplete(cmds.FtSearchGeoFilterRadius(_cmd).Mi()) - case "ft": - _cmd = cmds.Incomplete(cmds.FtSearchGeoFilterRadius(_cmd).Ft()) - default: - panic(fmt.Sprintf("invalid unit, want m | km | mi | ft, got %v", filter.Unit)) + // [VERBATIM] + if options.Verbatim { + _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Verbatim()) } - } - // [INKEYS count key [key ...]] - if len(options.InKeys) > 0 { - _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Inkeys(str(len(options.InKeys))).Key(argsToSlice(options.InKeys)...)) - } - // [ INFIELDS count field [field ...]] - if len(options.InFields) > 0 { - _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Infields(str(len(options.InFields))).Field(argsToSlice(options.InFields)...)) - } - // [RETURN count identifier [AS property] [ identifier [AS property] ...]] - if len(options.Return) > 0 { - _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Return(str(len(options.Return)))) - for _, re := range options.Return { - _cmd = cmds.Incomplete(cmds.FtSearchReturnReturn(_cmd).Identifier(re.FieldName).As(re.As)) + // [NOSTOPWORDS] + if options.NoStopWords { + _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Nostopwords()) } - } - // FIXME: go-redis doesn't implement SUMMARIZE option - // [SUMMARIZE [ FIELDS count field [field ...]] [FRAGS num] [LEN fragsize] [SEPARATOR separator]] - // [SLOP slop] - if options.Slop > 0 { - _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Slop(int64(options.Slop))) - } - // [TIMEOUT timeout] - if options.Timeout > 0 { - _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Timeout(int64(options.Timeout))) - } - // [INORDER] - if options.InOrder { - _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Inorder()) - } - // [LANGUAGE language] - if options.Language != "" { - _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Language(options.Language)) - } - // [EXPANDER expander] - if options.Expander != "" { - _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Expander(options.Expander)) - } - // [SCORER scorer] - if options.Scorer != "" { - _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Scorer(options.Scorer)) - } - // [EXPLAINSCORE] - if options.ExplainScore { - _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Explainscore()) - } - // [PAYLOAD payload] - if options.Payload != "" { - _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Payload(options.Payload)) - } - // [SORTBY sortby [ ASC | DESC] [WITHCOUNT]] - if options.SortBy != nil { - if len(options.SortBy) != 1 { - panic(fmt.Sprintf("options.SortBy can only have 1 element, got %v", len(options.SortBy))) + // [WITHSCORES] + if options.WithScores { + _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Withscores()) } - sortBy := options.SortBy[0] - _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Sortby(sortBy.FieldName)) - if sortBy.Asc == sortBy.Desc && sortBy.Asc { - panic("options.SortBy[0] should specify either ASC or DESC") + // [WITHPAYLOADS] + if options.WithPayloads { + _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Withpayloads()) } - if sortBy.Asc { - _cmd = cmds.Incomplete(cmds.FtSearchSortbySortby(_cmd).Asc()) - } else { - _cmd = cmds.Incomplete(cmds.FtSearchSortbySortby(_cmd).Desc()) + // [WITHSORTKEYS] + if options.WithSortKeys { + _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Withsortkeys()) } - if options.SortByWithCount { - _cmd = cmds.Incomplete(cmds.FtSearchSortbySortby(_cmd).Withcount()) + // [FILTER numeric_field min max [ FILTER numeric_field min max ...]] + for _, filter := range options.Filters { + min, err := strconv.ParseFloat(str(filter.Min), 64) + if err != nil { + panic(fmt.Sprintf("failed to parse min %v to float64", filter.Min)) + } + max, err := strconv.ParseFloat(str(filter.Max), 64) + if err != nil { + panic(fmt.Sprintf("failed to parse max %v to float64", filter.Max)) + } + _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Filter(str(filter.FieldName)).Min(min).Max(max)) + } + // [GEOFILTER geo_field lon lat radius m | km | mi | ft [ GEOFILTER geo_field lon lat radius m | km | mi | ft ...]] + for _, filter := range options.GeoFilter { + _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Geofilter(filter.FieldName).Lon(filter.Longitude).Lat(filter.Latitude).Radius(filter.Radius)) + switch filter.Unit { + case "m": + _cmd = cmds.Incomplete(cmds.FtSearchGeoFilterRadius(_cmd).M()) + case "km": + _cmd = cmds.Incomplete(cmds.FtSearchGeoFilterRadius(_cmd).Km()) + case "mi": + _cmd = cmds.Incomplete(cmds.FtSearchGeoFilterRadius(_cmd).Mi()) + case "ft": + _cmd = cmds.Incomplete(cmds.FtSearchGeoFilterRadius(_cmd).Ft()) + default: + panic(fmt.Sprintf("invalid unit, want m | km | mi | ft, got %v", filter.Unit)) + } } - } - // [LIMIT offset num] - if options.LimitOffset >= 0 && options.Limit > 0 { - _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Limit().OffsetNum(int64(options.Limit), int64(options.LimitOffset))) - } - // [PARAMS nargs name value [ name value ...]] - if options.Params != nil { - _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Params().Nargs(int64(len(options.Params)))) - for name, val := range options.Params { - _cmd = cmds.Incomplete(cmds.FtSearchParamsNargs(_cmd).NameValue().NameValue(name, str(val))) + // [INKEYS count key [key ...]] + if len(options.InKeys) > 0 { + _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Inkeys(str(len(options.InKeys))).Key(argsToSlice(options.InKeys)...)) + } + // [ INFIELDS count field [field ...]] + if len(options.InFields) > 0 { + _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Infields(str(len(options.InFields))).Field(argsToSlice(options.InFields)...)) + } + // [RETURN count identifier [AS property] [ identifier [AS property] ...]] + if len(options.Return) > 0 { + var numOfArgs int64 = 0 + for _, re := range options.Return { + numOfArgs++ + if re.As != "" { + numOfArgs += 2 + } + } + _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Return(str(numOfArgs))) + for _, re := range options.Return { + _cmd = cmds.Incomplete(cmds.FtSearchReturnReturn(_cmd).Identifier(re.FieldName)) + if re.As != "" { + _cmd = cmds.Incomplete(cmds.FtSearchReturnIdentifiersIdentifier(_cmd).As(re.As)) + } + } + } + // FIXME: go-redis doesn't implement SUMMARIZE option + // [SUMMARIZE [ FIELDS count field [field ...]] [FRAGS num] [LEN fragsize] [SEPARATOR separator]] + // [SLOP slop] + if options.Slop > 0 { + _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Slop(int64(options.Slop))) + } + // [TIMEOUT timeout] + if options.Timeout > 0 { + _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Timeout(int64(options.Timeout))) + } + // [INORDER] + if options.InOrder { + _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Inorder()) + } + // [LANGUAGE language] + if options.Language != "" { + _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Language(options.Language)) + } + // [EXPANDER expander] + if options.Expander != "" { + _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Expander(options.Expander)) + } + // [SCORER scorer] + if options.Scorer != "" { + _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Scorer(options.Scorer)) + } + // [EXPLAINSCORE] + if options.ExplainScore { + _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Explainscore()) + } + // [PAYLOAD payload] + if options.Payload != "" { + _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Payload(options.Payload)) + } + // [SORTBY sortby [ ASC | DESC] [WITHCOUNT]] + if options.SortBy != nil { + if len(options.SortBy) != 1 { + panic(fmt.Sprintf("options.SortBy can only have 1 element, got %v", len(options.SortBy))) + } + sortBy := options.SortBy[0] + _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Sortby(sortBy.FieldName)) + if sortBy.Asc == sortBy.Desc && sortBy.Asc { + panic("options.SortBy[0] should specify either ASC or DESC") + } + if sortBy.Asc { + _cmd = cmds.Incomplete(cmds.FtSearchSortbySortby(_cmd).Asc()) + } else { + _cmd = cmds.Incomplete(cmds.FtSearchSortbySortby(_cmd).Desc()) + } + if options.SortByWithCount { + _cmd = cmds.Incomplete(cmds.FtSearchSortbySortby(_cmd).Withcount()) + } + } + // [LIMIT offset num] + if options.LimitOffset >= 0 && options.Limit > 0 { + _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Limit().OffsetNum(int64(options.Limit), int64(options.LimitOffset))) + } + // [PARAMS nargs name value [ name value ...]] + if options.Params != nil { + _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Params().Nargs(int64(len(options.Params)))) + for name, val := range options.Params { + _cmd = cmds.Incomplete(cmds.FtSearchParamsNargs(_cmd).NameValue().NameValue(name, str(val))) + } + } + // [DIALECT dialect] + if options.DialectVersion > 0 { + _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Dialect(int64(options.DialectVersion))) } - } - // [DIALECT dialect] - if options.DialectVersion > 0 { - _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Dialect(int64(options.DialectVersion))) } cmd := cmds.FtSearchQuery(_cmd).Build() fmt.Print(cmd.Commands()) diff --git a/rueidiscompat/adapter_test.go b/rueidiscompat/adapter_test.go index effc77bb..279d4f6f 100644 --- a/rueidiscompat/adapter_test.go +++ b/rueidiscompat/adapter_test.go @@ -12046,7 +12046,7 @@ func testAdapterCache(resp3 bool) { }) - FIt("should FTAggregate sort and limit", Label("search", "ftaggregate"), func() { + It("should FTAggregate sort and limit", Label("search", "ftaggregate"), func() { text1 := &FieldSchema{FieldName: "t1", FieldType: SearchFieldTypeText} text2 := &FieldSchema{FieldName: "t2", FieldType: SearchFieldTypeText} val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, text1, text2).Result() @@ -12266,7 +12266,7 @@ func testAdapterCache(resp3 bool) { Expect(res.Docs[0].Fields["txt"]).To(BeEquivalentTo("telmatosaurus")) }) - It("should FTSynUpdate", Label("search", "ftsynupdate"), func() { + FIt("should FTSynUpdate", Label("search", "ftsynupdate"), func() { text1 := &FieldSchema{FieldName: "title", FieldType: SearchFieldTypeText} text2 := &FieldSchema{FieldName: "body", FieldType: SearchFieldTypeText} From de6fdcb7638f21bdcb291da1a8e111804bd97591 Mon Sep 17 00:00:00 2001 From: Eric Chang Date: Wed, 20 Nov 2024 22:50:13 +0800 Subject: [PATCH 24/49] refactor(adapter_test.go): add testAdapterSearchRESP2, testAdapterSearchRESP3 and compat-redisearch --- docker-compose.yml | 4 + rueidiscompat/adapter_test.go | 510 ++++++++++++++++++---------------- 2 files changed, 277 insertions(+), 237 deletions(-) diff --git a/docker-compose.yml b/docker-compose.yml index 8b1945c5..ca93886c 100644 --- a/docker-compose.yml +++ b/docker-compose.yml @@ -35,6 +35,10 @@ services: image: redis:5-alpine ports: - "6356:6379" + compat-redisearch: + image: redis/redis-stack:7.4.0-v0 + ports: + - "6381:6379" sentinel: image: redis:7.4-alpine entrypoint: diff --git a/rueidiscompat/adapter_test.go b/rueidiscompat/adapter_test.go index 279d4f6f..87ff0775 100644 --- a/rueidiscompat/adapter_test.go +++ b/rueidiscompat/adapter_test.go @@ -57,17 +57,19 @@ func TestAdapter(t *testing.T) { } var ( - err error - ctx context.Context - clientresp2 rueidis.Client - clusterresp2 rueidis.Client - clientresp3 rueidis.Client - clusterresp3 rueidis.Client - adapterresp2 Cmdable - adaptercluster2 Cmdable - adapterresp3 Cmdable - adapter2resp3 Cmdable - adaptercluster3 Cmdable + err error + ctx context.Context + clientresp2 rueidis.Client + clientsearchresp2 rueidis.Client + clusterresp2 rueidis.Client + clientresp3 rueidis.Client + clusterresp3 rueidis.Client + adapterresp2 Cmdable + adaptersearchresp2 Cmdable + adaptercluster2 Cmdable + adapterresp3 Cmdable + adapter2resp3 Cmdable + adaptercluster3 Cmdable ) var _ = BeforeSuite(func() { @@ -91,6 +93,13 @@ var _ = BeforeSuite(func() { DisableCache: true, }) Expect(err).NotTo(HaveOccurred()) + clientsearchresp2, err = rueidis.NewClient(rueidis.ClientOption{ + InitAddress: []string{"127.0.0.1:6381"}, + ClientName: "rueidis", + DisableCache: true, + AlwaysRESP2: true, + }) + Expect(err).NotTo(HaveOccurred()) clusterresp2, err = rueidis.NewClient(rueidis.ClientOption{ InitAddress: []string{"127.0.0.1:7007"}, ClientName: "rueidis", @@ -98,6 +107,7 @@ var _ = BeforeSuite(func() { }) Expect(err).NotTo(HaveOccurred()) adapterresp2 = NewAdapter(clientresp2) + adaptersearchresp2 = NewAdapter(clientsearchresp2) adaptercluster2 = NewAdapter(clusterresp2) }) @@ -114,11 +124,13 @@ var _ = Describe("RESP3 Commands", func() { testAdapter(true) testAdapterCache(true) testCluster(true) + testAdapterSearchRESP3() }) var _ = Describe("RESP2 Commands", func() { testAdapter(false) testCluster(false) + testAdapterSearchRESP2() }) func testCluster(resp3 bool) { @@ -11547,20 +11559,223 @@ func testAdapterCache(resp3 bool) { }) }) }) +} + +func testAdapterSearchRESP3() { + var adapter Cmdable + + BeforeEach(func() { + adapter = adapterresp3 + Expect(adapter.FlushDB(ctx).Err()).NotTo(HaveOccurred()) + Expect(adapter.FlushAll(ctx).Err()).NotTo(HaveOccurred()) + }) - Describe("RediSearch commands Resp 2", Label("search"), func() { + Describe("RediSearch commands Resp 3", Label("search"), func() { + ctx := context.TODO() + + // BeforeEach(func() { + // client = redis.NewClient(&redis.Options{Addr: ":6379", Protocol: 3, UnstableResp3: true}) + // client2 = redis.NewClient(&redis.Options{Addr: ":6379", Protocol: 3}) + // Expect(client.FlushDB(ctx).Err()).NotTo(HaveOccurred()) + // }) + + It("should handle FTAggregate with Unstable RESP3 Search Module and without stability", Label("search", "ftcreate", "ftaggregate"), func() { + text1 := &FieldSchema{FieldName: "PrimaryKey", FieldType: SearchFieldTypeText, Sortable: true} + num1 := &FieldSchema{FieldName: "CreatedDateTimeUTC", FieldType: SearchFieldTypeNumeric, Sortable: true} + val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, text1, num1).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(val).To(BeEquivalentTo("OK")) + WaitForIndexing(clientresp3, "idx1", 3) + + adapter.HSet(ctx, "doc1", "PrimaryKey", "9::362330", "CreatedDateTimeUTC", "637387878524969984") + adapter.HSet(ctx, "doc2", "PrimaryKey", "9::362329", "CreatedDateTimeUTC", "637387875859270016") + + options := &FTAggregateOptions{Apply: []FTAggregateApply{{Field: "@CreatedDateTimeUTC * 10", As: "CreatedDateTimeUTC"}}} + res, err := adapter.FTAggregateWithArgs(ctx, "idx1", "*", options).RawResult() + results := res.(map[interface{}]interface{})["results"].([]interface{}) + Expect(results[0].(map[interface{}]interface{})["extra_attributes"].(map[interface{}]interface{})["CreatedDateTimeUTC"]). + To(Or(BeEquivalentTo("6373878785249699840"), BeEquivalentTo("6373878758592700416"))) + Expect(results[1].(map[interface{}]interface{})["extra_attributes"].(map[interface{}]interface{})["CreatedDateTimeUTC"]). + To(Or(BeEquivalentTo("6373878785249699840"), BeEquivalentTo("6373878758592700416"))) + + rawVal := adapter.FTAggregateWithArgs(ctx, "idx1", "*", options).RawVal() + rawValResults := rawVal.(map[interface{}]interface{})["results"].([]interface{}) + Expect(err).NotTo(HaveOccurred()) + Expect(rawValResults[0]).To(Or(BeEquivalentTo(results[0]), BeEquivalentTo(results[1]))) + Expect(rawValResults[1]).To(Or(BeEquivalentTo(results[0]), BeEquivalentTo(results[1]))) + + // Test with UnstableResp3 false + Expect(func() { + options = &FTAggregateOptions{Apply: []FTAggregateApply{{Field: "@CreatedDateTimeUTC * 10", As: "CreatedDateTimeUTC"}}} + rawRes, _ := adapter2resp3.FTAggregateWithArgs(ctx, "idx1", "*", options).RawResult() + rawVal = adapter2resp3.FTAggregateWithArgs(ctx, "idx1", "*", options).RawVal() + Expect(rawRes).To(BeNil()) + Expect(rawVal).To(BeNil()) + }).Should(Panic()) + + }) + + It("should handle FTInfo with Unstable RESP3 Search Module and without stability", Label("search", "ftcreate", "ftinfo"), func() { + val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, &FieldSchema{FieldName: "txt", FieldType: SearchFieldTypeText, Sortable: true, NoStem: true}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(val).To(BeEquivalentTo("OK")) + WaitForIndexing(clientresp3, "idx1", 3) + + resInfo, err := adapter.FTInfo(ctx, "idx1").RawResult() + Expect(err).NotTo(HaveOccurred()) + attributes := resInfo.(map[interface{}]interface{})["attributes"].([]interface{}) + flags := attributes[0].(map[interface{}]interface{})["flags"].([]interface{}) + Expect(flags).To(ConsistOf("SORTABLE", "NOSTEM")) + + valInfo := adapter.FTInfo(ctx, "idx1").RawVal() + attributes = valInfo.(map[interface{}]interface{})["attributes"].([]interface{}) + flags = attributes[0].(map[interface{}]interface{})["flags"].([]interface{}) + Expect(flags).To(ConsistOf("SORTABLE", "NOSTEM")) + + // Test with UnstableResp3 false + Expect(func() { + rawResInfo, _ := adapter2resp3.FTInfo(ctx, "idx1").RawResult() + rawValInfo := adapter2resp3.FTInfo(ctx, "idx1").RawVal() + Expect(rawResInfo).To(BeNil()) + Expect(rawValInfo).To(BeNil()) + }).Should(Panic()) + }) + + It("should handle FTSpellCheck with Unstable RESP3 Search Module and without stability", Label("search", "ftcreate", "ftspellcheck"), func() { + text1 := &FieldSchema{FieldName: "f1", FieldType: SearchFieldTypeText} + text2 := &FieldSchema{FieldName: "f2", FieldType: SearchFieldTypeText} + val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, text1, text2).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(val).To(BeEquivalentTo("OK")) + WaitForIndexing(clientresp3, "idx1", 3) + + adapter.HSet(ctx, "doc1", "f1", "some valid content", "f2", "this is sample text") + adapter.HSet(ctx, "doc2", "f1", "very important", "f2", "lorem ipsum") + + resSpellCheck, err := adapter.FTSpellCheck(ctx, "idx1", "impornant").RawResult() + valSpellCheck := adapter.FTSpellCheck(ctx, "idx1", "impornant").RawVal() + Expect(err).NotTo(HaveOccurred()) + Expect(valSpellCheck).To(BeEquivalentTo(resSpellCheck)) + results := resSpellCheck.(map[interface{}]interface{})["results"].(map[interface{}]interface{}) + Expect(results["impornant"].([]interface{})[0].(map[interface{}]interface{})["important"]).To(BeEquivalentTo(0.5)) + + // Test with UnstableResp3 false + Expect(func() { + rawResSpellCheck, _ := adapter2resp3.FTSpellCheck(ctx, "idx1", "impornant").RawResult() + rawValSpellCheck := adapter2resp3.FTSpellCheck(ctx, "idx1", "impornant").RawVal() + Expect(rawResSpellCheck).To(BeNil()) + Expect(rawValSpellCheck).To(BeNil()) + }).Should(Panic()) + }) + + It("should handle FTSearch with Unstable RESP3 Search Module and without stability", Label("search", "ftcreate", "ftsearch"), func() { + val, err := adapter.FTCreate(ctx, "txt", &FTCreateOptions{StopWords: []interface{}{"foo", "bar", "baz"}}, &FieldSchema{FieldName: "txt", FieldType: SearchFieldTypeText}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(val).To(BeEquivalentTo("OK")) + WaitForIndexing(clientresp3, "txt", 3) + adapter.HSet(ctx, "doc1", "txt", "foo baz") + adapter.HSet(ctx, "doc2", "txt", "hello world") + res1, err := adapter.FTSearchWithArgs(ctx, "txt", "foo bar", &FTSearchOptions{NoContent: true}).RawResult() + val1 := adapter.FTSearchWithArgs(ctx, "txt", "foo bar", &FTSearchOptions{NoContent: true}).RawVal() + Expect(err).NotTo(HaveOccurred()) + Expect(val1).To(BeEquivalentTo(res1)) + totalResults := res1.(map[interface{}]interface{})["total_results"] + Expect(totalResults).To(BeEquivalentTo(int64(0))) + res2, err := adapter.FTSearchWithArgs(ctx, "txt", "foo bar hello world", &FTSearchOptions{NoContent: true}).RawResult() + Expect(err).NotTo(HaveOccurred()) + totalResults2 := res2.(map[interface{}]interface{})["total_results"] + Expect(totalResults2).To(BeEquivalentTo(int64(1))) + + // Test with UnstableResp3 false + Expect(func() { + rawRes2, _ := adapter2resp3.FTSearchWithArgs(ctx, "txt", "foo bar hello world", &FTSearchOptions{NoContent: true}).RawResult() + rawVal2 := adapter2resp3.FTSearchWithArgs(ctx, "txt", "foo bar hello world", &FTSearchOptions{NoContent: true}).RawVal() + Expect(rawRes2).To(BeNil()) + Expect(rawVal2).To(BeNil()) + }).Should(Panic()) + }) + It("should handle FTSynDump with Unstable RESP3 Search Module and without stability", Label("search", "ftsyndump"), func() { + text1 := &FieldSchema{FieldName: "title", FieldType: SearchFieldTypeText} + text2 := &FieldSchema{FieldName: "body", FieldType: SearchFieldTypeText} + val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{OnHash: true}, text1, text2).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(val).To(BeEquivalentTo("OK")) + WaitForIndexing(clientresp3, "idx1", 3) + + resSynUpdate, err := adapter.FTSynUpdate(ctx, "idx1", "id1", []interface{}{"boy", "child", "offspring"}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(resSynUpdate).To(BeEquivalentTo("OK")) + + resSynUpdate, err = adapter.FTSynUpdate(ctx, "idx1", "id1", []interface{}{"baby", "child"}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(resSynUpdate).To(BeEquivalentTo("OK")) + + resSynUpdate, err = adapter.FTSynUpdate(ctx, "idx1", "id1", []interface{}{"tree", "wood"}).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(resSynUpdate).To(BeEquivalentTo("OK")) + + resSynDump, err := adapter.FTSynDump(ctx, "idx1").RawResult() + valSynDump := adapter.FTSynDump(ctx, "idx1").RawVal() + Expect(err).NotTo(HaveOccurred()) + Expect(valSynDump).To(BeEquivalentTo(resSynDump)) + Expect(resSynDump.(map[interface{}]interface{})["baby"]).To(BeEquivalentTo([]interface{}{"id1"})) + + // Test with UnstableResp3 false + Expect(func() { + rawResSynDump, _ := adapter2resp3.FTSynDump(ctx, "idx1").RawResult() + rawValSynDump := adapter2resp3.FTSynDump(ctx, "idx1").RawVal() + Expect(rawResSynDump).To(BeNil()) + Expect(rawValSynDump).To(BeNil()) + }).Should(Panic()) + }) + + It("should test not affected Resp 3 Search method - FTExplain", Label("search", "ftexplain"), func() { + text1 := &FieldSchema{FieldName: "f1", FieldType: SearchFieldTypeText} + text2 := &FieldSchema{FieldName: "f2", FieldType: SearchFieldTypeText} + text3 := &FieldSchema{FieldName: "f3", FieldType: SearchFieldTypeText} + val, err := adapter.FTCreate(ctx, "txt", &FTCreateOptions{}, text1, text2, text3).Result() + Expect(err).NotTo(HaveOccurred()) + Expect(val).To(BeEquivalentTo("OK")) + WaitForIndexing(clientresp3, "txt", 3) + res1, err := adapter.FTExplain(ctx, "txt", "@f3:f3_val @f2:f2_val @f1:f1_val").Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res1).ToNot(BeEmpty()) + + // Test with UnstableResp3 false + Expect(func() { + res2, err := adapter2resp3.FTExplain(ctx, "txt", "@f3:f3_val @f2:f2_val @f1:f1_val").Result() + Expect(err).NotTo(HaveOccurred()) + Expect(res2).ToNot(BeEmpty()) + }).ShouldNot(Panic()) + }) + }) +} + +func testAdapterSearchRESP2() { + var adapter Cmdable + var client rueidis.Client + + BeforeEach(func() { + adapter = adaptersearchresp2 + client = clientsearchresp2 + + Expect(adapter.FlushDB(ctx).Err()).NotTo(HaveOccurred()) + Expect(adapter.FlushAll(ctx).Err()).NotTo(HaveOccurred()) + }) + + FDescribe("RediSearch commands Resp 2", Label("search"), func() { ctx := context.TODO() BeforeEach(func() { Expect(adapter.FlushDB(ctx).Err()).NotTo(HaveOccurred()) }) - It("should FTCreate and FTSearch WithScores", Label("search", "ftcreate", "ftsearch"), func() { + FIt("should FTCreate and FTSearch WithScores", Label("search", "ftcreate", "ftsearch"), func() { // FIXME: FieldType val, err := adapter.FTCreate(ctx, "txt", &FTCreateOptions{}, &FieldSchema{FieldName: "txt", FieldType: SearchFieldTypeText}).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "txt", 2) + WaitForIndexing(client, "txt", 2) adapter.HSet(ctx, "doc1", "txt", "foo baz") adapter.HSet(ctx, "doc2", "txt", "foo bar") res, err := adapter.FTSearchWithArgs(ctx, "txt", "foo ~bar", &FTSearchOptions{WithScores: true}).Result() @@ -11577,7 +11792,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "txt", &FTCreateOptions{StopWords: []interface{}{"foo", "bar", "baz"}}, &FieldSchema{FieldName: "txt", FieldType: SearchFieldTypeText}).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "txt", 2) + WaitForIndexing(client, "txt", 2) adapter.HSet(ctx, "doc1", "txt", "foo baz") adapter.HSet(ctx, "doc2", "txt", "hello world") res1, err := adapter.FTSearchWithArgs(ctx, "txt", "foo bar", &FTSearchOptions{NoContent: true}).Result() @@ -11592,7 +11807,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "txt", &FTCreateOptions{}, &FieldSchema{FieldName: "txt", FieldType: SearchFieldTypeText}, &FieldSchema{FieldName: "num", FieldType: SearchFieldTypeNumeric}, &FieldSchema{FieldName: "loc", FieldType: SearchFieldTypeGeo}).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "txt", 2) + WaitForIndexing(client, "txt", 2) adapter.HSet(ctx, "doc1", "txt", "foo bar", "num", 3.141, "loc", "-0.441,51.458") adapter.HSet(ctx, "doc2", "txt", "foo baz", "num", 2, "loc", "-0.1,51.2") res1, err := adapter.FTSearchWithArgs(ctx, "txt", "foo", &FTSearchOptions{Filters: []FTSearchFilter{{FieldName: "num", Min: 0, Max: 2}}, NoContent: true}).Result() @@ -11623,7 +11838,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "num", &FTCreateOptions{}, &FieldSchema{FieldName: "txt", FieldType: SearchFieldTypeText}, &FieldSchema{FieldName: "num", FieldType: SearchFieldTypeNumeric, Sortable: true}).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "num", 2) + WaitForIndexing(client, "num", 2) adapter.HSet(ctx, "doc1", "txt", "foo bar", "num", 1) adapter.HSet(ctx, "doc2", "txt", "foo baz", "num", 2) adapter.HSet(ctx, "doc3", "txt", "foo qux", "num", 3) @@ -11650,7 +11865,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "txt", &FTCreateOptions{}, &FieldSchema{FieldName: "title", FieldType: SearchFieldTypeText, Weight: 5}, &FieldSchema{FieldName: "body", FieldType: SearchFieldTypeText}).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "txt", 2) + WaitForIndexing(client, "txt", 2) adapter.HSet(ctx, "doc1", "title", "RediSearch", "body", "Redisearch impements a search engine on top of redis") res1, err := adapter.FTSearchWithArgs(ctx, "txt", "search engine", &FTSearchOptions{NoContent: true, Verbatim: true, LimitOffset: 0, Limit: 5}).Result() Expect(err).NotTo(HaveOccurred()) @@ -11667,7 +11882,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx", &FTCreateOptions{}, text1, text2, num, geo, tag).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "idx", 2) + WaitForIndexing(client, "idx", 2) adapter.HSet(ctx, "doc1", "field", "aaa", "text", "1", "numeric", 1, "geo", "1,1", "tag", "1") adapter.HSet(ctx, "doc2", "field", "aab", "text", "2", "numeric", 2, "geo", "2,2", "tag", "2") res1, err := adapter.FTSearch(ctx, "idx", "@text:aa*").Result() @@ -11703,7 +11918,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "txt", &FTCreateOptions{}, text1, text2, text3).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "txt", 2) + WaitForIndexing(client, "txt", 2) res1, err := adapter.FTExplain(ctx, "txt", "@f3:f3_val @f2:f2_val @f1:f1_val").Result() Expect(err).NotTo(HaveOccurred()) Expect(res1).ToNot(BeEmpty()) @@ -11716,11 +11931,11 @@ func testAdapterCache(resp3 bool) { val1, err := adapter.FTCreate(ctx, "testAlias", &FTCreateOptions{Prefix: []interface{}{"index1:"}}, text1).Result() Expect(err).NotTo(HaveOccurred()) Expect(val1).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "testAlias", 2) + WaitForIndexing(client, "testAlias", 2) val2, err := adapter.FTCreate(ctx, "testAlias2", &FTCreateOptions{Prefix: []interface{}{"index2:"}}, text2).Result() Expect(err).NotTo(HaveOccurred()) Expect(val2).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "testAlias2", 2) + WaitForIndexing(client, "testAlias2", 2) adapter.HSet(ctx, "index1:lonestar", "name", "lonestar") adapter.HSet(ctx, "index2:yogurt", "name", "yogurt") @@ -11755,7 +11970,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, &FieldSchema{FieldName: "txt", FieldType: SearchFieldTypeText, Sortable: true, NoStem: true}).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "idx1", 2) + WaitForIndexing(client, "idx1", 2) resInfo, err := adapter.FTInfo(ctx, "idx1").Result() Expect(err).NotTo(HaveOccurred()) @@ -11768,7 +11983,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, &FieldSchema{FieldName: "txt", FieldType: SearchFieldTypeText}).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "idx1", 2) + WaitForIndexing(client, "idx1", 2) resAlter, err := adapter.FTAlter(ctx, "idx1", false, []interface{}{"body", SearchFieldTypeText.String()}).Result() Expect(err).NotTo(HaveOccurred()) @@ -11787,7 +12002,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, text1, text2).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "idx1", 2) + WaitForIndexing(client, "idx1", 2) adapter.HSet(ctx, "doc1", "f1", "some valid content", "f2", "this is sample text") adapter.HSet(ctx, "doc2", "f1", "very important", "f2", "lorem ipsum") @@ -11834,7 +12049,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, text1, text2).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "idx1", 2) + WaitForIndexing(client, "idx1", 2) resDictAdd, err := adapter.FTDictAdd(ctx, "custom_dict", "item1", "item2", "item3").Result() Expect(err).NotTo(HaveOccurred()) @@ -11858,7 +12073,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, text1).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "idx1", 2) + WaitForIndexing(client, "idx1", 2) adapter.HSet(ctx, "doc1", "name", "Jon") adapter.HSet(ctx, "doc2", "name", "John") @@ -11873,7 +12088,7 @@ func testAdapterCache(resp3 bool) { val2, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, text2).Result() Expect(err).NotTo(HaveOccurred()) Expect(val2).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "idx1", 2) + WaitForIndexing(client, "idx1", 2) adapter.HSet(ctx, "doc1", "name", "Jon") adapter.HSet(ctx, "doc2", "name", "John") @@ -11891,7 +12106,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, text1).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "idx1", 2) + WaitForIndexing(client, "idx1", 2) adapter.HSet(ctx, "doc1", "description", "The quick brown fox jumps over the lazy dog") adapter.HSet(ctx, "doc2", "description", "Quick alice was beginning to get very tired of sitting by her quick sister on the bank, and of having nothing to do.") @@ -11948,7 +12163,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, text1, text2, text3, num).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "idx1", 2) + WaitForIndexing(client, "idx1", 2) adapter.HSet(ctx, "search", "title", "RediSearch", "body", "Redisearch impements a search engine on top of redis", @@ -12052,7 +12267,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, text1, text2).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "idx1", 2) + WaitForIndexing(client, "idx1", 2) adapter.HSet(ctx, "doc1", "t1", "a", "t2", "b") adapter.HSet(ctx, "doc2", "t1", "b", "t2", "a") @@ -12088,7 +12303,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, text1, text2).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "idx1", 2) + WaitForIndexing(client, "idx1", 2) adapter.HSet(ctx, "doc1", "t1", "hello", "t2", "world") @@ -12115,7 +12330,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, text1, num1).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "idx1", 2) + WaitForIndexing(client, "idx1", 2) adapter.HSet(ctx, "doc1", "PrimaryKey", "9::362330", "CreatedDateTimeUTC", "637387878524969984") adapter.HSet(ctx, "doc2", "PrimaryKey", "9::362329", "CreatedDateTimeUTC", "637387875859270016") @@ -12134,7 +12349,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, text1, num1).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "idx1", 2) + WaitForIndexing(client, "idx1", 2) adapter.HSet(ctx, "doc1", "name", "bar", "age", "25") adapter.HSet(ctx, "doc2", "name", "foo", "age", "19") @@ -12163,7 +12378,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{SkipInitialScan: true}, text1).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "idx1", 2) + WaitForIndexing(client, "idx1", 2) res, err := adapter.FTSearch(ctx, "idx1", "@foo:bar").Result() Expect(err).NotTo(HaveOccurred()) @@ -12176,7 +12391,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{OnJSON: true, Prefix: []interface{}{"king:"}}, text1).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "idx1", 2) + WaitForIndexing(client, "idx1", 2) adapter.JSONSet(ctx, "king:1", "$", `{"name": "henry"}`) adapter.JSONSet(ctx, "king:2", "$", `{"name": "james"}`) @@ -12195,7 +12410,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{OnJSON: true}, text1, num1).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "idx1", 2) + WaitForIndexing(client, "idx1", 2) adapter.JSONSet(ctx, "doc:1", "$", `{"name": "Jon", "age": 25}`) @@ -12213,7 +12428,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, tag1).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "idx1", 2) + WaitForIndexing(client, "idx1", 2) adapter.HSet(ctx, "1", "t", "HELLO") adapter.HSet(ctx, "2", "t", "hello") @@ -12232,7 +12447,7 @@ func testAdapterCache(resp3 bool) { val, err = adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, tag2).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "idx1", 2) + WaitForIndexing(client, "idx1", 2) res, err = adapter.FTSearch(ctx, "idx1", "@t:{HELLO}").Result() Expect(err).NotTo(HaveOccurred()) @@ -12251,7 +12466,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{OnJSON: true}, text1, num1).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "idx1", 2) + WaitForIndexing(client, "idx1", 2) res, err := adapter.FTSearchWithArgs(ctx, "idx1", "*", &FTSearchOptions{Return: []FTSearchReturn{{FieldName: "$.t", As: "txt"}}}).Result() Expect(err).NotTo(HaveOccurred()) @@ -12266,14 +12481,14 @@ func testAdapterCache(resp3 bool) { Expect(res.Docs[0].Fields["txt"]).To(BeEquivalentTo("telmatosaurus")) }) - FIt("should FTSynUpdate", Label("search", "ftsynupdate"), func() { + It("should FTSynUpdate", Label("search", "ftsynupdate"), func() { text1 := &FieldSchema{FieldName: "title", FieldType: SearchFieldTypeText} text2 := &FieldSchema{FieldName: "body", FieldType: SearchFieldTypeText} val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{OnHash: true}, text1, text2).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "idx1", 2) + WaitForIndexing(client, "idx1", 2) resSynUpdate, err := adapter.FTSynUpdateWithArgs(ctx, "idx1", "id1", &FTSynUpdateOptions{SkipInitialScan: true}, []interface{}{"boy", "child", "offspring"}).Result() Expect(err).NotTo(HaveOccurred()) @@ -12299,7 +12514,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{OnHash: true}, text1, text2).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "idx1", 2) + WaitForIndexing(client, "idx1", 2) resSynUpdate, err := adapter.FTSynUpdate(ctx, "idx1", "id1", []interface{}{"boy", "child", "offspring"}).Result() Expect(err).NotTo(HaveOccurred()) @@ -12337,7 +12552,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{OnJSON: true, Prefix: []interface{}{"king:"}}, text1, num1).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "idx1", 2) + WaitForIndexing(client, "idx1", 2) adapter.JSONSet(ctx, "king:1", "$", `{"name": "henry", "num": 42}`) adapter.JSONSet(ctx, "king:2", "$", `{"name": "james", "num": 3.14}`) @@ -12361,7 +12576,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{OnJSON: true, Prefix: []interface{}{"king:"}}, tag1).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "idx1", 2) + WaitForIndexing(client, "idx1", 2) adapter.JSONSet(ctx, "king:1", "$", `{"name": "henry", "country": {"name": "england"}}`) @@ -12379,7 +12594,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{OnJSON: true}, text1, text2).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "idx1", 2) + WaitForIndexing(client, "idx1", 2) adapter.JSONSet(ctx, "doc:1", "$", `{"prod:name": "RediSearch"}`) @@ -12408,7 +12623,7 @@ func testAdapterCache(resp3 bool) { &FieldSchema{FieldName: "v", FieldType: SearchFieldTypeVector, VectorArgs: &FTVectorArgs{HNSWOptions: hnswOptions}}).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "idx1", 2) + WaitForIndexing(client, "idx1", 2) adapter.HSet(ctx, "a", "v", "aaaaaaaa") adapter.HSet(ctx, "b", "v", "aaaabaaa") @@ -12430,7 +12645,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, &FieldSchema{FieldName: "name", FieldType: SearchFieldTypeText}).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "idx1", 2) + WaitForIndexing(client, "idx1", 2) adapter.HSet(ctx, "doc1", "name", "Alice") adapter.HSet(ctx, "doc2", "name", "Bob") @@ -12448,7 +12663,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, &FieldSchema{FieldName: "numval", FieldType: SearchFieldTypeNumeric}).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "idx1", 2) + WaitForIndexing(client, "idx1", 2) adapter.HSet(ctx, "doc1", "numval", 101) adapter.HSet(ctx, "doc2", "numval", 102) @@ -12466,7 +12681,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, &FieldSchema{FieldName: "g", FieldType: SearchFieldTypeGeo}).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "idx1", 2) + WaitForIndexing(client, "idx1", 2) adapter.HSet(ctx, "doc1", "g", "29.69465, 34.95126") adapter.HSet(ctx, "doc2", "g", "29.69350, 34.94737") @@ -12503,7 +12718,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, &FieldSchema{FieldName: "txt", FieldType: SearchFieldTypeText}).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "idx1", 2) + WaitForIndexing(client, "idx1", 2) res, err := adapter.FTInfo(ctx, "idx1").Result() Expect(err).NotTo(HaveOccurred()) @@ -12517,7 +12732,7 @@ func testAdapterCache(resp3 bool) { val, err = adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, &FieldSchema{FieldName: "txt", FieldType: SearchFieldTypeText, WithSuffixtrie: true}).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "idx1", 2) + WaitForIndexing(client, "idx1", 2) res, err = adapter.FTInfo(ctx, "idx1").Result() Expect(err).NotTo(HaveOccurred()) @@ -12531,7 +12746,7 @@ func testAdapterCache(resp3 bool) { val, err = adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, &FieldSchema{FieldName: "t", FieldType: SearchFieldTypeTag, WithSuffixtrie: true}).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "idx1", 2) + WaitForIndexing(client, "idx1", 2) res, err = adapter.FTInfo(ctx, "idx1").Result() Expect(err).NotTo(HaveOccurred()) @@ -12646,7 +12861,7 @@ func testAdapterCache(resp3 bool) { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, &FieldSchema{FieldName: "geom", FieldType: SearchFieldTypeGeoShape, GeoShapeFieldType: "FLAT"}).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "idx1", 2) + WaitForIndexing(client, "idx1", 2) adapter.HSet(ctx, "small", "geom", "POLYGON((1 1, 1 100, 100 100, 100 1, 1 1))") adapter.HSet(ctx, "large", "geom", "POLYGON((1 1, 1 200, 200 200, 200 1, 1 1))") @@ -12676,7 +12891,7 @@ func testAdapterCache(resp3 bool) { ).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "index", 2) + WaitForIndexing(client, "index", 2) }) It("should test geoshapes query intersects and disjoint", Label("NonRedisEnterprise"), func() { @@ -12754,7 +12969,7 @@ func testAdapterCache(resp3 bool) { &FieldSchema{FieldName: "description", FieldType: SearchFieldTypeText, IndexMissing: true}).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "idx1", 2) + WaitForIndexing(client, "idx1", 2) adapter.HSet(ctx, "property:1", map[string]interface{}{ "title": "Luxury Villa in Malibu", @@ -12798,7 +13013,7 @@ func testAdapterCache(resp3 bool) { &FieldSchema{FieldName: "description", FieldType: SearchFieldTypeText, IndexEmpty: true}).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp2, "idx1", 2) + WaitForIndexing(client, "idx1", 2) adapter.HSet(ctx, "property:1", map[string]interface{}{ "title": "Luxury Villa in Malibu", @@ -12837,186 +13052,6 @@ func testAdapterCache(resp3 bool) { Expect(res.Docs[1].ID).To(BeEquivalentTo("property:2")) }) }) - - Describe("RediSearch commands Resp 3", Label("search"), func() { - ctx := context.TODO() - - // BeforeEach(func() { - // client = redis.NewClient(&redis.Options{Addr: ":6379", Protocol: 3, UnstableResp3: true}) - // client2 = redis.NewClient(&redis.Options{Addr: ":6379", Protocol: 3}) - // Expect(client.FlushDB(ctx).Err()).NotTo(HaveOccurred()) - // }) - - It("should handle FTAggregate with Unstable RESP3 Search Module and without stability", Label("search", "ftcreate", "ftaggregate"), func() { - text1 := &FieldSchema{FieldName: "PrimaryKey", FieldType: SearchFieldTypeText, Sortable: true} - num1 := &FieldSchema{FieldName: "CreatedDateTimeUTC", FieldType: SearchFieldTypeNumeric, Sortable: true} - val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, text1, num1).Result() - Expect(err).NotTo(HaveOccurred()) - Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp3, "idx1", 3) - - adapter.HSet(ctx, "doc1", "PrimaryKey", "9::362330", "CreatedDateTimeUTC", "637387878524969984") - adapter.HSet(ctx, "doc2", "PrimaryKey", "9::362329", "CreatedDateTimeUTC", "637387875859270016") - - options := &FTAggregateOptions{Apply: []FTAggregateApply{{Field: "@CreatedDateTimeUTC * 10", As: "CreatedDateTimeUTC"}}} - res, err := adapter.FTAggregateWithArgs(ctx, "idx1", "*", options).RawResult() - results := res.(map[interface{}]interface{})["results"].([]interface{}) - Expect(results[0].(map[interface{}]interface{})["extra_attributes"].(map[interface{}]interface{})["CreatedDateTimeUTC"]). - To(Or(BeEquivalentTo("6373878785249699840"), BeEquivalentTo("6373878758592700416"))) - Expect(results[1].(map[interface{}]interface{})["extra_attributes"].(map[interface{}]interface{})["CreatedDateTimeUTC"]). - To(Or(BeEquivalentTo("6373878785249699840"), BeEquivalentTo("6373878758592700416"))) - - rawVal := adapter.FTAggregateWithArgs(ctx, "idx1", "*", options).RawVal() - rawValResults := rawVal.(map[interface{}]interface{})["results"].([]interface{}) - Expect(err).NotTo(HaveOccurred()) - Expect(rawValResults[0]).To(Or(BeEquivalentTo(results[0]), BeEquivalentTo(results[1]))) - Expect(rawValResults[1]).To(Or(BeEquivalentTo(results[0]), BeEquivalentTo(results[1]))) - - // Test with UnstableResp3 false - Expect(func() { - options = &FTAggregateOptions{Apply: []FTAggregateApply{{Field: "@CreatedDateTimeUTC * 10", As: "CreatedDateTimeUTC"}}} - rawRes, _ := adapter2resp3.FTAggregateWithArgs(ctx, "idx1", "*", options).RawResult() - rawVal = adapter2resp3.FTAggregateWithArgs(ctx, "idx1", "*", options).RawVal() - Expect(rawRes).To(BeNil()) - Expect(rawVal).To(BeNil()) - }).Should(Panic()) - - }) - - It("should handle FTInfo with Unstable RESP3 Search Module and without stability", Label("search", "ftcreate", "ftinfo"), func() { - val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, &FieldSchema{FieldName: "txt", FieldType: SearchFieldTypeText, Sortable: true, NoStem: true}).Result() - Expect(err).NotTo(HaveOccurred()) - Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp3, "idx1", 3) - - resInfo, err := adapter.FTInfo(ctx, "idx1").RawResult() - Expect(err).NotTo(HaveOccurred()) - attributes := resInfo.(map[interface{}]interface{})["attributes"].([]interface{}) - flags := attributes[0].(map[interface{}]interface{})["flags"].([]interface{}) - Expect(flags).To(ConsistOf("SORTABLE", "NOSTEM")) - - valInfo := adapter.FTInfo(ctx, "idx1").RawVal() - attributes = valInfo.(map[interface{}]interface{})["attributes"].([]interface{}) - flags = attributes[0].(map[interface{}]interface{})["flags"].([]interface{}) - Expect(flags).To(ConsistOf("SORTABLE", "NOSTEM")) - - // Test with UnstableResp3 false - Expect(func() { - rawResInfo, _ := adapter2resp3.FTInfo(ctx, "idx1").RawResult() - rawValInfo := adapter2resp3.FTInfo(ctx, "idx1").RawVal() - Expect(rawResInfo).To(BeNil()) - Expect(rawValInfo).To(BeNil()) - }).Should(Panic()) - }) - - It("should handle FTSpellCheck with Unstable RESP3 Search Module and without stability", Label("search", "ftcreate", "ftspellcheck"), func() { - text1 := &FieldSchema{FieldName: "f1", FieldType: SearchFieldTypeText} - text2 := &FieldSchema{FieldName: "f2", FieldType: SearchFieldTypeText} - val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, text1, text2).Result() - Expect(err).NotTo(HaveOccurred()) - Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp3, "idx1", 3) - - adapter.HSet(ctx, "doc1", "f1", "some valid content", "f2", "this is sample text") - adapter.HSet(ctx, "doc2", "f1", "very important", "f2", "lorem ipsum") - - resSpellCheck, err := adapter.FTSpellCheck(ctx, "idx1", "impornant").RawResult() - valSpellCheck := adapter.FTSpellCheck(ctx, "idx1", "impornant").RawVal() - Expect(err).NotTo(HaveOccurred()) - Expect(valSpellCheck).To(BeEquivalentTo(resSpellCheck)) - results := resSpellCheck.(map[interface{}]interface{})["results"].(map[interface{}]interface{}) - Expect(results["impornant"].([]interface{})[0].(map[interface{}]interface{})["important"]).To(BeEquivalentTo(0.5)) - - // Test with UnstableResp3 false - Expect(func() { - rawResSpellCheck, _ := adapter2resp3.FTSpellCheck(ctx, "idx1", "impornant").RawResult() - rawValSpellCheck := adapter2resp3.FTSpellCheck(ctx, "idx1", "impornant").RawVal() - Expect(rawResSpellCheck).To(BeNil()) - Expect(rawValSpellCheck).To(BeNil()) - }).Should(Panic()) - }) - - It("should handle FTSearch with Unstable RESP3 Search Module and without stability", Label("search", "ftcreate", "ftsearch"), func() { - val, err := adapter.FTCreate(ctx, "txt", &FTCreateOptions{StopWords: []interface{}{"foo", "bar", "baz"}}, &FieldSchema{FieldName: "txt", FieldType: SearchFieldTypeText}).Result() - Expect(err).NotTo(HaveOccurred()) - Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp3, "txt", 3) - adapter.HSet(ctx, "doc1", "txt", "foo baz") - adapter.HSet(ctx, "doc2", "txt", "hello world") - res1, err := adapter.FTSearchWithArgs(ctx, "txt", "foo bar", &FTSearchOptions{NoContent: true}).RawResult() - val1 := adapter.FTSearchWithArgs(ctx, "txt", "foo bar", &FTSearchOptions{NoContent: true}).RawVal() - Expect(err).NotTo(HaveOccurred()) - Expect(val1).To(BeEquivalentTo(res1)) - totalResults := res1.(map[interface{}]interface{})["total_results"] - Expect(totalResults).To(BeEquivalentTo(int64(0))) - res2, err := adapter.FTSearchWithArgs(ctx, "txt", "foo bar hello world", &FTSearchOptions{NoContent: true}).RawResult() - Expect(err).NotTo(HaveOccurred()) - totalResults2 := res2.(map[interface{}]interface{})["total_results"] - Expect(totalResults2).To(BeEquivalentTo(int64(1))) - - // Test with UnstableResp3 false - Expect(func() { - rawRes2, _ := adapter2resp3.FTSearchWithArgs(ctx, "txt", "foo bar hello world", &FTSearchOptions{NoContent: true}).RawResult() - rawVal2 := adapter2resp3.FTSearchWithArgs(ctx, "txt", "foo bar hello world", &FTSearchOptions{NoContent: true}).RawVal() - Expect(rawRes2).To(BeNil()) - Expect(rawVal2).To(BeNil()) - }).Should(Panic()) - }) - It("should handle FTSynDump with Unstable RESP3 Search Module and without stability", Label("search", "ftsyndump"), func() { - text1 := &FieldSchema{FieldName: "title", FieldType: SearchFieldTypeText} - text2 := &FieldSchema{FieldName: "body", FieldType: SearchFieldTypeText} - val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{OnHash: true}, text1, text2).Result() - Expect(err).NotTo(HaveOccurred()) - Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp3, "idx1", 3) - - resSynUpdate, err := adapter.FTSynUpdate(ctx, "idx1", "id1", []interface{}{"boy", "child", "offspring"}).Result() - Expect(err).NotTo(HaveOccurred()) - Expect(resSynUpdate).To(BeEquivalentTo("OK")) - - resSynUpdate, err = adapter.FTSynUpdate(ctx, "idx1", "id1", []interface{}{"baby", "child"}).Result() - Expect(err).NotTo(HaveOccurred()) - Expect(resSynUpdate).To(BeEquivalentTo("OK")) - - resSynUpdate, err = adapter.FTSynUpdate(ctx, "idx1", "id1", []interface{}{"tree", "wood"}).Result() - Expect(err).NotTo(HaveOccurred()) - Expect(resSynUpdate).To(BeEquivalentTo("OK")) - - resSynDump, err := adapter.FTSynDump(ctx, "idx1").RawResult() - valSynDump := adapter.FTSynDump(ctx, "idx1").RawVal() - Expect(err).NotTo(HaveOccurred()) - Expect(valSynDump).To(BeEquivalentTo(resSynDump)) - Expect(resSynDump.(map[interface{}]interface{})["baby"]).To(BeEquivalentTo([]interface{}{"id1"})) - - // Test with UnstableResp3 false - Expect(func() { - rawResSynDump, _ := adapter2resp3.FTSynDump(ctx, "idx1").RawResult() - rawValSynDump := adapter2resp3.FTSynDump(ctx, "idx1").RawVal() - Expect(rawResSynDump).To(BeNil()) - Expect(rawValSynDump).To(BeNil()) - }).Should(Panic()) - }) - - It("should test not affected Resp 3 Search method - FTExplain", Label("search", "ftexplain"), func() { - text1 := &FieldSchema{FieldName: "f1", FieldType: SearchFieldTypeText} - text2 := &FieldSchema{FieldName: "f2", FieldType: SearchFieldTypeText} - text3 := &FieldSchema{FieldName: "f3", FieldType: SearchFieldTypeText} - val, err := adapter.FTCreate(ctx, "txt", &FTCreateOptions{}, text1, text2, text3).Result() - Expect(err).NotTo(HaveOccurred()) - Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp3, "txt", 3) - res1, err := adapter.FTExplain(ctx, "txt", "@f3:f3_val @f2:f2_val @f1:f1_val").Result() - Expect(err).NotTo(HaveOccurred()) - Expect(res1).ToNot(BeEmpty()) - - // Test with UnstableResp3 false - Expect(func() { - res2, err := adapter2resp3.FTExplain(ctx, "txt", "@f3:f3_val @f2:f2_val @f1:f1_val").Result() - Expect(err).NotTo(HaveOccurred()) - Expect(res2).ToNot(BeEmpty()) - }).ShouldNot(Panic()) - }) - }) } func libCode(libName string) string { @@ -13057,6 +13092,7 @@ func (s *numberStruct) UnmarshalBinary(b []byte) error { func WaitForIndexing(c rueidis.Client, index string, protocolVersion int) { adapter := NewAdapter(c) + time.Sleep(1000 * time.Millisecond) for { res, err := adapter.FTInfo(context.Background(), index).Result() Expect(err).NotTo(HaveOccurred()) From 4eeaff719a191c931f875802428c06512623eb70 Mon Sep 17 00:00:00 2001 From: Eric Chang Date: Wed, 20 Nov 2024 22:53:15 +0800 Subject: [PATCH 25/49] fix(FT.SEARCH): add correct impl (array reply) --- rueidiscompat/command.go | 231 ++++++++++++++++++++++++++++----------- 1 file changed, 166 insertions(+), 65 deletions(-) diff --git a/rueidiscompat/command.go b/rueidiscompat/command.go index fe5be7dc..d72fc0ee 100644 --- a/rueidiscompat/command.go +++ b/rueidiscompat/command.go @@ -3924,100 +3924,201 @@ type FTSearchCmd struct { options *FTSearchOptions } -// Ref: https://redis.io/docs/latest/commands/ft.search/ +// Ref: https://github.com/redis/go-redis/blob/v9.7.0/search_commands.go#L1541 func (cmd *FTSearchCmd) from(res rueidis.RedisResult) { + // redis message type array is not a RESP3 map + // res may be Map in RESP3, but is array in RESP2 fmt.Printf("rueidisresult %#v\n", res.String()) if err := res.Error(); err != nil { cmd.SetErr(err) return } - m, err := res.ToMap() + + data, err := res.ToArray() if err != nil { cmd.SetErr(err) return } - totalResultsMsg, ok := m["total_results"] - if !ok { - cmd.SetErr(fmt.Errorf(`result map should contain key "total_results"`)) - } - totalResults, err := totalResultsMsg.AsInt64() - if err != nil { - cmd.SetErr(err) + + if len(data) < 1 { + cmd.SetErr(fmt.Errorf("unexpected search result format")) return } - resultsMsg, ok := m["results"] - if !ok { - cmd.SetErr(fmt.Errorf(`result map should contain key "results"`)) - } - resultsArr, err := resultsMsg.ToArray() + + total, err := data[0].AsInt64() if err != nil { cmd.SetErr(err) return } - ftSearchResult := FTSearchResult{Total: int(totalResults), Docs: make([]Document, 0, len(resultsArr))} - for _, result := range resultsArr { - // result: arr: id, doc2, score, 3, "extra_attributes": [foo, bar] - resultMap, err := result.ToMap() + + var results []Document + for i := 1; i < len(data); { + docID, err := data[i].ToString() if err != nil { - cmd.SetErr(err) + cmd.SetErr(fmt.Errorf("invalid total results format: %w", err)) return } - fmt.Println("resultMap", result.String()) - doc := Document{} - for k, v := range resultMap { - switch k { - case "id": - idStr, err := v.ToString() - if err != nil { - cmd.SetErr(err) - return - } - doc.ID = idStr - case "extra_attributes": - // doc.ID = resultArr[i+1].String() - strMap, err := v.AsStrMap() + + doc := Document{ + ID: docID, + Fields: make(map[string]string), + } + i++ + + if cmd.options.NoContent { + results = append(results, doc) + continue + } + + if cmd.options.WithScores && i < len(data) { + scoreStr, err := data[i].ToString() + if err != nil { + cmd.SetErr(fmt.Errorf("invalid score format: %w", err)) + return + } + score, err := strconv.ParseFloat(scoreStr, 64) + if err != nil { + cmd.SetErr(fmt.Errorf("invalid score format: %w", err)) + return + } + doc.Score = &score + i++ + } + + if cmd.options.WithPayloads && i < len(data) { + payload, err := data[i].ToString() + if err != nil { + cmd.SetErr(fmt.Errorf("invalid payload format: %w", err)) + return + } + doc.Payload = &payload + i++ + } + + if cmd.options.WithSortKeys && i < len(data) { + sortKey, err := data[i].ToString() + if err != nil { + cmd.SetErr(fmt.Errorf("invalid payload format: %w", err)) + return + } + doc.SortKey = &sortKey + i++ + } + + if i < len(data) { + fields, err := data[i].ToArray() + if err != nil { + cmd.SetErr(fmt.Errorf("invalid document fields format: %w", err)) + return + } + for j := 0; j < len(fields); j += 2 { + + key, err := fields[j].ToString() if err != nil { - cmd.SetErr(err) + cmd.SetErr(fmt.Errorf("invalid field key format: %w", err)) return } - doc.Fields = strMap - // docs[d].Doc, _ = record.values[j+1].AsStrMap() - case "score": - score, err := v.AsFloat64() + value, err := fields[j+1].ToString() if err != nil { - cmd.SetErr(err) + cmd.SetErr(fmt.Errorf("invalid field value format: %w", err)) return } - doc.Score = &score - case "payload": - if !v.IsNil() { - payload, err := v.ToString() - if err != nil { - cmd.SetErr(err) - return - } - doc.Payload = &payload - } - case "sortkey": - if !v.IsNil() { - sortKey, err := v.ToString() - if err != nil { - cmd.SetErr(err) - return - } - doc.SortKey = &sortKey - } + doc.Fields[key] = value } + i++ } - ftSearchResult.Docs = append(ftSearchResult.Docs, doc) - } - - cmd.SetVal(ftSearchResult) - - _r, _ := json.MarshalIndent(ftSearchResult, "", "\t") - fmt.Print(string(_r)) + results = append(results, doc) + } + + cmd.SetVal(FTSearchResult{ + Total: int(total), + Docs: results, + }) + /// Old, wrong parsing + + // totalResultsMsg, ok := m["total_results"] + // if !ok { + // cmd.SetErr(fmt.Errorf(`result map should contain key "total_results"`)) + // } + // totalResults, err := totalResultsMsg.AsInt64() + // if err != nil { + // cmd.SetErr(err) + // return + // } + // resultsMsg, ok := m["results"] + // if !ok { + // cmd.SetErr(fmt.Errorf(`result map should contain key "results"`)) + // } + // resultsArr, err := resultsMsg.ToArray() + // if err != nil { + // cmd.SetErr(err) + // return + // } + // ftSearchResult := FTSearchResult{Total: int(totalResults), Docs: make([]Document, 0, len(resultsArr))} + // for _, result := range resultsArr { + // // result: arr: id, doc2, score, 3, "extra_attributes": [foo, bar] + // resultMap, err := result.ToMap() + // if err != nil { + // cmd.SetErr(err) + // return + // } + // fmt.Println("resultMap", result.String()) + // doc := Document{} + // for k, v := range resultMap { + // switch k { + // case "id": + // idStr, err := v.ToString() + // if err != nil { + // cmd.SetErr(err) + // return + // } + // doc.ID = idStr + // case "extra_attributes": + // // doc.ID = resultArr[i+1].String() + // strMap, err := v.AsStrMap() + // if err != nil { + // cmd.SetErr(err) + // return + // } + // doc.Fields = strMap + // // docs[d].Doc, _ = record.values[j+1].AsStrMap() + // case "score": + // score, err := v.AsFloat64() + // if err != nil { + // cmd.SetErr(err) + // return + // } + // doc.Score = &score + // case "payload": + // if !v.IsNil() { + // payload, err := v.ToString() + // if err != nil { + // cmd.SetErr(err) + // return + // } + // doc.Payload = &payload + // } + // case "sortkey": + // if !v.IsNil() { + // sortKey, err := v.ToString() + // if err != nil { + // cmd.SetErr(err) + // return + // } + // doc.SortKey = &sortKey + // } + // } + // } + + // ftSearchResult.Docs = append(ftSearchResult.Docs, doc) + // } + + // cmd.SetVal(ftSearchResult) + + // _r, _ := json.MarshalIndent(ftSearchResult, "", "\t") + // fmt.Print(string(_r)) } From 20dc2baaff94daf9ed5e2268c50312f7a9aed583 Mon Sep 17 00:00:00 2001 From: Eric Chang Date: Wed, 20 Nov 2024 22:54:20 +0800 Subject: [PATCH 26/49] minor tweaks --- rueidiscompat/adapter.go | 76 +++++++++++++++++++++++++--------------- rueidiscompat/command.go | 5 +++ 2 files changed, 52 insertions(+), 29 deletions(-) diff --git a/rueidiscompat/adapter.go b/rueidiscompat/adapter.go index d16dff88..307b3c55 100644 --- a/rueidiscompat/adapter.go +++ b/rueidiscompat/adapter.go @@ -5002,24 +5002,15 @@ func (c *Compat) FTConfigSet(ctx context.Context, option string, value interface return newStatusCmd(c.client.Do(ctx, cmd)) } -// OnHash bool -// -// OnJSON bool -// Prefix []any -// Filter string -// DefaultLanguage string -// LanguageField string -// Score float64 -// ScoreField string -// PayloadField string -// MaxTextFields int -// NoOffsets bool -// Temporary int -// NoHL bool -// NoFields bool -// NoFreqs bool -// StopWords []any -// SkipInitialScan bool +// FTCreate - Creates a new index with the given options and schema. +// The 'index' parameter specifies the name of the index to create. +// The 'options' parameter specifies various options for the index, such as: +// whether to index hashes or JSONs, prefixes, filters, default language, score, score field, payload field, etc. +// The 'schema' parameter specifies the schema for the index, which includes the field name, field type, etc. +// For more information, please refer to the Redis documentation: +// [FT.CREATE]: (https://redis.io/commands/ft.create/) +// FTCreate aligns with go-redis v9.7.0. +// Ref: https://github.com/redis/go-redis/blob/v9.7.0/search_commands.go#L854 func (c *Compat) FTCreate(ctx context.Context, index string, options *FTCreateOptions, schema ...*FieldSchema) *StatusCmd { _cmd := cmds.Incomplete(c.client.B().FtCreate().Index(index)) if options != nil { @@ -5095,8 +5086,10 @@ func (c *Compat) FTCreate(ctx context.Context, index string, options *FTCreateOp _cmd = cmds.Incomplete(cmds.FtCreateIndex(_cmd).Schema()) // SCHEMA field_name [AS alias] TEXT | TAG | NUMERIC | GEO | VECTOR | GEOSHAPE [ SORTABLE [UNF]] // [NOINDEX] [ field_name [AS alias] TEXT | TAG | NUMERIC | GEO | VECTOR | GEOSHAPE [ SORTABLE [UNF]] [NOINDEX] ...] - for _, sc := range schema { + if sc.FieldName == "" || sc.FieldType == SearchFieldTypeInvalid { + panic("FT.CREATE: SCHEMA FieldName and FieldType are required") + } _cmd = cmds.Incomplete(cmds.FtCreateSchema(_cmd).FieldName(sc.FieldName)) if sc.As != "" { _cmd = cmds.Incomplete(cmds.FtCreateFieldFieldName(_cmd).As(sc.As)) @@ -5112,21 +5105,45 @@ func (c *Compat) FTCreate(ctx context.Context, index string, options *FTCreateOp _cmd = cmds.Incomplete(cmds.FtCreateFieldAs(_cmd).Geo()) case SearchFieldTypeVector: // FIXME: implement this - break - // if (sc.VectorArgs.FlatOptions == sc.VectorArgs.HNSWOptions) { - // panic("Vector index algorithm should be either FLAT or HNSW") - // } - // if (sc.VectorArgs.FlatOptions!= nil) { - // // (algo string, nargs int64, args ...string) - // _cmd = cmds.Incomplete(cmds.FtCreateFieldAs(_cmd).Vector("FLAT",sc.VectorArgs.FlatOptions.)) - // } else { - - // } + // VECTOR + // [ ...] + // Ref: https://redis.io/docs/latest/develop/interact/search-and-query/advanced-concepts/vectors/#create-a-vector-index + if sc.VectorArgs == nil { + panic("FT.CREATE: SCHEMA VectorArgs cannot be nil") + } + if sc.VectorArgs.FlatOptions != nil && sc.VectorArgs.HNSWOptions != nil { + panic("FT.CREATE: SCHEMA VectorArgs FlatOptions and HNSWOptions are mutually exclusive") + } + if sc.VectorArgs.FlatOptions != nil { + // args = append(args, "FLAT") + // _cmd = cmds.Incomplete(cmds.FtCreateFieldFieldTypeVector(_cmd).()) + if sc.VectorArgs.FlatOptions.Type == "" || sc.VectorArgs.FlatOptions.Dim == 0 || sc.VectorArgs.FlatOptions.DistanceMetric == "" { + panic("FT.CREATE: Type, Dim and DistanceMetric are required for VECTOR FLAT") + } + flatArgs := []interface{}{ + "TYPE", sc.VectorArgs.FlatOptions.Type, + "DIM", sc.VectorArgs.FlatOptions.Dim, + "DISTANCE_METRIC", sc.VectorArgs.FlatOptions.DistanceMetric, + } + if sc.VectorArgs.FlatOptions.InitialCapacity > 0 { + flatArgs = append(flatArgs, "INITIAL_CAP", sc.VectorArgs.FlatOptions.InitialCapacity) + } + if sc.VectorArgs.FlatOptions.BlockSize > 0 { + flatArgs = append(flatArgs, "BLOCK_SIZE", sc.VectorArgs.FlatOptions.BlockSize) + } + } case SearchFieldTypeGeoShape: + // FIXME: geo shape need a block + if sc.GeoShapeFieldType == "" { + panic("FT.CREATE: GeoShapeFieldType cannot be empty while SCHEMA FieldType is GEOSHAPE") + } _cmd = cmds.Incomplete(cmds.FtCreateFieldAs(_cmd).Geoshape()) default: panic(fmt.Sprintf("unexpected SearchFieldType: %s", sc.FieldType.String())) } + if sc.NoStem { + _cmd = cmds.Incomplete(cmds.FtCreateFieldFieldTypeText(_cmd).Nostem()) + } if sc.Sortable { _cmd = cmds.Incomplete(cmds.FtCreateFieldFieldTypeText(_cmd).Sortable()) } @@ -5224,6 +5241,7 @@ func (c *Compat) FTExplainWithArgs(ctx context.Context, index string, query stri func (c *Compat) FTInfo(ctx context.Context, index string) *FTInfoCmd { cmd := c.client.B().FtInfo().Index(index).Build() + fmt.Println(cmd.Commands()) return newFTInfoCmd(c.client.Do(ctx, cmd)) } diff --git a/rueidiscompat/command.go b/rueidiscompat/command.go index d72fc0ee..e7da0284 100644 --- a/rueidiscompat/command.go +++ b/rueidiscompat/command.go @@ -3827,6 +3827,11 @@ type FTInfoCmd struct { func (cmd *FTInfoCmd) from(res rueidis.RedisResult) { // FIXME: impl + fmt.Println(res.String()) + if err := res.Error(); err != nil { + cmd.SetErr(err) + return + } } func newFTInfoCmd(res rueidis.RedisResult) *FTInfoCmd { From 2a95d298d9f58ab5a1fff0e6d81115fb981c937b Mon Sep 17 00:00:00 2001 From: Eric Chang Date: Thu, 21 Nov 2024 22:19:35 +0800 Subject: [PATCH 27/49] fix: FT.INFO, FT.SPELLCHECK --- rueidiscompat/adapter.go | 25 +- rueidiscompat/adapter_test.go | 4 +- rueidiscompat/command.go | 446 +++++++++++++++++++++++++++------- rueidiscompat/util.go | 134 ++++++++++ 4 files changed, 505 insertions(+), 104 deletions(-) create mode 100644 rueidiscompat/util.go diff --git a/rueidiscompat/adapter.go b/rueidiscompat/adapter.go index 307b3c55..e4d89c2d 100644 --- a/rueidiscompat/adapter.go +++ b/rueidiscompat/adapter.go @@ -5252,18 +5252,25 @@ func (c *Compat) FTSpellCheck(ctx context.Context, index string, query string) * func (c *Compat) FTSpellCheckWithArgs(ctx context.Context, index string, query string, options *FTSpellCheckOptions) *FTSpellCheckCmd { _cmd := cmds.Incomplete(c.client.B().FtSpellcheck().Index(index).Query(query)) - _cmd = cmds.Incomplete(cmds.FtSpellcheckQuery(_cmd).Distance(int64(options.Distance))) - if options.Terms != nil { - if options.Terms.Inclusion != "INCLUDE" && options.Terms.Inclusion != "EXCLUDE" { - panic("Inclusion should be either INCLUDE or EXCLUDE") + if options != nil { + if options.Distance > 0 { + _cmd = cmds.Incomplete(cmds.FtSpellcheckQuery(_cmd).Distance(int64(options.Distance))) } - if options.Terms.Inclusion == "INCLUDE" { - _cmd = cmds.Incomplete(cmds.FtSpellcheckQuery(_cmd).TermsInclude().Dictionary(options.Terms.Dictionary).Terms(argsToSlice(options.Terms.Terms)...)) - } else { - _cmd = cmds.Incomplete(cmds.FtSpellcheckQuery(_cmd).TermsExclude().Dictionary(options.Terms.Dictionary).Terms(argsToSlice(options.Terms.Terms)...)) + if options.Terms != nil { + if options.Terms.Inclusion != "INCLUDE" && options.Terms.Inclusion != "EXCLUDE" { + panic("Inclusion should be either INCLUDE or EXCLUDE") + } + if options.Terms.Inclusion == "INCLUDE" { + _cmd = cmds.Incomplete(cmds.FtSpellcheckQuery(_cmd).TermsInclude().Dictionary(options.Terms.Dictionary).Terms(argsToSlice(options.Terms.Terms)...)) + } else { + _cmd = cmds.Incomplete(cmds.FtSpellcheckQuery(_cmd).TermsExclude().Dictionary(options.Terms.Dictionary).Terms(argsToSlice(options.Terms.Terms)...)) + } + } + if options.Dialect > 0 { + _cmd = cmds.Incomplete(cmds.FtSpellcheckQuery(_cmd).Dialect(int64(options.Dialect))) } } - cmd := cmds.FtSpellcheckQuery(_cmd).Dialect(int64(options.Dialect)).Build() + cmd := cmds.FtSpellcheckQuery(_cmd).Build() return newFTSpellCheckCmd(c.client.Do(ctx, cmd)) } diff --git a/rueidiscompat/adapter_test.go b/rueidiscompat/adapter_test.go index 87ff0775..a4a9a488 100644 --- a/rueidiscompat/adapter_test.go +++ b/rueidiscompat/adapter_test.go @@ -11770,7 +11770,7 @@ func testAdapterSearchRESP2() { Expect(adapter.FlushDB(ctx).Err()).NotTo(HaveOccurred()) }) - FIt("should FTCreate and FTSearch WithScores", Label("search", "ftcreate", "ftsearch"), func() { + It("should FTCreate and FTSearch WithScores", Label("search", "ftcreate", "ftsearch"), func() { // FIXME: FieldType val, err := adapter.FTCreate(ctx, "txt", &FTCreateOptions{}, &FieldSchema{FieldName: "txt", FieldType: SearchFieldTypeText}).Result() Expect(err).NotTo(HaveOccurred()) @@ -11996,7 +11996,7 @@ func testAdapterSearchRESP2() { }) - It("should FTSpellCheck", Label("search", "ftcreate", "ftsearch", "ftspellcheck"), func() { + FIt("should FTSpellCheck", Label("search", "ftcreate", "ftsearch", "ftspellcheck"), func() { text1 := &FieldSchema{FieldName: "f1", FieldType: SearchFieldTypeText} text2 := &FieldSchema{FieldName: "f2", FieldType: SearchFieldTypeText} val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, text1, text2).Result() diff --git a/rueidiscompat/command.go b/rueidiscompat/command.go index e7da0284..5655b20c 100644 --- a/rueidiscompat/command.go +++ b/rueidiscompat/command.go @@ -3736,7 +3736,7 @@ type FTExplainOptions struct { } type IndexErrors struct { - IndexingFailures int + IndexingFailures int `redis:"indexing failures"` LastIndexingError string LastIndexingErrorKey string } @@ -3769,13 +3769,13 @@ type FieldStatistic struct { } type GCStats struct { - BytesCollected int - TotalMsRun int - TotalCycles int - AverageCycleTimeMs string - LastRunTimeMs int - GCNumericTreesMissed int - GCBlocksDenied int + BytesCollected int `redis:"bytes_collected"` + TotalMsRun int `redis:"total_ms_run"` + TotalCycles int `redis:"total_cycles"` + AverageCycleTimeMs string `redis:"average_cycle_time_ms"` + LastRunTimeMs int `redis:"last_run_time_ms"` + GCNumericTreesMissed int `redis:"gc_numeric_trees_missed"` + GCBlocksDenied int `redis:"gc_blocks_denied"` } type IndexDefinition struct { @@ -3785,53 +3785,249 @@ type IndexDefinition struct { } type FTInfoResult struct { - IndexErrors IndexErrors - Attributes []FTAttribute - BytesPerRecordAvg string - Cleaning int - CursorStats CursorStats - DialectStats map[string]int - DocTableSizeMB float64 - FieldStatistics []FieldStatistic - GCStats GCStats - GeoshapesSzMB float64 - HashIndexingFailures int - IndexDefinition IndexDefinition - IndexName string - IndexOptions []string - Indexing int - InvertedSzMB float64 - KeyTableSizeMB float64 - MaxDocID int - NumDocs int - NumRecords int - NumTerms int - NumberOfUses int - OffsetBitsPerRecordAvg string - OffsetVectorsSzMB float64 - OffsetsPerTermAvg string - PercentIndexed float64 - RecordsPerDocAvg string - SortableValuesSizeMB float64 - TagOverheadSzMB float64 - TextOverheadSzMB float64 - TotalIndexMemorySzMB float64 - TotalIndexingTime int - TotalInvertedIndexBlocks int - VectorIndexSzMB float64 + IndexErrors IndexErrors `redis:"Index Errors"` + Attributes []FTAttribute `redis:"attributes"` + BytesPerRecordAvg string `redis:"bytes_per_record_avg"` + Cleaning int `redis:"cleaning"` + CursorStats CursorStats `redis:"cursor_stats"` + DialectStats map[string]int `redis:"dialect_stats"` + DocTableSizeMB float64 `redis:"doc_table_size_mb"` + FieldStatistics []FieldStatistic `redis:"field statistics"` + GCStats GCStats `redis:"gc_stats"` + GeoshapesSzMB float64 `redis:"geoshapes_sz_mb"` + HashIndexingFailures int `redis:"hash_indexing_failures"` + IndexDefinition IndexDefinition `redis:"index_definition"` + IndexName string `redis:"index_name"` + IndexOptions []string `redis:"index_options"` + Indexing int `redis:"indexing"` + InvertedSzMB float64 `redis:"inverted_sz_mb"` + KeyTableSizeMB float64 `redis:"key_table_size_mb"` + MaxDocID int `redis:"max_doc_id"` + NumDocs int `redis:"num_docs"` + NumRecords int `redis:"num_records"` + NumTerms int `redis:"num_terms"` + NumberOfUses int `redis:"number_of_uses"` + OffsetBitsPerRecordAvg string `redis:"offset_bits_per_record_avg"` + OffsetVectorsSzMB float64 `redis:"offset_vectors_sz_mb"` + OffsetsPerTermAvg string `redis:"offsets_per_term_avg"` + PercentIndexed float64 `redis:"percent_indexed"` + RecordsPerDocAvg string `redis:"records_per_doc_avg"` + SortableValuesSizeMB float64 `redis:"sortable_values_size_mb"` + TagOverheadSzMB float64 `redis:"tag_overhead_sz_mb"` + TextOverheadSzMB float64 `redis:"text_overhead_sz_mb"` + TotalIndexMemorySzMB float64 `redis:"total_index_memory_sz_mb"` + TotalIndexingTime int `redis:"total_indexing_time"` + TotalInvertedIndexBlocks int `redis:"total_inverted_index_blocks"` + VectorIndexSzMB float64 `redis:"vector_index_sz_mb"` } type FTInfoCmd struct { baseCmd[FTInfoResult] } +// Ref: https://github.com/redis/go-redis/blob/v9.7.0/search_commands.go#L1143 +func parseFTInfo(data map[string]interface{}) (FTInfoResult, error) { + var ftInfo FTInfoResult + // Manually parse each field from the map + if indexErrors, ok := data["Index Errors"].([]interface{}); ok { + ftInfo.IndexErrors = IndexErrors{ + IndexingFailures: ToInteger(indexErrors[1]), + LastIndexingError: ToString(indexErrors[3]), + LastIndexingErrorKey: ToString(indexErrors[5]), + } + } + + if attributes, ok := data["attributes"].([]interface{}); ok { + for _, attr := range attributes { + if attrMap, ok := attr.([]interface{}); ok { + att := FTAttribute{} + for i := 0; i < len(attrMap); i++ { + if ToLower(ToString(attrMap[i])) == "attribute" { + att.Attribute = ToString(attrMap[i+1]) + continue + } + if ToLower(ToString(attrMap[i])) == "identifier" { + att.Identifier = ToString(attrMap[i+1]) + continue + } + if ToLower(ToString(attrMap[i])) == "type" { + att.Type = ToString(attrMap[i+1]) + continue + } + if ToLower(ToString(attrMap[i])) == "weight" { + att.Weight = ToFloat(attrMap[i+1]) + continue + } + if ToLower(ToString(attrMap[i])) == "nostem" { + att.NoStem = true + continue + } + if ToLower(ToString(attrMap[i])) == "sortable" { + att.Sortable = true + continue + } + if ToLower(ToString(attrMap[i])) == "noindex" { + att.NoIndex = true + continue + } + if ToLower(ToString(attrMap[i])) == "unf" { + att.UNF = true + continue + } + if ToLower(ToString(attrMap[i])) == "phonetic" { + att.PhoneticMatcher = ToString(attrMap[i+1]) + continue + } + if ToLower(ToString(attrMap[i])) == "case_sensitive" { + att.CaseSensitive = true + continue + } + if ToLower(ToString(attrMap[i])) == "withsuffixtrie" { + att.WithSuffixtrie = true + continue + } + + } + ftInfo.Attributes = append(ftInfo.Attributes, att) + } + } + } + + ftInfo.BytesPerRecordAvg = ToString(data["bytes_per_record_avg"]) + ftInfo.Cleaning = ToInteger(data["cleaning"]) + + if cursorStats, ok := data["cursor_stats"].([]interface{}); ok { + ftInfo.CursorStats = CursorStats{ + GlobalIdle: ToInteger(cursorStats[1]), + GlobalTotal: ToInteger(cursorStats[3]), + IndexCapacity: ToInteger(cursorStats[5]), + IndexTotal: ToInteger(cursorStats[7]), + } + } + + if dialectStats, ok := data["dialect_stats"].([]interface{}); ok { + ftInfo.DialectStats = make(map[string]int) + for i := 0; i < len(dialectStats); i += 2 { + ftInfo.DialectStats[ToString(dialectStats[i])] = ToInteger(dialectStats[i+1]) + } + } + + ftInfo.DocTableSizeMB = ToFloat(data["doc_table_size_mb"]) + + if fieldStats, ok := data["field statistics"].([]interface{}); ok { + for _, stat := range fieldStats { + if statMap, ok := stat.([]interface{}); ok { + ftInfo.FieldStatistics = append(ftInfo.FieldStatistics, FieldStatistic{ + Identifier: ToString(statMap[1]), + Attribute: ToString(statMap[3]), + IndexErrors: IndexErrors{ + IndexingFailures: ToInteger(statMap[5].([]interface{})[1]), + LastIndexingError: ToString(statMap[5].([]interface{})[3]), + LastIndexingErrorKey: ToString(statMap[5].([]interface{})[5]), + }, + }) + } + } + } + + if gcStats, ok := data["gc_stats"].([]interface{}); ok { + ftInfo.GCStats = GCStats{} + for i := 0; i < len(gcStats); i += 2 { + if ToLower(ToString(gcStats[i])) == "bytes_collected" { + ftInfo.GCStats.BytesCollected = ToInteger(gcStats[i+1]) + continue + } + if ToLower(ToString(gcStats[i])) == "total_ms_run" { + ftInfo.GCStats.TotalMsRun = ToInteger(gcStats[i+1]) + continue + } + if ToLower(ToString(gcStats[i])) == "total_cycles" { + ftInfo.GCStats.TotalCycles = ToInteger(gcStats[i+1]) + continue + } + if ToLower(ToString(gcStats[i])) == "average_cycle_time_ms" { + ftInfo.GCStats.AverageCycleTimeMs = ToString(gcStats[i+1]) + continue + } + if ToLower(ToString(gcStats[i])) == "last_run_time_ms" { + ftInfo.GCStats.LastRunTimeMs = ToInteger(gcStats[i+1]) + continue + } + if ToLower(ToString(gcStats[i])) == "gc_numeric_trees_missed" { + ftInfo.GCStats.GCNumericTreesMissed = ToInteger(gcStats[i+1]) + continue + } + if ToLower(ToString(gcStats[i])) == "gc_blocks_denied" { + ftInfo.GCStats.GCBlocksDenied = ToInteger(gcStats[i+1]) + continue + } + } + } + + ftInfo.GeoshapesSzMB = ToFloat(data["geoshapes_sz_mb"]) + ftInfo.HashIndexingFailures = ToInteger(data["hash_indexing_failures"]) + + if indexDef, ok := data["index_definition"].([]interface{}); ok { + ftInfo.IndexDefinition = IndexDefinition{ + KeyType: ToString(indexDef[1]), + Prefixes: ToStringSlice(indexDef[3]), + DefaultScore: ToFloat(indexDef[5]), + } + } + + ftInfo.IndexName = ToString(data["index_name"]) + ftInfo.IndexOptions = ToStringSlice(data["index_options"].([]interface{})) + ftInfo.Indexing = ToInteger(data["indexing"]) + ftInfo.InvertedSzMB = ToFloat(data["inverted_sz_mb"]) + ftInfo.KeyTableSizeMB = ToFloat(data["key_table_size_mb"]) + ftInfo.MaxDocID = ToInteger(data["max_doc_id"]) + ftInfo.NumDocs = ToInteger(data["num_docs"]) + ftInfo.NumRecords = ToInteger(data["num_records"]) + ftInfo.NumTerms = ToInteger(data["num_terms"]) + ftInfo.NumberOfUses = ToInteger(data["number_of_uses"]) + ftInfo.OffsetBitsPerRecordAvg = ToString(data["offset_bits_per_record_avg"]) + ftInfo.OffsetVectorsSzMB = ToFloat(data["offset_vectors_sz_mb"]) + ftInfo.OffsetsPerTermAvg = ToString(data["offsets_per_term_avg"]) + ftInfo.PercentIndexed = ToFloat(data["percent_indexed"]) + ftInfo.RecordsPerDocAvg = ToString(data["records_per_doc_avg"]) + ftInfo.SortableValuesSizeMB = ToFloat(data["sortable_values_size_mb"]) + ftInfo.TagOverheadSzMB = ToFloat(data["tag_overhead_sz_mb"]) + ftInfo.TextOverheadSzMB = ToFloat(data["text_overhead_sz_mb"]) + ftInfo.TotalIndexMemorySzMB = ToFloat(data["total_index_memory_sz_mb"]) + ftInfo.TotalIndexingTime = ToInteger(data["total_indexing_time"]) + ftInfo.TotalInvertedIndexBlocks = ToInteger(data["total_inverted_index_blocks"]) + ftInfo.VectorIndexSzMB = ToFloat(data["vector_index_sz_mb"]) + + return ftInfo, nil +} + func (cmd *FTInfoCmd) from(res rueidis.RedisResult) { - // FIXME: impl - fmt.Println(res.String()) if err := res.Error(); err != nil { cmd.SetErr(err) return } + + m, err := res.AsMap() + if err != nil { + cmd.SetErr(err) + return + } + + anyMap := make(map[string]any, len(m)) + for k, v := range m { + anyMap[k], err = v.ToAny() + if err != nil { + cmd.SetErr(err) + return + } + } + + ftInfoResult, err := parseFTInfo(anyMap) + if err != nil { + cmd.SetErr(err) + return + } + cmd.SetVal(ftInfoResult) } func newFTInfoCmd(res rueidis.RedisResult) *FTInfoCmd { @@ -3862,19 +4058,39 @@ type SpellCheckSuggestion struct { Suggestion string } -type FTSpellCheckCmd struct{ baseCmd[SpellCheckResult] } +type FTSpellCheckCmd struct{ baseCmd[[]SpellCheckResult] } func (cmd *FTSpellCheckCmd) Val() []SpellCheckResult { - // FIXME: impl - return []SpellCheckResult{} + return cmd.val } func (cmd *FTSpellCheckCmd) Result() ([]SpellCheckResult, error) { - return cmd.Val(), cmd.err + return cmd.Val(), cmd.Err() } func (cmd *FTSpellCheckCmd) from(res rueidis.RedisResult) { // FIXME: impl + fmt.Println(res.String()) + arr, err := res.ToArray() + if err != nil { + cmd.SetErr(err) + return + } + AnyArr := make([]any, 0, len(arr)) + for _, e := range arr { + anyE, err := e.ToAny() + if err != nil { + cmd.SetErr(err) + return + } + AnyArr = append(AnyArr, anyE) + } + result, err := parseFTSpellCheck(AnyArr) + if err != nil { + cmd.SetErr(err) + return + } + cmd.SetVal(result) } func newFTSpellCheckCmd(res rueidis.RedisResult) *FTSpellCheckCmd { @@ -3883,6 +4099,61 @@ func newFTSpellCheckCmd(res rueidis.RedisResult) *FTSpellCheckCmd { return cmd } +func parseFTSpellCheck(data []interface{}) ([]SpellCheckResult, error) { + results := make([]SpellCheckResult, 0, len(data)) + + for _, termData := range data { + termInfo, ok := termData.([]interface{}) + if !ok || len(termInfo) != 3 { + return nil, fmt.Errorf("invalid term format") + } + + term, ok := termInfo[1].(string) + if !ok { + return nil, fmt.Errorf("invalid term format") + } + + suggestionsData, ok := termInfo[2].([]interface{}) + if !ok { + return nil, fmt.Errorf("invalid suggestions format") + } + + suggestions := make([]SpellCheckSuggestion, 0, len(suggestionsData)) + for _, suggestionData := range suggestionsData { + suggestionInfo, ok := suggestionData.([]interface{}) + if !ok || len(suggestionInfo) != 2 { + return nil, fmt.Errorf("invalid suggestion format") + } + + scoreStr, ok := suggestionInfo[0].(string) + if !ok { + return nil, fmt.Errorf("invalid suggestion score format") + } + score, err := strconv.ParseFloat(scoreStr, 64) + if err != nil { + return nil, fmt.Errorf("invalid suggestion score value") + } + + suggestion, ok := suggestionInfo[1].(string) + if !ok { + return nil, fmt.Errorf("invalid suggestion format") + } + + suggestions = append(suggestions, SpellCheckSuggestion{ + Score: score, + Suggestion: suggestion, + }) + } + + results = append(results, SpellCheckResult{ + Term: term, + Suggestions: suggestions, + }) + } + + return results, nil +} + type Document struct { ID string Score *float64 @@ -3933,30 +4204,26 @@ type FTSearchCmd struct { func (cmd *FTSearchCmd) from(res rueidis.RedisResult) { // redis message type array is not a RESP3 map // res may be Map in RESP3, but is array in RESP2 - fmt.Printf("rueidisresult %#v\n", res.String()) + fmt.Printf("\nrueidisresult %#v\n", res.String()) if err := res.Error(); err != nil { cmd.SetErr(err) return } - data, err := res.ToArray() if err != nil { cmd.SetErr(err) return } - if len(data) < 1 { cmd.SetErr(fmt.Errorf("unexpected search result format")) return } - total, err := data[0].AsInt64() if err != nil { cmd.SetErr(err) return } - var results []Document for i := 1; i < len(data); { docID, err := data[i].ToString() @@ -3964,53 +4231,49 @@ func (cmd *FTSearchCmd) from(res rueidis.RedisResult) { cmd.SetErr(fmt.Errorf("invalid total results format: %w", err)) return } - doc := Document{ ID: docID, Fields: make(map[string]string), } i++ - - if cmd.options.NoContent { - results = append(results, doc) - continue - } - - if cmd.options.WithScores && i < len(data) { - scoreStr, err := data[i].ToString() - if err != nil { - cmd.SetErr(fmt.Errorf("invalid score format: %w", err)) - return + if cmd.options != nil { + if cmd.options.NoContent { + results = append(results, doc) + continue } - score, err := strconv.ParseFloat(scoreStr, 64) - if err != nil { - cmd.SetErr(fmt.Errorf("invalid score format: %w", err)) - return + if cmd.options.WithScores && i < len(data) { + scoreStr, err := data[i].ToString() + if err != nil { + cmd.SetErr(fmt.Errorf("invalid score format: %w", err)) + return + } + score, err := strconv.ParseFloat(scoreStr, 64) + if err != nil { + cmd.SetErr(fmt.Errorf("invalid score format: %w", err)) + return + } + doc.Score = &score + i++ } - doc.Score = &score - i++ - } - - if cmd.options.WithPayloads && i < len(data) { - payload, err := data[i].ToString() - if err != nil { - cmd.SetErr(fmt.Errorf("invalid payload format: %w", err)) - return + if cmd.options.WithPayloads && i < len(data) { + payload, err := data[i].ToString() + if err != nil { + cmd.SetErr(fmt.Errorf("invalid payload format: %w", err)) + return + } + doc.Payload = &payload + i++ } - doc.Payload = &payload - i++ - } - - if cmd.options.WithSortKeys && i < len(data) { - sortKey, err := data[i].ToString() - if err != nil { - cmd.SetErr(fmt.Errorf("invalid payload format: %w", err)) - return + if cmd.options.WithSortKeys && i < len(data) { + sortKey, err := data[i].ToString() + if err != nil { + cmd.SetErr(fmt.Errorf("invalid payload format: %w", err)) + return + } + doc.SortKey = &sortKey + i++ } - doc.SortKey = &sortKey - i++ } - if i < len(data) { fields, err := data[i].ToArray() if err != nil { @@ -4018,7 +4281,6 @@ func (cmd *FTSearchCmd) from(res rueidis.RedisResult) { return } for j := 0; j < len(fields); j += 2 { - key, err := fields[j].ToString() if err != nil { cmd.SetErr(fmt.Errorf("invalid field key format: %w", err)) @@ -4033,10 +4295,8 @@ func (cmd *FTSearchCmd) from(res rueidis.RedisResult) { } i++ } - results = append(results, doc) } - cmd.SetVal(FTSearchResult{ Total: int(total), Docs: results, diff --git a/rueidiscompat/util.go b/rueidiscompat/util.go new file mode 100644 index 00000000..772b4b34 --- /dev/null +++ b/rueidiscompat/util.go @@ -0,0 +1,134 @@ +package rueidiscompat + +import ( + "context" + "net" + "strconv" + "strings" + "time" +) + +func Sleep(ctx context.Context, dur time.Duration) error { + t := time.NewTimer(dur) + defer t.Stop() + + select { + case <-t.C: + return nil + case <-ctx.Done(): + return ctx.Err() + } +} + +func ToLower(s string) string { + if isLower(s) { + return s + } + + b := make([]byte, len(s)) + for i := range b { + c := s[i] + if c >= 'A' && c <= 'Z' { + c += 'a' - 'A' + } + b[i] = c + } + return BytesToString(b) +} + +func BytesToString(b []byte) string { + return string(b) +} + +func StringToBytes(s string) []byte { + return []byte(s) +} + +func isLower(s string) bool { + for i := 0; i < len(s); i++ { + c := s[i] + if c >= 'A' && c <= 'Z' { + return false + } + } + return true +} + +func ReplaceSpaces(s string) string { + // Pre-allocate a builder with the same length as s to minimize allocations. + // This is a basic optimization; adjust the initial size based on your use case. + var builder strings.Builder + builder.Grow(len(s)) + + for _, char := range s { + if char == ' ' { + // Replace space with a hyphen. + builder.WriteRune('-') + } else { + // Copy the character as-is. + builder.WriteRune(char) + } + } + + return builder.String() +} + +func GetAddr(addr string) string { + ind := strings.LastIndexByte(addr, ':') + if ind == -1 { + return "" + } + + if strings.IndexByte(addr, '.') != -1 { + return addr + } + + if addr[0] == '[' { + return addr + } + return net.JoinHostPort(addr[:ind], addr[ind+1:]) +} + +func ToInteger(val interface{}) int { + switch v := val.(type) { + case int: + return v + case int64: + return int(v) + case string: + i, _ := strconv.Atoi(v) + return i + default: + return 0 + } +} + +func ToFloat(val interface{}) float64 { + switch v := val.(type) { + case float64: + return v + case string: + f, _ := strconv.ParseFloat(v, 64) + return f + default: + return 0.0 + } +} + +func ToString(val interface{}) string { + if str, ok := val.(string); ok { + return str + } + return "" +} + +func ToStringSlice(val interface{}) []string { + if arr, ok := val.([]interface{}); ok { + result := make([]string, len(arr)) + for i, v := range arr { + result[i] = ToString(v) + } + return result + } + return nil +} From 76bb0d9aaeacf205def9a04c89deae1c530fa75b Mon Sep 17 00:00:00 2001 From: Eric Chang Date: Fri, 22 Nov 2024 06:48:15 +0800 Subject: [PATCH 28/49] doc(util.go): add liscence --- rueidiscompat/util.go | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) diff --git a/rueidiscompat/util.go b/rueidiscompat/util.go index 772b4b34..335bd0c2 100644 --- a/rueidiscompat/util.go +++ b/rueidiscompat/util.go @@ -1,3 +1,29 @@ +// Copyright (c) 2013 The github.com/go-redis/redis Authors. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + package rueidiscompat import ( From 8cbc291f7e2534876fa787c858b85d396037d2f7 Mon Sep 17 00:00:00 2001 From: Eric Chang Date: Fri, 22 Nov 2024 07:04:50 +0800 Subject: [PATCH 29/49] feat(FT.CONFIG_GET): impl --- rueidiscompat/command.go | 30 ++++++++++++++++++------------ 1 file changed, 18 insertions(+), 12 deletions(-) diff --git a/rueidiscompat/command.go b/rueidiscompat/command.go index 5655b20c..a40afa6f 100644 --- a/rueidiscompat/command.go +++ b/rueidiscompat/command.go @@ -3358,36 +3358,42 @@ func newJSONSliceCmd(res rueidis.RedisResult) *JSONSliceCmd { return cmd } -type mapStringInterface map[string]any type MapMapStringInterfaceCmd struct { - baseCmd[map[string]mapStringInterface] + baseCmd[map[string]any] } func (cmd *MapMapStringInterfaceCmd) from(res rueidis.RedisResult) { - // outerMap: map[string]mapStringInterface - outerMap, err := res.ToMap() + arr, err := res.ToArray() if err != nil { cmd.SetErr(err) return } - cmd.val = make(map[string]mapStringInterface, len(outerMap)) - for k, v := range outerMap { - // _m: map[string]any - _m, err := v.ToMap() + data := make(map[string]any, len(arr)/2) + for i := 0; i < len(arr); i++ { + arr1, err := arr[i].ToArray() if err != nil { cmd.SetErr(err) return } - cmd.val[k] = make(map[string]any, len(_m)) - for _k, _v := range _m { - val, err := _v.ToAny() + for _i := 0; _i < len(arr1); _i += 2 { + key, err := arr1[_i].ToString() if err != nil { cmd.SetErr(err) return } - cmd.val[k][_k] = val + if !arr1[_i+1].IsNil() { + value, err := arr1[_i+1].ToAny() + if err != nil { + cmd.SetErr(err) + return + } + data[key] = value + } else { + data[key] = nil + } } } + cmd.SetVal(data) } func newMapMapStringInterfaceCmd(res rueidis.RedisResult) *MapMapStringInterfaceCmd { From fa13b50aac015d6e39af7ff9018d5c8bfc8ec300 Mon Sep 17 00:00:00 2001 From: Eric Chang Date: Fri, 22 Nov 2024 08:52:25 +0800 Subject: [PATCH 30/49] feat(FT.SYNDUMP, FTSYNUPDATE): impl --- rueidiscompat/adapter.go | 23 +++++- rueidiscompat/adapter_test.go | 5 +- rueidiscompat/command.go | 134 ++++++++++++++++++---------------- 3 files changed, 94 insertions(+), 68 deletions(-) diff --git a/rueidiscompat/adapter.go b/rueidiscompat/adapter.go index e4d89c2d..1d81f0b3 100644 --- a/rueidiscompat/adapter.go +++ b/rueidiscompat/adapter.go @@ -5440,15 +5440,30 @@ func (c *Compat) FTSearchWithArgs(ctx context.Context, index string, query strin return newFTSearchCmd(c.client.Do(ctx, cmd), options) } -func (c *Compat) FTSynDump(ctx context.Context, index string) *FTSynDumpCmd { return nil } +func (c *Compat) FTSynDump(ctx context.Context, index string) *FTSynDumpCmd { + cmd := c.client.B().FtSyndump().Index(index).Build() + return newFTSynDumpCmd(c.client.Do(ctx, cmd)) +} + func (c *Compat) FTSynUpdate(ctx context.Context, index string, synGroupId interface{}, terms []interface{}) *StatusCmd { - return nil + cmd := c.client.B().FtSynupdate().Index(index).SynonymGroupId(str(synGroupId)).Term(argToSlice(terms)...).Build() + return newStatusCmd(c.client.Do(ctx, cmd)) } + func (c *Compat) FTSynUpdateWithArgs(ctx context.Context, index string, synGroupId interface{}, options *FTSynUpdateOptions, terms []interface{}) *StatusCmd { - return nil + _cmd := cmds.Incomplete(c.client.B().FtSynupdate().Index(index).SynonymGroupId(str(synGroupId))) + if options != nil { + if options.SkipInitialScan { + _cmd = cmds.Incomplete(cmds.FtSynupdateSynonymGroupId(_cmd).Skipinitialscan()) + } + } + cmd := cmds.FtSynupdateSynonymGroupId(_cmd).Term(argsToSlice(terms)...).Build() + return newStatusCmd(c.client.Do(ctx, cmd)) } + func (c *Compat) FTTagVals(ctx context.Context, index string, field string) *StringSliceCmd { - return nil + cmd := c.client.B().FtTagvals().Index(index).FieldName(field).Build() + return newStringSliceCmd(c.client.Do(ctx, cmd)) } func (c CacheCompat) BitCount(ctx context.Context, key string, bitCount *BitCount) *IntCmd { diff --git a/rueidiscompat/adapter_test.go b/rueidiscompat/adapter_test.go index a4a9a488..c23628ad 100644 --- a/rueidiscompat/adapter_test.go +++ b/rueidiscompat/adapter_test.go @@ -11996,7 +11996,7 @@ func testAdapterSearchRESP2() { }) - FIt("should FTSpellCheck", Label("search", "ftcreate", "ftsearch", "ftspellcheck"), func() { + It("should FTSpellCheck", Label("search", "ftcreate", "ftsearch", "ftspellcheck"), func() { text1 := &FieldSchema{FieldName: "f1", FieldType: SearchFieldTypeText} text2 := &FieldSchema{FieldName: "f2", FieldType: SearchFieldTypeText} val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, text1, text2).Result() @@ -12508,7 +12508,6 @@ func testAdapterSearchRESP2() { }) It("should FTSynDump", Label("search", "ftsyndump"), func() { - text1 := &FieldSchema{FieldName: "title", FieldType: SearchFieldTypeText} text2 := &FieldSchema{FieldName: "body", FieldType: SearchFieldTypeText} val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{OnHash: true}, text1, text2).Result() @@ -12641,7 +12640,7 @@ func testAdapterSearchRESP2() { Expect(res.Docs[0].Fields["__v_score"]).To(BeEquivalentTo("0")) }) - It("should FTCreate and FTSearch text params", Label("search", "ftcreate", "ftsearch"), func() { + FIt("should FTCreate and FTSearch text params", Label("search", "ftcreate", "ftsearch"), func() { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, &FieldSchema{FieldName: "name", FieldType: SearchFieldTypeText}).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) diff --git a/rueidiscompat/command.go b/rueidiscompat/command.go index a40afa6f..61fa658f 100644 --- a/rueidiscompat/command.go +++ b/rueidiscompat/command.go @@ -58,6 +58,10 @@ func (cmd *baseCmd[T]) Val() T { return cmd.val } +func (cmd *baseCmd[T]) SetRawVal(val T) { + cmd.val = val +} + func (cmd *baseCmd[T]) RawVal() any { return cmd.rawVal } @@ -3464,89 +3468,71 @@ type FTAggregateOptions struct { } type AggregateCmd struct { - baseCmd[FTAggregateResult] + baseCmd[*FTAggregateResult] } func (cmd *AggregateCmd) from(res rueidis.RedisResult) { - fmt.Printf("rueidisresult %#v\n", res.String()) - if err := res.Error(); err != nil { cmd.SetErr(err) return } - m, err := res.ToMap() + rows, err := res.ToArray() if err != nil { cmd.SetErr(err) return } - totalResultsMsg, ok := m["total_results"] - if !ok { - cmd.SetErr(fmt.Errorf(`result map should contain key "total_results"`)) + anyArr := make([]any, 0, len(rows)) + for _, e := range rows { + anyE, err := e.ToAny() + if err != nil { + cmd.SetErr(err) + return + } + anyArr = append(anyArr, anyE) } - totalResults, err := totalResultsMsg.AsInt64() + result, err := processAggregateResult(anyArr) if err != nil { cmd.SetErr(err) return } - resultsMsg, ok := m["results"] - if !ok { - cmd.SetErr(fmt.Errorf(`result map should contain key "results"`)) + cmd.SetVal(result) +} + +// Ref: https://github.com/redis/go-redis/blob/v9.7.0/search_commands.go#L584 +func processAggregateResult(data []interface{}) (*FTAggregateResult, error) { + if len(data) == 0 { + return nil, fmt.Errorf("no data returned") } - resultsArr, err := resultsMsg.ToArray() - if err != nil { - cmd.SetErr(err) - return + + total, ok := data[0].(int64) + if !ok { + return nil, fmt.Errorf("invalid total format") } - ftAggregateResult := FTAggregateResult{Total: int(totalResults), Rows: make([]AggregateRow, 0, len(resultsArr))} - for _, result := range resultsArr { - resultMap, err := result.ToMap() - if err != nil { - cmd.SetErr(err) - return + + rows := make([]AggregateRow, 0, len(data)-1) + for _, row := range data[1:] { + fields, ok := row.([]interface{}) + if !ok { + return nil, fmt.Errorf("invalid row format") } - fmt.Println("resultMap", result.String()) - // FIXME: unknown length? - row := AggregateRow{Fields: make(map[string]any)} - for k, v := range resultMap { - switch k { - case "extra_attributes": - // simple string - _m, err := v.AsMap() - if err != nil { - cmd.SetErr(err) - return - } - for _k, _v := range _m { - anyVal, err := _v.ToAny() - if err != nil { - cmd.SetErr(err) - return - } - row.Fields[_k] = anyVal - } - case "values": - // FIXME: do we have this? - continue - default: - fmt.Println("xxx got v", v.String()) - // case "id": - // idStr, err := v.ToString() - // if err != nil { - // cmd.SetErr(err) - // return - // } - // row. = idStr + + rowMap := make(map[string]interface{}) + for i := 0; i < len(fields); i += 2 { + key, ok := fields[i].(string) + if !ok { + return nil, fmt.Errorf("invalid field key format") } + value := fields[i+1] + rowMap[key] = value } - - ftAggregateResult.Rows = append(ftAggregateResult.Rows, row) + rows = append(rows, AggregateRow{Fields: rowMap}) } - cmd.SetVal(ftAggregateResult) - - _r, _ := json.MarshalIndent(ftAggregateResult, "", "\t") - fmt.Print(string(_r)) - + result := &FTAggregateResult{ + Total: int(total), + Rows: rows, + } + return result, nil } func newAggregateCmd(res rueidis.RedisResult) *AggregateCmd { @@ -4417,7 +4403,33 @@ func (cmd *FTSynDumpCmd) RawResult() (any, error) { } func (cmd *FTSynDumpCmd) from(res rueidis.RedisResult) { - // FIXME: impl + if err := res.Error(); err != nil { + cmd.SetErr(err) + return + } + arr, err := res.ToArray() + if err != nil { + cmd.SetErr(err) + return + } + results := make([]FTSynDumpResult, 0, len(arr)/2) + for i := 0; i < len(arr); i += 2 { + term, err := arr[i].ToString() + if err != nil { + cmd.SetErr(err) + return + } + synonyms, err := arr[i+1].AsStrSlice() + if err != nil { + cmd.SetErr(err) + return + } + results = append(results, FTSynDumpResult{ + Term: term, + Synonyms: synonyms, + }) + } + cmd.SetVal(results) } func newFTSynDumpCmd(res rueidis.RedisResult) *FTSynDumpCmd { From 6b50b1af4127ed4931ce6e686c7ce5f496d50c88 Mon Sep 17 00:00:00 2001 From: Eric Chang Date: Fri, 22 Nov 2024 15:36:51 +0800 Subject: [PATCH 31/49] feat(FT.SEARCH): fix params --- rueidiscompat/adapter.go | 2 +- rueidiscompat/adapter_test.go | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/rueidiscompat/adapter.go b/rueidiscompat/adapter.go index 1d81f0b3..ab68e999 100644 --- a/rueidiscompat/adapter.go +++ b/rueidiscompat/adapter.go @@ -5425,7 +5425,7 @@ func (c *Compat) FTSearchWithArgs(ctx context.Context, index string, query strin } // [PARAMS nargs name value [ name value ...]] if options.Params != nil { - _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Params().Nargs(int64(len(options.Params)))) + _cmd = cmds.Incomplete(cmds.FtSearchQuery(_cmd).Params().Nargs(int64(len(options.Params) * 2))) for name, val := range options.Params { _cmd = cmds.Incomplete(cmds.FtSearchParamsNargs(_cmd).NameValue().NameValue(name, str(val))) } diff --git a/rueidiscompat/adapter_test.go b/rueidiscompat/adapter_test.go index c23628ad..27a8e652 100644 --- a/rueidiscompat/adapter_test.go +++ b/rueidiscompat/adapter_test.go @@ -12640,7 +12640,7 @@ func testAdapterSearchRESP2() { Expect(res.Docs[0].Fields["__v_score"]).To(BeEquivalentTo("0")) }) - FIt("should FTCreate and FTSearch text params", Label("search", "ftcreate", "ftsearch"), func() { + It("should FTCreate and FTSearch text params", Label("search", "ftcreate", "ftsearch"), func() { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, &FieldSchema{FieldName: "name", FieldType: SearchFieldTypeText}).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) @@ -12752,7 +12752,7 @@ func testAdapterSearchRESP2() { Expect(res.Attributes[0].WithSuffixtrie).To(BeTrue()) }) - It("should test dialect 4", Label("search", "ftcreate", "ftsearch", "NonRedisEnterprise"), func() { + FIt("should test dialect 4", Label("search", "ftcreate", "ftsearch", "NonRedisEnterprise"), func() { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{ Prefix: []interface{}{"resource:"}, }, &FieldSchema{ From 74846aab03e58d40f91a4b1b7b93071e4a212089 Mon Sep 17 00:00:00 2001 From: Eric Chang Date: Fri, 22 Nov 2024 21:20:52 +0800 Subject: [PATCH 32/49] fix(FT.SEARCH): fix test: should FTCreate GeoShape --- rueidiscompat/adapter.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rueidiscompat/adapter.go b/rueidiscompat/adapter.go index ab68e999..b31fe54c 100644 --- a/rueidiscompat/adapter.go +++ b/rueidiscompat/adapter.go @@ -5137,7 +5137,7 @@ func (c *Compat) FTCreate(ctx context.Context, index string, options *FTCreateOp if sc.GeoShapeFieldType == "" { panic("FT.CREATE: GeoShapeFieldType cannot be empty while SCHEMA FieldType is GEOSHAPE") } - _cmd = cmds.Incomplete(cmds.FtCreateFieldAs(_cmd).Geoshape()) + _cmd = cmds.Incomplete(cmds.FtCreateFieldAs(_cmd).Geoshape().FieldName(sc.GeoShapeFieldType)) default: panic(fmt.Sprintf("unexpected SearchFieldType: %s", sc.FieldType.String())) } From 8400a8fae8cb3e07e96226228d237ca18e7da898 Mon Sep 17 00:00:00 2001 From: Eric Chang Date: Fri, 22 Nov 2024 21:25:09 +0800 Subject: [PATCH 33/49] fix(FT.SEARCH): fix test: should search missing fields --- rueidiscompat/adapter.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rueidiscompat/adapter.go b/rueidiscompat/adapter.go index b31fe54c..031fdb2b 100644 --- a/rueidiscompat/adapter.go +++ b/rueidiscompat/adapter.go @@ -5173,7 +5173,7 @@ func (c *Compat) FTCreate(ctx context.Context, index string, options *FTCreateOp _cmd = cmds.Incomplete(cmds.FtCreateFieldFieldTypeText(_cmd).Indexempty()) } if sc.IndexMissing { - _cmd = cmds.Incomplete(cmds.FtCreateFieldFieldTypeText(_cmd).Casesensitive()) + _cmd = cmds.Incomplete(cmds.FtCreateFieldFieldTypeText(_cmd).Indexmissing()) } } From 1056609f73a104b59707423299afcce205eba067 Mon Sep 17 00:00:00 2001 From: Eric Chang Date: Fri, 22 Nov 2024 21:48:06 +0800 Subject: [PATCH 34/49] fix(testAdapterSearchRESP2): make tests PASS --- rueidiscompat/adapter.go | 38 +++++++++++++++++++++++++++++++++++ rueidiscompat/adapter_test.go | 2 +- 2 files changed, 39 insertions(+), 1 deletion(-) diff --git a/rueidiscompat/adapter.go b/rueidiscompat/adapter.go index 031fdb2b..0558e57a 100644 --- a/rueidiscompat/adapter.go +++ b/rueidiscompat/adapter.go @@ -5114,7 +5114,10 @@ func (c *Compat) FTCreate(ctx context.Context, index string, options *FTCreateOp if sc.VectorArgs.FlatOptions != nil && sc.VectorArgs.HNSWOptions != nil { panic("FT.CREATE: SCHEMA VectorArgs FlatOptions and HNSWOptions are mutually exclusive") } + var args []any + algorithm := "" if sc.VectorArgs.FlatOptions != nil { + algorithm = "FLAT" // args = append(args, "FLAT") // _cmd = cmds.Incomplete(cmds.FtCreateFieldFieldTypeVector(_cmd).()) if sc.VectorArgs.FlatOptions.Type == "" || sc.VectorArgs.FlatOptions.Dim == 0 || sc.VectorArgs.FlatOptions.DistanceMetric == "" { @@ -5131,7 +5134,42 @@ func (c *Compat) FTCreate(ctx context.Context, index string, options *FTCreateOp if sc.VectorArgs.FlatOptions.BlockSize > 0 { flatArgs = append(flatArgs, "BLOCK_SIZE", sc.VectorArgs.FlatOptions.BlockSize) } + // args = append(args, len(flatArgs)) + args = flatArgs + // args = append(args, flatArgs...) } + if sc.VectorArgs.HNSWOptions != nil { + algorithm = "HNSW" + // args = append(args, "HNSW") + if sc.VectorArgs.HNSWOptions.Type == "" || sc.VectorArgs.HNSWOptions.Dim == 0 || sc.VectorArgs.HNSWOptions.DistanceMetric == "" { + panic("FT.CREATE: Type, Dim and DistanceMetric are required for VECTOR HNSW") + } + hnswArgs := []interface{}{ + "TYPE", sc.VectorArgs.HNSWOptions.Type, + "DIM", sc.VectorArgs.HNSWOptions.Dim, + "DISTANCE_METRIC", sc.VectorArgs.HNSWOptions.DistanceMetric, + } + if sc.VectorArgs.HNSWOptions.InitialCapacity > 0 { + hnswArgs = append(hnswArgs, "INITIAL_CAP", sc.VectorArgs.HNSWOptions.InitialCapacity) + } + if sc.VectorArgs.HNSWOptions.MaxEdgesPerNode > 0 { + hnswArgs = append(hnswArgs, "M", sc.VectorArgs.HNSWOptions.MaxEdgesPerNode) + } + if sc.VectorArgs.HNSWOptions.MaxAllowedEdgesPerNode > 0 { + hnswArgs = append(hnswArgs, "EF_CONSTRUCTION", sc.VectorArgs.HNSWOptions.MaxAllowedEdgesPerNode) + } + if sc.VectorArgs.HNSWOptions.EFRunTime > 0 { + hnswArgs = append(hnswArgs, "EF_RUNTIME", sc.VectorArgs.HNSWOptions.EFRunTime) + } + if sc.VectorArgs.HNSWOptions.Epsilon > 0 { + hnswArgs = append(hnswArgs, "EPSILON", sc.VectorArgs.HNSWOptions.Epsilon) + } + // args = append(args, len(hnswArgs)) + // args = append(args, hnswArgs...) + args = hnswArgs + } + _cmd = cmds.Incomplete(cmds.FtCreateFieldAs(_cmd).Vector(algorithm, int64(len(args)), argsToSlice(args)...)) + case SearchFieldTypeGeoShape: // FIXME: geo shape need a block if sc.GeoShapeFieldType == "" { diff --git a/rueidiscompat/adapter_test.go b/rueidiscompat/adapter_test.go index 27a8e652..149f03b9 100644 --- a/rueidiscompat/adapter_test.go +++ b/rueidiscompat/adapter_test.go @@ -12752,7 +12752,7 @@ func testAdapterSearchRESP2() { Expect(res.Attributes[0].WithSuffixtrie).To(BeTrue()) }) - FIt("should test dialect 4", Label("search", "ftcreate", "ftsearch", "NonRedisEnterprise"), func() { + It("should test dialect 4", Label("search", "ftcreate", "ftsearch", "NonRedisEnterprise"), func() { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{ Prefix: []interface{}{"resource:"}, }, &FieldSchema{ From d3ecd0949440d5f14f3c12421197dc2510868903 Mon Sep 17 00:00:00 2001 From: Eric Chang Date: Sat, 23 Nov 2024 20:42:55 +0800 Subject: [PATCH 35/49] wip: RESP3 --- rueidiscompat/adapter_test.go | 87 ++++++++++++++------------ rueidiscompat/command.go | 113 +++++++++++++++++++++++++++++++--- 2 files changed, 153 insertions(+), 47 deletions(-) diff --git a/rueidiscompat/adapter_test.go b/rueidiscompat/adapter_test.go index 149f03b9..796cea10 100644 --- a/rueidiscompat/adapter_test.go +++ b/rueidiscompat/adapter_test.go @@ -11570,15 +11570,9 @@ func testAdapterSearchRESP3() { Expect(adapter.FlushAll(ctx).Err()).NotTo(HaveOccurred()) }) - Describe("RediSearch commands Resp 3", Label("search"), func() { + FDescribe("RediSearch commands Resp 3", Label("search"), func() { ctx := context.TODO() - // BeforeEach(func() { - // client = redis.NewClient(&redis.Options{Addr: ":6379", Protocol: 3, UnstableResp3: true}) - // client2 = redis.NewClient(&redis.Options{Addr: ":6379", Protocol: 3}) - // Expect(client.FlushDB(ctx).Err()).NotTo(HaveOccurred()) - // }) - It("should handle FTAggregate with Unstable RESP3 Search Module and without stability", Label("search", "ftcreate", "ftaggregate"), func() { text1 := &FieldSchema{FieldName: "PrimaryKey", FieldType: SearchFieldTypeText, Sortable: true} num1 := &FieldSchema{FieldName: "CreatedDateTimeUTC", FieldType: SearchFieldTypeNumeric, Sortable: true} @@ -11592,27 +11586,31 @@ func testAdapterSearchRESP3() { options := &FTAggregateOptions{Apply: []FTAggregateApply{{Field: "@CreatedDateTimeUTC * 10", As: "CreatedDateTimeUTC"}}} res, err := adapter.FTAggregateWithArgs(ctx, "idx1", "*", options).RawResult() - results := res.(map[interface{}]interface{})["results"].([]interface{}) - Expect(results[0].(map[interface{}]interface{})["extra_attributes"].(map[interface{}]interface{})["CreatedDateTimeUTC"]). + // results := res.(map[interface{}]interface{})["results"].([]interface{}) + results := res.(map[string]interface{})["results"].([]interface{}) + // Expect(results[0].(map[interface{}]interface{})["extra_attributes"].(map[interface{}]interface{})["CreatedDateTimeUTC"]). + Expect(results[0].(map[string]interface{})["extra_attributes"].(map[string]interface{})["CreatedDateTimeUTC"]). To(Or(BeEquivalentTo("6373878785249699840"), BeEquivalentTo("6373878758592700416"))) - Expect(results[1].(map[interface{}]interface{})["extra_attributes"].(map[interface{}]interface{})["CreatedDateTimeUTC"]). + // Expect(results[1].(map[interface{}]interface{})["extra_attributes"].(map[interface{}]interface{})["CreatedDateTimeUTC"]). + Expect(results[1].(map[string]interface{})["extra_attributes"].(map[string]interface{})["CreatedDateTimeUTC"]). To(Or(BeEquivalentTo("6373878785249699840"), BeEquivalentTo("6373878758592700416"))) rawVal := adapter.FTAggregateWithArgs(ctx, "idx1", "*", options).RawVal() - rawValResults := rawVal.(map[interface{}]interface{})["results"].([]interface{}) + // rawValResults := rawVal.(map[interface{}]interface{})["results"].([]interface{}) + rawValResults := rawVal.(map[string]interface{})["results"].([]interface{}) Expect(err).NotTo(HaveOccurred()) Expect(rawValResults[0]).To(Or(BeEquivalentTo(results[0]), BeEquivalentTo(results[1]))) Expect(rawValResults[1]).To(Or(BeEquivalentTo(results[0]), BeEquivalentTo(results[1]))) // Test with UnstableResp3 false - Expect(func() { - options = &FTAggregateOptions{Apply: []FTAggregateApply{{Field: "@CreatedDateTimeUTC * 10", As: "CreatedDateTimeUTC"}}} - rawRes, _ := adapter2resp3.FTAggregateWithArgs(ctx, "idx1", "*", options).RawResult() - rawVal = adapter2resp3.FTAggregateWithArgs(ctx, "idx1", "*", options).RawVal() - Expect(rawRes).To(BeNil()) - Expect(rawVal).To(BeNil()) - }).Should(Panic()) - + // NOTE: rueidis can't support this behavior because we cannot know whether UnstableResp3 is enabled or not + // Expect(func() { + // options = &FTAggregateOptions{Apply: []FTAggregateApply{{Field: "@CreatedDateTimeUTC * 10", As: "CreatedDateTimeUTC"}}} + // rawRes, _ := adapter2resp3.FTAggregateWithArgs(ctx, "idx1", "*", options).RawResult() + // rawVal = adapter2resp3.FTAggregateWithArgs(ctx, "idx1", "*", options).RawVal() + // Expect(rawRes).To(BeNil()) + // Expect(rawVal).To(BeNil()) + // }).Should(Panic()) }) It("should handle FTInfo with Unstable RESP3 Search Module and without stability", Label("search", "ftcreate", "ftinfo"), func() { @@ -11623,22 +11621,28 @@ func testAdapterSearchRESP3() { resInfo, err := adapter.FTInfo(ctx, "idx1").RawResult() Expect(err).NotTo(HaveOccurred()) - attributes := resInfo.(map[interface{}]interface{})["attributes"].([]interface{}) - flags := attributes[0].(map[interface{}]interface{})["flags"].([]interface{}) + // attributes := resInfo.(map[interface{}]interface{})["attributes"].([]interface{}) + attributes := resInfo.(map[string]interface{})["attributes"].([]interface{}) + // flags := attributes[0].(map[interface{}]interface{})["flags"].([]interface{}) + flags := attributes[0].(map[string]interface{})["flags"].([]interface{}) Expect(flags).To(ConsistOf("SORTABLE", "NOSTEM")) - valInfo := adapter.FTInfo(ctx, "idx1").RawVal() - attributes = valInfo.(map[interface{}]interface{})["attributes"].([]interface{}) - flags = attributes[0].(map[interface{}]interface{})["flags"].([]interface{}) + valInfo, err := adapter.FTInfo(ctx, "idx1").RawResult() + Expect(err).NotTo(HaveOccurred()) + // attributes = valInfo.(map[interface{}]interface{})["attributes"].([]interface{}) + attributes = valInfo.(map[string]interface{})["attributes"].([]interface{}) + // flags = attributes[0].(map[interface{}]interface{})["flags"].([]interface{}) + flags = attributes[0].(map[string]interface{})["flags"].([]interface{}) Expect(flags).To(ConsistOf("SORTABLE", "NOSTEM")) // Test with UnstableResp3 false - Expect(func() { - rawResInfo, _ := adapter2resp3.FTInfo(ctx, "idx1").RawResult() - rawValInfo := adapter2resp3.FTInfo(ctx, "idx1").RawVal() - Expect(rawResInfo).To(BeNil()) - Expect(rawValInfo).To(BeNil()) - }).Should(Panic()) + // NOTE: rueidis can't support this behavior because we cannot know whether UnstableResp3 is enabled or not + // Expect(func() { + // rawResInfo, _ := adapter2resp3.FTInfo(ctx, "idx1").RawResult() + // rawValInfo := adapter2resp3.FTInfo(ctx, "idx1").RawVal() + // Expect(rawResInfo).To(BeNil()) + // Expect(rawValInfo).To(BeNil()) + // }).Should(Panic()) }) It("should handle FTSpellCheck with Unstable RESP3 Search Module and without stability", Label("search", "ftcreate", "ftspellcheck"), func() { @@ -11656,19 +11660,22 @@ func testAdapterSearchRESP3() { valSpellCheck := adapter.FTSpellCheck(ctx, "idx1", "impornant").RawVal() Expect(err).NotTo(HaveOccurred()) Expect(valSpellCheck).To(BeEquivalentTo(resSpellCheck)) - results := resSpellCheck.(map[interface{}]interface{})["results"].(map[interface{}]interface{}) - Expect(results["impornant"].([]interface{})[0].(map[interface{}]interface{})["important"]).To(BeEquivalentTo(0.5)) + // results := resSpellCheck.(map[interface{}]interface{})["results"].(map[interface{}]interface{}) + results := resSpellCheck.(map[string]interface{})["results"].(map[string]interface{}) + // Expect(results["impornant"].([]interface{})[0].(map[interface{}]interface{})["important"]).To(BeEquivalentTo(0.5)) + Expect(results["impornant"].([]interface{})[0].(map[string]interface{})["important"]).To(BeEquivalentTo(0.5)) // Test with UnstableResp3 false - Expect(func() { - rawResSpellCheck, _ := adapter2resp3.FTSpellCheck(ctx, "idx1", "impornant").RawResult() - rawValSpellCheck := adapter2resp3.FTSpellCheck(ctx, "idx1", "impornant").RawVal() - Expect(rawResSpellCheck).To(BeNil()) - Expect(rawValSpellCheck).To(BeNil()) - }).Should(Panic()) + // NOTE: rueidis can't support this behavior because we cannot know whether UnstableResp3 is enabled or not + // Expect(func() { + // rawResSpellCheck, _ := adapter2resp3.FTSpellCheck(ctx, "idx1", "impornant").RawResult() + // rawValSpellCheck := adapter2resp3.FTSpellCheck(ctx, "idx1", "impornant").RawVal() + // Expect(rawResSpellCheck).To(BeNil()) + // Expect(rawValSpellCheck).To(BeNil()) + // }).Should(Panic()) }) - It("should handle FTSearch with Unstable RESP3 Search Module and without stability", Label("search", "ftcreate", "ftsearch"), func() { + FIt("should handle FTSearch with Unstable RESP3 Search Module and without stability", Label("search", "ftcreate", "ftsearch"), func() { val, err := adapter.FTCreate(ctx, "txt", &FTCreateOptions{StopWords: []interface{}{"foo", "bar", "baz"}}, &FieldSchema{FieldName: "txt", FieldType: SearchFieldTypeText}).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) @@ -11763,7 +11770,7 @@ func testAdapterSearchRESP2() { Expect(adapter.FlushAll(ctx).Err()).NotTo(HaveOccurred()) }) - FDescribe("RediSearch commands Resp 2", Label("search"), func() { + Describe("RediSearch commands Resp 2", Label("search"), func() { ctx := context.TODO() BeforeEach(func() { diff --git a/rueidiscompat/command.go b/rueidiscompat/command.go index 61fa658f..bc6b473c 100644 --- a/rueidiscompat/command.go +++ b/rueidiscompat/command.go @@ -58,8 +58,8 @@ func (cmd *baseCmd[T]) Val() T { return cmd.val } -func (cmd *baseCmd[T]) SetRawVal(val T) { - cmd.val = val +func (cmd *baseCmd[T]) SetRawVal(rawVal any) { + cmd.rawVal = rawVal } func (cmd *baseCmd[T]) RawVal() any { @@ -3476,6 +3476,34 @@ func (cmd *AggregateCmd) from(res rueidis.RedisResult) { cmd.SetErr(err) return } + anyRes, err := res.ToAny() + if err != nil { + cmd.SetErr(err) + return + } + cmd.SetRawVal(anyRes) + if !(res.IsMap() || res.IsArray()) { + panic("res should be either map(RESP3) or array(RESP2)") + } + if res.IsMap() { + total, docs, err := res.AsFtAggregate() + if err != nil { + cmd.SetErr(err) + return + } + aggResult := &FTAggregateResult{Total: int(total)} + for _, doc := range docs { + anyMap := make(map[string]any, len(doc)) + for k, v := range doc { + anyMap[k] = v + } + aggResult.Rows = append(aggResult.Rows, AggregateRow{anyMap}) + } + fmt.Println("docs", docs) + cmd.SetVal(aggResult) + return + } + // is RESP2 array rows, err := res.ToArray() if err != nil { cmd.SetErr(err) @@ -3998,13 +4026,17 @@ func (cmd *FTInfoCmd) from(res rueidis.RedisResult) { cmd.SetErr(err) return } - m, err := res.AsMap() if err != nil { cmd.SetErr(err) return } - + anyM, err := res.ToAny() + if err != nil { + cmd.SetErr(err) + return + } + cmd.SetRawVal(anyM) anyMap := make(map[string]any, len(m)) for k, v := range m { anyMap[k], err = v.ToAny() @@ -4013,7 +4045,6 @@ func (cmd *FTInfoCmd) from(res rueidis.RedisResult) { return } } - ftInfoResult, err := parseFTInfo(anyMap) if err != nil { cmd.SetErr(err) @@ -4061,13 +4092,80 @@ func (cmd *FTSpellCheckCmd) Result() ([]SpellCheckResult, error) { } func (cmd *FTSpellCheckCmd) from(res rueidis.RedisResult) { - // FIXME: impl - fmt.Println(res.String()) + if err := res.Error(); err != nil { + cmd.SetErr(err) + return + } + if !(res.IsMap() || res.IsArray()) { + panic("res should be either map(RESP3) or array(RESP2)") + } + if res.IsMap() { + // is RESP3 map + m, err := res.ToMap() + if err != nil { + cmd.SetErr(err) + } + // fmt.Println(res.String()) + fmt.Println(m) + anyM, err := res.ToAny() + if err != nil { + cmd.SetErr(err) + return + } + cmd.SetRawVal(anyM) + spellCheckResults := []SpellCheckResult{} + result := m["results"] + resultMap, err := result.ToMap() + if err != nil { + cmd.SetErr(err) + return + } + for k, v := range resultMap { + result := SpellCheckResult{} + result.Term = k + suggestions, err := v.ToArray() + if err != nil { + cmd.SetErr(err) + return + } + for _, suggestion := range suggestions { + // map key: suggestion, score + sugMap, err := suggestion.ToMap() + if err != nil { + cmd.SetErr(err) + return + } + for _k, _v := range sugMap { + score, err := _v.ToFloat64() + if err != nil { + cmd.SetErr(err) + return + } + fmt.Println("k: ", _k, "v", score) + result.Suggestions = append(result.Suggestions, SpellCheckSuggestion{Suggestion: _k, Score: score}) + } + + // for + // result.Suggestions = SpellCheckSuggestion{Suggestion: suggestion} + } + spellCheckResults = append(spellCheckResults, result) + } + cmd.SetVal(spellCheckResults) + // results := resSpellCheck.(map[interface{}]interface{})["results"].(map[interface{}]interface{}) + return + } + // is RESP2 array arr, err := res.ToArray() if err != nil { cmd.SetErr(err) return } + anyRes, err := res.ToAny() + if err != nil { + cmd.SetErr(err) + return + } + cmd.SetRawVal(anyRes) AnyArr := make([]any, 0, len(arr)) for _, e := range arr { anyE, err := e.ToAny() @@ -4082,6 +4180,7 @@ func (cmd *FTSpellCheckCmd) from(res rueidis.RedisResult) { cmd.SetErr(err) return } + cmd.SetVal(result) } From a4a1a3b4ccaee8140b0b9d262f02b69d42d5bf0d Mon Sep 17 00:00:00 2001 From: Eric Chang Date: Sat, 23 Nov 2024 20:44:16 +0800 Subject: [PATCH 36/49] refactor(pipeline.go): remove unused var --- rueidiscompat/pipeline.go | 2 -- 1 file changed, 2 deletions(-) diff --git a/rueidiscompat/pipeline.go b/rueidiscompat/pipeline.go index 439d974a..15e0a39e 100644 --- a/rueidiscompat/pipeline.go +++ b/rueidiscompat/pipeline.go @@ -97,8 +97,6 @@ type Pipeline struct { rets []Cmder } -var pp = Pipeline{} - func (c *Pipeline) Command(ctx context.Context) *CommandsInfoCmd { ret := c.comp.Command(ctx) c.rets = append(c.rets, ret) From 733459803921d183f99f3ba4fec872939a6c23db Mon Sep 17 00:00:00 2001 From: Eric Chang Date: Sat, 23 Nov 2024 21:20:12 +0800 Subject: [PATCH 37/49] feat(message.go): add IsMap, IsArray helper --- message.go | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/message.go b/message.go index ec49c18a..73eccd55 100644 --- a/message.go +++ b/message.go @@ -456,7 +456,7 @@ func (r RedisResult) ToMap() (v map[string]RedisMessage, err error) { if r.err != nil { err = r.err } else { - v, err = r.val.ToMap() + v, err = r.val.AsMap() } return } @@ -471,6 +471,16 @@ func (r RedisResult) ToAny() (v any, err error) { return } +// IsMap delegates to RedisMessage.IsMap +func (r RedisResult) IsMap() bool { + return r.val.IsMap() +} + +// IsArray delegates to RedisMessage.IsArray +func (r RedisResult) IsArray() bool { + return r.val.IsArray() +} + // IsCacheHit delegates to RedisMessage.IsCacheHit func (r RedisResult) IsCacheHit() bool { return r.val.IsCacheHit() From 91b42487136baca1ffef878e4cc24e1f3a3713ab Mon Sep 17 00:00:00 2001 From: Eric Chang Date: Sat, 23 Nov 2024 22:06:34 +0800 Subject: [PATCH 38/49] feat(FT.SEARCH): fix resp3 tests --- rueidiscompat/adapter_test.go | 19 ++++--- rueidiscompat/command.go | 97 ++++++++++++++++++++++++++++++++++- 2 files changed, 107 insertions(+), 9 deletions(-) diff --git a/rueidiscompat/adapter_test.go b/rueidiscompat/adapter_test.go index 796cea10..9ea5178d 100644 --- a/rueidiscompat/adapter_test.go +++ b/rueidiscompat/adapter_test.go @@ -11686,20 +11686,23 @@ func testAdapterSearchRESP3() { val1 := adapter.FTSearchWithArgs(ctx, "txt", "foo bar", &FTSearchOptions{NoContent: true}).RawVal() Expect(err).NotTo(HaveOccurred()) Expect(val1).To(BeEquivalentTo(res1)) - totalResults := res1.(map[interface{}]interface{})["total_results"] + totalResults := res1.(map[string]interface{})["total_results"] + // totalResults := res1.(map[interface{}]interface{})["total_results"] Expect(totalResults).To(BeEquivalentTo(int64(0))) res2, err := adapter.FTSearchWithArgs(ctx, "txt", "foo bar hello world", &FTSearchOptions{NoContent: true}).RawResult() Expect(err).NotTo(HaveOccurred()) - totalResults2 := res2.(map[interface{}]interface{})["total_results"] + totalResults2 := res2.(map[string]interface{})["total_results"] + // totalResults2 := res2.(map[interface{}]interface{})["total_results"] Expect(totalResults2).To(BeEquivalentTo(int64(1))) // Test with UnstableResp3 false - Expect(func() { - rawRes2, _ := adapter2resp3.FTSearchWithArgs(ctx, "txt", "foo bar hello world", &FTSearchOptions{NoContent: true}).RawResult() - rawVal2 := adapter2resp3.FTSearchWithArgs(ctx, "txt", "foo bar hello world", &FTSearchOptions{NoContent: true}).RawVal() - Expect(rawRes2).To(BeNil()) - Expect(rawVal2).To(BeNil()) - }).Should(Panic()) + // NOTE: rueidis can't support this behavior because we cannot know whether UnstableResp3 is enabled or not + // Expect(func() { + // rawRes2, _ := adapter2resp3.FTSearchWithArgs(ctx, "txt", "foo bar hello world", &FTSearchOptions{NoContent: true}).RawResult() + // rawVal2 := adapter2resp3.FTSearchWithArgs(ctx, "txt", "foo bar hello world", &FTSearchOptions{NoContent: true}).RawVal() + // Expect(rawRes2).To(BeNil()) + // Expect(rawVal2).To(BeNil()) + // }).Should(Panic()) }) It("should handle FTSynDump with Unstable RESP3 Search Module and without stability", Label("search", "ftsyndump"), func() { text1 := &FieldSchema{FieldName: "title", FieldType: SearchFieldTypeText} diff --git a/rueidiscompat/command.go b/rueidiscompat/command.go index bc6b473c..7d4fdda0 100644 --- a/rueidiscompat/command.go +++ b/rueidiscompat/command.go @@ -4301,6 +4301,102 @@ func (cmd *FTSearchCmd) from(res rueidis.RedisResult) { cmd.SetErr(err) return } + anyRes, err := res.ToAny() + if err != nil { + cmd.SetErr(err) + return + } + cmd.SetRawVal(anyRes) + if !(res.IsMap() || res.IsArray()) { + panic("res should be either map(RESP3) or array(RESP2)") + } + if res.IsMap() { + // is RESP3 map + m, err := res.ToMap() + if err != nil { + cmd.SetErr(err) + return + } + totalResultsMsg, ok := m["total_results"] + if !ok { + cmd.SetErr(fmt.Errorf(`result map should contain key "total_results"`)) + } + totalResults, err := totalResultsMsg.AsInt64() + if err != nil { + cmd.SetErr(err) + return + } + resultsMsg, ok := m["results"] + if !ok { + cmd.SetErr(fmt.Errorf(`result map should contain key "results"`)) + } + resultsArr, err := resultsMsg.ToArray() + if err != nil { + cmd.SetErr(err) + return + } + ftSearchResult := FTSearchResult{Total: int(totalResults), Docs: make([]Document, 0, len(resultsArr))} + for _, result := range resultsArr { + // result: arr: id, doc2, score, 3, "extra_attributes": [foo, bar] + resultMap, err := result.ToMap() + if err != nil { + cmd.SetErr(err) + return + } + fmt.Println("resultMap", result.String()) + doc := Document{} + for k, v := range resultMap { + switch k { + case "id": + idStr, err := v.ToString() + if err != nil { + cmd.SetErr(err) + return + } + doc.ID = idStr + case "extra_attributes": + // doc.ID = resultArr[i+1].String() + strMap, err := v.AsStrMap() + if err != nil { + cmd.SetErr(err) + return + } + doc.Fields = strMap + // docs[d].Doc, _ = record.values[j+1].AsStrMap() + case "score": + score, err := v.AsFloat64() + if err != nil { + cmd.SetErr(err) + return + } + doc.Score = &score + case "payload": + if !v.IsNil() { + payload, err := v.ToString() + if err != nil { + cmd.SetErr(err) + return + } + doc.Payload = &payload + } + case "sortkey": + if !v.IsNil() { + sortKey, err := v.ToString() + if err != nil { + cmd.SetErr(err) + return + } + doc.SortKey = &sortKey + } + } + } + + ftSearchResult.Docs = append(ftSearchResult.Docs, doc) + } + cmd.SetVal(ftSearchResult) + return + } + // is RESP2 array data, err := res.ToArray() if err != nil { cmd.SetErr(err) @@ -4475,7 +4571,6 @@ func (cmd *FTSearchCmd) from(res rueidis.RedisResult) { // _r, _ := json.MarshalIndent(ftSearchResult, "", "\t") // fmt.Print(string(_r)) - } func newFTSearchCmd(res rueidis.RedisResult, options *FTSearchOptions) *FTSearchCmd { From 8ade9d7a61e0707544940d36a7e50ddb7d227297 Mon Sep 17 00:00:00 2001 From: Eric Chang Date: Sat, 23 Nov 2024 22:26:57 +0800 Subject: [PATCH 39/49] fix tests --- rueidiscompat/adapter_test.go | 42 ++++++------ rueidiscompat/command.go | 123 +++++++++------------------------- 2 files changed, 53 insertions(+), 112 deletions(-) diff --git a/rueidiscompat/adapter_test.go b/rueidiscompat/adapter_test.go index 9ea5178d..09437a3b 100644 --- a/rueidiscompat/adapter_test.go +++ b/rueidiscompat/adapter_test.go @@ -68,7 +68,6 @@ var ( adaptersearchresp2 Cmdable adaptercluster2 Cmdable adapterresp3 Cmdable - adapter2resp3 Cmdable adaptercluster3 Cmdable ) @@ -85,7 +84,6 @@ var _ = BeforeSuite(func() { }) Expect(err).NotTo(HaveOccurred()) adapterresp3 = NewAdapter(clientresp3) - adapter2resp3 = NewAdapter(clientresp3) adaptercluster3 = NewAdapter(clusterresp3) clientresp2, err = rueidis.NewClient(rueidis.ClientOption{ InitAddress: []string{"127.0.0.1:6356"}, @@ -11563,9 +11561,11 @@ func testAdapterCache(resp3 bool) { func testAdapterSearchRESP3() { var adapter Cmdable + var client rueidis.Client BeforeEach(func() { adapter = adapterresp3 + client = clientresp3 Expect(adapter.FlushDB(ctx).Err()).NotTo(HaveOccurred()) Expect(adapter.FlushAll(ctx).Err()).NotTo(HaveOccurred()) }) @@ -11579,7 +11579,7 @@ func testAdapterSearchRESP3() { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, text1, num1).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp3, "idx1", 3) + WaitForIndexing(client, "idx1", 3) adapter.HSet(ctx, "doc1", "PrimaryKey", "9::362330", "CreatedDateTimeUTC", "637387878524969984") adapter.HSet(ctx, "doc2", "PrimaryKey", "9::362329", "CreatedDateTimeUTC", "637387875859270016") @@ -11602,8 +11602,8 @@ func testAdapterSearchRESP3() { Expect(rawValResults[0]).To(Or(BeEquivalentTo(results[0]), BeEquivalentTo(results[1]))) Expect(rawValResults[1]).To(Or(BeEquivalentTo(results[0]), BeEquivalentTo(results[1]))) - // Test with UnstableResp3 false // NOTE: rueidis can't support this behavior because we cannot know whether UnstableResp3 is enabled or not + // Test with UnstableResp3 false // Expect(func() { // options = &FTAggregateOptions{Apply: []FTAggregateApply{{Field: "@CreatedDateTimeUTC * 10", As: "CreatedDateTimeUTC"}}} // rawRes, _ := adapter2resp3.FTAggregateWithArgs(ctx, "idx1", "*", options).RawResult() @@ -11617,7 +11617,7 @@ func testAdapterSearchRESP3() { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, &FieldSchema{FieldName: "txt", FieldType: SearchFieldTypeText, Sortable: true, NoStem: true}).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp3, "idx1", 3) + WaitForIndexing(client, "idx1", 3) resInfo, err := adapter.FTInfo(ctx, "idx1").RawResult() Expect(err).NotTo(HaveOccurred()) @@ -11635,8 +11635,8 @@ func testAdapterSearchRESP3() { flags = attributes[0].(map[string]interface{})["flags"].([]interface{}) Expect(flags).To(ConsistOf("SORTABLE", "NOSTEM")) - // Test with UnstableResp3 false // NOTE: rueidis can't support this behavior because we cannot know whether UnstableResp3 is enabled or not + // Test with UnstableResp3 false // Expect(func() { // rawResInfo, _ := adapter2resp3.FTInfo(ctx, "idx1").RawResult() // rawValInfo := adapter2resp3.FTInfo(ctx, "idx1").RawVal() @@ -11651,7 +11651,7 @@ func testAdapterSearchRESP3() { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{}, text1, text2).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp3, "idx1", 3) + WaitForIndexing(client, "idx1", 3) adapter.HSet(ctx, "doc1", "f1", "some valid content", "f2", "this is sample text") adapter.HSet(ctx, "doc2", "f1", "very important", "f2", "lorem ipsum") @@ -11665,8 +11665,8 @@ func testAdapterSearchRESP3() { // Expect(results["impornant"].([]interface{})[0].(map[interface{}]interface{})["important"]).To(BeEquivalentTo(0.5)) Expect(results["impornant"].([]interface{})[0].(map[string]interface{})["important"]).To(BeEquivalentTo(0.5)) - // Test with UnstableResp3 false // NOTE: rueidis can't support this behavior because we cannot know whether UnstableResp3 is enabled or not + // Test with UnstableResp3 false // Expect(func() { // rawResSpellCheck, _ := adapter2resp3.FTSpellCheck(ctx, "idx1", "impornant").RawResult() // rawValSpellCheck := adapter2resp3.FTSpellCheck(ctx, "idx1", "impornant").RawVal() @@ -11675,11 +11675,11 @@ func testAdapterSearchRESP3() { // }).Should(Panic()) }) - FIt("should handle FTSearch with Unstable RESP3 Search Module and without stability", Label("search", "ftcreate", "ftsearch"), func() { + It("should handle FTSearch with Unstable RESP3 Search Module and without stability", Label("search", "ftcreate", "ftsearch"), func() { val, err := adapter.FTCreate(ctx, "txt", &FTCreateOptions{StopWords: []interface{}{"foo", "bar", "baz"}}, &FieldSchema{FieldName: "txt", FieldType: SearchFieldTypeText}).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp3, "txt", 3) + WaitForIndexing(client, "txt", 3) adapter.HSet(ctx, "doc1", "txt", "foo baz") adapter.HSet(ctx, "doc2", "txt", "hello world") res1, err := adapter.FTSearchWithArgs(ctx, "txt", "foo bar", &FTSearchOptions{NoContent: true}).RawResult() @@ -11695,8 +11695,8 @@ func testAdapterSearchRESP3() { // totalResults2 := res2.(map[interface{}]interface{})["total_results"] Expect(totalResults2).To(BeEquivalentTo(int64(1))) - // Test with UnstableResp3 false // NOTE: rueidis can't support this behavior because we cannot know whether UnstableResp3 is enabled or not + // Test with UnstableResp3 false // Expect(func() { // rawRes2, _ := adapter2resp3.FTSearchWithArgs(ctx, "txt", "foo bar hello world", &FTSearchOptions{NoContent: true}).RawResult() // rawVal2 := adapter2resp3.FTSearchWithArgs(ctx, "txt", "foo bar hello world", &FTSearchOptions{NoContent: true}).RawVal() @@ -11710,7 +11710,7 @@ func testAdapterSearchRESP3() { val, err := adapter.FTCreate(ctx, "idx1", &FTCreateOptions{OnHash: true}, text1, text2).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp3, "idx1", 3) + WaitForIndexing(client, "idx1", 3) resSynUpdate, err := adapter.FTSynUpdate(ctx, "idx1", "id1", []interface{}{"boy", "child", "offspring"}).Result() Expect(err).NotTo(HaveOccurred()) @@ -11728,15 +11728,17 @@ func testAdapterSearchRESP3() { valSynDump := adapter.FTSynDump(ctx, "idx1").RawVal() Expect(err).NotTo(HaveOccurred()) Expect(valSynDump).To(BeEquivalentTo(resSynDump)) - Expect(resSynDump.(map[interface{}]interface{})["baby"]).To(BeEquivalentTo([]interface{}{"id1"})) + // Expect(resSynDump.(map[interface{}]interface{})["baby"]).To(BeEquivalentTo([]interface{}{"id1"})) + Expect(resSynDump.(map[string]interface{})["baby"]).To(BeEquivalentTo([]interface{}{"id1"})) + // NOTE: rueidis can't support this behavior because we cannot know whether UnstableResp3 is enabled or not // Test with UnstableResp3 false - Expect(func() { - rawResSynDump, _ := adapter2resp3.FTSynDump(ctx, "idx1").RawResult() - rawValSynDump := adapter2resp3.FTSynDump(ctx, "idx1").RawVal() - Expect(rawResSynDump).To(BeNil()) - Expect(rawValSynDump).To(BeNil()) - }).Should(Panic()) + // Expect(func() { + // rawResSynDump, _ := adapter2resp3.FTSynDump(ctx, "idx1").RawResult() + // rawValSynDump := adapter2resp3.FTSynDump(ctx, "idx1").RawVal() + // Expect(rawResSynDump).To(BeNil()) + // Expect(rawValSynDump).To(BeNil()) + // }).Should(Panic()) }) It("should test not affected Resp 3 Search method - FTExplain", Label("search", "ftexplain"), func() { @@ -11746,7 +11748,7 @@ func testAdapterSearchRESP3() { val, err := adapter.FTCreate(ctx, "txt", &FTCreateOptions{}, text1, text2, text3).Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(BeEquivalentTo("OK")) - WaitForIndexing(clientresp3, "txt", 3) + WaitForIndexing(client, "txt", 3) res1, err := adapter.FTExplain(ctx, "txt", "@f3:f3_val @f2:f2_val @f1:f1_val").Result() Expect(err).NotTo(HaveOccurred()) Expect(res1).ToNot(BeEmpty()) diff --git a/rueidiscompat/command.go b/rueidiscompat/command.go index 7d4fdda0..b40e0e61 100644 --- a/rueidiscompat/command.go +++ b/rueidiscompat/command.go @@ -4488,89 +4488,6 @@ func (cmd *FTSearchCmd) from(res rueidis.RedisResult) { Total: int(total), Docs: results, }) - /// Old, wrong parsing - - // totalResultsMsg, ok := m["total_results"] - // if !ok { - // cmd.SetErr(fmt.Errorf(`result map should contain key "total_results"`)) - // } - // totalResults, err := totalResultsMsg.AsInt64() - // if err != nil { - // cmd.SetErr(err) - // return - // } - // resultsMsg, ok := m["results"] - // if !ok { - // cmd.SetErr(fmt.Errorf(`result map should contain key "results"`)) - // } - // resultsArr, err := resultsMsg.ToArray() - // if err != nil { - // cmd.SetErr(err) - // return - // } - // ftSearchResult := FTSearchResult{Total: int(totalResults), Docs: make([]Document, 0, len(resultsArr))} - // for _, result := range resultsArr { - // // result: arr: id, doc2, score, 3, "extra_attributes": [foo, bar] - // resultMap, err := result.ToMap() - // if err != nil { - // cmd.SetErr(err) - // return - // } - // fmt.Println("resultMap", result.String()) - // doc := Document{} - // for k, v := range resultMap { - // switch k { - // case "id": - // idStr, err := v.ToString() - // if err != nil { - // cmd.SetErr(err) - // return - // } - // doc.ID = idStr - // case "extra_attributes": - // // doc.ID = resultArr[i+1].String() - // strMap, err := v.AsStrMap() - // if err != nil { - // cmd.SetErr(err) - // return - // } - // doc.Fields = strMap - // // docs[d].Doc, _ = record.values[j+1].AsStrMap() - // case "score": - // score, err := v.AsFloat64() - // if err != nil { - // cmd.SetErr(err) - // return - // } - // doc.Score = &score - // case "payload": - // if !v.IsNil() { - // payload, err := v.ToString() - // if err != nil { - // cmd.SetErr(err) - // return - // } - // doc.Payload = &payload - // } - // case "sortkey": - // if !v.IsNil() { - // sortKey, err := v.ToString() - // if err != nil { - // cmd.SetErr(err) - // return - // } - // doc.SortKey = &sortKey - // } - // } - // } - - // ftSearchResult.Docs = append(ftSearchResult.Docs, doc) - // } - - // cmd.SetVal(ftSearchResult) - - // _r, _ := json.MarshalIndent(ftSearchResult, "", "\t") - // fmt.Print(string(_r)) } func newFTSearchCmd(res rueidis.RedisResult, options *FTSearchOptions) *FTSearchCmd { @@ -4585,15 +4502,6 @@ type FTSynUpdateOptions struct { type FTSynDumpCmd struct { baseCmd[[]FTSynDumpResult] - rawVal any -} - -func (cmd *FTSynDumpCmd) RawVal() any { - return cmd.rawVal -} - -func (cmd *FTSynDumpCmd) RawResult() (any, error) { - return cmd.rawVal, cmd.Err() } func (cmd *FTSynDumpCmd) from(res rueidis.RedisResult) { @@ -4601,6 +4509,37 @@ func (cmd *FTSynDumpCmd) from(res rueidis.RedisResult) { cmd.SetErr(err) return } + anyRes, err := res.ToAny() + if err != nil { + cmd.SetErr(err) + return + } + cmd.SetRawVal(anyRes) + if !(res.IsMap() || res.IsArray()) { + panic("res should be either map(RESP3) or array(RESP2)") + } + if res.IsMap() { + // is RESP3 map + m, err := res.ToMap() + if err != nil { + cmd.SetErr(err) + return + } + fmt.Println(m) + fmt.Println(res.String()) + results := make([]FTSynDumpResult, 0, len(m)) + for term, synMsg := range m { + synonyms, err := synMsg.AsStrSlice() + if err != nil { + cmd.SetErr(err) + return + } + results = append(results, FTSynDumpResult{Term: term, Synonyms: synonyms}) + } + cmd.SetVal(results) + return + } + // is RESP2 array arr, err := res.ToArray() if err != nil { cmd.SetErr(err) From d9a8d6e8049f6ceec797c8a86bbc7ab99dbe172c Mon Sep 17 00:00:00 2001 From: Eric Chang Date: Sun, 24 Nov 2024 15:52:38 +0800 Subject: [PATCH 40/49] fix tests --- rueidiscompat/adapter_test.go | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/rueidiscompat/adapter_test.go b/rueidiscompat/adapter_test.go index 09437a3b..63e19261 100644 --- a/rueidiscompat/adapter_test.go +++ b/rueidiscompat/adapter_test.go @@ -11753,12 +11753,13 @@ func testAdapterSearchRESP3() { Expect(err).NotTo(HaveOccurred()) Expect(res1).ToNot(BeEmpty()) + // NOTE: rueidis can't support this behavior because we cannot know whether UnstableResp3 is enabled or not // Test with UnstableResp3 false - Expect(func() { - res2, err := adapter2resp3.FTExplain(ctx, "txt", "@f3:f3_val @f2:f2_val @f1:f1_val").Result() - Expect(err).NotTo(HaveOccurred()) - Expect(res2).ToNot(BeEmpty()) - }).ShouldNot(Panic()) + // Expect(func() { + // res2, err := adapter2resp3.FTExplain(ctx, "txt", "@f3:f3_val @f2:f2_val @f1:f1_val").Result() + // Expect(err).NotTo(HaveOccurred()) + // Expect(res2).ToNot(BeEmpty()) + // }).ShouldNot(Panic()) }) }) } From f4a53c7a86aeef257e7dbc695413c64f1c414a91 Mon Sep 17 00:00:00 2001 From: Eric Chang Date: Sun, 24 Nov 2024 16:08:06 +0800 Subject: [PATCH 41/49] refactor: add docs --- rueidiscompat/adapter.go | 137 +++++++++++++++++++++++++++++++++++++-- 1 file changed, 132 insertions(+), 5 deletions(-) diff --git a/rueidiscompat/adapter.go b/rueidiscompat/adapter.go index 0558e57a..33a422d0 100644 --- a/rueidiscompat/adapter.go +++ b/rueidiscompat/adapter.go @@ -4840,13 +4840,22 @@ func (c *Compat) FT_List(ctx context.Context) *StringSliceCmd { return newStringSliceCmd(c.client.Do(ctx, cmd)) } +// FTAggregate - Performs a search query on an index and applies a series of aggregate transformations to the result. +// The 'index' parameter specifies the index to search, and the 'query' parameter specifies the search query. +// For more information, please refer to the Redis documentation: +// [FT.AGGREGATE]: (https://redis.io/commands/ft.aggregate/) +// see go-redis v9.7.0 https://github.com/redis/go-redis/blob/v9.7.0/search_commands.go#L473 func (c *Compat) FTAggregate(ctx context.Context, index string, query string) *MapStringInterfaceCmd { cmd := c.client.B().FtAggregate().Index(index).Query(query).Build() return newMapStringInterfaceCmd(c.client.Do(ctx, cmd)) } -// FTAggregateWithArgs aligns with go-redis' implementation. -// see: go-redis v9.7.0: https://github.com/redis/go-redis/blob/ed37c33a9037483ad2a6b1042e5eb6df89009a1c/search_commands.go#L671 +// FTAggregateWithArgs - Performs a search query on an index and applies a series of aggregate transformations to the result. +// The 'index' parameter specifies the index to search, and the 'query' parameter specifies the search query. +// This function also allows for specifying additional options such as: Verbatim, LoadAll, Load, Timeout, GroupBy, SortBy, SortByMax, Apply, LimitOffset, Limit, Filter, WithCursor, Params, and DialectVersion. +// For more information, please refer to the Redis documentation: +// [FT.AGGREGATE]: (https://redis.io/commands/ft.aggregate/) +// see: go-redis v9.7.0: https://github.com/redis/go-redis/blob/v9.7.0/search_commands.go#L671 func (c *Compat) FTAggregateWithArgs(ctx context.Context, index string, query string, options *FTAggregateOptions) *AggregateCmd { _cmd := cmds.Incomplete(c.client.B().FtAggregate().Index(index).Query(query)) if options != nil { @@ -4965,21 +4974,43 @@ func (c *Compat) FTAggregateWithArgs(ctx context.Context, index string, query st return newAggregateCmd(c.client.Do(ctx, cmd)) } +// FTAliasAdd - Adds an alias to an index. +// The 'index' parameter specifies the index to which the alias is added, and the 'alias' parameter specifies the alias. +// For more information, please refer to the Redis documentation: +// [FT.ALIASADD]: (https://redis.io/commands/ft.aliasadd/) +// see go-redis v9.7.0 https://github.com/redis/go-redis/blob/v9.7.0/search_commands.go#L782 func (c *Compat) FTAliasAdd(ctx context.Context, index string, alias string) *StatusCmd { cmd := c.client.B().FtAliasadd().Alias(alias).Index(index).Build() return newStatusCmd(c.client.Do(ctx, cmd)) } +// FTAliasDel - Removes an alias from an index. +// The 'alias' parameter specifies the alias to be removed. +// For more information, please refer to the Redis documentation: +// [FT.ALIASDEL]: (https://redis.io/commands/ft.aliasdel/) +// see go-redis v9.7.0 https://github.com/redis/go-redis/blob/v9.7.0/search_commands.go#L793 func (c *Compat) FTAliasDel(ctx context.Context, alias string) *StatusCmd { cmd := c.client.B().FtAliasdel().Alias(alias).Build() return newStatusCmd(c.client.Do(ctx, cmd)) } +// FTAliasUpdate - Updates an alias to an index. +// The 'index' parameter specifies the index to which the alias is updated, and the 'alias' parameter specifies the alias. +// If the alias already exists for a different index, it updates the alias to point to the specified index instead. +// For more information, please refer to the Redis documentation: +// [FT.ALIASUPDATE]: (https://redis.io/commands/ft.aliasupdate/) +// see go-redis v9.7.0 https://github.com/redis/go-redis/blob/v9.7.0/search_commands.go#L804 func (c *Compat) FTAliasUpdate(ctx context.Context, index string, alias string) *StatusCmd { cmd := c.client.B().FtAliasupdate().Alias(alias).Index(index).Build() return newStatusCmd(c.client.Do(ctx, cmd)) } +// FTAlter - Alters the definition of an existing index. +// The 'index' parameter specifies the index to alter, and the 'skipInitialScan' parameter specifies whether to skip the initial scan. +// The 'definition' parameter specifies the new definition for the index. +// For more information, please refer to the Redis documentation: +// [FT.ALTER]: (https://redis.io/commands/ft.alter/) +// see go-redis v9.7.0 https://github.com/redis/go-redis/blob/v9.7.0/search_commands.go#L815 func (c *Compat) FTAlter(ctx context.Context, index string, skipInitalScan bool, definition []interface{}) *StatusCmd { _cmd := cmds.Incomplete(c.client.B().FtAlter().Index(index)) if skipInitalScan { @@ -4992,11 +5023,21 @@ func (c *Compat) FTAlter(ctx context.Context, index string, skipInitalScan bool, return newStatusCmd(c.client.Do(ctx, cmd)) } +// FTConfigGet - Retrieves the value of a RediSearch configuration parameter. +// The 'option' parameter specifies the configuration parameter to retrieve. +// For more information, please refer to the Redis documentation: +// [FT.CONFIG GET]: (https://redis.io/commands/ft.config-get/) +// see go-redis v9.7.0 https://github.com/redis/go-redis/blob/v9.7.0/search_commands.go#L831 func (c *Compat) FTConfigGet(ctx context.Context, option string) *MapMapStringInterfaceCmd { cmd := c.client.B().FtConfigGet().Option(option).Build() return newMapMapStringInterfaceCmd(c.client.Do(ctx, cmd)) } +// FTConfigSet - Sets the value of a RediSearch configuration parameter. +// The 'option' parameter specifies the configuration parameter to set, and the 'value' parameter specifies the new value. +// For more information, please refer to the Redis documentation: +// [FT.CONFIG SET]: (https://redis.io/commands/ft.config-set/) +// see go-redis v9.7.0 https://github.com/redis/go-redis/blob/v9.7.0/search_commands.go#L841 func (c *Compat) FTConfigSet(ctx context.Context, option string, value interface{}) *StatusCmd { cmd := c.client.B().FtConfigSet().Option(option).Value(str(value)).Build() return newStatusCmd(c.client.Do(ctx, cmd)) @@ -5010,7 +5051,7 @@ func (c *Compat) FTConfigSet(ctx context.Context, option string, value interface // For more information, please refer to the Redis documentation: // [FT.CREATE]: (https://redis.io/commands/ft.create/) // FTCreate aligns with go-redis v9.7.0. -// Ref: https://github.com/redis/go-redis/blob/v9.7.0/search_commands.go#L854 +// see go-redis v9.7.0 https://github.com/redis/go-redis/blob/v9.7.0/search_commands.go#L854 func (c *Compat) FTCreate(ctx context.Context, index string, options *FTCreateOptions, schema ...*FieldSchema) *StatusCmd { _cmd := cmds.Incomplete(c.client.B().FtCreate().Index(index)) if options != nil { @@ -5220,36 +5261,71 @@ func (c *Compat) FTCreate(ctx context.Context, index string, options *FTCreateOp return newStatusCmd(c.client.Do(ctx, cmd)) } +// FTCursorDel - Deletes a cursor from an existing index. +// The 'index' parameter specifies the index from which to delete the cursor, and the 'cursorId' parameter specifies the ID of the cursor to delete. +// For more information, please refer to the Redis documentation: +// [FT.CURSOR DEL]: (https://redis.io/commands/ft.cursor-del/) +// see go-redis v9.7.0 https://github.com/redis/go-redis/blob/v9.7.0/search_commands.go#L1032 func (c *Compat) FTCursorDel(ctx context.Context, index string, cursorId int) *StatusCmd { cmd := c.client.B().FtCursorDel().Index(index).CursorId(int64(cursorId)).Build() return newStatusCmd(c.client.Do(ctx, cmd)) } +// FTCursorRead - Reads the next results from an existing cursor. +// The 'index' parameter specifies the index from which to read the cursor, the 'cursorId' parameter specifies the ID of the cursor to read, and the 'count' parameter specifies the number of results to read. +// For more information, please refer to the Redis documentation: +// [FT.CURSOR READ]: (https://redis.io/commands/ft.cursor-read/) +// see go-redis v9.7.0 https://github.com/redis/go-redis/blob/v9.7.0/search_commands.go#L1042 func (c *Compat) FTCursorRead(ctx context.Context, index string, cursorId int, count int) *MapStringInterfaceCmd { cmd := c.client.B().FtCursorRead().Index(index).CursorId(int64(cursorId)).Count(int64(count)).Build() return newMapStringInterfaceCmd(c.client.Do(ctx, cmd)) } +// FTDictAdd - Adds terms to a dictionary. +// The 'dict' parameter specifies the dictionary to which to add the terms, and the 'term' parameter specifies the terms to add. +// For more information, please refer to the Redis documentation: +// [FT.DICTADD]: (https://redis.io/commands/ft.dictadd/) +// see go-redis v9.7.0 https://github.com/redis/go-redis/blob/v9.7.0/search_commands.go#L1056 func (c *Compat) FTDictAdd(ctx context.Context, dict string, term ...interface{}) *IntCmd { cmd := c.client.B().FtDictadd().Dict(dict).Term(argsToSlice(term)...).Build() return newIntCmd(c.client.Do(ctx, cmd)) } +// FTDictDel - Deletes terms from a dictionary. +// The 'dict' parameter specifies the dictionary from which to delete the terms, and the 'term' parameter specifies the terms to delete. +// For more information, please refer to the Redis documentation: +// [FT.DICTDEL]: (https://redis.io/commands/ft.dictdel/) +// see go-redis v9.7.0 https://github.com/redis/go-redis/blob/v9.7.0/search_commands.go#L1068 func (c *Compat) FTDictDel(ctx context.Context, dict string, term ...interface{}) *IntCmd { cmd := c.client.B().FtDictdel().Dict(dict).Term(argsToSlice(term)...).Build() return newIntCmd(c.client.Do(ctx, cmd)) } +// FTDictDump - Returns all terms in the specified dictionary. +// The 'dict' parameter specifies the dictionary from which to return the terms. +// For more information, please refer to the Redis documentation: +// [FT.DICTDUMP]: (https://redis.io/commands/ft.dictdump/) +// see go-redis v9.7.0 https://github.com/redis/go-redis/blob/v9.7.0/search_commands.go#L1080 func (c *Compat) FTDictDump(ctx context.Context, dict string) *StringSliceCmd { cmd := c.client.B().FtDictdump().Dict(dict).Build() return newStringSliceCmd(c.client.Do(ctx, cmd)) } +// FTDropIndex - Deletes an index. +// The 'index' parameter specifies the index to delete. +// For more information, please refer to the Redis documentation: +// [FT.DROPINDEX]: (https://redis.io/commands/ft.dropindex/) +// see go-redis v9.7.0 https://github.com/redis/go-redis/blob/v9.7.0/search_commands.go#L1090 func (c *Compat) FTDropIndex(ctx context.Context, index string) *StatusCmd { cmd := c.client.B().FtDropindex().Index(index).Build() return newStatusCmd(c.client.Do(ctx, cmd)) } +// FTDropIndexWithArgs - Deletes an index with options. +// The 'index' parameter specifies the index to delete, and the 'options' parameter specifies the DeleteDocs option for docs deletion. +// For more information, please refer to the Redis documentation: +// [FT.DROPINDEX]: (https://redis.io/commands/ft.dropindex/) +// see go-redis v9.7.0 https://github.com/redis/go-redis/blob/v9.7.0/search_commands.go#L1101 func (c *Compat) FTDropIndexWithArgs(ctx context.Context, index string, options *FTDropIndexOptions) *StatusCmd { _cmd := cmds.Incomplete(c.client.B().FtDropindex().Index(index)) if options.DeleteDocs { @@ -5259,11 +5335,21 @@ func (c *Compat) FTDropIndexWithArgs(ctx context.Context, index string, options return newStatusCmd(c.client.Do(ctx, cmd)) } +// FTExplain - Returns the execution plan for a complex query. +// The 'index' parameter specifies the index to query, and the 'query' parameter specifies the query string. +// For more information, please refer to the Redis documentation: +// [FT.EXPLAIN]: (https://redis.io/commands/ft.explain/) +// see go-redis v9.7.0 https://github.com/redis/go-redis/blob/v9.7.0/search_commands.go#L1117 func (c *Compat) FTExplain(ctx context.Context, index string, query string) *StringCmd { cmd := c.client.B().FtExplain().Index(index).Query(query).Build() return newStringCmd(c.client.Do(ctx, cmd)) } +// FTExplainWithArgs - Returns the execution plan for a complex query with options. +// The 'index' parameter specifies the index to query, the 'query' parameter specifies the query string, and the 'options' parameter specifies the Dialect for the query. +// For more information, please refer to the Redis documentation: +// [FT.EXPLAIN]: (https://redis.io/commands/ft.explain/) +// see go-redis v9.7.0 https://github.com/redis/go-redis/blob/v9.7.0/search_commands.go#L1127 func (c *Compat) FTExplainWithArgs(ctx context.Context, index string, query string, options *FTExplainOptions) *StringCmd { _cmd := cmds.Incomplete(c.client.B().FtExplain().Index(index).Query(query)) if options != nil { @@ -5277,17 +5363,34 @@ func (c *Compat) FTExplainWithArgs(ctx context.Context, index string, query stri return newStringCmd(c.client.Do(ctx, cmd)) } +// FTInfo - Retrieves information about an index. +// The 'index' parameter specifies the index to retrieve information about. +// For more information, please refer to the Redis documentation: +// [FT.INFO]: (https://redis.io/commands/ft.info/) +// see go-redis v9.7.0 https://github.com/redis/go-redis/blob/v9.7.0/search_commands.go#L1393 func (c *Compat) FTInfo(ctx context.Context, index string) *FTInfoCmd { cmd := c.client.B().FtInfo().Index(index).Build() fmt.Println(cmd.Commands()) return newFTInfoCmd(c.client.Do(ctx, cmd)) } +// FTSpellCheck - Checks a query string for spelling errors. +// For more details about spellcheck query please follow: +// https://redis.io/docs/interact/search-and-query/advanced-concepts/spellcheck/ +// For more information, please refer to the Redis documentation: +// [FT.SPELLCHECK]: (https://redis.io/commands/ft.spellcheck/) +// see go-redis v9.7.0 https://github.com/redis/go-redis/blob/v9.7.0/search_commands.go#L1404 func (c *Compat) FTSpellCheck(ctx context.Context, index string, query string) *FTSpellCheckCmd { cmd := c.client.B().FtSpellcheck().Index(index).Query(query).Build() return newFTSpellCheckCmd(c.client.Do(ctx, cmd)) } +// FTSpellCheckWithArgs - Checks a query string for spelling errors with additional options. +// For more details about spellcheck query please follow: +// https://redis.io/docs/interact/search-and-query/advanced-concepts/spellcheck/ +// For more information, please refer to the Redis documentation: +// [FT.SPELLCHECK]: (https://redis.io/commands/ft.spellcheck/) +// see go-redis v9.7.0 https://github.com/redis/go-redis/blob/v9.7.0/search_commands.go#L1416 func (c *Compat) FTSpellCheckWithArgs(ctx context.Context, index string, query string, options *FTSpellCheckOptions) *FTSpellCheckCmd { _cmd := cmds.Incomplete(c.client.B().FtSpellcheck().Index(index).Query(query)) if options != nil { @@ -5312,6 +5415,11 @@ func (c *Compat) FTSpellCheckWithArgs(ctx context.Context, index string, query s return newFTSpellCheckCmd(c.client.Do(ctx, cmd)) } +// FTSearch - Executes a search query on an index. +// The 'index' parameter specifies the index to search, and the 'query' parameter specifies the search query. +// For more information, please refer to the Redis documentation: +// [FT.SEARCH]: (https://redis.io/commands/ft.search/) +// see go-redis v9.7.0 https://github.com/redis/go-redis/blob/v9.7.0/search_commands.go#L1679 func (c *Compat) FTSearch(ctx context.Context, index string, query string) *FTSearchCmd { cmd := c.client.B().FtSearch().Index(index).Query(query).Build() return newFTSearchCmd(c.client.Do(ctx, cmd), nil) @@ -5322,8 +5430,7 @@ func (c *Compat) FTSearch(ctx context.Context, index string, query string) *FTSe // and the 'options' parameter specifies additional options for the search. // For more information, please refer to the Redis documentation: // [FT.SEARCH]: (https://redis.io/commands/ft.search/) -// FTSearchWithArgs Aligns with go-redis v9.7.0. -// Ref: https://github.com/redis/go-redis/blob/ed37c33a9037483ad2a6b1042e5eb6df89009a1c/search_commands.go#L1802 +// see go-redis v9.7.0 https://github.com/redis/go-redis/blob/v9.7.0/search_commands.go#L1802 func (c *Compat) FTSearchWithArgs(ctx context.Context, index string, query string, options *FTSearchOptions) *FTSearchCmd { _cmd := cmds.Incomplete(c.client.B().FtSearch().Index(index).Query(query)) if options != nil { @@ -5478,16 +5585,31 @@ func (c *Compat) FTSearchWithArgs(ctx context.Context, index string, query strin return newFTSearchCmd(c.client.Do(ctx, cmd), options) } +// FTSynDump - Dumps the contents of a synonym group. +// The 'index' parameter specifies the index to dump. +// For more information, please refer to the Redis documentation: +// [FT.SYNDUMP]: (https://redis.io/commands/ft.syndump/) +// see go-redis v9.7.0 https://github.com/redis/go-redis/blob/v9.7.0/search_commands.go#L1987 func (c *Compat) FTSynDump(ctx context.Context, index string) *FTSynDumpCmd { cmd := c.client.B().FtSyndump().Index(index).Build() return newFTSynDumpCmd(c.client.Do(ctx, cmd)) } +// FTSynUpdate - Creates or updates a synonym group with additional terms. +// The 'index' parameter specifies the index to update, the 'synGroupId' parameter specifies the synonym group id, and the 'terms' parameter specifies the additional terms. +// For more information, please refer to the Redis documentation: +// [FT.SYNUPDATE]: (https://redis.io/commands/ft.synupdate/) +// see go-redis v9.7.0 https://github.com/redis/go-redis/blob/v9.7.0/search_commands.go#L1997 func (c *Compat) FTSynUpdate(ctx context.Context, index string, synGroupId interface{}, terms []interface{}) *StatusCmd { cmd := c.client.B().FtSynupdate().Index(index).SynonymGroupId(str(synGroupId)).Term(argToSlice(terms)...).Build() return newStatusCmd(c.client.Do(ctx, cmd)) } +// FTSynUpdateWithArgs - Creates or updates a synonym group with additional terms and options. +// The 'index' parameter specifies the index to update, the 'synGroupId' parameter specifies the synonym group id, the 'options' parameter specifies additional options for the update, and the 'terms' parameter specifies the additional terms. +// For more information, please refer to the Redis documentation: +// [FT.SYNUPDATE]: (https://redis.io/commands/ft.synupdate/) +// see go-redis v9.7.0 https://github.com/redis/go-redis/blob/v9.7.0/search_commands.go#L2009 func (c *Compat) FTSynUpdateWithArgs(ctx context.Context, index string, synGroupId interface{}, options *FTSynUpdateOptions, terms []interface{}) *StatusCmd { _cmd := cmds.Incomplete(c.client.B().FtSynupdate().Index(index).SynonymGroupId(str(synGroupId))) if options != nil { @@ -5499,6 +5621,11 @@ func (c *Compat) FTSynUpdateWithArgs(ctx context.Context, index string, synGroup return newStatusCmd(c.client.Do(ctx, cmd)) } +// FTTagVals - Returns all distinct values indexed in a tag field. +// The 'index' parameter specifies the index to check, and the 'field' parameter specifies the tag field to retrieve values from. +// For more information, please refer to the Redis documentation: +// [FT.TAGVALS]: (https://redis.io/commands/ft.tagvals/) +// see go-redis v9.7.0 https://github.com/redis/go-redis/blob/v9.7.0/search_commands.go#L2024 func (c *Compat) FTTagVals(ctx context.Context, index string, field string) *StringSliceCmd { cmd := c.client.B().FtTagvals().Index(index).FieldName(field).Build() return newStringSliceCmd(c.client.Do(ctx, cmd)) From 5fb4efb8ba2463f3bd2f5515f9522f811b924ccf Mon Sep 17 00:00:00 2001 From: Eric Chang Date: Sun, 24 Nov 2024 16:11:44 +0800 Subject: [PATCH 42/49] refactor: remove unused comment --- rueidiscompat/adapter.go | 13 ------------- 1 file changed, 13 deletions(-) diff --git a/rueidiscompat/adapter.go b/rueidiscompat/adapter.go index 33a422d0..8d471964 100644 --- a/rueidiscompat/adapter.go +++ b/rueidiscompat/adapter.go @@ -5145,9 +5145,6 @@ func (c *Compat) FTCreate(ctx context.Context, index string, options *FTCreateOp case SearchFieldTypeGeo: _cmd = cmds.Incomplete(cmds.FtCreateFieldAs(_cmd).Geo()) case SearchFieldTypeVector: - // FIXME: implement this - // VECTOR - // [ ...] // Ref: https://redis.io/docs/latest/develop/interact/search-and-query/advanced-concepts/vectors/#create-a-vector-index if sc.VectorArgs == nil { panic("FT.CREATE: SCHEMA VectorArgs cannot be nil") @@ -5159,8 +5156,6 @@ func (c *Compat) FTCreate(ctx context.Context, index string, options *FTCreateOp algorithm := "" if sc.VectorArgs.FlatOptions != nil { algorithm = "FLAT" - // args = append(args, "FLAT") - // _cmd = cmds.Incomplete(cmds.FtCreateFieldFieldTypeVector(_cmd).()) if sc.VectorArgs.FlatOptions.Type == "" || sc.VectorArgs.FlatOptions.Dim == 0 || sc.VectorArgs.FlatOptions.DistanceMetric == "" { panic("FT.CREATE: Type, Dim and DistanceMetric are required for VECTOR FLAT") } @@ -5175,13 +5170,10 @@ func (c *Compat) FTCreate(ctx context.Context, index string, options *FTCreateOp if sc.VectorArgs.FlatOptions.BlockSize > 0 { flatArgs = append(flatArgs, "BLOCK_SIZE", sc.VectorArgs.FlatOptions.BlockSize) } - // args = append(args, len(flatArgs)) args = flatArgs - // args = append(args, flatArgs...) } if sc.VectorArgs.HNSWOptions != nil { algorithm = "HNSW" - // args = append(args, "HNSW") if sc.VectorArgs.HNSWOptions.Type == "" || sc.VectorArgs.HNSWOptions.Dim == 0 || sc.VectorArgs.HNSWOptions.DistanceMetric == "" { panic("FT.CREATE: Type, Dim and DistanceMetric are required for VECTOR HNSW") } @@ -5205,14 +5197,11 @@ func (c *Compat) FTCreate(ctx context.Context, index string, options *FTCreateOp if sc.VectorArgs.HNSWOptions.Epsilon > 0 { hnswArgs = append(hnswArgs, "EPSILON", sc.VectorArgs.HNSWOptions.Epsilon) } - // args = append(args, len(hnswArgs)) - // args = append(args, hnswArgs...) args = hnswArgs } _cmd = cmds.Incomplete(cmds.FtCreateFieldAs(_cmd).Vector(algorithm, int64(len(args)), argsToSlice(args)...)) case SearchFieldTypeGeoShape: - // FIXME: geo shape need a block if sc.GeoShapeFieldType == "" { panic("FT.CREATE: GeoShapeFieldType cannot be empty while SCHEMA FieldType is GEOSHAPE") } @@ -5255,8 +5244,6 @@ func (c *Compat) FTCreate(ctx context.Context, index string, options *FTCreateOp _cmd = cmds.Incomplete(cmds.FtCreateFieldFieldTypeText(_cmd).Indexmissing()) } } - - // FIXME: handle index properly cmd := cmds.FtCreateFieldFieldTypeText(_cmd).Build() return newStatusCmd(c.client.Do(ctx, cmd)) } From b302843f231d22c907de75ad40b7c2a35c638b04 Mon Sep 17 00:00:00 2001 From: Eric Chang Date: Sun, 24 Nov 2024 16:15:37 +0800 Subject: [PATCH 43/49] refactor: remove unused debug log --- rueidiscompat/command.go | 18 ------------------ 1 file changed, 18 deletions(-) diff --git a/rueidiscompat/command.go b/rueidiscompat/command.go index b40e0e61..9925af4a 100644 --- a/rueidiscompat/command.go +++ b/rueidiscompat/command.go @@ -3499,7 +3499,6 @@ func (cmd *AggregateCmd) from(res rueidis.RedisResult) { } aggResult.Rows = append(aggResult.Rows, AggregateRow{anyMap}) } - fmt.Println("docs", docs) cmd.SetVal(aggResult) return } @@ -4105,8 +4104,6 @@ func (cmd *FTSpellCheckCmd) from(res rueidis.RedisResult) { if err != nil { cmd.SetErr(err) } - // fmt.Println(res.String()) - fmt.Println(m) anyM, err := res.ToAny() if err != nil { cmd.SetErr(err) @@ -4141,17 +4138,12 @@ func (cmd *FTSpellCheckCmd) from(res rueidis.RedisResult) { cmd.SetErr(err) return } - fmt.Println("k: ", _k, "v", score) result.Suggestions = append(result.Suggestions, SpellCheckSuggestion{Suggestion: _k, Score: score}) } - - // for - // result.Suggestions = SpellCheckSuggestion{Suggestion: suggestion} } spellCheckResults = append(spellCheckResults, result) } cmd.SetVal(spellCheckResults) - // results := resSpellCheck.(map[interface{}]interface{})["results"].(map[interface{}]interface{}) return } // is RESP2 array @@ -4180,7 +4172,6 @@ func (cmd *FTSpellCheckCmd) from(res rueidis.RedisResult) { cmd.SetErr(err) return } - cmd.SetVal(result) } @@ -4293,10 +4284,6 @@ type FTSearchCmd struct { // Ref: https://github.com/redis/go-redis/blob/v9.7.0/search_commands.go#L1541 func (cmd *FTSearchCmd) from(res rueidis.RedisResult) { - // redis message type array is not a RESP3 map - // res may be Map in RESP3, but is array in RESP2 - fmt.Printf("\nrueidisresult %#v\n", res.String()) - if err := res.Error(); err != nil { cmd.SetErr(err) return @@ -4337,13 +4324,11 @@ func (cmd *FTSearchCmd) from(res rueidis.RedisResult) { } ftSearchResult := FTSearchResult{Total: int(totalResults), Docs: make([]Document, 0, len(resultsArr))} for _, result := range resultsArr { - // result: arr: id, doc2, score, 3, "extra_attributes": [foo, bar] resultMap, err := result.ToMap() if err != nil { cmd.SetErr(err) return } - fmt.Println("resultMap", result.String()) doc := Document{} for k, v := range resultMap { switch k { @@ -4362,7 +4347,6 @@ func (cmd *FTSearchCmd) from(res rueidis.RedisResult) { return } doc.Fields = strMap - // docs[d].Doc, _ = record.values[j+1].AsStrMap() case "score": score, err := v.AsFloat64() if err != nil { @@ -4525,8 +4509,6 @@ func (cmd *FTSynDumpCmd) from(res rueidis.RedisResult) { cmd.SetErr(err) return } - fmt.Println(m) - fmt.Println(res.String()) results := make([]FTSynDumpResult, 0, len(m)) for term, synMsg := range m { synonyms, err := synMsg.AsStrSlice() From 4ab2a21dbf16a5b7051eb46b17cc1347e7fb8487 Mon Sep 17 00:00:00 2001 From: Eric Chang Date: Sun, 24 Nov 2024 16:17:43 +0800 Subject: [PATCH 44/49] refactor: remove ginkgo focus --- rueidiscompat/adapter_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rueidiscompat/adapter_test.go b/rueidiscompat/adapter_test.go index 63e19261..068c3373 100644 --- a/rueidiscompat/adapter_test.go +++ b/rueidiscompat/adapter_test.go @@ -11570,7 +11570,7 @@ func testAdapterSearchRESP3() { Expect(adapter.FlushAll(ctx).Err()).NotTo(HaveOccurred()) }) - FDescribe("RediSearch commands Resp 3", Label("search"), func() { + Describe("RediSearch commands Resp 3", Label("search"), func() { ctx := context.TODO() It("should handle FTAggregate with Unstable RESP3 Search Module and without stability", Label("search", "ftcreate", "ftaggregate"), func() { From 93207867568955ff770d1e7b8bb667c4292ef427 Mon Sep 17 00:00:00 2001 From: Eric Chang Date: Sun, 24 Nov 2024 18:55:41 +0800 Subject: [PATCH 45/49] refactor(search_command.json): revert unrelated change --- hack/cmds/commands_search.json | 290 +++++++++++++++++++++++++-------- 1 file changed, 221 insertions(+), 69 deletions(-) diff --git a/hack/cmds/commands_search.json b/hack/cmds/commands_search.json index aa144e56..d9a304e7 100644 --- a/hack/cmds/commands_search.json +++ b/hack/cmds/commands_search.json @@ -14,7 +14,10 @@ "name": "data_type", "command": "ON", "type": "enum", - "enum": ["HASH", "JSON"], + "enum": [ + "HASH", + "JSON" + ], "optional": true }, { @@ -72,7 +75,9 @@ { "name": "maxtextfields", "type": "enum", - "enum": ["MAXTEXTFIELDS"], + "enum": [ + "MAXTEXTFIELDS" + ], "optional": true }, { @@ -84,25 +89,33 @@ { "name": "nooffsets", "type": "enum", - "enum": ["NOOFFSETS"], + "enum": [ + "NOOFFSETS" + ], "optional": true }, { "name": "nohl", "type": "enum", - "enum": ["NOHL"], + "enum": [ + "NOHL" + ], "optional": true }, { "name": "nofields", "type": "enum", - "enum": ["NOFIELDS"], + "enum": [ + "NOFIELDS" + ], "optional": true }, { "name": "nofreqs", "type": "enum", - "enum": ["NOFREQS"], + "enum": [ + "NOFREQS" + ], "optional": true }, { @@ -125,13 +138,17 @@ { "name": "skipinitialscan", "type": "enum", - "enum": ["SKIPINITIALSCAN"], + "enum": [ + "SKIPINITIALSCAN" + ], "optional": true }, { "name": "schema", "type": "enum", - "enum": ["SCHEMA"] + "enum": [ + "SCHEMA" + ] }, { "name": "field", @@ -151,7 +168,14 @@ { "name": "field_type", "type": "enum", - "enum": ["TEXT", "TAG", "NUMERIC", "GEO", "VECTOR", "GEOSHAPE"] + "enum": [ + "TEXT", + "TAG", + "NUMERIC", + "GEO", + "VECTOR", + "GEOSHAPE" + ] }, { "name": "option", @@ -167,12 +191,16 @@ { "name": "sortable", "type": "enum", - "enum": ["SORTABLE"] + "enum": [ + "SORTABLE" + ] }, { "name": "UNF", "type": "enum", - "enum": ["UNF"], + "enum": [ + "UNF" + ], "optional": true } ] @@ -181,13 +209,17 @@ "name": "noindex", "type": "enum", "optional": true, - "enum": ["NOINDEX"] + "enum": [ + "NOINDEX" + ] }, { "name": "NOSTEM", "type": "enum", "optional": true, - "enum": ["NOSTEM"] + "enum": [ + "NOSTEM" + ] }, { "name": "PHONETIC", @@ -211,25 +243,33 @@ "name": "CASESENSITIVE", "type": "enum", "optional": true, - "enum": ["CASESENSITIVE"] + "enum": [ + "CASESENSITIVE" + ] }, - { + { "name": "WITHSUFFIXTRIE", "type": "enum", "optional": true, - "enum": ["WITHSUFFIXTRIE"] + "enum": [ + "WITHSUFFIXTRIE" + ] }, - { + { "name": "INDEXEMPTY", "type": "enum", "optional": true, - "enum": ["INDEXEMPTY"] + "enum": [ + "INDEXEMPTY" + ] }, - { + { "name": "INDEXMISSING", "type": "enum", "optional": true, - "enum": ["INDEXMISSING"] + "enum": [ + "INDEXMISSING" + ] } ] } @@ -308,18 +348,24 @@ { "name": "skipinitialscan", "type": "enum", - "enum": ["SKIPINITIALSCAN"], + "enum": [ + "SKIPINITIALSCAN" + ], "optional": true }, { "name": "schema", "type": "enum", - "enum": ["SCHEMA"] + "enum": [ + "SCHEMA" + ] }, { "name": "add", "type": "enum", - "enum": ["ADD"] + "enum": [ + "ADD" + ] }, { "name": "field", @@ -344,7 +390,9 @@ { "name": "delete docs", "type": "enum", - "enum": ["DD"], + "enum": [ + "DD" + ], "optional": true } ], @@ -430,7 +478,9 @@ { "name": "increment score", "type": "enum", - "enum": ["INCR"], + "enum": [ + "INCR" + ], "optional": true }, { @@ -458,19 +508,25 @@ { "name": "fuzzy", "type": "enum", - "enum": ["FUZZY"], + "enum": [ + "FUZZY" + ], "optional": true }, { "name": "withscores", "type": "enum", - "enum": ["WITHSCORES"], + "enum": [ + "WITHSCORES" + ], "optional": true }, { "name": "withpayloads", "type": "enum", - "enum": ["WITHPAYLOADS"], + "enum": [ + "WITHPAYLOADS" + ], "optional": true }, { @@ -526,7 +582,9 @@ { "name": "skipinitialscan", "type": "enum", - "enum": ["SKIPINITIALSCAN"], + "enum": [ + "SKIPINITIALSCAN" + ], "optional": true }, { @@ -577,7 +635,10 @@ { "name": "inclusion", "type": "enum", - "enum": ["INCLUDE", "EXCLUDE"] + "enum": [ + "INCLUDE", + "EXCLUDE" + ] }, { "name": "dictionary", @@ -710,37 +771,49 @@ "name": "nocontent", "type": "enum", "optional": true, - "enum": ["NOCONTENT"] + "enum": [ + "NOCONTENT" + ] }, { "name": "verbatim", "type": "enum", "optional": true, - "enum": ["VERBATIM"] + "enum": [ + "VERBATIM" + ] }, { "name": "nostopwords", "type": "enum", "optional": true, - "enum": ["NOSTOPWORDS"] + "enum": [ + "NOSTOPWORDS" + ] }, { "name": "withscores", "type": "enum", "optional": true, - "enum": ["WITHSCORES"] + "enum": [ + "WITHSCORES" + ] }, { "name": "withpayloads", "type": "enum", "optional": true, - "enum": ["WITHPAYLOADS"] + "enum": [ + "WITHPAYLOADS" + ] }, { "name": "withsortkeys", "type": "enum", "optional": true, - "enum": ["WITHSORTKEYS"] + "enum": [ + "WITHSORTKEYS" + ] }, { "name": "filter", @@ -789,7 +862,12 @@ { "name": "radius_type", "type": "enum", - "enum": ["m", "km", "mi", "ft"] + "enum": [ + "m", + "km", + "mi", + "ft" + ] } ] }, @@ -864,7 +942,9 @@ { "name": "summarize", "type": "enum", - "enum": ["SUMMARIZE"] + "enum": [ + "SUMMARIZE" + ] }, { "name": "fields", @@ -911,7 +991,9 @@ { "name": "highlight", "type": "enum", - "enum": ["HIGHLIGHT"] + "enum": [ + "HIGHLIGHT" + ] }, { "name": "fields", @@ -938,11 +1020,19 @@ { "name": "tags", "type": "enum", - "enum": ["TAGS"] + "enum": [ + "TAGS" + ] }, { - "name": ["open", "close"], - "type": ["string", "string"] + "name": [ + "open", + "close" + ], + "type": [ + "string", + "string" + ] } ] } @@ -964,7 +1054,9 @@ "name": "tags", "type": "enum", "optional": true, - "enum": ["INORDER"] + "enum": [ + "INORDER" + ] }, { "name": "language", @@ -988,7 +1080,9 @@ "name": "explainscore", "type": "enum", "optional": true, - "enum": ["EXPLAINSCORE"] + "enum": [ + "EXPLAINSCORE" + ] }, { "name": "payload", @@ -1010,13 +1104,18 @@ "name": "order", "type": "enum", "optional": true, - "enum": ["ASC", "DESC"] + "enum": [ + "ASC", + "DESC" + ] }, { "name": "withcount", "type": "enum", "optional": true, - "enum": ["WITHCOUNT"] + "enum": [ + "WITHCOUNT" + ] } ] }, @@ -1028,11 +1127,19 @@ { "name": "limit", "type": "enum", - "enum": ["LIMIT"] + "enum": [ + "LIMIT" + ] }, { - "name": ["offset", "num"], - "type": ["integer", "integer"] + "name": [ + "offset", + "num" + ], + "type": [ + "integer", + "integer" + ] } ] }, @@ -1043,15 +1150,23 @@ { "name": "params", "type": "enum", - "enum": ["PARAMS"] + "enum": [ + "PARAMS" + ] }, { "name": "NARGS", "type": "integer" }, { - "name": ["name", "value"], - "type": ["string", "string"], + "name": [ + "name", + "value" + ], + "type": [ + "string", + "string" + ], "multiple": true } ] @@ -1083,7 +1198,9 @@ "name": "verbatim", "type": "enum", "optional": true, - "enum": ["VERBATIM"] + "enum": [ + "VERBATIM" + ] }, { "name": "timeout", @@ -1102,7 +1219,9 @@ "name": "loadall", "type": "enum", "optional": true, - "enum": ["LOAD *"] + "enum": [ + "LOAD *" + ] }, { "name": "load", @@ -1174,7 +1293,10 @@ { "name": "order", "type": "enum", - "enum": ["ASC", "DESC"], + "enum": [ + "ASC", + "DESC" + ], "optional": true } ] @@ -1204,7 +1326,10 @@ { "name": "order", "type": "enum", - "enum": ["ASC", "DESC"], + "enum": [ + "ASC", + "DESC" + ], "optional": true } ] @@ -1215,10 +1340,12 @@ "command": "MAX", "optional": true }, - { + { "name": "withcount", "type": "enum", - "enum": ["WITHCOUNT"], + "enum": [ + "WITHCOUNT" + ], "optional": true } ] @@ -1249,11 +1376,19 @@ { "name": "limit", "type": "enum", - "enum": ["LIMIT"] + "enum": [ + "LIMIT" + ] }, { - "name": ["offset", "num"], - "type": ["integer", "integer"] + "name": [ + "offset", + "num" + ], + "type": [ + "integer", + "integer" + ] } ] }, @@ -1273,7 +1408,9 @@ { "name": "withcursor", "type": "enum", - "enum": ["WITHCURSOR"] + "enum": [ + "WITHCURSOR" + ] }, { "name": "read_size", @@ -1296,15 +1433,23 @@ { "name": "params", "type": "enum", - "enum": ["PARAMS"] + "enum": [ + "PARAMS" + ] }, { "name": "NARGS", "type": "integer" }, { - "name": ["name", "value"], - "type": ["string", "string"], + "name": [ + "name", + "value" + ], + "type": [ + "string", + "string" + ], "multiple": true } ] @@ -1312,7 +1457,9 @@ { "name": "addscores", "type": "enum", - "enum": ["ADDSCORES"], + "enum": [ + "ADDSCORES" + ], "optional": true }, { @@ -1335,12 +1482,17 @@ { "name": "querytype", "type": "enum", - "enum": ["SEARCH", "AGGREGATE"] + "enum": [ + "SEARCH", + "AGGREGATE" + ] }, { "name": "limited", "type": "enum", - "enum": ["LIMITED"], + "enum": [ + "LIMITED" + ], "optional": true }, { @@ -1389,4 +1541,4 @@ "since": "1.1.0", "group": "search" } -} +} \ No newline at end of file From 766159e5b05da09c194afea90e3e19af3b1eb69f Mon Sep 17 00:00:00 2001 From: Eric Chang Date: Sun, 24 Nov 2024 19:21:07 +0800 Subject: [PATCH 46/49] minor tweaks --- rueidiscompat/adapter.go | 2 -- 1 file changed, 2 deletions(-) diff --git a/rueidiscompat/adapter.go b/rueidiscompat/adapter.go index 8d471964..abb6f42e 100644 --- a/rueidiscompat/adapter.go +++ b/rueidiscompat/adapter.go @@ -428,7 +428,6 @@ type CoreCmdable interface { SearchCmdable } -// TODO SearchCmdable type SearchCmdable interface { FT_List(ctx context.Context) *StringSliceCmd FTAggregate(ctx context.Context, index string, query string) *MapStringInterfaceCmd @@ -5095,7 +5094,6 @@ func (c *Compat) FTCreate(ctx context.Context, index string, options *FTCreateOp } // [TEMPORARY seconds] // FIXME: reudis: Temporary should not be float64 - // TRY FT.CREATE myindex2 ON JSON PREFIX 1 doc: TEMPORARY 1.1 SCHEMA $.name AS name TEXT if options.Temporary > 0 { _cmd = cmds.Incomplete(cmds.FtCreateIndex(_cmd).Temporary(float64(options.Temporary))) } From ea70f3b7ff117e183ccb0cd4c9631e8dd6bbc1e1 Mon Sep 17 00:00:00 2001 From: Eric Chang Date: Mon, 25 Nov 2024 08:30:40 +0800 Subject: [PATCH 47/49] fix: revert accidentally committed code in RedisResult.ToMap --- message.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/message.go b/message.go index 73eccd55..ff1bb828 100644 --- a/message.go +++ b/message.go @@ -456,7 +456,7 @@ func (r RedisResult) ToMap() (v map[string]RedisMessage, err error) { if r.err != nil { err = r.err } else { - v, err = r.val.AsMap() + v, err = r.val.ToMap() } return } From a8eb47c0cd438f6aa68890d760236659a3b6a4fb Mon Sep 17 00:00:00 2001 From: Eric Chang Date: Mon, 25 Nov 2024 08:34:42 +0800 Subject: [PATCH 48/49] refactor(util.go): remove unused function --- rueidiscompat/util.go | 14 -------------- 1 file changed, 14 deletions(-) diff --git a/rueidiscompat/util.go b/rueidiscompat/util.go index 335bd0c2..b91740f0 100644 --- a/rueidiscompat/util.go +++ b/rueidiscompat/util.go @@ -27,25 +27,11 @@ package rueidiscompat import ( - "context" "net" "strconv" "strings" - "time" ) -func Sleep(ctx context.Context, dur time.Duration) error { - t := time.NewTimer(dur) - defer t.Stop() - - select { - case <-t.C: - return nil - case <-ctx.Done(): - return ctx.Err() - } -} - func ToLower(s string) string { if isLower(s) { return s From ec1b38904ab2b0adb0b5f4320ffc583fa360448e Mon Sep 17 00:00:00 2001 From: Eric Chang Date: Mon, 25 Nov 2024 10:44:03 +0800 Subject: [PATCH 49/49] refactor(message.go): remove RedisResult.IsMap, RedisResult.IsArray --- message.go | 10 ------- rueidiscompat/adapter.go | 2 -- rueidiscompat/command.go | 57 +++++++++++++++++++++++++++------------- 3 files changed, 39 insertions(+), 30 deletions(-) diff --git a/message.go b/message.go index ff1bb828..ec49c18a 100644 --- a/message.go +++ b/message.go @@ -471,16 +471,6 @@ func (r RedisResult) ToAny() (v any, err error) { return } -// IsMap delegates to RedisMessage.IsMap -func (r RedisResult) IsMap() bool { - return r.val.IsMap() -} - -// IsArray delegates to RedisMessage.IsArray -func (r RedisResult) IsArray() bool { - return r.val.IsArray() -} - // IsCacheHit delegates to RedisMessage.IsCacheHit func (r RedisResult) IsCacheHit() bool { return r.val.IsCacheHit() diff --git a/rueidiscompat/adapter.go b/rueidiscompat/adapter.go index abb6f42e..4de9dbf9 100644 --- a/rueidiscompat/adapter.go +++ b/rueidiscompat/adapter.go @@ -5355,7 +5355,6 @@ func (c *Compat) FTExplainWithArgs(ctx context.Context, index string, query stri // see go-redis v9.7.0 https://github.com/redis/go-redis/blob/v9.7.0/search_commands.go#L1393 func (c *Compat) FTInfo(ctx context.Context, index string) *FTInfoCmd { cmd := c.client.B().FtInfo().Index(index).Build() - fmt.Println(cmd.Commands()) return newFTInfoCmd(c.client.Do(ctx, cmd)) } @@ -5566,7 +5565,6 @@ func (c *Compat) FTSearchWithArgs(ctx context.Context, index string, query strin } } cmd := cmds.FtSearchQuery(_cmd).Build() - fmt.Print(cmd.Commands()) return newFTSearchCmd(c.client.Do(ctx, cmd), options) } diff --git a/rueidiscompat/command.go b/rueidiscompat/command.go index 9925af4a..79514734 100644 --- a/rueidiscompat/command.go +++ b/rueidiscompat/command.go @@ -3482,11 +3482,16 @@ func (cmd *AggregateCmd) from(res rueidis.RedisResult) { return } cmd.SetRawVal(anyRes) - if !(res.IsMap() || res.IsArray()) { + msg, err := res.ToMessage() + if err != nil { + cmd.SetErr(err) + return + } + if !(msg.IsMap() || msg.IsArray()) { panic("res should be either map(RESP3) or array(RESP2)") } - if res.IsMap() { - total, docs, err := res.AsFtAggregate() + if msg.IsMap() { + total, docs, err := msg.AsFtAggregate() if err != nil { cmd.SetErr(err) return @@ -3503,7 +3508,7 @@ func (cmd *AggregateCmd) from(res rueidis.RedisResult) { return } // is RESP2 array - rows, err := res.ToArray() + rows, err := msg.ToArray() if err != nil { cmd.SetErr(err) return @@ -4095,16 +4100,22 @@ func (cmd *FTSpellCheckCmd) from(res rueidis.RedisResult) { cmd.SetErr(err) return } - if !(res.IsMap() || res.IsArray()) { + msg, err := res.ToMessage() + if err != nil { + cmd.SetErr(err) + return + } + if !(msg.IsMap() || msg.IsArray()) { panic("res should be either map(RESP3) or array(RESP2)") } - if res.IsMap() { + if msg.IsMap() { // is RESP3 map - m, err := res.ToMap() + m, err := msg.ToMap() if err != nil { cmd.SetErr(err) + return } - anyM, err := res.ToAny() + anyM, err := msg.ToAny() if err != nil { cmd.SetErr(err) return @@ -4147,12 +4158,12 @@ func (cmd *FTSpellCheckCmd) from(res rueidis.RedisResult) { return } // is RESP2 array - arr, err := res.ToArray() + arr, err := msg.ToArray() if err != nil { cmd.SetErr(err) return } - anyRes, err := res.ToAny() + anyRes, err := msg.ToAny() if err != nil { cmd.SetErr(err) return @@ -4294,12 +4305,17 @@ func (cmd *FTSearchCmd) from(res rueidis.RedisResult) { return } cmd.SetRawVal(anyRes) - if !(res.IsMap() || res.IsArray()) { + msg, err := res.ToMessage() + if err != nil { + cmd.SetErr(err) + return + } + if !(msg.IsMap() || msg.IsArray()) { panic("res should be either map(RESP3) or array(RESP2)") } - if res.IsMap() { + if msg.IsMap() { // is RESP3 map - m, err := res.ToMap() + m, err := msg.ToMap() if err != nil { cmd.SetErr(err) return @@ -4381,7 +4397,7 @@ func (cmd *FTSearchCmd) from(res rueidis.RedisResult) { return } // is RESP2 array - data, err := res.ToArray() + data, err := msg.ToArray() if err != nil { cmd.SetErr(err) return @@ -4499,12 +4515,17 @@ func (cmd *FTSynDumpCmd) from(res rueidis.RedisResult) { return } cmd.SetRawVal(anyRes) - if !(res.IsMap() || res.IsArray()) { + msg, err := res.ToMessage() + if err != nil { + cmd.SetErr(err) + return + } + if !(msg.IsMap() || msg.IsArray()) { panic("res should be either map(RESP3) or array(RESP2)") } - if res.IsMap() { + if msg.IsMap() { // is RESP3 map - m, err := res.ToMap() + m, err := msg.ToMap() if err != nil { cmd.SetErr(err) return @@ -4522,7 +4543,7 @@ func (cmd *FTSynDumpCmd) from(res rueidis.RedisResult) { return } // is RESP2 array - arr, err := res.ToArray() + arr, err := msg.ToArray() if err != nil { cmd.SetErr(err) return