Paquete google.golang.org/appengine/datastore (v1.6.8)

Version latest

• 1.6.8 (latest)
• 1.6.7

Nota: Para obtener más información sobre este paquete, como el acceso a versiones anteriores, consulta este paquete en pkg.go.dev.

El almacén de datos en paquete proporciona un cliente para el servicio del almacén de datos de App Engine.

Operaciones básicas

Las entidades son la unidad de almacenamiento y se asocian con una clave. Una clave consiste en una clave principal opcional, un ID de aplicación de una string, una categoría de string (también conocida como tipo de entidad) y una StringID o una IntID. Un StringID también se conoce como un nombre de entidad o nombre de clave.

Es válido crear una clave con IntID cero y StringID cero; esto se denomina clave incompleta y no hace referencia a ninguna entidad guardada. Poner una entidad en el almacén de datos bajo una clave incompleta hará que se genere una clave única para esa entidad, con IntID distinto de cero.

El contenido de una entidad es una asignación de nombres de campos que distinguen entre mayúsculas y minúsculas con valores. Los tipos de valor válidos son los siguientes:

• números enteros con signo (int, int8, int16, int32 e int64)
• bool,
• string,
• float32 y float64,
• []byte (hasta 1 megabyte) de longitud
• cualquier tipo cuyo tipo subyacente sea uno de los anteriores,
• ByteString,
• *Key,
• time.Time (almacenado con precisión de microsegundos).
• appengine.BlobKey,
• appengine.GeoPoint,
• structs cuyos campos son todos tipos de valores válidos,
• porciones de cualquiera de las anteriores.

Las porciones de las estructuras son válidas, como lo son las estructuras que contienen porciones. Sin embargo, si una estructura contiene otra, entonces, como máximo, se puede repetir una de ellas. Esto descalifica los tipos de estructura definidos recursivamente: cualquier estructura T que (directa o indirectamente) contenga una []T.

Las funciones Get y Put cargan y guardan el contenido de una entidad. El contenido de una entidad lo representa típicamente un puntero a estructura.

Código de ejemplo:

type Entity struct {
    Value string
}

func handle(w http.ResponseWriter, r *http.Request) {
    ctx := appengine.NewContext(r)

    k := datastore.NewKey(ctx, "Entity", "stringID", 0, nil)
    e := new(Entity)
    if err := datastore.Get(ctx, k, e); err != nil {
        http.Error(w, err.Error(), 500)
        return
    }

    old := e.Value
    e.Value = r.URL.Path

    if _, err := datastore.Put(ctx, k, e); err != nil {
        http.Error(w, err.Error(), 500)
        return
    }

    w.Header().Set("Content-Type", "text/plain; charset=utf-8")
    fmt.Fprintf(w, "old=%q\nnew=%q\n", old, e.Value)
}

GetMulti, PutMulti y DeleteMulti son versiones por lotes de las funciones Get, Put y Delete. Toman una []*Clave en lugar de una *Clave, y pueden mostrar un appengine.MultiError cuando encuentran una falla parcial.

Propiedades

El contenido de una entidad puede representarse mediante diferentes tipos. Estos son típicamente punteros a estructura, pero también pueden ser cualquier tipo que implemente la interfaz PropertyLoadSaver. Si usas un puntero a estructura, no tienes que implementar explícitamente la interfaz PropertyLoadSaver; el almacén de datos se convertirá automáticamente mediante reflexión. Si un puntero a estructura implementa esa interfaz, esos métodos se utilizarán con preferencia al comportamiento predeterminado para los punteros a estructura. Los punteros a estructura están más tipificados y son más fáciles de usar; los PropertyLoadSavers son más flexibles.

Los tipos reales que se pasan no tienen que coincidir entre las llamadas Get y Put, o incluso entre diferentes llamadas al almacén de datos. Es válido poner *PropertyList y obtener la misma entidad que *myStruct, o poner *myStruct0 y obtener *myStruct1. Conceptualmente, cualquier entidad se guarda como una secuencia de propiedades y se carga en el valor de destino en una base de propiedad por propiedad. Cuando se carga en un puntero a estructura, una entidad que no se puede representar completamente (como un campo que falta) generará un error ErrFieldMismatch, pero depende de quién hace la llamada si este error es total, recuperable o susceptible de que se lo pase por alto.

De forma predeterminada, para los punteros a estructura, todas las propiedades están potencialmente indexadas, y el nombre de la propiedad es el mismo que el nombre del campo (y, por lo tanto, debe comenzar con una letra en mayúscula).

