Fix memory corruption bug in impl/memory

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 52 matching lines @@
         // metadata describing the total number of columns that this query requires to
         // execute perfectly.
         numCols int
 }
 
 type indexDefinitionSortable struct {
         // eqFilts is the list of ACTUAL prefix columns. Note that it may contain
         // redundant columns! (e.g. (tag, tag) is a perfectly valid prefix, becuase
         // (tag=1, tag=2) is a perfectly valid query).
         eqFilts []ds.IndexColumn
-        coll    *memCollection
+        coll    memCollection
 }
 
 func (i *indexDefinitionSortable) hasAncestor() bool {
         return len(i.eqFilts) > 0 && i.eqFilts[0].Property == "__ancestor__"
 }
 
 func (i *indexDefinitionSortable) numEqHits(c *constraints) int {
         ret := 0
         for _, filt := range i.eqFilts {
                 if _, ok := c.constraints[filt.Property]; ok {
@@ skipping 40 matching lines @@
 // maybeAddDefinition possibly adds a new indexDefinitionSortable to this slice.
 // It's only added if it could be useful in servicing q, otherwise this function
 // is a noop.
 //
 // This returns true iff the proposed index is OK and depletes missingTerms to
 // empty.
 //
 // If the proposed index is PERFECT (e.g. contains enough columns to cover all
 // equality filters, and also has the correct suffix), idxs will be replaced
 // with JUST that index, and this will return true.
-func (idxs *indexDefinitionSortableSlice) maybeAddDefinition(q *reducedQuery, s *memStore, missingTerms stringset.Set, id *ds.IndexDefinition) bool {
+func (idxs *indexDefinitionSortableSlice) maybeAddDefinition(q *reducedQuery, s memStore, missingTerms stringset.Set, id *ds.IndexDefinition) bool {
         // Kindless queries are handled elsewhere.
         if id.Kind != q.kind {
                 impossible(
                         fmt.Errorf("maybeAddDefinition given index with wrong kind %q v %q", id.Kind, q.kind))
         }
 
         // If we're an ancestor query, and the index is compound, but doesn't include
         // an Ancestor field, it doesn't work. Builtin indexes can be used for
         // ancestor queries (and have !Ancestor), assuming that it's only equality
         // filters (plus inequality on __key__), or a single inequality.
@@ skipping 78 matching lines @@
                 *idxs = indexDefinitionSortableSlice{toAdd}
         } else {
                 *idxs = append(*idxs, toAdd)
         }
         return missingTerms.Len() == 0
 }
 
 // getRelevantIndexes retrieves the relevant indexes which could be used to
 // service q. It returns nil if it's not possible to service q with the current
 // indexes.
-func getRelevantIndexes(q *reducedQuery, s *memStore) (indexDefinitionSortableSlice, error) {
+func getRelevantIndexes(q *reducedQuery, s memStore) (indexDefinitionSortableSlice, error) {
         missingTerms := stringset.New(len(q.eqFilters))
         for k := range q.eqFilters {
                 if k == "__ancestor__" {
                         // ancestor is not a prefix which can be satisfied by a single index. It
                         // must be satisfied by ALL indexes (and has special logic for this in
                         // the addDefinition logic)
                         continue
                 }
                 missingTerms.Add(k)
         }
@@ skipping 217 matching lines @@
                         // in ret.original above will be sufficient.
                         continue
                 }
                 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) {
+func getIndexes(q *reducedQuery, s memStore) ([]*iterDefinition, error) {
         relevantIdxs := indexDefinitionSortableSlice(nil)
         if q.kind == "" {
                 if coll := s.GetCollection("ents:" + q.ns); coll != nil {
                         relevantIdxs = indexDefinitionSortableSlice{{coll: coll}}
                 }
         } else {
                 err := error(nil)
                 relevantIdxs, err = getRelevantIndexes(q, s)
                 if err != nil {
                         return nil, err
@@ skipping 60 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
 }