Créer, récupérer, mettre à jour et supprimer des entités

Dans Datastore, les objets de données sont appelés entités. Chacune de ces entités possède un genre spécifique qui la classe dans une catégorie pour les besoins des requêtes. Par exemple, si vous écrivez une application de ressources humaines, vous pouvez représenter chaque employé avec une entité du genre Employee. Sachez que les valeurs de données des entités apparaissent sous la forme de propriétés. Pour en savoir plus sur les entités, consultez le document conceptuel Entités, propriétés et clés.

Créer des entités et définir les propriétés

Dans Go, pour créer une entité, construisez une instance d'une structure Go, renseignez ses champs, puis appelez datastore.Put pour l'enregistrer dans Datastore. Seuls les champs exportés (commençant par une lettre majuscule) seront enregistrés dans Datastore. Vous pouvez spécifier le nom de clé de l'entité en transmettant un argument stringID non vide à datastore.NewKey.

L'exemple suivant crée une entité du genre Employee, renseigne ses valeurs de propriété et l'enregistre dans 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
	}
	// ...
}

Le type Employee déclare quatre champs pour le modèle de données : FirstName, LastName, HireDate et AttendedHRTraining.

Si vous fournissez un nom de clé vide ou utilisez datastore.NewIncompleteKey, Datastore génère automatiquement un ID numérique pour la clé de l'entité :

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

Récupérer des entités

Pour récupérer une entité identifiée par une clé donnée, transmettez l'élément *datastore.Key en tant qu'argument à la fonction datastore.Get. Vous pouvez générer l'élément *datastore.Key à l'aide de la fonction 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 insère une instance de la structure Go appropriée.

Mettre à jour des entités

Pour mettre à jour une entité existante, modifiez les attributs de la structure, puis appelez datastore.Put. Les données écrasent l'entité existante. L'objet entier est envoyé à Datastore à chaque appel de datastore.Put.

Supprimer des entités

Selon la clé d'une entité, vous pouvez supprimer l'entité à l'aide de la fonction datastore.Delete :

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

Suppression groupée d'entités

Si vous devez supprimer un grand nombre d'entités, nous vous recommandons d'utiliser Dataflow pour supprimer ces entités de manière groupée.

Utiliser des opérations par lots

Vous pouvez utiliser les opérations par lot suivantes si vous souhaitez agir sur plusieurs entités avec un seul appel Datastore :

Voici un exemple d'appel par lot :

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

Les opérations par lot n'entraînent pas de modification des coûts. Vous serez facturé pour chaque clé employée dans ces opérations, que cette clé existe ou non. La taille des entités impliquées dans une opération n'a pas d'incidence sur les coûts.