Creazione e utilizzo delle chiavi di entità

Go Java PHP Python

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

• Il namespace dell'entità, che consente la multi-tenancy
• Il tipo di entità, che la classifica ai fini delle query Datastore
• Un percorso predecessore facoltativo che individua l'entità all'interno della gerarchia di Datastore.
• Un identificatore per la singola entità, che può essere
  • una stringa nome chiave
  • un ID numerico intero

Poiché l'identificatore fa parte della chiave dell'entità, è associato in modo permanente 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 a una proprietà il nome "key". Questo nome è riservato a una proprietà speciale utilizzata per archiviare la chiave del modello. Sebbene possa funzionare localmente, una proprietà denominata "key" impedirà il deployment in App Engine.

Specificare un nome 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)

Assegnare identificatori

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

• Il criterio default genera una sequenza casuale di ID non utilizzati distribuiti in modo approssimativamente 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 dipendere dal loro ordine, la cosa migliore da fare è utilizzare l'allocazione manuale.

Nota: anziché utilizzare stringhe di nomi chiave o generare automaticamente ID numerici, le applicazioni avanzate a volte potrebbero voler assegnare manualmente i propri ID numerici alle entità che creano. Tieni presente, tuttavia, 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 è che la tua applicazione ottenga un blocco di ID con le datastore.AllocateIDs funzione. Il generatore di ID automatici di Datastore terrà traccia degli ID allocati con questo metodo ed eviterà di riutilizzarli per un'altra entità, quindi puoi utilizzare questi ID in sicurezza senza conflitti.

Utilizzare i percorsi predecessori

Le entità in Cloud Datastore formano uno spazio strutturato gerarchicamente simile alla struttura di directory di un file system. Quando crei un'entità, puoi facoltativamente designarne un'altra come entità principale; la nuova entità è un'entità secondaria dell'entità principale (tieni presente che, a differenza di un file system, l'entità principale non deve esistere). Un'entità senza un'entità principale è un'entità radice. L'associazione tra un'entità e la sua entità principale è 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à principale o a due entità radice (quelle senza entità principale).

L'entità principale di un'entità, l'entità principale dell'entità principale e così via in modo ricorsivo sono i suoi predecessori; i suoi elementi secondari, gli elementi secondari degli elementi secondari e così via sono i suoi discendenti. Entità base e tutti i suoi discendenti appartengono allo stesso gruppo di entità. La sequenza di entità che inizia con un'entità radice e procede da entità principale a entità secondaria, fino a un'entità specifica, costituisce il percorso predecessore di quell'entità. La chiave completa che identifica l'entità è costituita da una sequenza di coppie tipo-identificatore che specificano il percorso predecessore e terminano con quelle dell'entità stessa:

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

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

[Person:GreatGrandpa]

Questo concetto è illustrato nel seguente diagramma:

Per designare l'entità principale di un'entità, utilizza l'argomento parent a datastore.NewKey. Il valore di questo argomento deve essere la chiave dell'entità padre. L'esempio seguente crea un'entità di tipo Address e designa un'entità Employee come entità 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)