Los campos pueden tener una etiqueta datastore:"name,options". El nombre de la etiqueta es el nombre de la propiedad, que debe ser uno o más identificadores de Go válidos unidos por ".", pero puede comenzar con una letra en minúscula. Un nombre de etiqueta vacío significa que simplemente se usará el nombre del campo. Si el nombre de la etiqueta es "-", el almacén de datos pasará por alto ese campo.

Las únicas opciones válidas son “omitempty” y “firestore”.

Si las opciones incluyen "omitempty" y el valor del campo está vacío, el campo se omitirá en Guardar. Los valores vacíos son false, 0, cualquier valor de interfaz nulo y cualquier array, porción, mapa o string de longitud cero. Los valores del campo struct nunca estarán vacíos.

Si la opción incluye "noindex", el campo no se indexará. Todos los campos se indexan de forma predeterminada. Las strings o los segmentos de bytes con más de 1,500 bytes no se pueden indexar; los campos que se usan para almacenar strings largas y fragmentos de bytes deben estar etiquetados con “getIamPolicy” o provocarán que las operaciones Put fallen.

Para usar varias opciones, sepáralas con una coma. El orden no es importante.

Si la opción es "", entonces se puede omitir la coma.

Código de ejemplo:

// A and B are renamed to a and b.
// A, C and J are not indexed.
// D's tag is equivalent to having no tag at all (E).
// I is ignored entirely by the datastore.
// J has tag information for both the datastore and json packages.
type TaggedStruct struct {
    A int `datastore:"a,noindex"`
    B int `datastore:"b"`
    C int `datastore:",noindex"`
    D int `datastore:""`
    E int
    I int `datastore:"-"`
    J int `datastore:",noindex" json:"j"`
}

Propiedades estructuradas

Si la estructura a la que se apunta contiene otras estructuras, las estructuras anidadas o incrustadas se acoplan. Por ejemplo, dadas las siguientes definiciones:

type Inner1 struct {
    W int32
    X string
}

type Inner2 struct {
    Y float64
}

type Inner3 struct {
    Z bool
}

type Outer struct {
    A int16
    I []Inner1
    J Inner2
    Inner3
}

entonces las propiedades de un Outer serían equivalentes a las siguientes:

type OuterEquivalent struct {
    A     int16
    IDotW []int32  `datastore:"I.W"`
    IDotX []string `datastore:"I.X"`
    JDotY float64  `datastore:"J.Y"`
    Z     bool
}

Si el campo Inner3 incorporado de Outer se etiquetó como datastore:"Foo", entonces el campo equivalente sería: FooDotZ bool datastore:"Foo.Z".

Si una estructura externa se etiqueta como "noindex", todos sus campos acoplados implícitos son efectivamente "noindex".

La interfaz PropertyLoadSaver

El contenido de una entidad también puede representarse mediante cualquier tipo que implemente la interfaz PropertyLoadSaver. Este tipo puede ser un puntero a estructura, pero no tiene que serlo. El paquete del almacén de datos llamará a Load cuando obtenga los contenidos de la entidad, y a Save cuando ponga los contenidos de la entidad. Entre los usos posibles, se incluyen derivar campos no almacenados, verificar campos o indexar un campo solo si su valor es positivo.

Código de ejemplo:

type CustomPropsExample struct {
    I, J int
    // Sum is not stored, but should always be equal to I + J.
    Sum int `datastore:"-"`
}

func (x *CustomPropsExample) Load(ps []datastore.Property) error {
    // Load I and J as usual.
    if err := datastore.LoadStruct(x, ps); err != nil {
        return err
    }
    // Derive the Sum field.
    x.Sum = x.I + x.J
    return nil
}

func (x *CustomPropsExample) Save() ([]datastore.Property, error) {
    // Validate the Sum field.
    if x.Sum != x.I + x.J {
        return nil, errors.New("CustomPropsExample has inconsistent sum")
    }
    // Save I and J as usual. The code below is equivalent to calling
    // "return datastore.SaveStruct(x)", but is done manually for
    // demonstration purposes.
    return []datastore.Property{
        {
            Name:  "I",
            Value: int64(x.I),
        },
        {
            Name:  "J",
            Value: int64(x.J),
        },
    }, nil
}

El tipo *PropertyList implementa PropertyLoadSaver y, por lo tanto, puede contener el contenido de una entidad arbitraria.

