Make impl/memory have an AppID.

impl/memory/datastore_index_selection.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"
         "fmt"
         "sort"
@@ skipping 18 matching lines @@
         }
         return fmt.Sprintf(
                 "Insufficient indexes. Consider adding:\n%s", yaml)
 }
 
 // reducedQuery contains only the pieces of the query necessary to iterate for
 // results.
 //   deduplication is applied externally
 //   projection / keysonly / entity retrieval is done externally
 type reducedQuery struct {
+        aid  string
         ns   string
         kind string
 
         // eqFilters indicate the set of all prefix constraints which need to be
         // fulfilled in the composite query. All of these will translate into prefix
         // bytes for SOME index.
         eqFilters map[string]stringset.Set
 
         // suffixFormat is the PRECISE listing of the suffix columns that ALL indexes
         //   in the multi query will have.
@@ skipping 322 matching lines @@
                 if q.suffixFormat[0].Descending {
                         chopped = serialize.Invert(chopped)
                 }
                 def.prefix = serialize.Join(def.prefix, chopped)
 
                 // Update start and end, since we know that if they contain anything, they
                 // contain values for the __key__ field.
                 if def.start != nil {
                         offset := 0
                         if len(q.suffixFormat) > 1 {
-                                chunks, _ := parseSuffix(q.ns, q.suffixFormat, def.start, 1)
+                                chunks, _ := parseSuffix(q.aid, q.ns, q.suffixFormat, def.start, 1)
                                 offset = len(chunks[0])
                         }
                         if !bytes.HasPrefix(def.start[offset:], chopped) {
                                 // again, shouldn't happen, but if it does, we want to know about it.
                                 impossible(fmt.Errorf(
                                         "start suffix for implied ancestor doesn't start with ancestor! start:%v ancestor:%v",
                                         def.start, chopped))
                         }
                         def.start = def.start[:offset+len(chopped)]
                 }
                 if def.end != nil {
                         offset := 0
                         if len(q.suffixFormat) > 1 {
-                                chunks, _ := parseSuffix(q.ns, q.suffixFormat, def.end, 1)
+                                chunks, _ := parseSuffix(q.aid, q.ns, q.suffixFormat, def.end, 1)
                                 offset = len(chunks[0])
                         }
                         if !bytes.HasPrefix(def.end[offset:], chopped) {
                                 impossible(fmt.Errorf(
                                         "end suffix for implied ancestor doesn't start with ancestor! end:%v ancestor:%v",
                                         def.end, chopped))
                         }
                         def.end = def.end[:offset+len(chopped)]
                 }
         }
@@ skipping 140 matching lines @@
                 if bestIdx == nil {
                         // something is really wrong here... if relevantIdxs is !nil, then we
                         // should always be able to make progress in this loop.
                         impossible(fmt.Errorf("deadlock: cannot fulfil query?"))
                 }
                 ret = append(ret, generate(q, bestIdx, constraints))
         }
 
         return ret, nil
 }