Python 2.7 è deprecato. Non potrai eseguire il deployment di applicazioni Python 2.7, anche se la tua organizzazione in precedenza utilizzava una policy dell'organizzazione per riattivare i deployment dei runtime legacy. Le tue applicazioni Python 2.7 esistenti continueranno a essere eseguite e a ricevere traffico. Ti consigliamo di eseguire la migrazione all'ultima versione supportata di Python.

Funzioni di Datastore

Nota:gli sviluppatori che creano nuove applicazioni sono fortemente incoraggiati a utilizzare la libreria client NDB, che offre diversi vantaggi rispetto a questa libreria client, ad esempio la memorizzazione automatica nella cache delle entità tramite l'API Memcache. Se al momento utilizzi la libreria client DB precedente, leggi la guida alla migrazione da DB a NDB.

Le funzioni descritte in questa pagina sono definite nel pacchetto google.appengine.ext.db.

Funzioni

allocate_ids (model, count)

Alloca un batch di ID nel datastore per una combinazione di tipo e parent del datastore.

Gli ID allocati in questo modo non verranno utilizzati dal generatore automatico di sequenze di ID di Datastore e possono essere utilizzati nelle chiavi delle entità senza conflitti.

Argomenti

model: La chiave del modello per cui allocare un batch di ID. Si tratta di una chiave normale, ma per determinare quale sequenza di ID utilizzare sono necessari solo l'elemento principale e il tipo di chiave.
count: Il numero di ID da allocare.

Restituisce una tupla del primo e dell'ultimo ID allocati. Ad esempio, se hai allocato 10 ID utilizzando questa funzione, riceverai un valore restituito nel formato (1, 10), non un elenco completo degli ID creati.

Esempio di allocazione e utilizzo degli ID:

# allocate for MyModel without an instance
handmade_key = db.Key.from_path('MyModel', 1)
first_batch = db.allocate_ids(handmade_key, 10)
first_range = range(first_batch[0], first_batch[1] + 1)

# or allocate using an existing key
model_instance = MyModel.all().get()
second_batch = db.allocate_ids(model_instance.key(), 10)
second_range = range(second_batch[0], second_batch[1] + 1)

# and then use them! woo!
my_id = second_range.pop(0)
new_key = db.Key.from_path('MyModel', my_id)
new_instance = MyModel(key=new_key)
new_instance.put()
assert new_instance.key().id() == my_id

# the Datastore will not assign ids in first_batch or second_batch
another_instance = MyModel()
another_instance.put()
assert another_instance.key().id() not in first_range
assert another_instance.key().id() not in second_range

allocate_ids_async (model, count)

Alloca in modo asincrono un batch di ID nel datastore per una combinazione di tipo e parent del datastore.

Questa funzione è identica a allocate_ids() tranne per il fatto che restituisce un oggetto asincrono. Puoi chiamare get_result() sul valore restituito per bloccare la chiamata e restituire il risultato.

Argomenti

model: Un'istanza db.Model , una chiave o una stringa da utilizzare come modello per specificare la sequenza di ID in cui allocare gli ID. Gli ID restituiti devono essere utilizzati solo in entità con lo stesso genitore (se presente) e tipo di questa chiave.
count: Il numero di ID da allocare.

Restituisce una tupla del primo e dell'ultimo ID allocati. Ad esempio, se hai allocato 10 ID utilizzando questa funzione, otterrai un valore restituito nel formato (1, 10), non un elenco completo degli ID creati.

allocate_id_range (model, start, end, **kwargs)

Alloca un intervallo di ID con endpoint specifici. Una volta allocati questi ID, puoi assegnarli manualmente alle entità appena create.

L'allocatore automatico di ID di Datastore non assegna mai una chiave già allocata (tramite l'allocazione automatica di ID o tramite una chiamata `allocate_ids` esplicita). Di conseguenza, le entità scritte nell'intervallo di chiavi specificato non verranno mai sovrascritte. Tuttavia, la scrittura di entità con chiavi assegnate manualmente in questo intervallo potrebbe sovrascrivere entità esistenti (o nuove entità scritte da una richiesta separata), a seconda dello stato dell'intervallo di chiavi restituito.

Utilizza questa funzione solo se disponi di un intervallo di ID numerici esistente che vuoi riservare (ad esempio, per il caricamento collettivo di entità che hanno già ID). Se non ti interessa quali ID ricevi, utilizza allocate_ids() in alternativa.

