Refactor keys and queries in datastore service and implementation.

service/datastore/pls_impl.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.
 
 // HEAVILY adapted from github.com/golang/appengine/datastore
 
 package datastore
 
 import (
         "fmt"
@@ skipping 124 matching lines @@
         } else if requireSlice {
                 return "multiple-valued property requires a slice field type"
         }
 
         if ret, ok := doConversion(v); ok {
                 if ret != "" {
                         return ret
                 }
         } else {
                 knd := v.Kind()
-                if v.Type().Implements(typeOfKey) {
-                        knd = reflect.Interface
-                }
 
                 project := PTNull
                 overflow := (func(interface{}) bool)(nil)
                 set := (func(interface{}))(nil)
 
                 switch knd {
                 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
                         project = PTInt
                         overflow = func(x interface{}) bool { return v.OverflowInt(x.(int64)) }
                         set = func(x interface{}) { v.SetInt(x.(int64)) }
                 case reflect.Bool:
                         project = PTBool
                         set = func(x interface{}) { v.SetBool(x.(bool)) }
                 case reflect.String:
                         project = PTString
                         set = func(x interface{}) { v.SetString(x.(string)) }
                 case reflect.Float32, reflect.Float64:
                         project = PTFloat
                         overflow = func(x interface{}) bool { return v.OverflowFloat(x.(float64)) }
                         set = func(x interface{}) { v.SetFloat(x.(float64)) }
-                case reflect.Interface:
+                case reflect.Ptr:
                         project = PTKey
                         set = func(x interface{}) {
-                                if k, ok := x.(Key); ok {
+                                if k, ok := x.(*Key); ok {
                                         v.Set(reflect.ValueOf(k))
                                 }
                         }
                 case reflect.Struct:
                         switch v.Type() {
                         case typeOfTime:
                                 project = PTTime
                                 set = func(x interface{}) { v.Set(reflect.ValueOf(x)) }
                         case typeOfGeoPoint:
                                 project = PTGeoPoint
@@ skipping 299 matching lines @@
                                 }
                         case reflect.Slice:
                                 if reflect.PtrTo(ft.Elem()).Implements(typeOfPropertyConverter) {
                                         st.convert = true
                                 } else if ft.Elem().Kind() == reflect.Struct {
                                         substructType = ft.Elem()
                                 }
                                 st.isSlice = ft.Elem().Kind() != reflect.Uint8
                                 c.hasSlice = c.hasSlice || st.isSlice
                         case reflect.Interface:
-                                if ft != typeOfKey {
-                                        c.problem = me("field %q has non-concrete interface type %s",
-                                                f.Name, f.Type)
-                                        return
-                                }
+                                c.problem = me("field %q has non-concrete interface type %s",
+                                        f.Name, f.Type)
+                                return
                         }
                 }
 
                 if substructType != nil {
                         sub := getStructCodecLocked(substructType)
                         if sub.problem != nil {
                                 if sub.problem == errRecursiveStruct {
                                         c.problem = me("field %q is recursively defined", f.Name)
                                 } else {
                                         c.problem = me("field %q has problem: %s", f.Name, sub.problem)
@@ skipping 67 matching lines @@
                 switch val {
                 case "on", "On", "true":
                         return true, nil
                 case "off", "Off", "false":
                         return false, nil
                 }
                 return nil, fmt.Errorf("Toggle field has bad/missing default, got %q", val)
         }
         return nil, fmt.Errorf("helper: meta field with bad type/value %s/%q", t, val)
 }