Creazione e utilizzo delle chiavi di entità

Questa API è supportata per i runtime di prima generazione e può essere utilizzata durante l'upgrade ai runtime di seconda generazione corrispondenti. Se esegui l'aggiornamento al runtime di App Engine Go 1.12 o versioni successive, consulta la guida alla migrazione per conoscere le opzioni di migrazione per i servizi in bundle legacy.

Ogni entità in Datastore ha una chiave che la identifica in modo univoco. La chiave è costituita dai seguenti componenti:

• Lo spazio dei nomi dell'entità, che consente la multitenancy
• Il kind dell'entità, che la classifica ai fini delle query Datastore
• Un percorso predecessore facoltativo che individua l'entità all'interno della gerarchia Datastore.

• Un identificatore per la singola entità, che può essere

  • Una stringa del nome della chiave
  • un ID numerico intero

Poiché l'identificatore fa parte della chiave dell'entità, viene associato definitivamente all'entità e non può essere modificato. Puoi assegnare l'identificatore in due modi:

• Specifica la tua stringa nome chiave per l'entità.
• Consenti a Datastore di assegnare automaticamente all'entità un ID numerico intero.

Non assegnare il nome "chiave" alla proprietà. Questo nome è riservato a una proprietà speciale utilizzata per archiviare la chiave del modello. Anche se può funzionare localmente, una proprietà denominata "key" impedisce il deployment in App Engine.

Specifica del nome della chiave per un'entità

Per assegnare un nome chiave a un'entità, fornisci un argomento stringID non vuoto a datastore.NewKey:

// Create a key with a key name "asalieri".
key := datastore.NewKey(
	ctx,        // context.Context
	"Employee", // Kind
	"asalieri", // String ID; empty means no string ID
	0,          // Integer ID; if 0, generate automatically. Ignored if string ID specified.
	nil,        // Parent Key; nil means no parent
)

Per consentire a Datastore di assegnare automaticamente un ID numerico, utilizza un argomento stringID vuoto:

// Create a key such as Employee:8261.
key := datastore.NewKey(ctx, "Employee", "", 0, nil)
// This is equivalent:
key = datastore.NewIncompleteKey(ctx, "Employee", nil)

Assegnazione degli identificatori

Puoi configurare Datastore per generare ID automatici utilizzando due diversi criteri per gli ID automatici:

• Il criterio default genera una sequenza casuale di ID non utilizzati, distribuiti approssimativamente in modo uniforme. Ogni ID può contenere fino a 16 cifre decimali.
• Il criterio legacy crea una sequenza di ID interi più piccoli non consecutivi.

Se vuoi mostrare gli ID entità all'utente e/o dipendono dal loro ordine, la soluzione migliore è utilizzare l'allocazione manuale.

Nota: anziché utilizzare stringhe dei nomi delle chiavi o generare ID numerici automaticamente, a volte le applicazioni avanzate potrebbero voler assegnare manualmente i propri ID numerici alle entità che creano. Tuttavia, tieni presente che non esiste nulla che impedisca a Datastore di assegnare uno dei tuoi ID numerici manuali a un'altra entità. L'unico modo per evitare questi conflitti è fare in modo che l'applicazione riceva un blocco di ID con la funzione datastore.AllocateIDs. Il generatore di ID automatico di Datastore tiene traccia degli ID allocati con questa funzione e eviterà di riutilizzarli per un'altra entità. In questo modo, puoi utilizzare questi ID in modo sicuro senza conflitti.

Utilizzo dei percorsi predecessori

Le entità in Cloud Datastore formano uno spazio strutturato in modo gerarchico simile alla struttura di directory di un file system. Quando crei un'entità, puoi eventualmente indicare un'altra entità come parent;; la nuova entità è un'entità parent; dell'entità padre (tieni presente che, a differenza di un file system, l'entità padre non deve necessariamente esistere). Un'entità senza un'entità padre è un'entità principale. L'associazione tra un'entità e l'entità padre è permanente e non può essere modificata una volta creata l'entità. Cloud Datastore non assegnerà mai lo stesso ID numerico a due entità con la stessa entità padre o a due entità radice (senza un elemento padre).

L'entità padre, l'entità padre e così via in modo ricorsivo, sono i suoi antenati; i suoi figli, i figli di figli e così via sono i suoi discendenti. Un'entità base e tutti i suoi discendenti appartengono allo stesso gruppo di entità. La sequenza di entità che inizia con un'entità radice e che prosegue dalla risorsa padre a quella figlio e che porta a una determinata entità, costituisce il percorso predecessore di quell'entità. La chiave completa che identifica l'entità è composta da una sequenza di coppie tipo-identificatore che specifica il percorso predecessore e termina con quelli dell'entità stessa:

[Person:GreatGrandpa, Person:Grandpa, Person:Dad, Person:Me]

Per unentità base, il percorso predecessore è vuoto e la chiave è costituita esclusivamente dal tipo e dall'identificatore dell'entità:

[Person:GreatGrandpa]

Questo concetto è illustrato dal seguente diagramma:

Per designare l'entità padre di un'entità, utilizza l'argomento parent per datastore.NewKey. Il valore di questo argomento deve essere la chiave dell'entità padre. L'esempio seguente crea un'entità di tipo Address e indica un'entità Employee come principale:

// Create Employee entity
employee := &Employee{ /* ... */ }
employeeKey, err := datastore.Put(ctx, datastore.NewIncompleteKey(ctx, "Employee", nil), employee)

// Use Employee as Address entity's parent
// and save Address entity to datastore
address := &Address{ /* ... */ }
addressKey := datastore.NewIncompleteKey(ctx, "Address", employeeKey)
_, err = datastore.Put(ctx, addressKey, address)