Argomenti

model: Un'istanza db.Model , una chiave o una stringa da utilizzare come modello per specificare la sequenza di ID in cui allocare gli ID. Gli ID restituiti devono essere utilizzati solo in entità con lo stesso genitore (se presente) e tipo di questa chiave.
start: Il primo ID da allocare, un numero.
end: L'ultimo ID da allocare, un numero.

Restituisce uno dei seguenti valori: (KEY_RANGE_EMPTY, KEY_RANGE_CONTENTION, KEY_RANGE_COLLISION). Se non KEY_RANGE_EMPTY, questo rappresenta un potenziale problema con l'utilizzo dell'intervallo di chiavi allocato.

create_transaction_options (**kwargs)

Crea un oggetto di opzioni di transazione (classe TransactionOptions) per controllare l'esecuzione della transazione. Passa l'oggetto risultante come primo argomento alla funzione run_in_transaction_options().

Argomenti

propagation [propagazione]

Cosa fare se questa funzione transazionale viene chiamata dall'interno di un'altra transazione:

CONSENTITO: Se è già in corso una transazione, continua a utilizzarla; in caso contrario, avviane una.
Nota:se una funzione che utilizza questo criterio genera un'eccezione, probabilmente non è sicuro rilevarla ed eseguire il commit della transazione esterna. La funzione potrebbe aver lasciato la transazione esterna in uno stato errato.
OBBLIGATORIO: Continua nella transazione esistente, se presente; in caso contrario, genera un'eccezione BadRequestError.
Nota:se una funzione che utilizza questo criterio genera un'eccezione, probabilmente non è sicuro rilevarla ed eseguire il commit della transazione esterna. La funzione potrebbe aver lasciato la transazione esterna in uno stato errato.
INDEPENDENT: Crea una nuova transazione, mettendo in pausa quelle esistenti.
Nota:una funzione che utilizza questo criterio non deve restituire entità lette nella nuova transazione, in quanto le entità non sono coerenti a livello transazionale con la transazione esterna.
ANNIDATO: (Funzionalità non ancora supportata) Crea una transazione nidificata all'interno di una esistente.

xg

Se True, consenti transazioni cross-group (XG). Genera un'eccezione BadArgumentError se impostato su un valore non booleano.

retries

Numero di nuovi tentativi da effettuare in caso di errore del commit della transazione.

deadline

Tempo massimo, in secondi, di attesa prima che Datastore restituisca un risultato prima di interrompere l'operazione con un errore. Accetta un valore intero o con virgola mobile. Non può essere impostato su un valore superiore a quello predefinito (60 secondi), ma può essere ridotto per garantire che una determinata operazione non vada a buon fine rapidamente (ad esempio, per restituire una risposta più rapida all'utente, riprovare l'operazione, provare un'operazione diversa o aggiungere l'operazione a una coda di attività).

L'esempio seguente crea le opzioni per una successiva transazione cross-group (XG):

from google.appengine.ext import db

xg_on = db.create_transaction_options(xg=True)

def my_txn():
  x = MyModel(a=3)
  x.put()
  y = MyModel(a=7)
  y.put()

db.run_in_transaction_options(xg_on, my_txn)

delete (models, deadline=60)

Elimina una o più istanze del modello da Datastore.

Argomenti

modelli: Un'istanza del modello, una chiave entità, o un elenco (o altro iterabile) di istanze del modello o chiavi entità da eliminare.
deadline: Tempo massimo, in secondi, di attesa prima che Datastore restituisca un risultato prima di interrompere l'operazione con un errore. Accetta un valore intero o con virgola mobile. Non può essere impostato su un valore superiore a quello predefinito (60 secondi), ma può essere ridotto per garantire che una determinata operazione non vada a buon fine rapidamente (ad esempio, per restituire una risposta più rapida all'utente, riprovare l'operazione, provare un'operazione diversa o aggiungere l'operazione a una coda di attività).

Come per put(), se vengono fornite più chiavi, queste potrebbero trovarsi in più di un gruppo di entità.

Verrà sempre generata un'eccezione se si verifica un errore durante l'operazione, anche se alcune delle entità sono state effettivamente eliminate. Se la chiamata viene restituita senza generare un'eccezione, tutte le entità sono state eliminate correttamente.

