Remarque : Python 2.7 n'est plus compatible à partir du 31 janvier 2024. Vos applications Python 2.7 existantes continueront à fonctionner et à recevoir du trafic. Toutefois, App Engine peut bloquer le redéploiement des applications qui utilisent des environnements d'exécution après leur date de fin de compatibilité. Nous vous recommandons de migrer vers la dernière version compatible de Python.

Fonctions Datastore

Remarque : Les développeurs qui créent des applications sont vivement encouragés à utiliser la bibliothèque cliente NDB qui présente plusieurs avantages supplémentaires par rapport à cette bibliothèque cliente, tels que la mise en cache automatique des entités via l'API Memcache. Si vous utilisez actuellement l'ancienne bibliothèque cliente DB, consultez le guide de migration de DB vers NDB.

Les fonctions décrites sur cette page sont définies dans le package google.appengine.ext.db.

Fonctions

allocate_ids (model, count)

Alloue un lot d'identifiants dans le datastore pour une combinaison de genre et de parent du datastore.

Les identifiants attribués de cette manière ne sont pas utilisés par le générateur automatique de séquence d'identification de Datastore et peuvent être utilisés sans conflit dans les clés d'entité.

Arguments

model: Clé de modèle à laquelle allouer un lot d'identifiants. Il s'agit d'une clé standard, mais seuls le parent et le genre de la clé sont nécessaires pour déterminer la séquence d'identification à utiliser.
count: Nombre d'identifiants à allouer.

Affiche un tuple des premier et dernier identifiants alloués. Par exemple, si vous avez alloué 10 identifiants à l'aide de cette fonction, une valeur au format (1, 10) est affichée au lieu de la liste complète des identifiants créés.

Exemple d'allocation et d'utilisation d'identifiants :

# 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)

Alloue en mode asynchrone un lot d'identifiants dans le datastore pour une combinaison de genre et de parent du datastore.

Cette fonction est identique à allocate_ids(), sauf qu'elle affiche un objet asynchrone. Vous pouvez appeler get_result() sur la valeur renvoyée pour bloquer l'appel et afficher le résultat.

Arguments

model: Chaîne, clé ou instance db.Model servant de modèle pour spécifier la séquence d'identification à laquelle allouer des ID. Les identifiants affichés ne doivent être utilisés que dans les entités ayant les mêmes parent (le cas échéant) et genre que cette clé.
count: Nombre d'identifiants à allouer.

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

Alloue une plage d'identifiants avec des points de terminaison spécifiques. Une fois ces identifiants alloués, vous pouvez les attribuer manuellement aux nouvelles entités.

L'outil d'attribution automatique d'identifiants du datastore n'affecte jamais une clé déjà attribuée (que ce soit par attribution automatique d'identifiants ou par un appel explicite de la fonction "allocate_ids"). Par conséquent, les entités écrites dans la plage de clés donnée ne seront jamais remplacées. Toutefois, l'écriture d'entités auxquelles des clés de cette plage ont été attribuées manuellement risque de remplacer des entités existantes (ou de nouvelles entités écrites par une requête distincte) en fonction de l'état de la plage de clés affiché.

N'utilisez cette fonction que si vous souhaitez réserver une plage d'identifiants numériques existante (par exemple, pour charger en bloc des entités ayant déjà des identifiants). Si les ID que vous recevez n'ont pas d'importance, utilisez plutôt la fonction allocate_ids().

Arguments

model: Chaîne, clé ou instance db.Model servant de modèle pour spécifier la séquence d'identification à laquelle allouer des ID. Les identifiants affichés ne doivent être utilisés que dans les entités ayant les mêmes parent (le cas échéant) et genre que cette clé.
start: Premier identifiant à allouer, sous forme de nombre.
end: Dernier identifiant à allouer, sous forme de nombre.

Affiche l'un des éléments (KEY_RANGE_EMPTY, KEY_RANGE_CONTENTION, KEY_RANGE_COLLISION). S'il ne s'agit pas de KEY_RANGE_EMPTY, cela représente un problème potentiel au niveau de l'utilisation de la plage de clés allouée.

create_transaction_options (**kwargs)

Crée un objet d'options de transaction (classe TransactionOptions) pour contrôler l'exécution de la transaction. Vous transmettez l'objet obtenu en tant que premier argument à la fonction run_in_transaction_options().

Arguments

propagation

Marche à suivre si cette fonction transactionnelle est appelée depuis une autre transaction :

ALLOWED: Si une transaction est déjà en cours, continuez de l'utiliser. Sinon, commencez-en une.
Remarque : Si une fonction utilisant cette règle génère une exception, il est probablement risqué de capturer l'exception et d'effectuer un commit de la transaction externe, car il se peut que la fonction ait laissé la transaction externe en mauvais état.
MANDATORY: Continuez dans la transaction existante, le cas échéant. Sinon, générez une exception BadRequestError.
Remarque : Si une fonction utilisant cette règle génère une exception, il est probablement risqué de capturer l'exception et d'effectuer un commit de la transaction externe, car il se peut que la fonction ait laissé la transaction externe en mauvais état.
INDEPENDENT: Créez une transaction en mettant en pause toute transaction existante.
Remarque : Une fonction utilisant cette stratégie ne doit afficher aucune entité lue dans la nouvelle transaction, car ces entités ne sont pas cohérentes avec la transaction externe pour ce qui est des transactions.
NESTED: (Pas encore compatible) Créez une transaction imbriquée dans une transaction existante.

xg

Si la valeur est True, autorisez les transactions entre groupes (XG). Génère une exception BadArgumentError, si elle est définie sur une valeur non booléenne.

retries

Nombre de tentatives en cas d'échec du commit de la transaction.

deadline

Délai d'attente maximal exprimé en secondes au terme duquel Datastore renvoie un résultat avant d'abandonner en signalant une erreur. Accepte un entier ou une valeur à virgule flottante. Ne peut pas être défini sur une valeur supérieure à la valeur par défaut (60 secondes). Toutefois, il est possible de définir une durée plus courte pour garantir qu'une opération particulière échoue rapidement (par exemple, pour renvoyer une réponse plus rapide à l'utilisateur, retenter une opération, lancer une autre opération ou ajouter l'opération à une file d'attente de tâches).

