From 69656fd2e93596b93b92ed1e2ae9fdef164c819e Mon Sep 17 00:00:00 2001 From: Carsten Rietz Date: Tue, 12 Nov 2024 08:36:36 +0100 Subject: [PATCH] docstore/memdocstore: #3508 nested query --- docstore/memdocstore/mem.go | 39 ++++++++++++++++------------ docstore/memdocstore/mem_test.go | 44 ++++++++++++++++++++++++++++++++ docstore/memdocstore/query.go | 13 ++++++++++ 3 files changed, 80 insertions(+), 16 deletions(-) diff --git a/docstore/memdocstore/mem.go b/docstore/memdocstore/mem.go index a5470261b6..802e310b19 100644 --- a/docstore/memdocstore/mem.go +++ b/docstore/memdocstore/mem.go @@ -399,16 +399,31 @@ func (c *collection) checkRevision(arg driver.Document, current storedDoc) error // getAtFieldPath gets the value of m at fp. It returns an error if fp is invalid // (see getParentMap). -func getAtFieldPath(m map[string]interface{}, fp []string) (interface{}, error) { - m2, err := getParentMap(m, fp, false) - if err != nil { - return nil, err +func getAtFieldPath(m map[string]interface{}, fp []string) (result interface{}, err error) { + + var get func(m interface{}, name string) interface{} + get = func(m interface{}, name string) interface{} { + switch concrete := m.(type) { + case map[string]interface{}: + return concrete[name] + case []interface{}: + result := []interface{}{} + for _, e := range concrete { + result = append(result, get(e, name)) + } + return result + } + return nil } - v, ok := m2[fp[len(fp)-1]] - if ok { - return v, nil + result = m + for _, k := range fp { + next := get(result, k) + if next == nil { + return nil, gcerr.Newf(gcerr.NotFound, nil, "field %s not found", strings.Join(fp, ".")) + } + result = next } - return nil, gcerr.Newf(gcerr.NotFound, nil, "field %s not found", fp) + return result, nil } // setAtFieldPath sets m's value at fp to val. It creates intermediate maps as @@ -422,14 +437,6 @@ func setAtFieldPath(m map[string]interface{}, fp []string, val interface{}) erro return nil } -// Delete the value from m at the given field path, if it exists. -func deleteAtFieldPath(m map[string]interface{}, fp []string) { - m2, _ := getParentMap(m, fp, false) // ignore error - if m2 != nil { - delete(m2, fp[len(fp)-1]) - } -} - // getParentMap returns the map that directly contains the given field path; // that is, the value of m at the field path that excludes the last component // of fp. If a non-map is encountered along the way, an InvalidArgument error is diff --git a/docstore/memdocstore/mem_test.go b/docstore/memdocstore/mem_test.go index 2129f62ef7..467ba945f7 100644 --- a/docstore/memdocstore/mem_test.go +++ b/docstore/memdocstore/mem_test.go @@ -16,6 +16,7 @@ package memdocstore import ( "context" + "io" "os" "path/filepath" "testing" @@ -129,6 +130,49 @@ func TestUpdateAtomic(t *testing.T) { } } +func TestQueryNested(t *testing.T) { + ctx := context.Background() + + count := func(iter *docstore.DocumentIterator) (c int) { + doc := docmap{} + for { + if err := iter.Next(ctx, doc); err != nil { + if err == io.EOF { + break + } + t.Fatal(err) + } + c++ + } + return c + } + + dc, err := newCollection(drivertest.KeyField, nil, nil) + if err != nil { + t.Fatal(err) + } + coll := docstore.NewCollection(dc) + defer coll.Close() + + doc := docmap{drivertest.KeyField: "TestQueryNested", + "list": []any{docmap{"a": "A"}}, + "map": docmap{"b": "B"}, + dc.RevisionField(): nil, + } + if err := coll.Put(ctx, doc); err != nil { + t.Fatal(err) + } + + got := count(coll.Query().Where("list.a", "=", "A").Get(ctx)) + if got != 1 { + t.Errorf("got %v docs when filtering by list.a, want 1", got) + } + got = count(coll.Query().Where("map.b", "=", "B").Get(ctx)) + if got != 1 { + t.Errorf("got %v docs when filtering by map.b, want 1", got) + } +} + func TestSortDocs(t *testing.T) { newDocs := func() []storedDoc { return []storedDoc{ diff --git a/docstore/memdocstore/query.go b/docstore/memdocstore/query.go index 419017b993..e1407731a6 100644 --- a/docstore/memdocstore/query.go +++ b/docstore/memdocstore/query.go @@ -138,6 +138,19 @@ func compare(x1, x2 interface{}) (int, bool) { } return -1, true } + if v1.Kind() == reflect.Slice { + for i := 0; i < v1.Len(); i++ { + if c, ok := compare(x2, v1.Index(i).Interface()); ok { + if !ok { + return 0, false + } + if c == 0 { + return 0, true + } + } + } + return -1, true + } if v1.Kind() == reflect.String && v2.Kind() == reflect.String { return strings.Compare(v1.String(), v2.String()), true }