Attenzione: l'eliminazione di più entità in una singola operazione non garantisce che le eliminazioni avvengano in modo atomico, a meno che l'operazione non venga eseguita all'interno di una transazione. Altri processi che eseguono query su Datastore potrebbero visualizzare risultati incoerenti anche quando la query viene eseguita conelevata coerenzae.

delete_async (models, deadline=60)

Elimina in modo asincrono una o più istanze del modello dal Datastore.

Questa funzione è identica a delete() tranne per il fatto che restituisce un oggetto asincrono. Puoi chiamare get_result() sul valore restituito per bloccare la chiamata.

Argomenti

modelli: Un'istanza del modello, una chiave entità, o un elenco (o altro iterabile) di istanze del modello o chiavi entità da eliminare.
deadline: Tempo massimo, in secondi, di attesa prima che Datastore restituisca un risultato prima di interrompere l'operazione con un errore. Accetta un valore intero o con virgola mobile. Non può essere impostato su un valore superiore a quello predefinito (60 secondi), ma può essere ridotto per garantire che una determinata operazione non vada a buon fine rapidamente (ad esempio, per restituire una risposta più rapida all'utente, riprovare l'operazione, provare un'operazione diversa o aggiungere l'operazione a una coda di attività).

Come per put(), se vengono fornite più chiavi, queste possono appartenere a più di un gruppo di entità.

Questa funzione restituisce un oggetto che consente di bloccare il risultato della chiamata.

get (keys, read_policy=STRONG_CONSISTENCY, deadline=60)

Recupera le istanze del modello specifiche con le chiavi indicate da Datastore.

Argomenti

chiavi

Key Chiave dell'entità da recuperare, una rappresentazione di stringa della chiave o un elenco di chiavi o delle relative rappresentazioni di stringa.

read_policy

Leggi le norme che specificano il livello di coerenza dei dati desiderato:

STRONG_CONSISTENCY: Garantisce i risultati più recenti, ma è limitato a un singolo gruppo di entità.
EVENTUAL_CONSISTENCY: Può estendersi a più gruppi di entità, ma occasionalmente potrebbe restituire risultati non aggiornati. In generale, le query con coerenza finale vengono eseguite più rapidamente rispetto alle query con coerenza forte, ma non è garantito.

Nota:le query globali (non di antenati) ignorano questo argomento.

deadline

Se keys è costituito da una singola chiave (o dalla relativa rappresentazione di stringa), questa funzione restituisce l'istanza del modello associata alla chiave se la chiave esiste in Datastore, altrimenti None. Se keys è un elenco, il valore restituito è un elenco corrispondente di istanze del modello, con valori None in cui non esiste alcuna entità per una determinata chiave.

Vedi anche Model.get().

get_async (keys, read_policy=STRONG_CONSISTENCY, deadline=60)

Recupera in modo asincrono le istanze del modello specificate da Datastore.

Questa funzione è identica a get() tranne per il fatto che restituisce un oggetto asincrono. Puoi chiamare get_result() sul valore restituito per bloccare la chiamata e ottenere i risultati.

Argomenti

chiavi

Key Chiave dell'entità da recuperare, una rappresentazione di stringa della chiave o un elenco di chiavi o delle relative rappresentazioni di stringa.

read_policy

Leggi le norme che specificano il livello di coerenza dei dati desiderato:

STRONG_CONSISTENCY: Garantisce i risultati più recenti, ma è limitato a un singolo gruppo di entità.
EVENTUAL_CONSISTENCY: Può estendersi a più gruppi di entità, ma occasionalmente potrebbe restituire risultati non aggiornati. In generale, le query con coerenza finale vengono eseguite più rapidamente rispetto alle query con coerenza forte, ma non è garantito.

Nota:le query globali (non di antenati) ignorano questo argomento.

deadline

Vedi anche Model.get().

get_indexes ()

Restituisce un elenco di indici compositi appartenenti all'applicazione chiamante.

Il seguente esempio mostra come ottenere e utilizzare gli indici:

def get_index_state_as_string(index_state):
  return {db.Index.BUILDING:'BUILDING', db.Index.SERVING:'SERVING',
          db.Index.DELETING:'DELETING', db.Index.ERROR:'ERROR'}[index_state]

