Creazione, recupero, aggiornamento ed eliminazione delle entità

Gli oggetti di dati in Datastore sono noti come entità, ognuno dei quali è classificato in un determinato tipo ai fini delle query. Ad esempio, se stai scrivendo un'applicazione per le risorse umane, puoi rappresentare ogni dipendente con un'entità di tipo Employee. Tieni presente che i valori dei dati entità sono sotto forma di proprietà. Per ulteriori informazioni sulle entità, consulta la documentazione sui percorsi predecessori e sulle transazioni.

Creare entità e impostare le proprietà

Per creare un'entità e impostarla, richiama il metodo del costruttore per la relativa classe del modello. Consulta Creazione e utilizzo delle classi dei modelli di entità per informazioni sulla creazione di una classe dei modelli di entità.

L'esempio seguente mostra come richiamare un costruttore della classe del modello con argomenti 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 quando il processo termina, quindi devi mantenere anche l'entità in Datastore chiamando put() come segue:

sandy_key = sandy.put()

Tieni presente che questo restituisce 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à nel costruttore con argomenti parola 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 pratico populate() per impostare diverse proprietà in un'unica operazione: 
    sandy = Account()
sandy.populate(
    username='Sandy',
    userid=123,
    email='sandy@gmail.com')

Indipendentemente dal modo in cui scegli di impostare le proprietà dell'entità, i tipi di proprietà (in questo caso, StringProperty e IntegerProperty) applicano il controllo dei tipi.

Ad esempio:

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

Recupero di entità dalle chiavi

Se disponi della chiave di un'entità, puoi recuperare l'entità dal datastore:

sandy = sandy_key.get()

I metodi chiave 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 all'incorporamento in un URL:

url_string = sandy_key.urlsafe()

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

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

Nota che la stringa sicura per l'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 queste chiavi sicure per URL, non usare dati sensibili come gli indirizzi email come identificatori di entità. Una soluzione possibile è utilizzare un hash dei dati sensibili come identificatore. Ciò impedisce a terze parti, che possono vedere le chiavi criptate, di utilizzarle per raccogliere indirizzi email, anche se non impedisce loro di generare in modo indipendente il proprio hash di un indirizzo email noto e di utilizzarlo per verificare se quell'indirizzo è presente in Datastore.

Aggiornare le 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é una chiave di entità non cambia quando la aggiorni.

Eliminazione di entità

Quando un'entità non è più necessaria, puoi rimuoverla dal 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.

Utilizzo delle operazioni batch

Puoi elaborare una raccolta di entità o chiavi in una singola chiamata anziché in chiamate separate, ad esempio all'interno di un loop. Ne consegue una singola chiamata di procedura remota (RPC) per il batch, anziché una chiamata RPC separata per ogni entità.

Il seguente codice mostra come fare:

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 nel datastore. Questo metodo consente di ottenere meno chiamate a Datastore per l'intero batch. Il numero di chiamate per batch dipende dalle impostazioni delle dimensioni del batch.