Refactor keys and queries in datastore service and implementation.

service/datastore/pls_test.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.
 
 // adapted from github.com/golang/appengine/datastore
 
 package datastore
 
 import (
         "bytes"
@@ skipping 106 matching lines @@
 
 type G0 struct {
         G GeoPoint
 }
 
 type G1 struct {
         G []GeoPoint
 }
 
 type K0 struct {
-        K Key
+        K *Key
 }
 
 type K1 struct {
-        K []Key
+        K []*Key
 }
 
 type N0 struct {
         X0
         ID       int64  `gae:"$id"`
         _kind    string `gae:"$kind,whatnow"`
         Nonymous X0
         Ignore   string `gae:"-"`
         Other    string
 }
@@ skipping 182 matching lines @@
 }
 
 type Underspecified struct {
         Iface PropertyConverter
 }
 
 type MismatchTypes struct {
         S  string
         B  bool
         F  float32
-        K  Key
+        K  *Key
         T  time.Time
         G  GeoPoint
         IS []int
 }
 
 type BadMeta struct {
         ID int64  `gae:"$id"`
         id string `gae:"$id"`
 }
 
@@ skipping 175 matching lines @@
                 *c = Complex(complex(gval.Lat, gval.Lng))
                 return nil
         }
         return fmt.Errorf("nope")
 }
 
 type Impossible4 struct {
         Values []Complex
 }
 