L'exemple suivant crée les options pour une transaction entre groupes (XG) ultérieure :

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)

Supprime une ou plusieurs instances de modèle du datastore.

Arguments

models: Instance de modèle, clé d'entité ou liste (ou un autre élément itérable) d'instances de modèle ou de clés d'entité à supprimer.
deadline: Délai d'attente maximal exprimé en secondes au terme duquel Datastore renvoie un résultat avant d'abandonner en signalant une erreur. Accepte un entier ou une valeur à virgule flottante. Ne peut pas être défini sur une valeur supérieure à la valeur par défaut (60 secondes). Toutefois, il est possible de définir une durée plus courte pour garantir qu'une opération particulière échoue rapidement (par exemple, pour renvoyer une réponse plus rapide à l'utilisateur, retenter une opération, lancer une autre opération ou ajouter l'opération à une file d'attente de tâches).

Comme avec put(), si plusieurs clés sont fournies, elles peuvent appartenir à plusieurs groupes d'entités.

Si une erreur quelconque se produit pendant l'opération, le système génère toujours une exception, même si certaines des entités ont bien été supprimées. Si l'appel affiche un résultat sans générer d'exception, toutes les entités ont été supprimées.

Attention : La suppression de plusieurs entités en une seule opération ne garantit pas que les suppressions auront lieu de manière atomique, à moins que l'opération soit effectuée dans une transaction. D'autres processus interrogeant le datastore peuvent voir des résultats incohérents même lorsque la requête est exécutée avec une cohérence forte.

delete_async (models, deadline=60)

Supprime une ou plusieurs instances de modèle du datastore en mode asynchrone.

Cette fonction est identique à delete(), sauf qu'elle affiche un objet asynchrone. Vous pouvez appeler get_result() sur la valeur renvoyée pour bloquer l'appel.

Arguments

models: Instance de modèle, clé d'entité ou liste (ou un autre élément itérable) d'instances de modèle ou de clés d'entité à supprimer.
deadline: Délai d'attente maximal exprimé en secondes au terme duquel Datastore renvoie un résultat avant d'abandonner en signalant une erreur. Accepte un entier ou une valeur à virgule flottante. Ne peut pas être défini sur une valeur supérieure à la valeur par défaut (60 secondes). Toutefois, il est possible de définir une durée plus courte pour garantir qu'une opération particulière échoue rapidement (par exemple, pour renvoyer une réponse plus rapide à l'utilisateur, retenter une opération, lancer une autre opération ou ajouter l'opération à une file d'attente de tâches).

Comme avec put(), si plusieurs clés sont fournies, elles peuvent appartenir à plusieurs groupes d'entités.

Cette fonction affiche un objet vous permettant de bloquer le résultat de l'appel.

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

Récupérez la ou les instances de modèle spécifiques avec la ou les clés fournies à partir du datastore.

Arguments

keys

Classe Key de l'entité à récupérer, représentation de la clé sous forme de chaîne, ou liste de clés ou de leurs représentations sous forme de chaîne.