Consultas

Las consultas recuperan entidades en función de sus propiedades o el principal de la clave. La ejecución de una consulta produce una iteración de resultados: claves o pares (clave, entidad). Las consultas son reutilizables y es seguro llamar a Query.Run desde goroutines simultáneas. Las iteraciones no son seguras para el uso simultáneo.

Las consultas son inmutables y se crean llamando a NewQuery o se derivan de una consulta existente llamando a un método como Filter u Order que muestra un nuevo valor de consulta. Una consulta normalmente se construye llamando a NewQuery seguida de una cadena de ceros o más de estos métodos. Estos métodos son los siguientes:

• El principal y el filtro restringen las entidades mostradas mediante la ejecución de una consulta.
• El orden afecta el orden en el que se muestran.
• El proyecto restringe los campos mostrados.
• Anula la duplicación de entidades proyectadas.
• KeysOnly hace que el iterador muestre solo las claves, no los pares (clave, entidad).
• Start, End, Offset y Limit definen qué secuencia secundaria de entidades coincidentes se mostrarán. Start y End toman cursores, y Offset y Limit toman valores enteros. Start y Offset afectan al primer resultado, y End y Limit afectan a los últimos. Si se configuran Start y Offset, Offset es relativo a Start. Si se configuran End y Limit, prevalecerá la primera restricción. Limit es relativo a Start+Offset, no a End. Como caso especial, un límite negativo significa ilimitado.

Código de ejemplo:

type Widget struct {
    Description string
    Price       int
}

func handle(w http.ResponseWriter, r *http.Request) {
    ctx := appengine.NewContext(r)
    q := datastore.NewQuery("Widget").
        Filter("Price <", 1000).
        Order("-Price")
    b := new(bytes.Buffer)
    for t := q.Run(ctx); ; {
        var x Widget
        key, err := t.Next(&x)
        if err == datastore.Done {
            break
        }
        if err != nil {
            serveError(ctx, w, err)
            return
        }
        fmt.Fprintf(b, "Key=%v\nWidget=%#v\n\n", key, x)
    }
    w.Header().Set("Content-Type", "text/plain; charset=utf-8")
    io.Copy(w, b)
}

Transacciones

RunInTransaction ejecuta una función en una transacción.

Código de ejemplo:

type Counter struct {
    Count int
}

func inc(ctx context.Context, key *datastore.Key) (int, error) {
    var x Counter
    if err := datastore.Get(ctx, key, &x); err != nil && err != datastore.ErrNoSuchEntity {
        return 0, err
    }
    x.Count++
    if _, err := datastore.Put(ctx, key, &x); err != nil {
        return 0, err
    }
    return x.Count, nil
}

func handle(w http.ResponseWriter, r *http.Request) {
    ctx := appengine.NewContext(r)
    var count int
    err := datastore.RunInTransaction(ctx, func(ctx context.Context) error {
        var err1 error
        count, err1 = inc(ctx, datastore.NewKey(ctx, "Counter", "singleton", 0, nil))
        return err1
    }, nil)
    if err != nil {
        serveError(ctx, w, err)
        return
    }
    w.Header().Set("Content-Type", "text/plain; charset=utf-8")
    fmt.Fprintf(w, "Count=%d", count)
}

Metadatos

El paquete del almacén de datos proporciona acceso a algunos de los metadatos del almacén de datos de App Engine. Estos metadatos incluyen información sobre los grupos de entidades, los espacios de nombres, los tipos de entidades y las propiedades en el almacén de datos, así como las representaciones de propiedades de cada propiedad.

Código de ejemplo:

func handle(w http.ResponseWriter, r *http.Request) {
    // Print all the kinds in the datastore, with all the indexed
    // properties (and their representations) for each.
    ctx := appengine.NewContext(r)

    kinds, err := datastore.Kinds(ctx)
    if err != nil {
        serveError(ctx, w, err)
        return
    }

    w.Header().Set("Content-Type", "text/plain; charset=utf-8")
    for _, kind := range kinds {
        fmt.Fprintf(w, "%s:\n", kind)
        props, err := datastore.KindProperties(ctx, kind)
        if err != nil {
            fmt.Fprintln(w, "\t(unable to retrieve properties)")
            continue
        }
        for p, rep := range props {
            fmt.Fprintf(w, "\t-%s (%s)\n", p, strings.Join(rep, ", "))
        }
    }
}

Variables

