Interface update, per-method Contexts.

impl/memory/datastore_index_selection.go

 // Copyright 2015 The LUCI Authors. All rights reserved.
 // Use of this source code is governed under the Apache License, Version 2.0
 // 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
+        kc   ds.KeyContext
         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 139 matching lines @@
                 totalEqFilts++
         }
 
         // ok, we can actually use this
 
         // Grab the collection for convenience later. We don't want to invalidate this
         // index's potential just because the collection doesn't exist. If it's
         // a builtin and it doesn't exist, it still needs to be one of the 'possible'
         // indexes... it just means that the user's query will end up with no results.
         coll := s.GetCollection(
-                fmt.Sprintf("idx:%s:%s", q.ns, serialize.ToBytes(*id.PrepForIdxTable())))
+                fmt.Sprintf("idx:%s:%s", q.kc.Namespace, serialize.ToBytes(*id.PrepForIdxTable())))
 
         // First, see if it's a perfect match. If it is, then our search is over.
         //
         // A perfect match contains ALL the equality filter columns (or more, since
         // we can use residuals to fill in the extras).
         toAdd := indexDefinitionSortable{coll: coll}
         toAdd.eqFilts = eqFilts
         for _, sb := range toAdd.eqFilts {
                 missingTerms.Del(sb.Property)
         }
@@ skipping 101 matching lines @@
                 remains.SortBy = append(remains.SortBy, q.suffixFormat...)
                 last := remains.SortBy[len(remains.SortBy)-1]
                 if !last.Descending {
                         // this removes the __key__ column, since it's implicit.
                         remains.SortBy = remains.SortBy[:len(remains.SortBy)-1]
                 }
                 if remains.Builtin() {
                         impossible(
                                 fmt.Errorf("recommended missing index would be a builtin: %s", remains))
                 }
-                return nil, &ErrMissingIndex{q.ns, remains}
+                return nil, &ErrMissingIndex{q.kc.Namespace, remains}
         }
 
         return idxs, nil
 }
 
 // generate generates a single iterDefinition for the given index.
 func generate(q *reducedQuery, idx *indexDefinitionSortable, c *constraints) *iterDefinition {
         def := &iterDefinition{
                 c:     idx.coll,
                 start: q.start,
@@ skipping 131 matching lines @@
                 ret.constraints[prop] = bvals
         }
         return ret
 }
 
 // getIndexes returns a set of iterator definitions. Iterating over these
 // will result in matching suffixes.
 func getIndexes(q *reducedQuery, s memStore) ([]*iterDefinition, error) {
         relevantIdxs := indexDefinitionSortableSlice(nil)
         if q.kind == "" {
-                if coll := s.GetCollection("ents:" + q.ns); coll != nil {
+                if coll := s.GetCollection("ents:" + q.kc.Namespace); coll != nil {
                         relevantIdxs = indexDefinitionSortableSlice{{coll: coll}}
                 }
         } else {
                 err := error(nil)
                 relevantIdxs, err = getRelevantIndexes(q, s)
                 if err != nil {
                         return nil, err
                 }
         }
         if len(relevantIdxs) == 0 {
@@ skipping 57 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
 }