read_policy

Règles de lecture indiquant le niveau de cohérence des données souhaité :

STRONG_CONSISTENCY: Garantit l'obtention des résultats les plus récents, mais se limite à un seul groupe d'entités.
EVENTUAL_CONSISTENCY: Peut s'étendre à plusieurs groupes d'entités, mais peut parfois renvoyer des résultats obsolètes. En général, les requêtes cohérentes à terme s'exécutent plus rapidement que les requêtes fortement cohérentes, mais cela n'est pas garanti.

Remarque : Les requêtes globales (non ascendantes) ignorent cet argument.

deadline

Si l'argument keys consiste en une seule clé (ou sa représentation sous forme de chaîne), cette fonction renvoie l'instance de modèle associée à la clé si celle-ci existe dans le datastore. Sinon, elle renvoie None. Si keys est une liste, la valeur renvoyée est une liste correspondante d'instances de modèle, et la valeur None s'affiche lorsqu'aucune entité n'existe pour une clé donnée.

Voir aussi Model.get().

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

Récupère en mode asynchrone les instances Model spécifiées du datastore.

Cette fonction est identique à get(), sauf qu'elle affiche un objet asynchrone. Vous pouvez appeler get_result() sur la valeur renvoyée pour bloquer l'appel et obtenir les résultats.

Arguments

keys

Classe Key de l'entité à récupérer, représentation de la clé sous forme de chaîne, ou liste de clés ou de leurs représentations sous forme de chaîne.

read_policy

Règles de lecture indiquant le niveau de cohérence des données souhaité :

STRONG_CONSISTENCY: Garantit l'obtention des résultats les plus récents, mais se limite à un seul groupe d'entités.
EVENTUAL_CONSISTENCY: Peut s'étendre à plusieurs groupes d'entités, mais peut parfois renvoyer des résultats obsolètes. En général, les requêtes cohérentes à terme s'exécutent plus rapidement que les requêtes fortement cohérentes, mais cela n'est pas garanti.

Remarque : Les requêtes globales (non ascendantes) ignorent cet argument.

deadline

Voir aussi Model.get().

get_indexes ()

Affiche une liste d'index composites appartenant à l'application appelante.

L'exemple suivant montre comment obtenir et utiliser les index :

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 ()

Affiche de manière asynchrone une liste d'index composites appartenant à l'application appelante.

is_in_transaction ()

Affiche une valeur booléenne indiquant si l'étendue actuelle s'exécute dans une transaction.

model_to_protobuf (model_instance)

Crée la sérialisation de tampon de protocole d'une instance Model. Protocol Buffer (tampon de protocole) est le format de sérialisation de Google utilisé pour les appels de procédures à distance. Il permet par exemple de sérialiser des objets de datastore à des fins de sauvegarde et de restauration.

Attention : Cette fonction utilise un (ancien) format de tampon de protocole, qui est différent du format de tampon de protocole Open Source et n'est pas compatible avec la mise en œuvre Open Source.

Argument

model_instance: Instance de classe Model (ou sous-classe) à sérialiser.

Affiche la sérialisation du tampon de protocole de l'objet sous la forme d'une chaîne d'octets.

model_from_protobuf (pb)

Crée une instance de Model basée sur une sérialisation du tampon de protocole. Pour en savoir plus, consultez model_to_protobuf().

Argument

pb: Sérialisation de tampon de protocole, telle qu'affichée par model_to_protobuf().

Affiche un objet de la classe de genre appropriée. Si la classe de genre n'existe pas, génère une exception KindError. Si l'objet n'est pas valide selon le modèle, génère une exception BadValueError.

Vous pouvez enregistrer le nouvel objet dans le datastore comme n'importe quelle autre instance de Model ; par exemple en appelant sa méthode put(). L'objet conserve la clé qu'il avait lors de la création du tampon de protocole S'il existe déjà un objet associé à cette clé dans le datastore, l'objet désérialisé que vous enregistrez remplace l'objet existant.

Attention : Si la clé de l'objet utilise un ID attribué par le système et si cet ID n'a pas encore été attribué au chemin et au genre donnés, l'enregistrement aboutit, mais l'ID n'est pas réservé. Un objet créé ultérieurement peut se voir affecter cet identifiant et remplacer l'objet précédent. Pour des raisons de sécurité, ne restaurez les objets que dans l'application dans laquelle ils existaient lors de leur sérialisation.

model_is_projection (model_instance)

Affiche True si la requête spécifiée (model_instance) est une requête de projection au lieu d'une requête pour une entité complète.

Argument