def get_sort_direction_as_string(sort_direction):
  return {db.Index.ASCENDING:'ASCENDING',
          db.Index.DESCENDING:'DESCENDING'}[sort_direction]


def dump_indexes():
  for index, state in db.get_indexes():
    print "Kind: %s" % index.kind()
    print "State: %s" % get_index_state_as_string(state)
    print "Is ancestor: %s" % index.has_ancestor()
    for property_name, sort_direction in index.properties():
      print "  %s:%s" % (property_name,
                         get_sort_direction_as_string(sort_direction))

get_indexes_async ()

Restituisce in modo asincrono un elenco di indici compositi appartenenti all'applicazione chiamante.

is_in_transaction ()

Restituisce un valore booleano che indica se l'ambito corrente viene eseguito in una transazione.

model_to_protobuf (model_instance)

Crea la serializzazione del buffer del protocollo di un'istanza Model. Un buffer di protocollo è il formato di serializzazione di Google utilizzato per le chiamate di procedura remota e può essere utile per serializzare gli oggetti Datastore a fini di backup e ripristino.

Attenzione: questa funzione utilizza un formato diverso (precedente) per i buffer di protocollo rispetto al formato open source dei buffer di protocollo e non è compatibile con l'implementazione open source.

Argomento

model_instance: L'istanza della classe Model (o una sottoclasse) da serializzare.

Restituisce la serializzazione del buffer del protocollo dell'oggetto come stringa di byte.

model_from_protobuf (pb)

Crea un'istanza Model basata su una serializzazione di protocol buffer; per ulteriori informazioni, consulta model_to_protobuf().

Argomento

pb: La serializzazione del buffer del protocollo, restituita da model_to_protobuf().

Restituisce un oggetto della classe di tipo appropriata. Se la classe kind non esiste, genera un'eccezione KindError. Se l'oggetto non è valido in base al modello, genera un'eccezione BadValueError.

Puoi salvare il nuovo oggetto in Datastore come qualsiasi altra istanza Model, ad esempio chiamando il relativo metodo put(). L'oggetto conserva la chiave che aveva quando è stato creato il buffer del protocollo. Se esiste già un oggetto con quella chiave nel Datastore, il salvataggio dell'oggetto deserializzato sovrascrive l'oggetto esistente.

Attenzione:se la chiave dell'oggetto utilizza un ID assegnato dal sistema e questo ID non è ancora stato allocato per il percorso e il tipo specificati, il salvataggio andrà a buon fine, ma l'ID non è riservato. A un oggetto creato in futuro potrebbe essere assegnato questo ID, che sovrascriverebbe l'oggetto precedente. Per sicurezza, ripristina gli oggetti solo nella stessa applicazione in cui esistevano al momento della serializzazione.

model_is_projection (model_instance)

Restituisce True se la query specificata (model_instance) è una query di proiezione anziché una query per un'entità completa.

Argomento

model_instance: La query che stai controllando per determinare se si tratta di una query di proiezione.

Restituisce True se la query è una query di proiezione, False in caso contrario.

put (models, deadline=60)

Scrive una o più istanze del modello nel datastore.

Argomenti

modelli: Un'istanza del modello o un elenco di istanze del modello da archiviare.
deadline: Tempo massimo, in secondi, di attesa prima che Datastore restituisca un risultato prima di interrompere l'operazione con un errore. Accetta un valore intero o con virgola mobile. Non può essere impostato su un valore superiore a quello predefinito (60 secondi), ma può essere ridotto per garantire che una determinata operazione non vada a buon fine rapidamente (ad esempio, per restituire una risposta più rapida all'utente, riprovare l'operazione, provare un'operazione diversa o aggiungere l'operazione a una coda di attività).

Se vengono fornite più istanze del modello, queste potrebbero trovarsi in più di un gruppo di entità.

Verrà sempre generata un'eccezione se si verifica un errore durante l'operazione, anche se alcune delle entità sono state effettivamente scritte. Se la chiamata viene restituita senza generare un'eccezione, tutte le entità sono state scritte correttamente.

Se models è costituito da una singola istanza del modello, questa funzione restituisce l'oggetto Key corrispondente. Se models è un elenco, il valore restituito è un elenco di oggetti Key corrispondenti.