ErrInvalidEntityType, ErrInvalidKey, ErrNoSuchEntity

var (
	// ErrInvalidEntityType is returned when functions like Get or Next are
	// passed a dst or src argument of invalid type.
	ErrInvalidEntityType = errors.New("datastore: invalid entity type")
	// ErrInvalidKey is returned when an invalid key is presented.
	ErrInvalidKey = errors.New("datastore: invalid key")
	// ErrNoSuchEntity is returned when no entity was found for a given key.
	ErrNoSuchEntity = errors.New("datastore: no such entity")
)

Listo

var Done = errors.New("datastore: query has no more results")

Se muestra Done cuando se ha completado una iteración de la consulta.

ErrConcurrentTransaction

var ErrConcurrentTransaction = errors.New("datastore: concurrent transaction")

ErrConcurrentTransaction se muestra cuando se revierte una transacción debido a un conflicto con una transacción simultánea.

Funciones

func AllocateIDRange

func AllocateIDRange(c context.Context, kind string, parent *Key, start, end int64) (err error)

AllocateIDRange asigna un rango de IDs con extremos específicos. El rango es inclusivo en los extremos bajo y alto. Una vez que se han asignado estos IDs, puede vincularlos manualmente a las entidades recién creadas.

El asignador automático de ID de Datastore nunca asigna una clave que ya haya sido asignada (ya sea a través de la asignación automática de ID o mediante una llamada explícita a AllocateIDs). Como resultado, las entidades escritas en el rango de claves dado nunca se reemplazarán. Sin embargo, la escritura de entidades con claves asignadas manualmente en este rango puede reemplazar las entidades existentes (o las nuevas entidades escritas por una solicitud separada), en función del error mostrado.

Utiliza esta solo si tienes un rango de IDs numéricos existente que deseas reservar (por ejemplo, entidades de carga masiva que ya tienen ID). Si no te importa qué IDs recibes, es mejor que utilices AllocateIDs.

AssignIDRange muestra nil si el rango se asigna con éxito. Si ya existen una o más entidades con un ID en el rango dado, muestra un KeyRangeCollisionError. Si el almacén de datos ya tiene IDs de caché en este rango (p. ej., de una llamada anterior a AllocateIDRange), muestra un KeyRangeContentionError. Los errores de otros tipos indican problemas con los argumentos o un error que se muestra directamente desde Datastore.

func AllocateIDs

func AllocateIDs(c context.Context, kind string, parent *Key, n int) (low, high int64, err error)

AllocateIDs muestra un rango de n ID de números enteros con la combinación de tipo y superior dadas. kind no puede estar vacío; el superior puede ser nil. Los ID en el rango que se muestra no serán utilizados por el generador automático de secuencias de ID del almacén de datos, y se pueden usar con NewKey sin generar conflicto.

El rango es inclusivo en el extremo inferior y exclusivo en el extremo superior. En otras palabras, intID válidas x satisfacen low <= x && x < high.

Si no se muestra un error, low + n == high.

func Delete

func Delete(c context.Context, key *Key) error

Delete borra la entidad para la clave dada.

func DeleteMulti

func DeleteMulti(c context.Context, key []*Key) error

DeleteMulti es una versión por lotes de Delete.

func EnableKeyConversion

func EnableKeyConversion(ctx context.Context)

enableKeyConversion permite la compatibilidad de claves codificadas con la biblioteca cliente de Cloud Datastore (cloud.google.com/go/datastore). Las claves codificadas que genera la biblioteca cliente de Cloud Datastore se decodificarán en las claves del almacén de datos de App Engine.

El contexto proporcionado debe ser un contexto de App Engine si se ejecuta en el entorno de ejecución de primera generación de App Engine. Se puede llamar en el controlador /_ah/start. Es seguro llamar varias veces y es económico, por lo que también se puede insertar como middleware.

La habilitación de la compatibilidad de claves no afecta el formato de codificación que usa Key.Encode, solo expande el tipo de claves que se pueden decodificar con DecodeKey.

func Get

func Get(c context.Context, key *Key, dst interface{}) error

Get carga la entidad almacenada para k en dst, que debe ser un puntero a estructura, o implementa PropertyLoadSaver. Si no está dicha entidad para la clave, Get muestra ErrNoSuchEntity.

Los valores de los campos de estructura no coincidentes de dst no se modifican y los campos de tipo de segmento coincidentes no se restablecen antes de agregarlos. En particular, se recomienda pasar un puntero a una estructura de valor cero en cada llamada Get.