model_instance: Requête que vous vérifiez pour déterminer s'il s'agit d'une requête de projection.

Affiche True si la requête est une requête de projection, et False si ce n'est pas le cas.

put (models, deadline=60)

Écrit une ou plusieurs instances de modèle dans le datastore.

Arguments

models: Instance de modèle ou liste d'instances de modèle à stocker.
deadline: Délai d'attente maximal exprimé en secondes au terme duquel Datastore renvoie un résultat avant d'abandonner en signalant une erreur. Accepte un entier ou une valeur à virgule flottante. Ne peut pas être défini sur une valeur supérieure à la valeur par défaut (60 secondes). Toutefois, il est possible de définir une durée plus courte pour garantir qu'une opération particulière échoue rapidement (par exemple, pour renvoyer une réponse plus rapide à l'utilisateur, retenter une opération, lancer une autre opération ou ajouter l'opération à une file d'attente de tâches).

Si plusieurs instances de modèle sont fournies, elles peuvent se trouver dans plusieurs groupes d'entités.

Si une erreur quelconque se produit pendant l'opération, le système génère toujours une exception, même si certaines des entités ont bien été écrites. Si l'appel affiche un résultat sans générer d'exception, toutes les entités ont été écrites.

Si models consiste en une seule instance de modèle, cette fonction affiche l'objet Key correspondant. Si models est une liste, la valeur affichée est une liste des objets Key correspondants.

Attention : L'écriture de plusieurs entités en une seule opération ne garantit pas que les écritures auront lieu de manière atomique, à moins que l'opération soit effectuée dans une transaction. D'autres processus interrogeant le datastore peuvent voir des résultats incohérents même lorsque la requête est exécutée avec une cohérence forte.

put_async (models, deadline=60)

Écrit une ou plusieurs instances de modèle dans le datastore.

Cette fonction est identique à put(), sauf qu'elle affiche un objet asynchrone. Vous pouvez appeler get_result() sur la valeur renvoyée pour bloquer l'appel et obtenir les résultats.

Arguments

models: Instance de modèle ou liste d'instances de modèle à stocker.
deadline: Délai d'attente maximal exprimé en secondes au terme duquel Datastore renvoie un résultat avant d'abandonner en signalant une erreur. Accepte un entier ou une valeur à virgule flottante. Ne peut pas être défini sur une valeur supérieure à la valeur par défaut (60 secondes). Toutefois, il est possible de définir une durée plus courte pour garantir qu'une opération particulière échoue rapidement (par exemple, pour renvoyer une réponse plus rapide à l'utilisateur, retenter une opération, lancer une autre opération ou ajouter l'opération à une file d'attente de tâches).

Si plusieurs instances de modèle sont fournies, elles peuvent se trouver dans plusieurs groupes d'entités.

Cette fonction affiche un objet asynchrone sur lequel get_result() peut être appelé. Les résultats affichés sont les mêmes que pour put().

query_descendants (model_instance)

Affiche une requête sur tous les descendants de l'instance d'un modèle.

Argument

model_instance: Instance de modèle dont vous souhaitez rechercher les descendants.

run_in_transaction (function, *args, **kwargs)

Exécute une fonction contenant les mises à jour du datastore en une seule transaction. Si un code génère une exception lors de la transaction, un rollback est effectué pour toutes les mises à jour réalisées dans la transaction. Vous pouvez également utiliser le décorateur @db.transactional().

Arguments

function: Fonction à exécuter.
args: Arguments positionnels à transmettre à la fonction.
kwargs: Arguments à mots clés à transmettre à la fonction.

Si la fonction affiche une valeur, run_in_transaction() renvoie cette valeur à l'appelant.

Si la fonction génère une exception, la transaction est annulée. S'il s'agit de l'exception Rollback, elle n'est pas générée à nouveau. Toute autre exception est renvoyée à l'appelant.

Le datastore utilise un verrouillage optimiste et des tentatives renouvelées pour les transactions. Si la transaction préparée par la fonction ne peut pas faire l'objet d'un commit, run_in_transaction() appelle à nouveau la fonction, en effectuant jusqu'à trois nouvelles tentatives. (Pour utiliser un nombre de tentatives différent, utilisez run_in_transaction_custom_retries().) Étant donné que la fonction de transaction peut être appelée plusieurs fois pour une seule transaction, elle ne doit pas engendrer d'effets secondaires, par exemple des modifications sur les arguments.

Si le commit de la transaction est impossible, par exemple en raison d'un taux de conflits élevé, une exception TransactionFailedError est générée.

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)

