Crear, recuperar, actualizar y eliminar entidades

Los objetos de datos de Datastore se denominan entidades, y cada uno de ellos se clasifica en un tipo concreto para las consultas. Por ejemplo, si estás escribiendo una aplicación de recursos humanos, puedes representar a cada empleado con una entidad de tipo Employee. Ten en cuenta que los valores de los datos de la entidad tienen el formato de propiedades. Para obtener más información sobre las entidades, consulta el documento de conceptos Entidades, propiedades y claves.

Crear entidades y definir propiedades

En Go, se crea una entidad construyendo una instancia de una estructura de Go, rellenando sus campos y llamando a datastore.Put para guardarla en Datastore. Solo se guardarán en Datastore los campos exportados (que empiezan por una letra mayúscula). Puedes especificar el nombre de la clave de la entidad pasando un argumento stringID no vacío a datastore.NewKey.

En el siguiente ejemplo se crea una entidad de tipo Employee, se rellenan los valores de sus propiedades y se guarda en Datastore:

import (
	"context"
	"time"

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

type Employee struct {
	FirstName          string
	LastName           string
	HireDate           time.Time
	AttendedHRTraining bool
}

func f(ctx context.Context) {
	// ...
	employee := &Employee{
		FirstName: "Antonio",
		LastName:  "Salieri",
		HireDate:  time.Now(),
	}
	employee.AttendedHRTraining = true

	key := datastore.NewIncompleteKey(ctx, "Employee", nil)
	if _, err := datastore.Put(ctx, key, employee); err != nil {
		// Handle err
	}
	// ...
}

El tipo Employee declara cuatro campos para el modelo de datos: FirstName, LastName, HireDate y AttendedHRTraining.

Si proporcionas un nombre de clave vacío o usas datastore.NewIncompleteKey, Datastore generará automáticamente un ID numérico para la clave de la entidad:

employee := &Employee{
	FirstName: "Antonio",
	LastName:  "Salieri",
	HireDate:  time.Now(),
}
employee.AttendedHRTraining = true
key := datastore.NewIncompleteKey(ctx, "Employee", nil)
_, err = datastore.Put(ctx, key, employee)

Obtener entidades

Para recuperar una entidad identificada por una clave determinada, pasa el *datastore.Key como argumento a la función datastore.Get. Puedes generar el *datastore.Key con la función datastore.NewKey.

employeeKey := datastore.NewKey(ctx, "Employee", "asalieri", 0, nil)
addressKey := datastore.NewKey(ctx, "Address", "", 1, employeeKey)
var addr Address
err = datastore.Get(ctx, addressKey, &addr)

datastore.Get rellena una instancia de la estructura Go adecuada.

Actualizar entidades

Para actualizar una entidad, modifique los atributos de la estructura y, a continuación, llame a datastore.Put. Los datos sobrescriben la entidad. El objeto completo se envía a Datastore con cada llamada a datastore.Put.

Eliminar entidades

Si tienes la clave de una entidad, puedes eliminarla con la función datastore.Delete:

key := datastore.NewKey(ctx, "Employee", "asalieri", 0, nil)
err = datastore.Delete(ctx, key)

Eliminar entidades en bloque

Si necesitas eliminar un gran número de entidades, te recomendamos que utilices Dataflow para eliminar entidades en bloque.

Usar operaciones en lote

Puede usar las siguientes operaciones por lotes si quiere operar con varias entidades en una sola llamada a Datastore:

Aquí tienes un ejemplo de una llamada por lotes:

// A batch put.
_, err = datastore.PutMulti(ctx, []*datastore.Key{k1, k2, k3}, []interface{}{e1, e2, e3})

// A batch get.
var entities = make([]*T, 3)
err = datastore.GetMulti(ctx, []*datastore.Key{k1, k2, k3}, entities)

// A batch delete.
err = datastore.DeleteMulti(ctx, []*datastore.Key{k1, k2, k3})

Las operaciones por lotes no modifican tus costes. Se te cobrará por cada clave de una operación por lotes, independientemente de si existe o no. El tamaño de las entidades implicadas en una operación no afecta al coste.