ErrFieldMismatch se muestra cuando debe cargarse un campo en un tipo diferente en el que se almacenó o cuando falta un campo o no se exporta en la estructura de destino. ErrFieldMismatch solo se muestra si dst es un puntero a estructura.

func GetMulti

func GetMulti(c context.Context, key []*Key, dst interface{}) error

GetMulti es una versión por lotes de Get.

dst debe ser []S, []*S, []I o []P, para un tipo de estructura S, alguna interfaz de tipo I o algún tipo P ni puntero ni interfaz, de manera que P o *P implemente PropertyLoadSaver. Si es un []I, cada elemento debe ser un dst válido para Get: debe ser un puntero a estructura o implementar PropertyLoadSaver.

Como un caso especial, PropertyList es un tipo no válido para dst, aunque una PropertyList es una porción de estructuras. Se trata como no válido para evitar que se pase por error cuando se pretende usar []PropertyList.

func KindProperties

func KindProperties(ctx context.Context, kind string) (map[string][]string, error)

KindProperties muestra todas las propiedades indexadas para el tipo dado. Las propiedades se muestran como un mapa de nombres de propiedades a una porción de los tipos de representación. Los tipos de representación para los tipos de propiedad Go admitidos son los siguientes:

"INT64":     signed integers and time.Time
"DOUBLE":    float32 and float64
"BOOLEAN":   bool
"STRING":    string, []byte and ByteString
"POINT":     appengine.GeoPoint
"REFERENCE": *Key
"USER":      (not used in the Go runtime)

func Kinds

func Kinds(ctx context.Context) ([]string, error)

Kinds muestra los nombres de todos los tipos en el espacio de nombres actual.

func LoadStruct

func LoadStruct(dst interface{}, p []Property) error

LoadStruct carga las propiedades de p a dst. Este último debe ser un puntero de estructura.

func Namespaces

func Namespaces(ctx context.Context) ([]string, error)

Namespaces muestra todos los espacios de nombres del almacén de datos.

func RunInTransaction

func RunInTransaction(c context.Context, f func(tc context.Context) error, opts *TransactionOptions) error

RunInTransaction ejecuta f en una transacción. Llama a f con un contexto de transacción tc que f debe usar para todas las operaciones de App Engine.

Si f muestra nil, RunInTransaction intenta confirmar la transacción, y muestra nil si tiene éxito. Si la confirmación falla debido a una transacción conflictiva, RunInTransaction reintenta f, cada vez con un nuevo contexto de transacción. Se da por vencida y muestra ErrConcurrentTransaction después de tres intentos fallidos. Puedes especificar TransactionOptions.attempts para configurar la cantidad de intentos.

Si f muestra un valor que no es nil, no se aplicará ningún cambio del almacén de datos y RunInTransaction mostrará el mismo error. La función f no se reintenta.

Ten en cuenta que cuando se muestra f, la transacción aún no se ha confirmado. El código de llamada debe tener cuidado de no suponer que ninguno de los cambios de f se ha confirmado hasta que RunInTransaction muestre nil.

Como se puede llamar a f varias veces, f normalmente debería ser idempotent.datastore.Get no es idempotente cuando se deserializan los campos de segmentos.

Las transacciones anidadas no son compatibles; c no puede ser un contexto de transacción.

ByteString

type ByteString []byte

ByteString es una pequeña porción de bytes (hasta 1,500 bytes) que se puede indexar.

Cursor

type Cursor struct {
	// contains filtered or unexported fields
}

Cursor es la posición de un iterador. Se puede convertir hacia y desde una string opaca. Se puede usar un cursor desde diferentes solicitudes HTTP, pero solo con una consulta con las mismas restricciones de tipo, principal, filtro y orden.

func DecodeCursor

func DecodeCursor(s string) (Cursor, error)

DecodeCursor decodifica un cursor de su representación de string base-64.

func (Cursor) String

func (c Cursor) String() string

String muestra una representación de string base-64 de un cursor.

Entidad

type Entity struct {
	Key        *Key
	Properties []Property
}

Entity es el tipo de valor de una estructura anidada. Este tipo solo se usa para el valor de Property.

ErrFieldMismatch

type ErrFieldMismatch struct {
	StructType reflect.Type
	FieldName  string
	Reason     string
}