Exécute une fonction contenant les mises à jour du datastore dans une transaction unique, en effectuant le nombre de tentatives de transaction spécifié en cas de conflit. Si un code génère une exception lors de la transaction, un rollback est effectué pour toutes les mises à jour réalisées dans la transaction.

Hormis la possibilité de spécifier le nombre de tentatives, cette fonction se comporte de la même manière que run_in_transaction().

Arguments

retries: Nombre maximal d'appels de la fonction en cas de conflit au sein du groupe d'entités (plusieurs utilisateurs tentant de modifier le groupe simultanément).
function: Fonction à exécuter.
args: Arguments positionnels à transmettre à la fonction.
kwargs: Arguments à mots clés à transmettre à la fonction.

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

Exécute une fonction contenant les mises à jour du datastore dans une transaction unique, en utilisant les options définies dans un objet d'options de transaction. Si un code génère une exception lors de la transaction, un rollback est effectué pour toutes les mises à jour réalisées dans la transaction.

Pour les transactions entre groupes (XG), le paramètre xg de l'objet d'options de transaction doit être défini sur True.

Arguments

options: Objet d'options de transaction contenant les paramètres utilisés par cette transaction. Pour activer les transactions XG, son paramètre xg doit être défini sur True.
function: Fonction à exécuter.
args: Arguments positionnels à transmettre à la fonction.
kwargs: Arguments à mots clés à transmettre à la fonction.

Si la fonction affiche une valeur, run_in_transaction_options() renvoie cette valeur à l'appelant.

Si la fonction génère une exception, la transaction est annulée. S'il s'agit de l'exception Rollback, elle n'est pas générée à nouveau. Toute autre exception est renvoyée à l'appelant.

Le datastore utilise un verrouillage optimiste et des tentatives renouvelées pour les transactions. Si la transaction préparée par la fonction ne peut pas faire l'objet d'un commit, run_in_transaction_options() appelle à nouveau la fonction, en tentant de relancer la transaction selon le nombre de tentatives spécifié dans l'objet d'options de transaction. Dans la mesure où la fonction de transaction peut être appelée plusieurs fois pour une seule transaction, cette fonction ne doit pas engendrer d'effets secondaires, par exemple des modifications sur les arguments.

Si le commit de la transaction est impossible, par exemple en raison d'un taux de conflits élevé, une exception TransactionFailedError est générée.

L'exemple suivant montre comment utiliser cette fonction pour exécuter une transaction entre groupes :

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)

Crée et affiche une représentation du dictionnaire d'une instance de modèle.

Arguments

model_instance: Instance de modèle à copier.
dictionary: S'il est présent, dictionnaire dans lequel fusionner les données du modèle. Les valeurs de modèle écrasent les valeurs du dictionnaire. Les entrées du dictionnaire qui ne correspondent pas aux champs de l'instance de modèle sont conservées.

Décorateurs

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

Exécute une fonction dans une transaction db. Ainsi, au lieu d'appeler run_in_transaction(func), vous pouvez appeler func().

Arguments

propagation

Marche à suivre si cette fonction transactionnelle est appelée depuis une autre transaction :

ALLOWED: Si une transaction est déjà en cours, continuez de l'utiliser. Sinon, commencez-en une.
Remarque : Si une fonction utilisant cette règle génère une exception, il est probablement risqué de capturer l'exception et d'effectuer un commit de la transaction externe, car il se peut que la fonction ait laissé la transaction externe en mauvais état.
MANDATORY: Continuez dans la transaction existante, le cas échéant. Sinon, générez une exception BadRequestError.
Remarque : Si une fonction utilisant cette règle génère une exception, il est probablement risqué de capturer l'exception et d'effectuer un commit de la transaction externe, car il se peut que la fonction ait laissé la transaction externe en mauvais état.
INDEPENDENT: Créez une transaction en mettant en pause toute transaction existante.
Remarque : Une fonction utilisant cette stratégie ne doit afficher aucune entité lue dans la nouvelle transaction, car ces entités ne sont pas cohérentes avec la transaction externe pour ce qui est des transactions.
NESTED: (Pas encore compatible) Créez une transaction imbriquée dans une transaction existante.

xg

Si la valeur est True, autorisez les transactions entre groupes (XG). Génère une exception BadArgumentError, si elle est définie sur une valeur non booléenne.

retries

Nombre de tentatives en cas d'échec du commit de la transaction.

deadline

@db.non_transactional (allow_existing=True)

Garantit qu'une fonction est exécutée en dehors d'une transaction db, même si elle est appelée depuis une transaction.

Argument

allow_existing: Si la valeur est True, permet d'appeler la fonction depuis une transaction existante. Si la valeur est False, génère une exception BadRequestError à la place.