Creazione, recupero, aggiornamento ed eliminazione delle entità

Gli oggetti dati in Datastore sono noti come entità, ognuna delle quali è classificata come un determinato 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 saperne di più sulle entità, consulta il documento sui concetti Entità, proprietà e chiavi.

Creazione di entità e impostazione di proprietà

In Go, crei una nuova entità creando un'istanza di una struttura Go, completando i relativi campi e chiamando datastore.Put per salvarla in Datastore. In Datastore verranno salvati solo i campi esportati (che iniziano con una lettera maiuscola). 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 relativi valori di 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 della 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à

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 struttura Go appropriata.

Aggiornamento delle entità

Per aggiornare un'entità esistente, modifica gli attributi della struttura e poi 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.

Utilizzare le operazioni batch

Puoi utilizzare le seguenti operazioni collettive se vuoi operare su più entità in una singola chiamata a 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 collettiva, indipendentemente dal fatto che esista o meno. Le dimensioni delle entità coinvolte in un'operazione non influiscono sul costo.