Add __namespace__ metadata query support to impl/memory.

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 151 matching lines @@
                         return
                 }
         }
         err = executeQuery(fq, aid, ns, isTxn, idx, head, func(_ *ds.Key, _ ds.PropertyMap, _ ds.CursorCB) error {
                 ret++
                 return nil
         })
         return
 }
 
+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
+                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 == "" {

[dnj, 2016/04/16 00:18:26]

WDYT about adding a comment here about how datastore actually uses 1 as key for
empty namesapce, and that this isn't just some trick you're making up here.

[iannucci, 2016/04/16 00:51:52]

Sure. Done.

+                        k = ds.MakeKey(aid, "", "__namespace__", 1)
+                } else {
+                        k = ds.MakeKey(aid, "", "__namespace__", ns)
+                }
+                if err := cb(k, nil, cursFn); err != nil {
+                        return err
+                }
+        }
+        return nil
+}
+
 func executeQuery(fq *ds.FinalizedQuery, aid, ns string, isTxn bool, idx, head *memStore, cb ds.RawRunCB) error {
         rq, err := reduce(fq, aid, ns, isTxn)
         if err == ds.ErrNullQuery {
                 return nil
         }
         if err != nil {
                 return err
         }
 
+        if rq.kind == "__namespace__" {
+                return executeNamespaceQuery(fq, aid, head, cb)
+        }
+
         idxs, err := getIndexes(rq, idx)
         if err == ds.ErrNullQuery {
                 return nil
         }
         if err != nil {
                 return err
         }
 
         strategy := pickQueryStrategy(fq, rq, cb, head)
         if strategy == nil {
@@ skipping 42 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))
         })
 }