Switch to external stringset implementation.

impl/memory/datastore_query.go

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package memory
 
 import (
         "bytes"
         "encoding/base64"
         "errors"
         "fmt"
         "math"
         "strings"
 
         ds "github.com/luci/gae/service/datastore"
         "github.com/luci/gae/service/datastore/serialize"
         "github.com/luci/luci-go/common/cmpbin"
+        "github.com/luci/luci-go/common/stringset"
 )
 
 // MaxQueryComponents was lifted from a hard-coded constant in dev_appserver.
 // No idea if it's a real limit or just a convenience in the current dev
 // appserver implementation.
 const MaxQueryComponents = 100
 
 var errQueryDone = errors.New("query is done")
 
 type queryOp int
@@ skipping 130 matching lines @@
         return false
 }
 
 type queryImpl struct {
         ns string
 
         kind string
 
         // prop -> encoded values (which are ds.Property objects)
         // "__ancestor__" is the key for Ancestor queries.
-        eqFilters          map[string]stringSet
+        eqFilters          map[string]stringset.Set
         ineqFilter         queryIneqFilter
         order              []ds.IndexColumn
         startCursor        []byte
         startCursorColumns []ds.IndexColumn
         endCursor          []byte
         endCursorColumns   []ds.IndexColumn
 
         // All of these are applied in post (e.g. not during the native index scan).
         distinct            bool
         eventualConsistency bool
@@ skipping 40 matching lines @@
                         MaxQueryComponents, q.numComponents())
         }
         if len(q.project) == 0 && q.distinct {
                 // This must be delayed, because q.Distinct().Project("foo") is a valid
                 // construction. If we checked this in Distinct, it could be too early, and
                 // checking it in Project doesn't matter.
                 return nil, errors.New(
                         "gae/memory: Distinct() only makes sense on projection queries.")
         }
         if q.eqFilters["__ancestor__"] != nil && q.ineqFilter.prop == "__key__" {
-                anc := []byte(nil)
-                for k := range q.eqFilters["__ancestor__"] {
-                        anc = []byte(k)
-                        break
-                }
-                anc = anc[:len(anc)-1]
+                ancS, _ := q.eqFilters["__ancestor__"].Peek()
+                anc := []byte(ancS[:len(ancS)-1])
                 if q.ineqFilter.start != nil && !bytes.HasPrefix(q.ineqFilter.start, anc) {
                         return nil, errors.New(
                                 "gae/memory: __key__ inequality filter has a value outside of Ancestor()")
                 }
                 if q.ineqFilter.end != nil && !bytes.HasPrefix(q.ineqFilter.end, anc) {
                         return nil, errors.New(
                                 "gae/memory: __key__ inequality filter has a value outside of Ancestor()")
                 }
         }
 
@@ skipping 104 matching lines @@
         // overlapping range ends, then we don't have anything to do.
         if ret.end != nil && bytes.Compare(ret.start, ret.end) >= 0 {
                 return nil, errQueryDone
         }
 
         ret.numCols = len(ret.suffixFormat)
         for prop, vals := range ret.eqFilters {
                 if len(ret.suffixFormat) == 1 && prop == "__ancestor__" {
                         continue
                 }
-                ret.numCols += len(vals)
+                ret.numCols += vals.Len()
         }
 
         return ret, nil
 }
 
 func (q *queryImpl) numComponents() int {
         numComponents := len(q.order)
         if q.ineqFilter.prop != "" {
                 if q.ineqFilter.start != nil {
                         numComponents++
                 }
                 if q.ineqFilter.end != nil {
                         numComponents++
                 }
         }
         for _, v := range q.eqFilters {
-                numComponents += len(v)
+                numComponents += v.Len()
         }
         return numComponents
 }
 
 // checkMutateClone sees if the query has an error. If not, it clones the query,
 // and assigns the output of `check` to the query error slot. If check returns
 // nil, it calls `mutate` on the cloned query. The (possibly new) query is then
 // returned.
 func (q *queryImpl) checkMutateClone(check func() error, mutate func(*queryImpl)) *queryImpl {
         if q.err != nil {
                 return q
         }
         nq := *q
-        nq.eqFilters = make(map[string]stringSet, len(q.eqFilters))
+        nq.eqFilters = make(map[string]stringset.Set, len(q.eqFilters))
         for prop, vals := range q.eqFilters {
-                nq.eqFilters[prop] = vals.dup()
+                nq.eqFilters[prop] = vals.Dup()
         }
         nq.order = make([]ds.IndexColumn, len(q.order))
         copy(nq.order, q.order)
         nq.project = make([]string, len(q.project))
         copy(nq.project, q.project)
         if check != nil {
                 nq.err = check()
         }
         if nq.err == nil {
                 mutate(&nq)
@@ skipping 31 matching lines @@
 
 func (q *queryImpl) Distinct() ds.Query {
         return q.checkMutateClone(nil, func(q *queryImpl) {
                 q.distinct = true
         })
 }
 
 func (q *queryImpl) addEqFilt(prop string, p ds.Property) {
         binVal := string(serialize.ToBytes(p))
         if cur, ok := q.eqFilters[prop]; !ok {
-                q.eqFilters[prop] = stringSet{binVal: {}}
+                s := stringset.New(1)
+                s.Add(binVal)
+                q.eqFilters[prop] = s
         } else {
-                cur.add(binVal)
+                cur.Add(binVal)
         }
 }
 
 func (q *queryImpl) Filter(fStr string, val interface{}) ds.Query {
         prop := ""
         op := qInvalid
         p := ds.Property{}
         return q.checkMutateClone(
                 func() error {
                         var err error
@@ skipping 120 matching lines @@
                         q.order = append(q.order, col)
                 })
 }
 
 func (q *queryImpl) Project(fieldName ...string) ds.Query {
         return q.checkMutateClone(
                 func() error {
                         if q.keysOnly {
                                 return errors.New("cannot project a keysOnly query")
                         }
-                        dupCheck := stringSet{}
+                        dupCheck := stringset.New(len(fieldName) + len(q.project))
                         for _, f := range fieldName {
-                                if !dupCheck.add(f) {
+                                if !dupCheck.Add(f) {
                                         return fmt.Errorf("cannot project on the same field twice: %q", f)
                                 }
                                 if f == "" {
                                         return errors.New("cannot project on an empty field name")
                                 }
                                 if f == "__key__" {
                                         return fmt.Errorf("cannot project on __key__")
                                 }
                                 if _, ok := q.eqFilters[f]; ok {
                                         return fmt.Errorf(
@@ skipping 94 matching lines @@
                         q.endCursor = curs
                 })
 }
 
 func (q *queryImpl) EventualConsistency() ds.Query {
         return q.checkMutateClone(
                 nil, func(q *queryImpl) {
                         q.eventualConsistency = true
                 })
 }