El paquete de almacén de datos

import "google.golang.org/appengine/datastore"

Introducción

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 clase de string (también conocida como tipo de entidad) y una StringID o una IntID. A una StringID también se la conoce como un nombre de entidad o un 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:

- signed integers (int, int8, int16, int32 and int64),
- bool,
- string,
- float32 and float64,
- []byte (up to 1 megabyte in length),
- any type whose underlying type is one of the above predeclared types,
- ByteString,
- *Key,
- time.Time (stored with microsecond precision),
- appengine.BlobKey,
- appengine.GeoPoint,
- structs whose fields are all valid value types,
- slices of any of the above.

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 []*Key en lugar de *Key, y pueden mostrar appengine.MultiError cuando se encuentran un error 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 enviados no tienen que coincidir entre las llamadas Get y Put ni entre diferentes solicitudes de App Engine. 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. Si la opción es "noindex", el campo no se indexará. Si la opción es "", entonces se puede omitir la coma. No hay otras opciones reconocidas.

Los campos (excepto []byte) se indexan de forma predeterminada. Las string de más de 1,500 bytes no pueden indexarse; los campos utilizados para almacenar strings largas deben etiquetarse con "noindex". De forma similar, las ByteStrings con más de 1,500 bytes no pueden indexarse.

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 incrustado de Outer se etiquetara 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 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),
        },
    }
}

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:

- Ancestor and Filter constrain the entities returned by running a query.
- Order affects the order in which they are returned.
- Project constrains the fields returned.
- Distinct de-duplicates projected entities.
- KeysOnly makes the iterator return only keys, not (key, entity) pairs.
- Start, End, Offset and Limit define which sub-sequence of matching entities
  to return. Start and End take cursors, Offset and Limit take integers. Start
  and Offset affect the first result, End and Limit affect the last result.
  If both Start and Offset are set, then the offset is relative to Start.
  If both End and Limit are set, then the earliest constraint wins. Limit is
  relative to Start+Offset, not relative to End. As a special case, a
  negative limit means unlimited.

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))
        }
    }
}

Índice

Variables
func AllocateIDs(c context.Context, kind string, parent *Key, n int) (low, high int64, err error)
func Delete(c context.Context, key *Key) error
func DeleteMulti(c context.Context, key []*Key) error
func Get(c context.Context, key *Key, dst interface{}) error
func GetMulti(c context.Context, key []*Key, dst interface{}) error
func KindProperties(ctx context.Context, kind string) (map[string][]string, error)
func Kinds(ctx context.Context) ([]string, error)
func LoadStruct(dst interface{}, p []Property) error
func Namespaces(ctx context.Context) ([]string, error)
func Put(c context.Context, key *Key, src interface{}) (*Key, error)
func PutMulti(c context.Context, key []*Key, src interface{}) ([]*Key, error)
func RunInTransaction(c context.Context, f func(tc context.Context) error, opts *TransactionOptions) error
func SaveStruct(src interface{}) ([]Property, error)
type ByteString
type Cursor
    func DecodeCursor(s string) (Cursor, error)
    func (c Cursor) String() string
type Entity
type ErrFieldMismatch
    func (e *ErrFieldMismatch) Error() string
type Iterator
    func (t *Iterator) Cursor() (Cursor, error)
    func (t *Iterator) Next(dst interface{}) (*Key, error)
type Key
    func DecodeKey(encoded string) (*Key, error)
    func NewIncompleteKey(c context.Context, kind string, parent *Key) *Key
    func NewKey(c context.Context, kind, stringID string, intID int64, parent *Key) *Key
    func (k *Key) AppID() string
    func (k *Key) Encode() string
    func (k *Key) Equal(o *Key) bool
    func (k *Key) GobDecode(buf []byte) error
    func (k *Key) GobEncode() ([]byte, error)
    func (k *Key) Incomplete() bool
    func (k *Key) IntID() int64
    func (k *Key) Kind() string
    func (k *Key) MarshalJSON() ([]byte, error)
    func (k *Key) Namespace() string
    func (k *Key) Parent() *Key
    func (k *Key) String() string
    func (k *Key) StringID() string
    func (k *Key) UnmarshalJSON(buf []byte) error
type Property
type PropertyList
    func (l *PropertyList) Load(p []Property) error
    func (l *PropertyList) Save() ([]Property, error)
type PropertyLoadSaver
type Query
    func NewQuery(kind string) *Query
    func (q *Query) Ancestor(ancestor *Key) *Query
    func (q *Query) Count(c context.Context) (int, error)
    func (q *Query) Distinct() *Query
    func (q *Query) End(c Cursor) *Query
    func (q *Query) EventualConsistency() *Query
    func (q *Query) Filter(filterStr string, value interface{}) *Query
    func (q *Query) GetAll(c context.Context, dst interface{}) ([]*Key, error)
    func (q *Query) KeysOnly() *Query
    func (q *Query) Limit(limit int) *Query
    func (q *Query) Offset(offset int) *Query
    func (q *Query) Order(fieldName string) *Query
    func (q *Query) Project(fieldNames …string) *Query
    func (q *Query) Run(c context.Context) *Iterator
    func (q *Query) Start(c Cursor) *Query
type TransactionOptions

Variables

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")
)
var Done = errors.New("datastore: query has no more results")

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

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.

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 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. dst debe ser un puntero a estructura.

func Namespaces

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

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

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 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. Para configurar la cantidad de intentos se puede configurar especificar TransactionOptions.Attempts.

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 varias veces a f, f normalmente debería ser idempotente. 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.

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.

type ByteString

type ByteString []byte

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

type 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)

Decode 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.

type Entity

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.

type 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 a Iterator.Next.

func (*ErrFieldMismatch) Error

func (e *ErrFieldMismatch) Error() string

type Iterator

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.

type Key

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. kind no puede estar vacío.

func NewKey

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

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

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

type Property

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 Properties con el mismo nombre, siempre que p.Múltiple sea verdadero en todas las Properties de esa entidad con ese nombre.

type 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.

type PropertyLoadSaver

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

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

type Query

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) 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.

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.

type 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
}

TransactionOptions son las opciones para ejecutar una transacción.

¿Te ha resultado útil esta página? Enviar comentarios:

Enviar comentarios sobre...

Entorno estándar de App Engine para Go