Interface update, per-method Contexts.

impl/memory/datastore_query.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"
         "encoding/base64"
         "errors"
@@ skipping 136 matching lines @@
                         }
                         if len(upper) > 0 {
                                 hi = increment(serialize.Invert(upper))
                         }
                         upper, lower = lo, hi
                 }
         }
         return
 }
 
-func reduce(fq *ds.FinalizedQuery, aid, ns string, isTxn bool) (*reducedQuery, error) {
-        if err := fq.Valid(aid, ns); err != nil {
+func reduce(fq *ds.FinalizedQuery, kc ds.KeyContext, isTxn bool) (*reducedQuery, error) {
+        if err := fq.Valid(kc); err != nil {
                 return nil, err
         }
         if isTxn && fq.Ancestor() == nil {
                 return nil, fmt.Errorf("queries within a transaction must include an Ancestor filter")
         }
         if num := numComponents(fq); num > MaxQueryComponents {
                 return nil, fmt.Errorf(
                         "gae/memory: query is too large. may not have more than "+
                                 "%d filters + sort orders + ancestor total: had %d",
                         MaxQueryComponents, num)
         }
 
         ret := &reducedQuery{
-                aid:          aid,
-                ns:           ns,
+                kc:           kc,
                 kind:         fq.Kind(),
                 suffixFormat: fq.Orders(),
         }
 
         eqFilts := fq.EqFilters()
         ret.eqFilters = make(map[string]stringset.Set, len(eqFilts))
         for prop, vals := range eqFilts {
                 sVals := stringset.New(len(vals))
                 for _, v := range vals {
                         sVals.Add(string(serialize.ToBytes(v)))
@@ skipping 86 matching lines @@
                 // and the new value has overflowed this representation.
                 //
                 // Fortunately, the first byte of a serialized index column entry is a
                 // PropertyType byte, and the only valid values that we'll be incrementing
                 // are never equal to 0xFF, since they have the high bit set (so either they're
                 // 0x8*, or 0x7*, depending on if it's inverted).
                 impossible(fmt.Errorf("incrementing %v would require more sigfigs", bstr))
         }
         return ret
 }