Crea, recupera, actualiza y borra entidades

Los objetos de datos en Datastore se denominan entidades y cada una de ellas se clasifica en un tipo con el propósito de realizar consultas. Por ejemplo, si escribes una aplicación de recursos humanos, puedes representar a cada empleado con una entidad del tipo Employee. Ten en cuenta que los valores de datos de la entidad tienen el formato de propiedades. Para obtener más información sobre las entidades, consulta el documento de concepto Entidades, propiedades y claves.

Crea entidades y configura propiedades

En Go, para crear una entidad nueva debes construir una instancia de una estructura de Go, propagar sus campos y llamar a datastore.Put a fin de guardarla en Datastore. Solo se guardarán en Datastore los campos exportados (que empiecen con una letra mayúscula). Puede especificar el nombre de clave de la entidad si pasas un argumento stringID no vacío a datastore.NewKey.

En el siguiente ejemplo, se crea una entidad de categoría Employee, se propagan sus valores de propiedad y se la 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.

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

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

Recupera entidades

Para recuperar una entidad identificada mediante una clave determinada, pasa *datastore.Key como un argumento a la función datastore.Get. Puedes generar la *datastore.Key mediante 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 propaga una instancia de la estructura de Go adecuada.

Actualiza entidades

Para actualizar una entidad existente, modifica los atributos de la estructura y, luego, llama a datastore.Put. Los datos reemplazan la entidad existente. El objeto completo se envía a Datastore con cada llamada a datastore.Put.

Borra entidades

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

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

Borrar entidades de manera masiva

Si necesitas borrar una gran cantidad de entidades, te recomendamos usar Dataflow para borrar entidades de manera masiva.

Usa operaciones por lotes

Puedes usar las siguientes operaciones por lotes si deseas operar en varias entidades en una sola llamada a Datastore:

Este es 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 afectan los costos. Se te cobrará por cada clave de una operación por lotes, independientemente de si la clave existe o no. El tamaño de las entidades involucradas en una operación no afecta el costo.