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 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'identifiants du datastore et peuvent être utilisés sans conflit dans les clés d'entité.

Arguments

model
Clé de modèle à laquelle il faut 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'identifiants à 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 affichée pour bloquer l'appel et afficher le résultat.

Arguments

model
Instance db.Model, clé ou chaîne 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.

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.

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
Instance db.Model, clé ou chaîne 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, un nombre.
end
Dernier identifiant à allouer, un nombre.

Affiche l'un des éléments suivants (KEY_RANGE_EMPTY, KEY_RANGE_CONTENTION, KEY_RANGE_COLLISION). Si l'élément est autre que 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
Que faire 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 ce règlement 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 ce règlement 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 de 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 afficher une réponse plus rapide à l'utilisateur, retenter une opération ou ajouter l'opération à une file d'attente).

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
Une instance de modèle, une clé d'entité ou une 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 afficher une réponse plus rapide à l'utilisateur, retenter une opération ou ajouter l'opération à une file d'attente).

Comme avec put(), si plusieurs clés sont fournies, elles peuvent appartenir à plus d'un groupe 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 affichée pour bloquer l'appel.

Arguments

models
Une instance de modèle, une clé d'entité ou une 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 afficher une réponse plus rapide à l'utilisateur, retenter une opération ou ajouter l'opération à une file d'attente).

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

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

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.

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
Objet 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 à cohérence forte, mais cela n'est pas garanti.

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

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 afficher une réponse plus rapide à l'utilisateur, retenter une opération ou ajouter l'opération à une file d'attente).

Si la valeur keys consiste en une seule clé (ou sa représentation sous forme de chaîne), cette fonction affiche l'instance de modèle associée à la clé si la clé existe dans le datastore. Sinon, elle affiche None. Si la valeur keys est une liste, la valeur affiché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.

Consultez 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 affichée pour bloquer l'appel et obtenir les résultats.

Arguments

keys
Objet 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 à cohérence forte, mais cela n'est pas garanti.

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

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 afficher une réponse plus rapide à l'utilisateur, retenter une opération ou ajouter l'opération à une file d'attente).

Si la valeur keys consiste en une seule clé (ou sa représentation sous forme de chaîne), cette fonction affiche l'instance de modèle associée à la clé si la clé existe dans le datastore. Sinon, elle affiche None. Si la valeur keys est une liste, la valeur affiché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.

Consultez 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 du tampon de protocole d'une instance de 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 du 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 la 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 et non pas une requête pour une entité complète.

Argument

model_instance
La 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, 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 afficher une réponse plus rapide à l'utilisateur, retenter une opération ou ajouter l'opération à une file d'attente).

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 la valeur models consiste en une seule instance de modèle, cette fonction affiche l'objet Key correspondant. Si la valeur 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 affiché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 afficher une réponse plus rapide à l'utilisateur, retenter une opération ou ajouter l'opération à une file d'attente).

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.

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

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.

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

fonction
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 la valeur à l'appelant.

Si la fonction génère une exception, la transaction est annulée. Si l'exception est une 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 être validée, run_in_transaction() appelle à nouveau la fonction, en effectuant jusqu'à trois nouvelles tentatives. (Pour appliquer un nombre de tentatives différent, utilisez run_in_transaction_custom_retries().) 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.

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.

Cette fonction se comporte de manière identique à run_in_transaction(), si ce n'est qu'elle permet de spécifier le nombre de tentatives.

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 la valeur à l'appelant.

Si la fonction génère une exception, la transaction est annulée. Si l'exception est une 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 être validée, run_in_transaction_options() appelle à nouveau la fonction, en effectuant 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
Que faire 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 ce règlement 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 ce règlement 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 nouvelle 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 de 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 afficher une réponse plus rapide à l'utilisateur, retenter une opération ou ajouter l'opération à une file d'attente).
@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.
Cette page vous a-t-elle été utile ? Évaluez-la :

Envoyer des commentaires concernant…

Environnement standard App Engine pour Python 2