Attenzione: la scrittura di più entità in una singola operazione non garantisce che le scritture avvengano in modo atomico, a meno che l'operazione non venga eseguita all'interno di una transazione. Altri processi che eseguono query su Datastore potrebbero visualizzare risultati incoerenti anche quando la query viene eseguita conelevata coerenzae.

put_async (models, deadline=60)

Scrive una o più istanze del modello nel datastore.

Questa funzione è identica a put() tranne per il fatto che restituisce un oggetto asincrono. Puoi chiamare get_result() sul valore restituito per bloccare la chiamata e ottenere i risultati.

Argomenti

modelli: Un'istanza del modello o un elenco di istanze del modello da archiviare.
deadline: Tempo massimo, in secondi, di attesa prima che Datastore restituisca un risultato prima di interrompere l'operazione con un errore. Accetta un valore intero o con virgola mobile. Non può essere impostato su un valore superiore a quello predefinito (60 secondi), ma può essere ridotto per garantire che una determinata operazione non vada a buon fine rapidamente (ad esempio, per restituire una risposta più rapida all'utente, riprovare l'operazione, provare un'operazione diversa o aggiungere l'operazione a una coda di attività).

Se vengono fornite più istanze del modello, queste potrebbero trovarsi in più di un gruppo di entità.

Questa funzione restituisce un oggetto asincrono su cui get_result() può essere chiamato. I risultati restituiti sono gli stessi di put().

query_descendants (model_instance)

Restituisce una query per tutti i discendenti di un'istanza del modello.

Argomento

model_instance: L'istanza del modello di cui vuoi trovare i discendenti.

run_in_transaction (function, *args, **kwargs)

Esegue una funzione contenente aggiornamenti Datastore in una singola transazione. Se un codice genera un'eccezione durante la transazione, tutti gli aggiornamenti apportati alla transazione vengono annullati. In alternativa, puoi utilizzare il decoratore @db.transactional().

Argomenti

funzione: Funzione da eseguire.
args: Argomenti posizionali da passare alla funzione.
kwargs: Argomenti delle parole chiave da passare alla funzione.

Se la funzione restituisce un valore, run_in_transaction() restituisce il valore al chiamante.

Se la funzione genera un'eccezione, viene eseguito il rollback della transazione. Se l'eccezione è un'eccezione Rollback, non viene generata di nuovo; qualsiasi altra eccezione viene generata di nuovo per il chiamante.

Datastore utilizza il blocco ottimistico e i nuovi tentativi per le transazioni. Se la transazione preparata dalla funzione non può essere eseguita, run_in_transaction() chiama di nuovo la funzione, riprovando la transazione fino a 3 volte. (Per utilizzare un numero diverso di tentativi, utilizza run_in_transaction_custom_retries().) Poiché la funzione di transazione può essere chiamata più volte per una singola transazione, la funzione non deve avere effetti collaterali, incluse modifiche agli argomenti.

Se la transazione non può essere eseguita, ad esempio a causa di un elevato tasso di contesa, viene generata un'eccezione TransactionFailedError.

from google.appengine.ext import db

class Counter(db.Model):
  name = db.StringProperty()
  count = db.IntegerProperty(default=0)

def decrement(key, amount=1):
  counter = db.get(key)
  counter.count -= amount
  if counter.count < 0:        # Don't let counter go negative
    raise db.Rollback()
  db.put(counter)

q = db.GqlQuery("SELECT * FROM Counter WHERE name = :1", "foo")
counter = q.get()
db.run_in_transaction(decrement, counter.key(), amount=5)

run_in_transaction_custom_retries (retries, function, *args, **kwargs)

Esegue una funzione contenente aggiornamenti di Datastore in una singola transazione, riprovando la transazione un numero specificato di volte in caso di contesa. Se un codice genera un'eccezione durante la transazione, tutti gli aggiornamenti apportati alla transazione vengono annullati.

A parte la possibilità di specificare il numero di tentativi, questa funzione si comporta in modo identico a run_in_transaction().

Argomenti

retries: Numero massimo di volte in cui chiamare la funzione in caso di contesa all'interno del gruppo di entità (più di un utente che tenta di modificare il gruppo contemporaneamente).
funzione: Funzione da eseguire.
args: Argomenti posizionali da passare alla funzione.
kwargs: Argomenti delle parole chiave da passare alla funzione.

run_in_transaction_options (options, function, *args, **kwargs)