ErrFieldMismatch se muestra cuando debe cargarse un campo en un tipo diferente en el que se almacenó o cuando falta un campo o no se exporta en la estructura de destino. StructType es el tipo de estructura a la que apunta el argumento de destino pasado a Get o Iterator.Next.

func (*ErrFieldMismatch) Error

func (e *ErrFieldMismatch) Error() string

Iterador

type Iterator struct {
	// contains filtered or unexported fields
}

Iterator es el resultado de ejecutar una consulta.

func (*Iterator) Cursor

func (t *Iterator) Cursor() (Cursor, error)

Cursor muestra un cursor para la ubicación actual del iterador.

func (*Iterator) Next

func (t *Iterator) Next(dst interface{}) (*Key, error)

Next muestra la clave del siguiente resultado. Cuando no hay más resultados, se muestra Done como error.

Si la consulta no es solo de claves y dst es diferente de nil, también carga la entidad almacenada para esa clave en el puntero a estructura o PropertyLoadSaver dst, con la misma semántica y posibles errores que para la función Get.

Clave

type Key struct {
	// contains filtered or unexported fields
}

Key representa la clave del almacén de datos para una entidad almacenada y es inmutable.

func DecodeKey

func DecodeKey(encoded string) (*Key, error)

DecodeKey decodifica una clave de la representación opaca que muestra Encode.

func NewIncompleteKey

func NewIncompleteKey(c context.Context, kind string, parent *Key) *Key

NewIncompleteKey crea una nueva clave incompleta. Los similares no pueden estar vacíos.

func NewKey

func NewKey(c context.Context, kind, stringID string, intID int64, parent *Key) *Key

NewKey crea una nueva clave. El tipo no puede estar vacío. Uno o ambos de stringID e intID deben ser cero.j Si ambos son cero, la clave que se muestra estará incompleta. El superior debe ser una clave completa o nil.

func Put

func Put(c context.Context, key *Key, src interface{}) (*Key, error)

Put guarda la entidad src en el almacén de datos con la clave k. src debe ser un puntero a estructura o implementar PropertyLoadSaver; si es un puntero a estructura, se omitirán los campos no exportados de esa estructura. Si k es una clave incompleta, la clave que se muestra será una clave única generada por el almacén de datos.

func PutMulti

func PutMulti(c context.Context, key []*Key, src interface{}) ([]*Key, error)

PutMulti es una versión por lotes de Put.

src debe satisfacer las mismas condiciones que el argumento dst para GetMulti.

func (*Key) AppID

func (k *Key) AppID() string

AppID muestra el ID de la aplicación de la clave.

func (*Key) Encode

func (k *Key) Encode() string

Encode muestra una representación opaca de la clave adecuada para su uso en HTML y URL. Esto es compatible con los entornos de ejecución Python y Java.

func (*Key) Equal

func (k *Key) Equal(o *Key) bool

Equal muestra si dos claves son iguales.

func (*Key) GobDecode

func (k *Key) GobDecode(buf []byte) error

func (*Key) GobEncode

func (k *Key) GobEncode() ([]byte, error)

func (*Key) Incomplete

func (k *Key) Incomplete() bool

Incomplete muestra si la clave no se refiere a una entidad almacenada. En particular, si la clave tiene IntID cero y StringID cero.

func (*Key) IntID

func (k *Key) IntID() int64

IntID muestra el ID de número entero de la clave, que puede ser 0.

func (*Key) Kind

func (k *Key) Kind() string

Kind muestra el tipo de clave (también conocido como tipo de entidad).

func (*Key) MarshalJSON

func (k *Key) MarshalJSON() ([]byte, error)

func (*Key) Namespace

func (k *Key) Namespace() string

Namespace muestra el espacio de nombres de la clave.

func (*Key) Parent

func (k *Key) Parent() *Key

Parent muestra la clave principal de la clave, que puede ser nil.

func (*Key) String

func (k *Key) String() string

String muestra una representación de string de la clave.

func (*Key) StringID

func (k *Key) StringID() string

StringID muestra el ID de string de la clave (también conocido como nombre de entidad o nombre de clave), que puede ser "".

func (*Key) UnmarshalJSON

func (k *Key) UnmarshalJSON(buf []byte) error

KeyRangeCollisionError

type KeyRangeCollisionError struct {
	// contains filtered or unexported fields
}

func (*KeyRangeCollisionError) Error

func (e *KeyRangeCollisionError) Error() string

KeyRangeContentionError

type KeyRangeContentionError struct {
	// contains filtered or unexported fields
}

