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 149 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 200 matching lines @@
                         if len(q.suffixFormat) > 1 {
                                 chunks, _ := parseSuffix(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)]
+                        def.start = def.start[offset+len(chopped):]

[Vadim Sh., 2015/09/28 18:52:56]

diffs like this look scary.. Was there a bug here?

[iannucci, 2015/09/29 03:21:37]

Yeah there was. I fixed the tests for this too. Basically if you had an
inequality on __key__ and also had an ancestor and also ended up selecting a
built-in index, then this would incorrectly set the start/end points.

I actually had tests for these, but the expectations in the tests were totally
wrong >_<.

Now that you pointed it out, however, I was able to delete some more code here
which was an impossible case (the if statement above would only happen if you
had an inequality and an ancestor and a built-in index... but that's impossible!
if you look at the index listing on real appengine
(https://cloud.google.com/appengine/docs/go/datastore/indexes#Go_Index_configu...),
you can see that "Queries with ancestor and inequality filters" require new
indexes).

I also added some clarifying comment to this section.

                 }
                 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) {
                                 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[offset+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
 }