Add AutoIndex

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"
         "strings"
 
         ds "github.com/luci/gae/service/datastore"
         "github.com/luci/gae/service/datastore/serialize"
         "github.com/luci/luci-go/common/stringset"
 )
 
+// ErrMissingIndex is returned when the current indexes are not sufficient
+// for the current query.
+type ErrMissingIndex struct {
+        ns      string
+        Missing *ds.IndexDefinition
+}
+
+func (e *ErrMissingIndex) Error() string {
+        yaml, err := e.Missing.YAMLString()
+        if err != nil {
+                panic(err)
+        }
+        return fmt.Sprintf(
+                "Insufficient indexes. Consider adding:\n%s", yaml)
+}
+
 var bjoin = serialize.Join
 
 // 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 {
         ns   string
         kind string
 
@@ skipping 266 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, fmt.Errorf(
-                        "Your indexes are insufficient! Try adding:\n  %s", remains)
+                return nil, &ErrMissingIndex{q.ns, 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 217 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
 }