datastore: Fix AddIndexes with existing namespaces

impl/memory/datastore_query_execution.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"
         "errors"
         "fmt"
-        "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"
 )
 
 type queryStrategy interface {
         // handle applies the strategy to the embedded user callback.
         //   - rawData is the slice of encoded Properties from the index row
@@ skipping 160 matching lines @@
 
 func executeNamespaceQuery(fq *ds.FinalizedQuery, aid string, head *memStore, cb ds.RawRunCB) error {
         // these objects have no properties, so any filters on properties cause an
         // empty result.
         if len(fq.EqFilters()) > 0 || len(fq.Project()) > 0 || len(fq.Orders()) > 1 {
                 return nil
         }
         if !(fq.IneqFilterProp() == "" || fq.IneqFilterProp() == "__key__") {
                 return nil
         }
-        colls := head.GetCollectionNames()
-        foundEnts := false
         limit, hasLimit := fq.Limit()
         offset, hasOffset := fq.Offset()
         start, end := fq.Bounds()
 
         cursErr := errors.New("cursors not supported for __namespace__ query")
         cursFn := func() (ds.Cursor, error) { return nil, cursErr }
         if !(start == nil && end == nil) {
                 return cursErr
         }
-        for _, c := range colls {
-                if !strings.HasPrefix(c, "ents:") {
-                        if foundEnts {
-                                break
-                        }
-                        continue
-                }
-                foundEnts = true
+        for _, ns := range namespaces(head) {
                 if hasOffset && offset > 0 {
                         offset--
                         continue
                 }
                 if hasLimit {
                         if limit <= 0 {
                                 return ds.Stop
                         }
                         limit--
                 }
                 k := (*ds.Key)(nil)
-                ns := c[len("ents:"):]
                 if ns == "" {
                         // Datastore uses an id of 1 to indicate the default namespace in its
                         // metadata API.
                         k = ds.MakeKey(aid, "", "__namespace__", 1)
                 } else {
                         k = ds.MakeKey(aid, "", "__namespace__", ns)
                 }
                 if err := cb(k, nil, cursFn); err != nil {
                         return err
                 }
@@ skipping 69 matching lines @@
                 keyProp := decodedProps[len(decodedProps)-1]
                 if keyProp.Type() != ds.PTKey {
                         impossible(fmt.Errorf("decoded index row doesn't end with a Key: %#v", keyProp))
                 }
 
                 return strategy.handle(
                         rawData, decodedProps, keyProp.Value().(*ds.Key),
                         getCursorFn(suffix))
         })
 }