Add initial Query generation, correctness checking and index generation.

go/src/infra/gae/libs/wrapper/memory/key.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"
         "errors"
         "fmt"
@@ skipping 86 matching lines @@
         withNS nsOption = true
         noNS            = false
 )
 
 func keyBytes(nso nsOption, k *datastore.Key) []byte {
         buf := &bytes.Buffer{}
         writeKey(buf, nso, k)
         return buf.Bytes()
 }
 
-func keyFromByteString(nso nsOption, d string) (*datastore.Key, error) {
-        return readKey(bytes.NewBufferString(d), nso)
+func keyFromByteString(nso nsOption, d string, ns string) (*datastore.Key, error) {
+        return readKey(bytes.NewBufferString(d), nso, ns)
 }
 
 func writeKey(buf *bytes.Buffer, nso nsOption, k *datastore.Key) {
         // namespace ++ #tokens ++ [tok.kind ++ tok.stringID ++ tok.intID?]*
         namespace, toks := keyToToks(k)
         if nso == withNS {
                 writeString(buf, namespace)
         }
         funnybase.WriteUint(buf, uint64(len(toks)))
         for _, tok := range toks {
                 writeString(buf, tok.kind)
                 writeString(buf, tok.stringID)
                 if tok.stringID == "" {
                         funnybase.WriteUint(buf, tok.intID)
                 }
         }
 }
 
-func readKey(buf *bytes.Buffer, nso nsOption) (*datastore.Key, error) {
-        namespace := ""
+func readKey(buf *bytes.Buffer, nso nsOption, ns string) (*datastore.Key, error) {
+        namespace := ns
         if nso == withNS {
                 err := error(nil)
                 if namespace, err = readString(buf); err != nil {
                         return nil, err
                 }
         }
 
         numToks, err := funnybase.ReadUint(buf)
         if err != nil {
                 return nil, err
@@ skipping 88 matching lines @@
 // keyCouldBeValid is like keyValid, but it allows for the possibility that the
 // last token of the key is Incomplete(). It returns true if the Key will become
 // valid once it recieves an automatically-assigned ID.
 func keyCouldBeValid(ns string, k *datastore.Key, opt keyValidOption) bool {
         // adds an id to k if it's incomplete.
         if k.Incomplete() {
                 k = newKey(ns, k.Kind(), "", 1, k.Parent())
         }
         return keyValid(ns, k, opt)
 }