From eaa4757000a13976d4d1f5a0d11264270e407fba Mon Sep 17 00:00:00 2001 From: Ilya Kompaniets Date: Tue, 17 Sep 2024 15:49:31 +0300 Subject: [PATCH] Added search engine --- db/db.go | 9 + db/helpers.go | 4 + db/search/compare.go | 64 ++++++ db/search/cursor.go | 239 +++++++++++++++++++++ db/search/engine.go | 452 +++++++++++++++++++++++++++++++++++++++ db/search/offsets.go | 29 +++ db/search/paging.go | 67 ++++++ db/search/paging_test.go | 114 ++++++++++ 8 files changed, 978 insertions(+) create mode 100644 db/search/compare.go create mode 100644 db/search/cursor.go create mode 100644 db/search/engine.go create mode 100644 db/search/offsets.go create mode 100644 db/search/paging.go create mode 100644 db/search/paging_test.go diff --git a/db/db.go b/db/db.go index 140fc8c..bff8e96 100644 --- a/db/db.go +++ b/db/db.go @@ -339,6 +339,15 @@ type Recommendation struct { RecommendedVal int64 } +// BadInputError Special error indicating bad user input as opposed to a database error +type BadInputError struct { + Details error +} + +func (bi BadInputError) Error() string { + return bi.Details.Error() +} + // DBType - database type type DBType struct { Driver DialectName // driver name (used in the code) diff --git a/db/helpers.go b/db/helpers.go index 62b8a60..1a1aab9 100644 --- a/db/helpers.go +++ b/db/helpers.go @@ -277,6 +277,10 @@ func ParseScheme(s string) (scheme string, uri string, err error) { return parts[0], parts[1], nil } +func FormatTimeStamp(timestamp time.Time) string { + return fmt.Sprintf("%vns", timestamp.UTC().UnixNano()) +} + // Cond represents a condition type Cond struct { Col string diff --git a/db/search/compare.go b/db/search/compare.go new file mode 100644 index 0000000..4b548a6 --- /dev/null +++ b/db/search/compare.go @@ -0,0 +1,64 @@ +package search + +import ( + "fmt" + + "github.com/acronis/perfkit/db" +) + +type comparator[T Searchable[T]] func(a, b T) bool +type comparators[T Searchable[T]] map[string]map[string]comparator[T] + +func makeComparator[T Searchable[T]](values []string, comparable comparators[T]) (comparator[T], error) { + var less func(a, b T) bool + if len(values) == 0 { + return less, nil + } + + var finalLess func(a, b T) bool + + for i := len(values) - 1; i >= 0; i-- { + value := values[i] + + fnc, field, err := db.ParseFunc(value) + if err != nil { + return nil, err + } + + if fnc == "" { + return nil, fmt.Errorf("empty order function") + } + + if field == "" { + return nil, fmt.Errorf("empty order field") + } + + fieldComparators, ok := comparable[field] + if !ok { + return nil, fmt.Errorf("bad order field '%v'", field) + } + + less, ok := fieldComparators[fnc] + if !ok { + return nil, fmt.Errorf("bad order function '%v'", fnc) + } + + if finalLess == nil { + finalLess = less + } else { + var deepLess = finalLess + + finalLess = func(a, b T) bool { + if less(a, b) { + return true + } else if less(b, a) { + return false + } + + return deepLess(a, b) + } + } + } + + return finalLess, nil +} diff --git a/db/search/cursor.go b/db/search/cursor.go new file mode 100644 index 0000000..3d89b6b --- /dev/null +++ b/db/search/cursor.go @@ -0,0 +1,239 @@ +package search + +import ( + "fmt" + + "github.com/acronis/perfkit/db" +) + +type sorting struct { + Field string + Func string +} + +func uniqueSort(encodedSorts []string, uniqueFields map[string]bool, cursors map[string]string) ([]string, []sorting, error) { + var hasUniqueSorting = false + var uniqueOrderDirection int + + var encoded []string + var sorts []sorting + + for _, v := range encodedSorts { + var fnc, field, err = db.ParseFunc(v) + if err != nil { + return nil, nil, err + } + + var nullable, unique = uniqueFields[field] + hasUniqueSorting = hasUniqueSorting || (unique && !nullable) + + encoded = append(encoded, v) + sorts = append(sorts, sorting{ + Field: field, + Func: fnc, + }) + + switch fnc { + case "asc": + uniqueOrderDirection++ + case "desc": + uniqueOrderDirection-- + } + + if unique { + if !nullable { + break + } else if cursors != nil { + if val, ok := cursors[field]; ok && val != db.SpecialConditionIsNull { + if fnc != "desc" { + break + } + } + } + } + } + + if !hasUniqueSorting { + if uniqueOrderDirection >= 0 { + encoded = append(encoded, "asc(id)") + sorts = append(sorts, sorting{Field: "id", Func: "asc"}) + } else { + encoded = append(encoded, "desc(id)") + sorts = append(sorts, sorting{Field: "id", Func: "desc"}) + } + } + + return encoded, sorts, nil +} + +func orderCondition(val, fnc string) (expr string, flag bool, err error) { + var direction string + switch fnc { + case "asc": + switch val { + case db.SpecialConditionIsNull: + return db.SpecialConditionIsNotNull, false, nil + case db.SpecialConditionIsNotNull: + return "", true, nil + default: + direction = "gt" + } + case "desc": + switch val { + case db.SpecialConditionIsNotNull: + return db.SpecialConditionIsNull, false, nil + case db.SpecialConditionIsNull: + return "", true, nil + default: + direction = "lt" + } + default: + return "", false, fmt.Errorf("missing ordering for cursor") + } + + return fmt.Sprintf("%s(%v)", direction, val), false, nil +} + +func splitQueryOnLightWeightQueries(pt PageToken, uniqueFields map[string]bool) ([]PageToken, error) { + var tokens []PageToken + + if len(pt.Fields) == 0 { + tokens = append(tokens, pt) + return tokens, nil + } + + // check for unique sorting + var encodedSorts, sorts, err = uniqueSort(pt.Order, uniqueFields, pt.Cursor) + if err != nil { + return nil, err + } + + if len(pt.Cursor) == 0 { + pt.Order = encodedSorts + tokens = append(tokens, pt) + return tokens, nil + } + + // construct sort map for fast access + var orderFunctions = map[string]string{} + for _, sort := range sorts { + orderFunctions[sort.Field] = sort.Func + } + + // add condition based on cursor + var whereFromCursor = func(fld, val string, pt *PageToken) (bool, error) { + var filter, empty, filterErr = orderCondition(val, orderFunctions[fld]) + if filterErr != nil { + return false, filterErr + } + + if empty { + return true, nil + } + + pt.Filter[fld] = append(pt.Filter[fld], filter) + return false, nil + } + + for cursor := range pt.Cursor { + if _, ok := orderFunctions[cursor]; !ok { + return nil, fmt.Errorf("prohibited cursor, not mentioned it order: %v", cursor) + } + } + + // split to x page tokens + for i := range sorts { + var cpt = pt + var last = len(sorts) - 1 - i + + // copy filters + cpt.Filter = make(map[string][]string, len(sorts)-1-i) + for k, v := range pt.Filter { + cpt.Filter[k] = v + } + + // add equal condition on all fields except last in sorts + for j := 0; j <= last-1; j++ { + var fld = sorts[j].Field + var val = pt.Cursor[fld] + + cpt.Filter[fld] = append(cpt.Filter[fld], val) + } + + // add gt / lt condition for last sorting + var empty bool + if val, ok := cpt.Cursor[sorts[last].Field]; ok { + if empty, err = whereFromCursor(sorts[last].Field, val, &cpt); err != nil { + return nil, err + } + } else { + continue + } + + if empty { + continue + } + + // Add only needed sort to cpt + cpt.Order = []string{} + for j := last; j <= len(sorts)-1; j++ { + cpt.Order = append(cpt.Order, encodedSorts[j]) + + var sortField = sorts[j].Field + if nullable, unique := uniqueFields[sortField]; unique { + if !nullable { + break + } + + var becomeUnique = false + // for ASC if we have a value, that means we already select all null rows + // for DESC Nulls can start at any row + if sorts[j].Func == "asc" { + for _, val := range cpt.Filter[sortField] { + if val != db.SpecialConditionIsNull { + becomeUnique = true + break + } + } + } + if becomeUnique { + break + } + } + } + + cpt.Cursor = nil + + tokens = append(tokens, cpt) + } + + return tokens, nil +} + +func createNextCursorBasedPageToken[T Searchable[T]](previousPageToken PageToken, items []T, limit int64, + cursorGen func(entity *T, field string) (string, error), uniqueFields map[string]bool) (*PageToken, error) { + if int64(len(items)) < limit { + return nil, nil + } + + var pt PageToken + pt.Cursor = make(map[string]string) + pt.Fields = previousPageToken.Fields + + var encoded, sorts, err = uniqueSort(previousPageToken.Order, uniqueFields, previousPageToken.Cursor) + if err != nil { + return nil, err + } + pt.Order = encoded + + var last = items[len(items)-1] + for _, sort := range sorts { + var value string + if value, err = cursorGen(&last, sort.Field); err != nil { + return nil, err + } + pt.Cursor[sort.Field] = value + } + + return &pt, nil +} diff --git a/db/search/engine.go b/db/search/engine.go new file mode 100644 index 0000000..bc79d36 --- /dev/null +++ b/db/search/engine.go @@ -0,0 +1,452 @@ +package search + +import ( + "fmt" + "strconv" + "sync" + "time" + + "github.com/acronis/perfkit/db" +) + +func id2str(id int64) string { + return fmt.Sprintf("%v", id) +} + +func str2id(s string) (int64, error) { + return strconv.ParseInt(s, 10, 64) +} + +func int64Min(a, b int64) int64 { + if a < b { + return a + } + return b +} + +type Searchable[T any] interface { + Less(T) bool + Equal(T) bool + Cursor(string) (string, error) +} + +type Searcher[T any] interface { + Search(*db.SelectCtrl) ([]T, int64, error) +} + +type loadedPage[T Searchable[T]] struct { + Items []T + Size int64 + Timestamp string +} + +type searchEngine[T Searchable[T]] struct { + lods map[string][]string + comparators map[string]map[string]comparator[T] + equalFunc comparator[T] + loadFunc func(Searcher[T], *db.SelectCtrl) ([]T, int64, error) + uniqueFields map[string]bool + cursorGen func(entity *T, field string) (string, error) +} + +func cleanSources[T Searchable[T]](sources map[string]Searcher[T]) map[string]Searcher[T] { + for key, source := range sources { + if source == nil { + delete(sources, key) + } + } + + return sources +} + +func (e *searchEngine[T]) search(sources map[string]Searcher[T], pt PageToken, limit int64, cursorPagingEnabled bool) (*loadedPage[T], *PageToken, error) { + var finalPage = loadedPage[T]{Timestamp: db.FormatTimeStamp(time.Now())} + + sources = cleanSources(sources) + if len(sources) == 0 { + return &finalPage, nil, nil + } + + var sorts []string + if cursorPagingEnabled { + if encoded, _, sortsErr := uniqueSort(pt.Order, e.uniqueFields, pt.Cursor); sortsErr != nil { + return nil, nil, db.BadInputError{Details: fmt.Errorf("unique sort creation error: %v", sortsErr)} + } else { + sorts = encoded + } + } else { + sorts = pt.Order + } + + var less, cmpErr = makeComparator(sorts, e.comparators) + if cmpErr != nil { + return nil, nil, db.BadInputError{Details: fmt.Errorf("creation cmp error: %v", cmpErr)} + } + + var pts []PageToken + var offsets map[string]int64 + if cursorPagingEnabled { + var err error + if pts, err = splitQueryOnLightWeightQueries(pt, e.uniqueFields); err != nil { + return nil, nil, db.BadInputError{Details: fmt.Errorf("cursor modify error: %v", err)} + } + } else { + pts = append(pts, pt) + offsets = pt.Offsets + sources = cutSourcesByOffsets(sources, offsets) + } + + var finalList = []T{} + var finalCount int64 + for _, cpt := range pts { + var pages, counts, err = e.load(sources, cpt, limit) + if err != nil { + return nil, nil, err + } + + if len(cpt.Fields) == 0 { + for _, count := range counts { + finalCount += count + } + continue + } + + pages = cleanPages(pages) + if less == nil && len(pages) > 1 { + return nil, nil, db.BadInputError{Details: fmt.Errorf("failed to merge multiple pages, order is empty: %v", err)} + } + finalList, offsets = e.merge(finalList, pages, limit, less, offsets) + + if len(finalList) >= int(limit) { + break + } + } + + if len(pt.Fields) == 0 { + finalPage.Size = finalCount + return &finalPage, nil, nil + } + + var nextPageToken *PageToken + var err error + if cursorPagingEnabled { + if nextPageToken, err = createNextCursorBasedPageToken(pt, finalList, limit, e.cursorGen, e.uniqueFields); err != nil { + return nil, nil, db.BadInputError{Details: fmt.Errorf("creation cmp error: %v", err)} + } + } else { + nextPageToken = createNextOffsetBasedPageToken(pt, offsets) + } + + finalPage.Items = finalList + finalPage.Size = int64(len(finalPage.Items)) + + return &finalPage, nextPageToken, nil +} + +type loadResult[T Searchable[T]] struct { + key string + items []T + count int64 + err error +} + +func (e *searchEngine[T]) load(sources map[string]Searcher[T], pt PageToken, limit int64) (pages map[string][]T, counts map[string]int64, err error) { + sources = cleanSources(sources) + + pages = map[string][]T{} + counts = map[string]int64{} + if len(sources) == 0 { + return nil, nil, nil + } + + if len(sources) == 1 { + for key, source := range sources { + var offset = pt.Offsets[key] + var ctrl = newSelectCtrl(pt, limit, offset) + var items, count, err = e.loadFunc(source, ctrl) + if err != nil { + return nil, nil, err + } + pages[key] = items + counts[key] = count + return pages, counts, nil + } + } + + var results = make([]loadResult[T], len(sources)) + var wg sync.WaitGroup + wg.Add(len(sources)) + + var i = 0 + for k, s := range sources { + go func(key string, source Searcher[T], index int) { + var offset = pt.Offsets[key] + var ctrl = newSelectCtrl(pt, limit, offset) + + var result = loadResult[T]{key: key} + result.items, result.count, result.err = e.loadFunc(source, ctrl) + results[index] = result + + wg.Done() + }(k, s, i) + + i++ + } + wg.Wait() + + for _, result := range results { + if result.err != nil { + return nil, nil, result.err + } + + // nolint:gocritic // TODO: >= is suspicious here. should be > ? + if len(result.items) >= 0 { + pages[result.key] = result.items + counts[result.key] = result.count + } + } + + return pages, counts, nil +} + +type pageToMerge[T Searchable[T]] struct { + key string + items []T + used int64 +} + +// Not safe +func (p *pageToMerge[T]) headPlus(index int64) T { + return p.items[p.used+index] +} + +func (p *pageToMerge[T]) isSafeHeadPlus(index int64) bool { + return p.used+index < int64(len(p.items)) +} + +func cleanPages[T Searchable[T]](pages map[string][]T) map[string][]T { + for key, page := range pages { + if len(page) == 0 { + delete(pages, key) + } + } + + return pages +} + +// nolint:funlen // TODO: Try to split this function +func (e *searchEngine[T]) merge(finalList []T, pages map[string][]T, limit int64, less comparator[T], offsets map[string]int64) ([]T, map[string]int64) { + pages = cleanPages(pages) + + if len(pages) == 0 { + return finalList, nil + } + + var usedTombstones = map[string]int64{} + var pagesToMerge []pageToMerge[T] + for key, page := range pages { + pagesToMerge = append(pagesToMerge, pageToMerge[T]{ + key: key, + items: page, + used: 0, + }) + } + + // Algorithm explanation + // + // At the beginning we have + // 1. Final list + // 2. Multiple (or single) arrays in any order + // + // Elements in each array are sorted in 'less' order. + // Assume 'less' order is just asc(id). + // So, may have: + // + // Final list: + // 1 - 2 - 3 - 4 + // + // Pages to merge: + // 7 - 8 - 9 + // 9 - 10 - 12 + // 5 - 6 - 11 + // + // Limit: 7 + // + // Initial finalList that we have can be empty or already have some elements. + + for len(pagesToMerge) > 0 && int64(len(finalList)) < limit { + // If there is only one page, append it without merge + // Final list: 1 - 2 - 3 - 4 + // Page to merge: 5 - 6 - 7 + // Limit: 7 + // + // Final list: 1 - 2 - 3 - 4 - 5 - 6 - 7 + if len(pagesToMerge) == 1 { + var numberOfItemsToTake = int64Min(limit-int64(len(finalList)), int64(len(pagesToMerge[0].items))-pagesToMerge[0].used) + finalList = append(finalList, pagesToMerge[0].items[pagesToMerge[0].used:pagesToMerge[0].used+numberOfItemsToTake]...) + pagesToMerge[0].used += numberOfItemsToTake + break + } + + // If there are multiple pages, execute invariant of loop. + // Invariant of loop: all loaded pages heads have to be arranged in order defined by function ctor.less(a, b). + // Head is page.items[p.used] + // (i) - means head + // If it was: + // Pages to merge: + // (7) - 8 - 9 + // (9) - 10 - 12 + // (5) - 6 - 11 + // + // We should make: + // Pages to merge: + // (5) - 6 - 11 + // (7) - 8 - 9 + // (9) - 10 - 12 + // + // Sort to invariant condition: + var swapped = true + for swapped { + swapped = false + for i := 1; i < len(pagesToMerge); i++ { + if less(pagesToMerge[i].headPlus(0), pagesToMerge[i-1].headPlus(0)) { + pagesToMerge[i], pagesToMerge[i-1] = pagesToMerge[i-1], pagesToMerge[i] + swapped = true + } + } + } + + // Most of the logic will be executed only with 0 and 1 pages in the list, so let's define them. + var first = pagesToMerge[0] + var second = pagesToMerge[1] + + // We should search minimal element from first page, larger than the head from the second one + // (i) - means head + // If it was: + // Pages to merge: + // (5) - 6 - 11 + // (7) - 8 - 9 + // (9) - 10 - 12 + // + // We should make: + // Pages to merge: + // 5 - 6 - (11) + // (7) - 8 - 9 + // (9) - 10 - 12 + var numberOfItemsInFinalList = int64(len(finalList)) + var numberOfItemsToTake int64 = 0 + for numberOfItemsInFinalList+numberOfItemsToTake < limit && + first.isSafeHeadPlus(numberOfItemsToTake) && + less(first.headPlus(numberOfItemsToTake), second.headPlus(0)) { + numberOfItemsToTake++ + } + + // We should search equal elements from all pages to merge and deduplicate them + // Here is very important assumption: + // Duplicates can be presented not more than in two pages. + // + // (i) - means head + // If it was: + // Pages to merge: + // 7 - 8 - (9) + // (9) - 10 - 12 + // 5 - 6 - (11) + // + // We should make: + // Pages to merge: + // 7 - 8 - 9 - () + // 9 - (10) - 12 + // 5 - 6 - (11) + for numberOfItemsInFinalList+numberOfItemsToTake < limit && + first.isSafeHeadPlus(numberOfItemsToTake) && + second.isSafeHeadPlus(0) && + e.equalFunc(first.headPlus(numberOfItemsToTake), second.headPlus(0)) { + numberOfItemsToTake++ + second.used++ + } + + // Not same, not less and not bigger + // Increment numberOfItemsToTake anyway to avoid infinite loop + if numberOfItemsToTake == 0 { + numberOfItemsToTake++ + } + + // Append the smallest items to final page + // (i) - means head + // If it was: + // Final list: 1 - 2 - 3 - 4 + // Pages to merge: + // 5 - 6 - (11) + // (7) - 8 - 9 + // (9) - 10 - 12 + // + // We should make: + // Final list: 1 - 2 - 3 - 4 - 5 - 6 + // Pages to merge: + // 5 - 6 - (11) + // (7) - 8 - 9 + // (9) - 10 - 12 + finalList = append(finalList, first.items[first.used:first.used+numberOfItemsToTake]...) + first.used += numberOfItemsToTake + pagesToMerge[0] = first + pagesToMerge[1] = second + + // Drop pages to merge with all used elements + // (i) - means head + // If it was: + // Pages to merge: + // 7 - 8 - 9 - () + // 9 - (10) - 12 + // 5 - 6 - (11) + // + // We should make: + // Pages to merge: + // 9 - (10) - 12 + // 5 - 6 - (11) + for i := 0; i < len(pagesToMerge); i++ { + if pagesToMerge[i].isSafeHeadPlus(0) { + continue + } + for j := i + 1; j < len(pagesToMerge); j++ { + pagesToMerge[j], pagesToMerge[j-1] = pagesToMerge[j-1], pagesToMerge[j] + } + + var pageToRemove = pagesToMerge[len(pagesToMerge)-1] + if pageToRemove.used == limit { + usedTombstones[pageToRemove.key] = pageToRemove.used + } + + pagesToMerge = pagesToMerge[:len(pagesToMerge)-1] + i-- + } + } + + var lastMergeOffsets map[string]int64 + for _, page := range pagesToMerge { + if page.used == int64(len(page.items)) && int64(len(page.items)) < limit { + continue + } + if lastMergeOffsets == nil { + lastMergeOffsets = map[string]int64{} + } + lastMergeOffsets[page.key] = page.used + } + + for src, offset := range usedTombstones { + if lastMergeOffsets == nil { + lastMergeOffsets = map[string]int64{} + } + lastMergeOffsets[src] = offset + } + + if offsets != nil { + for src := range lastMergeOffsets { + if used, ok := offsets[src]; ok { + lastMergeOffsets[src] += used + } + } + } + offsets = lastMergeOffsets + + return finalList, offsets +} diff --git a/db/search/offsets.go b/db/search/offsets.go new file mode 100644 index 0000000..edb20ed --- /dev/null +++ b/db/search/offsets.go @@ -0,0 +1,29 @@ +package search + +func cutSourcesByOffsets[T Searchable[T]](sources map[string]Searcher[T], offsets map[string]int64) map[string]Searcher[T] { + if offsets == nil { + return sources + } + + for src := range sources { + if _, ok := offsets[src]; !ok { + delete(sources, src) + } + } + + return sources +} + +// nolint:unparam TODO: Add more error handling? +func createNextOffsetBasedPageToken(previousPageToken PageToken, usedFromSources map[string]int64) *PageToken { + if usedFromSources == nil { + return nil + } + + return &PageToken{ + Fields: previousPageToken.Fields, + Offsets: usedFromSources, + Filter: previousPageToken.Filter, + Order: previousPageToken.Order, + } +} diff --git a/db/search/paging.go b/db/search/paging.go new file mode 100644 index 0000000..b7a7e92 --- /dev/null +++ b/db/search/paging.go @@ -0,0 +1,67 @@ +package search + +import ( + "encoding/base64" + "encoding/json" + + "github.com/acronis/perfkit/db" +) + +type PageToken struct { + Fields []string `json:"fields"` + Filter map[string][]string `json:"filter"` + Order []string `json:"order"` + Offsets map[string]int64 `json:"offsets"` + Cursor map[string]string `json:"cursor"` +} + +func (pt *PageToken) HasFilter(key string) bool { + if pt.Filter == nil { + return false + } + f, ok := pt.Filter[key] + return ok && len(f) > 0 +} + +func (pt *PageToken) HasOrder(key string) bool { + if pt.Order == nil { + return false + } + for _, o := range pt.Order { + _, field, err := db.ParseFunc(o) + if err != nil { + return false + } + if key == field { + return true + } + } + return false +} + +func (pt *PageToken) Pack() (string, error) { + var b, err = json.Marshal(&pt) + if err != nil { + return "", err + } + + return base64.StdEncoding.EncodeToString(b), nil +} + +func (pt *PageToken) Unpack(s string) error { + var b, err = base64.StdEncoding.DecodeString(s) + if err != nil { + return err + } + + return json.Unmarshal(b, pt) +} + +func newSelectCtrl(pt PageToken, limit int64, offset int64) *db.SelectCtrl { + return &db.SelectCtrl{ + Fields: pt.Fields, + Page: db.Page{Limit: limit, Offset: offset}, + Where: pt.Filter, + Order: pt.Order, + } +} diff --git a/db/search/paging_test.go b/db/search/paging_test.go new file mode 100644 index 0000000..20e86d7 --- /dev/null +++ b/db/search/paging_test.go @@ -0,0 +1,114 @@ +package search + +import ( + "reflect" + "testing" +) + +func TestPageTokenPacking(t *testing.T) { + var pts, ptd PageToken + var s string + var err error + + var eq = func(l, r PageToken) bool { + return reflect.DeepEqual(l, r) + } + + if s, err = pts.Pack(); err != nil { + t.Error(err) + return + } + + if err = ptd.Unpack(s); err != nil { + t.Error(err) + return + } + + if !eq(pts, ptd) { + t.Error("tokens differ", pts, ptd) + return + } + + pts.Fields = []string{"id", "uuid"} + + if s, err = pts.Pack(); err != nil { + t.Error(err) + return + } + + if err = ptd.Unpack(s); err != nil { + t.Error(err) + return + } + + if !eq(pts, ptd) { + t.Error("tokens differ", pts, ptd) + return + } + + pts.Offsets = map[string]int64{} + pts.Offsets["default:1"] = 100500 + + if s, err = pts.Pack(); err != nil { + t.Error(err) + return + } + + if err = ptd.Unpack(s); err != nil { + t.Error(err) + return + } + + if !eq(pts, ptd) { + t.Error("tokens differ", pts, ptd) + return + } + + pts.Filter = map[string][]string{ + "xk": {"xv"}, + "yk": {"yv1, yv2"}, + "zk": {}, + "nk": nil, + } + + if s, err = pts.Pack(); err != nil { + t.Error(err) + return + } + + if err = ptd.Unpack(s); err != nil { + t.Error(err) + return + } + + if !eq(pts, ptd) { + t.Error("tokens differ", pts, ptd) + return + } +} + +func TestCursorGen(t *testing.T) { + var pt = PageToken{ + Filter: map[string][]string{ + "f1": {"1"}, + }, + Order: []string{"asc(f2)"}, + } + + var ctrl = newSelectCtrl(pt, 10, 0) + + if ctrl.Page.Limit != 10 || ctrl.Page.Offset != 0 { + t.Error("wrong page", ctrl.Page) + return + } + + if len(ctrl.Order) != 1 || ctrl.Order[0] != "asc(f2)" { + t.Error("wrong order", ctrl.Order) + return + } + + if len(ctrl.Where) != 1 || len(ctrl.Where["f1"]) != 1 || ctrl.Where["f1"][0] != "1" { + t.Error("wrong where", ctrl.Where) + return + } +}