-// TODO(riannucci): see if there's a way to NOT have this be a duplicate of
-// key.Generic. I couldn't figure out the package interdependency, and this
-// allows things to be in separate packages.
-type genericKey struct {
-        kind string
-        sid  string
-        iid  int64
-
-        aid string
-        ns  string
-
-        parent *genericKey
-}
-
-func (g *genericKey) Kind() string      { return g.kind }
-func (g *genericKey) StringID() string  { return g.sid }
-func (g *genericKey) IntID() int64      { return g.iid }
-func (g *genericKey) AppID() string     { return g.aid }
-func (g *genericKey) Namespace() string { return g.ns }
-func (g *genericKey) Parent() Key       { return g.parent }
-
-func marshalDSKey(b *bytes.Buffer, k *genericKey) {
-        if k.parent != nil {
-                marshalDSKey(b, k.parent)
-        }
-        b.WriteByte('/')
-        b.WriteString(k.kind)
-        b.WriteByte(',')
-        if k.sid != "" {
-                b.WriteString(k.sid)
-        } else {
-                b.WriteString(strconv.FormatInt(k.iid, 10))
-        }
-}
-
-func (g *genericKey) String() string {
-        if g == nil {
-                return ""
-        }
-        b := bytes.NewBuffer(make([]byte, 0, 512))
-        marshalDSKey(b, g)
-        return b.String()
-}
-
-func (g *genericKey) Incomplete() bool {
-        return g.iid == 0 && g.sid == ""
-}
-
-func (g *genericKey) Valid(allowSpecial bool, aid, ns string) bool {
-        if g == nil {
-                return false
-        }
-        if aid != g.AppID() || ns != g.Namespace() {
-                return false
-        }
-        for ; g != nil; g = g.parent {
-                if !allowSpecial && len(g.Kind()) >= 2 && g.Kind()[:2] == "__" {
-                        return false
-                }
-                if g.Kind() == "" || g.AppID() == "" {
-                        return false
-                }
-                if g.StringID() != "" && g.IntID() != 0 {
-                        return false
-                }
-                if g.parent != nil {
-                        if g.parent.Incomplete() {
-                                return false
-                        }
-                        if g.parent.AppID() != g.AppID() || g.parent.Namespace() != g.Namespace() {
-                                return false
-                        }
-                }
-        }
-        return true
-}
-
-func (g *genericKey) PartialValid(aid, ns string) bool {
-        if g.Incomplete() {
-                g = mkKey(g.AppID(), g.Namespace(), g.Kind(), 1, g.Parent()).(*genericKey)
-        }
-        return g.Valid(false, aid, ns)
-}
-
-var _ Key = (*genericKey)(nil)
-
-func mkKey(aid, ns string, pairs ...interface{}) Key {
-        ret := (*genericKey)(nil)
-        if len(pairs)%2 != 0 {
-                ret, _ = pairs[len(pairs)-1].(*genericKey)
-                pairs = pairs[:len(pairs)-1]
-        }
-        for i := 0; i < len(pairs); i += 2 {
-                kind := pairs[i].(string)
-                id := pairs[i+1]
-                ret = &genericKey{
-                        kind:   kind,
-                        aid:    aid,
-                        ns:     ns,
-                        parent: ret,
-                }
-                ret.sid, _ = id.(string)
-                iid, ok := id.(int)
-                if ok {
-                        ret.iid = int64(iid)
-                } else {
-                        ret.iid, _ = id.(int64)
-                }
-        }
-        return ret
-}
-
 type DerivedKey struct {
-        K *genericKey
+        K *Key
 }
 
 type IfaceKey struct {
-        K Key
+        K *Key
 }
 
 type testCase struct {
         desc       string
         src        interface{}
         want       interface{}
         plsErr     string
         saveErr    string
         plsLoadErr string
         loadErr    string
@@ skipping 70 matching lines @@
                 src:  &K0{K: testKey2a},
                 want: &K0{K: testKey2b},
         },
         {
                 desc: "nil key",
                 src:  &K0{},
                 want: &K0{},
         },
         {
                 desc: "all nil keys in slice",
-                src:  &K1{[]Key{nil, nil}},
-                want: &K1{[]Key{nil, nil}},
+                src:  &K1{[]*Key{nil, nil}},
+                want: &K1{[]*Key{nil, nil}},
         },
         {
                 desc: "some nil keys in slice",
-                src:  &K1{[]Key{testKey1a, nil, testKey2a}},
-                want: &K1{[]Key{testKey1b, nil, testKey2b}},
+                src:  &K1{[]*Key{testKey1a, nil, testKey2a}},
+                want: &K1{[]*Key{testKey1b, nil, testKey2b}},
         },
         {
                 desc:    "overflow",
                 src:     &O0{I: 1 << 48},
                 want:    &O1{},
                 loadErr: "overflow",
         },
         {
                 desc: "time",
                 src:  &T{T: time.Unix(1e9, 0).UTC()},
@@ skipping 147 matching lines @@
                                 mp(GeoPoint{Lat: 1, Lng: 2}), mp(GeoPoint{Lat: 3, Lng: 4})},
                 },
         },
         {
                 desc:    "convertable complex slice (bad load)",
                 src:     PropertyMap{"Values": {mp("hello")}},
                 want:    &Impossible4{[]Complex(nil)},
                 loadErr: "nope",
         },
         {
-                desc: "allow concrete Key implementors (save)",
-                src:  &DerivedKey{testKey2a.(*genericKey)},
+                desc: "allow concrete *Key implementors (save)",
+                src:  &DerivedKey{testKey2a},
                 want: &IfaceKey{testKey2b},
         },
         {
-                desc: "allow concrete Key implementors (load)",
+                desc: "allow concrete *Key implementors (load)",
                 src:  &IfaceKey{testKey2b},
-                want: &DerivedKey{testKey2a.(*genericKey)},
+                want: &DerivedKey{testKey2a},
         },
         {
                 desc:    "save []float64 load []int64",
                 src:     &Y0{B: true, F: []float64{7, 8, 9}},
                 want:    &Y2{B: true},
                 loadErr: "type mismatch",
         },
         {
                 desc:    "single slice is too long",
                 src:     &Y0{F: make([]float64, maxIndexedProperties+1)},
@@ skipping 166 matching lines @@
                                 mp(nil),
                                 mp(7),
                                 mp(nil),
                         },
                 },
                 want: &struct {
                         I int64
                         B bool
                         S string
                         F float64
-                        K Key
+                        K *Key
                         T time.Time
                         J []int64
                 }{
                         J: []int64{0, 7, 0},
                 },
         },
         {
                 desc: "save outer load props",
                 src: &Outer{
                         A: 1,
@@ skipping 706 matching lines @@
 
                 Convey("Bad default meta type", func() {
                         type BadDefault struct {
                                 Val time.Time `gae:"$meta,tomorrow"`
                         }
                         pls := GetPLS(&BadDefault{})
                         So(pls.Problem().Error(), ShouldContainSubstring, "bad type")
                 })
         })
 }