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 la documentazione sui percorsi degli antenati e sulle transazioni.

Creazione di entità e impostazione di proprietà

Puoi creare un'entità e un set chiamando il metodo del costruttore per la relativa classe di modello. Per informazioni su come creare una classe di modelli di entità, consulta Creare e utilizzare le classi di modelli di entità.

L'esempio seguente mostra come chiamare il costruttore di una classe di modelli con argomenti di parole chiave:

sandy = Account(
    username='Sandy', userid=123, email='sandy@example.com')

Questo codice crea un oggetto nella memoria principale del programma. Tuttavia, tieni presente che l'entità scompare al termine del processo, pertanto devi anche persisterla in Datastore chiamando put(), come segue:

sandy_key = sandy.put()

Tieni presente che viene restituita una chiave che puoi utilizzare per recuperare l'entità da Datastore in un secondo momento.

Imposta le proprietà utilizzando una delle seguenti opzioni:

Specifica le proprietà dell'entità al costruttore con gli argomenti delle parole chiave:
```
sandy = Account(
    username='Sandy', userid=123, email='sandy@example.com')
```

Imposta le proprietà manualmente dopo la creazione dell'entità:

sandy = Account()
sandy.username = 'Sandy'
sandy.userid = 123
sandy.email = 'sandy@example.com'

Utilizza il metodo di utilità populate() per impostare più proprietà in un'unica operazione:

sandy = Account()
sandy.populate(
    username='Sandy',
    userid=123,
    email='sandy@gmail.com')

Indipendentemente da come scegli di impostare le proprietà dell'entità, i tipi di proprietà (in questo caso StringProperty e IntegerProperty) applicano il controllo del tipo.

Ad esempio:

bad = Account(
    username='Sandy', userid='not integer')  # raises an exception

...

sandy.username = 42  # raises an exception

Recupero delle entità dalle chiavi

Se hai la chiave di un'entità, puoi recuperarla da Datastore:

sandy = sandy_key.get()

I metodi Key kind() e id() recuperano il tipo e l'identificatore dell'entità dalla chiave:

kind_string = sandy_key.kind()  # returns 'Account'
ident = sandy_key.id()  # returns '2'

Puoi anche utilizzare la chiave di un'entità per ottenere una stringa codificata adatta per l'inserimento in un URL:

url_string = sandy_key.urlsafe()

Viene prodotto un risultato come agVoZWxsb3IPCxIHQWNjb3VudBiZiwIM che in seguito può essere utilizzato per ricostruire la chiave e recuperare l'entità originale:

sandy_key = ndb.Key(urlsafe=url_string)
sandy = sandy_key.get()

Tieni presente che la stringa sicura per gli URL sembra criptica, ma non è criptata. Può essere facilmente decodificato per recuperare il tipo e l'identificatore dell'entità originale:

key = Key(urlsafe=url_string)
kind_string = key.kind()
ident = key.id()

Se utilizzi chiavi sicure per gli URL, non utilizzare dati sensibili come gli indirizzi email come identificatori di entità. Una possibile soluzione sarebbe utilizzare un hash dei dati sensibili come identificatore. In questo modo, le terze parti che possono vedere le chiavi criptate non possono utilizzarle per raccogliere indirizzi email, ma possono generare in modo indipendente il proprio hash di un indirizzo email noto e utilizzarlo per verificare se l'indirizzo è presente in Datastore.

Aggiornamento delle entità

Per aggiornare un'entità esistente, recuperala da Datastore, modifica le sue proprietà e archiviala di nuovo:

sandy = key.get()
sandy.email = 'sandy@example.co.uk'
sandy.put()

In questo caso puoi ignorare il valore restituito da put(), poiché la chiave dell'entità non cambia quando la aggiorni.

Eliminazione di entità

Quando un'entità non è più necessaria, puoi rimuoverla da Datastore con il metodo delete() della chiave:

sandy.key.delete()

Tieni presente che si tratta di un'operazione sulla chiave, non sull'entità stessa. Restituisce sempre None.

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 elaborare una raccolta di entità o chiavi in una singola chiamata anziché singolarmente in chiamate separate, ad esempio all'interno di un ciclo. Il risultato è una singola chiamata di procedura remota (RPC) per il batch, anziché una chiamata RPC distinta per ogni entità.

Il seguente codice mostra come eseguire questa operazione:

list_of_keys = ndb.put_multi(list_of_entities)
list_of_entities = ndb.get_multi(list_of_keys)
ndb.delete_multi(list_of_keys)

Nel codice riportato sopra, passi un elenco di oggetti chiave a ndb.get_multi per recuperare più entità in un batch. ndb.get_multi restituisce un elenco di oggetti entità con valori None per le chiavi che non hanno un'entità corrispondente in Datastore. Se ottieni le entità in questo modo, il numero di chiamate a Datastore per l'intero batch sarà inferiore. Il numero di chiamate per batch dipende dalle impostazioni della dimensione del batch.