func (*KeyRangeContentionError) Error

func (e *KeyRangeContentionError) Error() string

Propiedad

type Property struct {
	// Name is the property name.
	Name string
	// Value is the property value. The valid types are:
	//	- int64
	//	- bool
	//	- string
	//	- float64
	//	- ByteString
	//	- *Key
	//	- time.Time
	//	- appengine.BlobKey
	//	- appengine.GeoPoint
	//	- []byte (up to 1 megabyte in length)
	//	- *Entity (representing a nested struct)
	// This set is smaller than the set of valid struct field types that the
	// datastore can load and save. A Property Value cannot be a slice (apart
	// from []byte); use multiple Properties instead. Also, a Value's type
	// must be explicitly on the list above; it is not sufficient for the
	// underlying type to be on that list. For example, a Value of "type
	// myInt64 int64" is invalid. Smaller-width integers and floats are also
	// invalid. Again, this is more restrictive than the set of valid struct
	// field types.
	//
	// A Value will have an opaque type when loading entities from an index,
	// such as via a projection query. Load entities into a struct instead
	// of a PropertyLoadSaver when using a projection query.
	//
	// A Value may also be the nil interface value; this is equivalent to
	// Python's None but not directly representable by a Go struct. Loading
	// a nil-valued property into a struct will set that field to the zero
	// value.
	Value interface{}
	// NoIndex is whether the datastore cannot index this property.
	NoIndex bool
	// Multiple is whether the entity can have multiple properties with
	// the same name. Even if a particular instance only has one property with
	// a certain name, Multiple should be true if a struct would best represent
	// it as a field of type []T instead of type T.
	Multiple bool
}

Property es un par nombre/valor más algunos metadatos. El contenido de una entidad del almacén de datos se carga y guarda como una secuencia de Properties. Una entidad puede tener múltiples propiedades con el mismo nombre, siempre que p.Multiple sea true en todas las propiedades de esa entidad con ese nombre.

func SaveStruct

func SaveStruct(src interface{}) ([]Property, error)

SaveStruct muestra las propiedades de src como una porción de Properties.src debe ser un puntero a estructura.

PropertyList

type PropertyList []Property

PropertyList convierte una []Property para implementar PropertyLoadSaver.

func (*PropertyList) Load

func (l *PropertyList) Load(p []Property) error

Load carga todas las propiedades proporcionadas en l. No reinicia primero *l a una porción vacía.

func (*PropertyList) Save

func (l *PropertyList) Save() ([]Property, error)

Save guarda todas las propiedades de l como una porción o Properties.

PropertyLoadSaver

type PropertyLoadSaver interface {
	Load([]Property) error
	Save() ([]Property, error)
}

PropertyLoadSaver se puede convertir desde y a una porción de Properties.

Consulta

type Query struct {
	// contains filtered or unexported fields
}

Query representa una consulta del almacén de datos.

func NewQuery

func NewQuery(kind string) *Query

NewQuery crea una nueva consulta para un tipo de entidad específica.

Si la categoría está vacía se mostrarán todas las entidades, incluidas las entidades creadas y administradas por otras características de App Engine, y se denomina consulta sin categoría. Las consultas sin categoría no pueden incluir filtros ni órdenes de clasificación para los valores de las propiedades.

func (*Query) Ancestor

func (q *Query) Ancestor(ancestor *Key) *Query

Ancestor muestra una consulta derivada con un filtro de principal. El principal no debe ser nil.

func (*Query) BatchSize

func (q *Query) BatchSize(size int) *Query

BatchSize muestra una consulta derivada para recuperar la cantidad de resultados proporcionados a la vez. Este valor debe ser mayor que cero, igual o menor que el límite.

func (*Query) Count

func (q *Query) Count(c context.Context) (int, error)

Count muestra la cantidad de resultados para la consulta.

El tiempo de ejecución y la cantidad de llamadas a la API realizadas por Count se escalan linealmente con la suma de la compensación y el límite de la consulta. A menos que se espere un conteo de resultados pequeño, se recomienda especificar un límite; de lo contrario, Count continuará hasta que finalice el conteo o expire el contexto proporcionado.

func (*Query) Distinct

func (q *Query) Distinct() *Query

Distinct muestra una consulta derivada que produce entidades deduplicadas con respecto al conjunto de campos proyectados. Solo se utiliza para consultas de proyección. No se puede usar Distinct con DistinctOn.

func (*Query) DistinctOn

