Creazione, recupero, aggiornamento ed eliminazione delle entità

Gli oggetti dati in Datastore sono noti come entità, ognuna delle quali è classificata in base a un particolare tipo ai fini delle query. Ad esempio, se stai scrivendo un'applicazione per le risorse umane, potresti rappresentare ogni dipendente con un'entità di tipo Employee. Tieni presente che i valori dei dati delle entità sono sotto forma di proprietà. Per ulteriori informazioni sulle entità, consulta il documento concettuale Entità, proprietà e chiavi.

Creazione di entità e impostazione di proprietà

In Go, crei una nuova entità costruendo un'istanza di una struttura Go, compilando i relativi campi e chiamando datastore.Put per salvarla in Datastore. Solo i campi esportati (che iniziano con una lettera maiuscola) verranno salvati in Datastore. Puoi specificare il nome della chiave dell'entità passando un argomento stringID non vuoto a datastore.NewKey.

Il seguente esempio crea un'entità di tipo Employee, compila i valori delle relative proprietà e la salva in 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
	}
	// ...
}

Il tipo Employee dichiara quattro campi per il modello dei dati: FirstName, LastName, HireDate e AttendedHRTraining.

Se fornisci un nome di chiave vuoto o utilizzi datastore.NewIncompleteKey, Datastore genererà automaticamente un ID numerico per la chiave dell'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)

Recupero delle entità in corso…

Per recuperare un'entità identificata da una determinata chiave, passa *datastore.Key come argomento alla funzione datastore.Get. Puoi generare *datastore.Key utilizzando la funzione 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 compila un'istanza della struct Go appropriata.

Aggiornamento delle entità

Per aggiornare un'entità esistente, modifica gli attributi dello struct, quindi chiama datastore.Put. I dati sovrascrivono l'entità esistente. L'intero oggetto viene inviato a Datastore a ogni chiamata a datastore.Put.

Eliminazione di entità

Data la chiave di un'entità, puoi eliminarla con la funzione datastore.Delete:

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

Eliminazione di entità in blocco

Se devi eliminare un numero elevato di entità, ti consigliamo di utilizzare Dataflow per eliminare le entità in blocco.

Utilizzo delle operazioni batch

Puoi utilizzare le seguenti operazioni batch se vuoi operare su più entità in una singola chiamata Datastore:

Ecco un esempio di chiamata batch:

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

Le operazioni collettive non modificano i costi. Ti verrà addebitato il costo di ogni chiave in un'operazione batch, indipendentemente dall'esistenza di ciascuna chiave. Le dimensioni delle entità coinvolte in un'operazione non influiscono sul costo.