Esegue una funzione contenente aggiornamenti Datastore in una singola transazione utilizzando le opzioni specificate in un oggetto delle opzioni di transazione. Se un codice genera un'eccezione durante la transazione, tutti gli aggiornamenti di Datastore apportati alla transazione vengono annullati.

Per le transazioni cross-group (XG), il parametro xg nell'oggetto delle opzioni di transazione deve essere impostato su True.

Argomenti

opzioni: L'oggetto delle opzioni di transazione contenente le impostazioni utilizzate da questa transazione. Per attivare le transazioni XG, il parametro xg deve essere impostato su True.
funzione: Funzione da eseguire.
args: Argomenti posizionali da passare alla funzione.
kwargs: Argomenti delle parole chiave da passare alla funzione.

Se la funzione restituisce un valore, run_in_transaction_options() restituisce il valore al chiamante.

Datastore utilizza il blocco ottimistico e i nuovi tentativi per le transazioni. Se non è possibile eseguire il commit della transazione preparata dalla funzione, run_in_transaction_options() chiama di nuovo la funzione, riprovando la transazione fino al numero di tentativi specificato nell'oggetto delle opzioni di transazione. Poiché la funzione di transazione può essere chiamata più di una volta per una singola transazione, la funzione non deve avere effetti collaterali, incluse modifiche agli argomenti.

Se la transazione non può essere eseguita, ad esempio a causa di un elevato tasso di contesa, viene generata un'eccezione TransactionFailedError.

L'esempio seguente mostra come utilizzare questa funzione per eseguire una transazione tra gruppi:

from google.appengine.ext import db

xg_options = db.create_transaction_options(xg=True)

def my_txn():
  x = MyModel(a=3)
  x.put()
  y = MyModel(a=7)
  y.put()

db.run_in_transaction_options(xg_options, my_txn)

to_dict (model_instance, dictionary=None)

Crea e restituisce una rappresentazione di dizionario di un'istanza del modello.

Argomenti

model_instance: Istanza del modello da copiare.
dizionario: Se presente, dizionario in cui unire i dati del modello. I valori del modello sovrascrivono i valori del dizionario; le voci del dizionario non corrispondenti ai campi nell'istanza del modello vengono conservate.

Decoratori

@db.transactional (propagation=ALLOWED, xg=False, retries=3, deadline=60)

Fa sì che una funzione venga eseguita all'interno di una transazione db. Pertanto, anziché chiamare run_in_transaction(func), puoi chiamare func().

Argomenti

propagation [propagazione]

Cosa fare se questa funzione transazionale viene chiamata dall'interno di un'altra transazione:

CONSENTITO: Se è già in corso una transazione, continua a utilizzarla; in caso contrario, avviane una.
Nota:se una funzione che utilizza questo criterio genera un'eccezione, probabilmente non è sicuro rilevarla ed eseguire il commit della transazione esterna. La funzione potrebbe aver lasciato la transazione esterna in uno stato errato.
OBBLIGATORIO: Continua nella transazione esistente, se presente; in caso contrario, genera un'eccezione BadRequestError.
Nota:se una funzione che utilizza questo criterio genera un'eccezione, probabilmente non è sicuro rilevarla ed eseguire il commit della transazione esterna. La funzione potrebbe aver lasciato la transazione esterna in uno stato errato.
INDEPENDENT: Crea una nuova transazione, mettendo in pausa quelle esistenti.
Nota:una funzione che utilizza questo criterio non deve restituire entità lette nella nuova transazione, in quanto le entità non sono coerenti a livello transazionale con la transazione esterna.
ANNIDATO: (Funzionalità non ancora supportata) Crea una transazione nidificata all'interno di una esistente.

xg

Se True, consenti transazioni cross-group (XG). Genera un'eccezione BadArgumentError se impostato su un valore non booleano.

retries

Numero di nuovi tentativi da effettuare in caso di errore del commit della transazione.

deadline

@db.non_transactional (allow_existing=True)

Garantisce che una funzione venga eseguita al di fuori di una transazione db, anche se chiamata dall'interno di una transazione.

Argomento

allow_existing: Se True, consenti la chiamata della funzione dall'interno di una transazione esistente; se False, genera un'eccezione BadRequestError.

Funzioni di Datastore Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Funzioni

Decoratori

Funzioni di Datastore