func (q *Query) DistinctOn(fieldNames string) *Query

DistinctOn muestra una consulta derivada que produce entidades deduplicadas con respecto al conjunto de los campos especificados. Solo se utiliza para consultas de proyección. La lista de campos debe ser un subconjunto de la lista de campos proyectados. No se puede usar DistinctOn con Distinct.

func (*Query) End

func (q *Query) End(c Cursor) *Query

Fin muestra una consulta derivada con el punto final dado.

func (*Query) EventualConsistency

func (q *Query) EventualConsistency() *Query

EventualConsistency muestra una consulta derivada que muestra resultados con coherencia eventual. Solo tiene efecto en las consultas de los principales.

func (*Query) Filter

func (q *Query) Filter(filterStr string, value interface{}) *Query

El filtro muestra una consulta derivada con un filtro basado en campos. El argumento filterStr debe ser un nombre de campo seguido de un espacio opcional, seguido de un operador, uno de ">", "<", ">=", "<=", o "=". Los campos se comparan con el valor proporcionado mediante el operador. Los filtros múltiples son juntan mediante AND.

func (*Query) GetAll

func (q *Query) GetAll(c context.Context, dst interface{}) ([]*Key, error)

GetAll ejecuta la consulta en el contexto dado y muestra todas las claves que coinciden con esa consulta, además de anexar los valores a dst.

dst debe tener el tipo []S o *[]*S o *[]P, para algún tipo de estructura S o algún tipo P sin interfaz, sin puntero, de manera que P o * P implementa PropertyLoadSaver.

Como un caso especial, *PropertyList es un tipo no válido para dst, aunque una PropertyList es una porción de estructuras. Se trata como no válido para evitar que se pase por error cuando se pretende usar *[]PropertyList.

Las claves que muestra GetAll tendrán una correspondencia 1-1 con las entidades agregadas a dst.

Si q es una consulta de "solo claves", GetAll ignora dst y solo muestra las claves.

El tiempo de ejecución y la cantidad de llamadas a la API realizadas por GetAll se escalan linealmente con la suma de la compensación y el límite de la consulta. A menos que se espere un conteo de resultados pequeño, se recomienda especificar un límite; de lo contrario, GetAll continuará hasta que termine de recopilar resultados o expire el contexto proporcionado.

func (*Query) KeysOnly

func (q *Query) KeysOnly() *Query

KeysOnly muestra una consulta derivada que produce solo claves, no claves y entidades. No se puede utilizar con consultas de proyección.

func (*Query) Limit

func (q *Query) Limit(limit int) *Query

Limit muestra una consulta derivada que tiene un límite en la cantidad de resultados que se muestran. Un valor negativo significa ilimitado.

func (*Query) Offset

func (q *Query) Offset(offset int) *Query

Offset muestra una consulta derivada que tiene una compensación de cuántas claves omitir antes de mostrar los resultados. No se acepta un valor negativo.

func (*Query) Order

func (q *Query) Order(fieldName string) *Query

Order muestra una consulta derivada con un orden de clasificación basado en campos. Los órdenes se aplican en el orden en que se agregan. El orden predeterminado es ascendente; para ordenar en orden descendente agrega un signo menos (-) antes de fieldName.

func (*Query) Project

func (q *Query) Project(fieldNames string) *Query

Project muestra una consulta derivada que produce solo los campos dados. No se puede utilizar con KeysOnly.

func (*Query) Run

func (q *Query) Run(c context.Context) *Iterator

Run ejecuta la consulta en el contexto dado.

func (*Query) Start

func (q *Query) Start(c Cursor) *Query

Start muestra una consulta derivada con el punto de inicio dado.

TransactionOptions

type TransactionOptions struct {
	// XG is whether the transaction can cross multiple entity groups. In
	// comparison, a single group transaction is one where all datastore keys
	// used have the same root key. Note that cross group transactions do not
	// have the same behavior as single group transactions. In particular, it
	// is much more likely to see partially applied transactions in different
	// entity groups, in global queries.
	// It is valid to set XG to true even if the transaction is within a
	// single entity group.
	XG bool
	// Attempts controls the number of retries to perform when commits fail
	// due to a conflicting transaction. If omitted, it defaults to 3.
	Attempts int
	// ReadOnly controls whether the transaction is a read only transaction.
	// Read only transactions are potentially more efficient.
	ReadOnly bool
}

TransactionOptions son las opciones para ejecutar una transacción.