forked from longtao.wu/droboticflow
95 lines
2.3 KiB
Go
95 lines
2.3 KiB
Go
package store
|
|
|
|
import (
|
|
"fmt"
|
|
"sort"
|
|
|
|
"go.mongodb.org/mongo-driver/bson"
|
|
)
|
|
|
|
// Group only IDENTICAL version sets. Flattening all revisions into one global
|
|
// $in would read unrelated historical versions. Rare sets retain the old OR
|
|
// batches, so fragmented legacy histories do not turn into one query per task.
|
|
func workforceSliceReadFilters(versions map[string]map[int]bool, grouped bool) []bson.M {
|
|
type group struct {
|
|
ids []string
|
|
revisions []int
|
|
}
|
|
groups := map[string]*group{}
|
|
ids := make([]string, 0, len(versions))
|
|
for id := range versions {
|
|
ids = append(ids, id)
|
|
}
|
|
sort.Strings(ids)
|
|
if !grouped {
|
|
return workforceLegacySliceFilters(nil, ids, versions)
|
|
}
|
|
for _, id := range ids {
|
|
revs := []int{}
|
|
for v := range versions[id] {
|
|
revs = append(revs, v)
|
|
}
|
|
sort.Ints(revs)
|
|
key := fmt.Sprint(revs)
|
|
g := groups[key]
|
|
if g == nil {
|
|
g = &group{revisions: revs}
|
|
groups[key] = g
|
|
}
|
|
g.ids = append(g.ids, id)
|
|
}
|
|
filters := []bson.M{}
|
|
keys := []string{}
|
|
for k := range groups {
|
|
keys = append(keys, k)
|
|
}
|
|
sort.Strings(keys)
|
|
left := []string{}
|
|
for _, key := range keys {
|
|
g := groups[key]
|
|
if len(g.ids) < 200 {
|
|
left = append(left, g.ids...)
|
|
continue
|
|
}
|
|
batch := []string{}
|
|
bytes := 128 + len(g.revisions)*16
|
|
flush := func() {
|
|
if len(batch) > 0 {
|
|
filters = append(filters, bson.M{"taskId": bson.M{"$in": batch}, "revision": bson.M{"$in": g.revisions}})
|
|
}
|
|
batch = nil
|
|
bytes = 128 + len(g.revisions)*16
|
|
}
|
|
for _, id := range g.ids {
|
|
if len(batch) >= 2000 || (len(batch) > 0 && bytes+len(id)+16 > 256<<10) {
|
|
flush()
|
|
}
|
|
batch = append(batch, id)
|
|
bytes += len(id) + 16
|
|
}
|
|
flush()
|
|
}
|
|
sort.Strings(left)
|
|
return workforceLegacySliceFilters(filters, left, versions)
|
|
}
|
|
|
|
func workforceLegacySliceFilters(filters []bson.M, ids []string, versions map[string]map[int]bool) []bson.M {
|
|
clauses := bson.A{}
|
|
for _, id := range ids {
|
|
revs := []int{}
|
|
for v := range versions[id] {
|
|
revs = append(revs, v)
|
|
}
|
|
sort.Ints(revs)
|
|
clauses = append(clauses, bson.M{"taskId": id, "revision": bson.M{"$in": revs}})
|
|
if len(clauses) == 200 {
|
|
filters = append(filters, bson.M{"$or": clauses})
|
|
clauses = nil
|
|
}
|
|
}
|
|
if len(clauses) > 0 {
|
|
filters = append(filters, bson.M{"$or": clauses})
|
|
}
|
|
return filters
|
|
}
|