Add transaction buffer filter.

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 111 matching lines @@
         for i, sb := range sortBy[numEqFilts:] {
                 if q.suffixFormat[i] != sb {
                         return false
                 }
         }
 
         if id.Builtin() && numEqFilts == 0 {
                 if len(q.eqFilters) > 1 || (len(q.eqFilters) == 1 && q.eqFilters["__ancestor__"] == nil) {
                         return false
                 }
+                if len(sortBy) > 1 && q.eqFilters["__ancestor__"] != nil {
+                        return false
+                }
         }
 
         // Make sure the equalities section doesn't contain any properties we don't
         // want in our query.
         //
         // numByProp && totalEqFilts will be used to see if this is a perfect match
         // later.
         numByProp := make(map[string]int, len(q.eqFilters))
         totalEqFilts := 0
 
@@ skipping 187 matching lines @@
                 // anything which is a descendant or an exact match.  Removing the last byte
                 // from the key (the terminating null) allows this trick to work. Otherwise
                 // it would be a closed range of EXACTLY this key.
                 chopped := []byte(anc[:len(anc)-1])
                 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.
+                // contain values for the __key__ field. This is necessary because bytes
+                // are shifting from the suffix to the prefix, and start/end should only
+                // contain suffix (variable) bytes.
                 if def.start != nil {
-                        offset := 0
-                        if len(q.suffixFormat) > 1 {
-                                chunks, _ := parseSuffix(q.ns, q.suffixFormat, def.start, 1)
-                                offset = len(chunks[0])
-                        }

[iannucci, 2015/09/29 04:43:27]

So it turned out that these were just wrong. These assumed that it was possible
to have an inequality AND an ancestor AND fill it with a builtin query. This is
not a possible combination, and there's now a check in maybeAddDefinition above
that will prevent this.

-                        if !bytes.HasPrefix(def.start[offset:], chopped) {
+                        if !bytes.HasPrefix(def.start, 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)]
+                        def.start = def.start[len(chopped):]
                 }
                 if def.end != nil {
-                        offset := 0
-                        if len(q.suffixFormat) > 1 {
-                                chunks, _ := parseSuffix(q.ns, q.suffixFormat, def.end, 1)
-                                offset = len(chunks[0])
-                        }
-                        if !bytes.HasPrefix(def.end[offset:], chopped) {
+                        if !bytes.HasPrefix(def.end, 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)]
+                        def.end = def.end[len(chopped):]
                 }
         }
 
         return def
 }
 
 type constraints struct {
         constraints     map[string][][]byte
         original        map[string][][]byte
         residualMapping map[string]int
@@ skipping 132 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
 }