a ù!fã@s$dZddlmZGdd„deƒZdS)z5Create / interact with gcloud datastore transactions.é)ÚBatchcs\eZdZdZ‡fdd„Zedd„ƒZ‡fdd„Z‡fdd „Z‡fd d „Z ‡fd d „Z ‡Z S)Ú Transactiona¢ An abstraction representing datastore Transactions. Transactions can be used to build up a bulk mutation and ensure all or none succeed (transactionally). For example, the following snippet of code will put the two ``save`` operations (either ``insert`` or ``upsert``) into the same mutation, and execute those within a transaction:: >>> from gcloud import datastore >>> client = datastore.Client() >>> with client.transaction(): ... client.put_multi([entity1, entity2]) Because it derives from :class:`Batch <.datastore.batch.Batch>`, :class:`Transaction` also provides :meth:`put` and :meth:`delete` methods:: >>> with client.transaction() as xact: ... xact.put(entity1) ... xact.delete(entity2.key) By default, the transaction is rolled back if the transaction block exits with an error:: >>> with client.transaction(): ... do_some_work() ... raise SomeException() # rolls back If the transaction block exists without an exception, it will commit by default. .. warning:: Inside a transaction, automatically assigned IDs for entities will not be available at save time! That means, if you try:: >>> with client.transaction(): ... entity = datastore.Entity(key=client.key('Thing')) ... client.put(entity) ``entity`` won't have a complete key until the transaction is committed. Once you exit the transaction (or call :meth:`commit`), the automatically generated ID will be assigned to the entity:: >>> with client.transaction(): ... entity = datastore.Entity(key=client.key('Thing')) ... client.put(entity) ... print(entity.key.is_partial) # There is no ID on this key. ... True >>> print(entity.key.is_partial) # There *is* an ID. False If you don't want to use the context manager you can initialize a transaction manually:: >>> transaction = client.transaction() >>> transaction.begin() >>> >>> entity = datastore.Entity(key=client.key('Thing')) >>> transaction.put(entity) >>> >>> if error: ... transaction.rollback() ... else: ... transaction.commit() :type client: :class:`gcloud.datastore.client.Client` :param client: the client used to connect to datastore. cstt|ƒ |¡d|_dS)N)ÚsuperrÚ__init__Ú_id)ÚselfÚclient©Ú __class__©ú]/var/www/html/python-backend/venv/lib/python3.9/site-packages/gcloud/datastore/transaction.pyr]szTransaction.__init__cCs|jS)ztGetter for the transaction ID. :rtype: string :returns: The ID of the current transaction. )r©rr r r ÚidaszTransaction.idcs tt|ƒ ¡}t|tƒr|SdS)a&Return the topmost transaction. .. note:: If the topmost element on the stack is not a transaction, returns None. :rtype: :class:`gcloud.datastore.transaction.Transaction` or None :returns: The current transaction (if any are active). N)rrÚcurrentÚ isinstance)rÚtopr r r rjs  zTransaction.currentcs"tt|ƒ ¡|j |j¡|_dS)aBegins a transaction. This method is called automatically when entering a with statement, however it can be called explicitly if you don't want to use a context manager. :raises: :class:`ValueError` if the transaction has already begun. N)rrÚbeginÚ connectionZbegin_transactionÚprojectrr r r r rys zTransaction.beginc sFz*|j |j|j¡Wtt|ƒ ¡d|_ntt|ƒ ¡d|_0dS)zÚRolls back the current transaction. This method has necessary side-effects: - Sets the current connection's transaction reference to None. - Sets the current transaction's ID to None. N)rÚrollbackrrrrr r r r r…s þzTransaction.rollbackcs&ztt|ƒ ¡Wd|_nd|_0dS)a-Commits the transaction. This is called automatically upon exiting a with statement, however it can be called explicitly if you don't want to use a context manager. This method has necessary side-effects: - Sets the current transaction's ID to None. N)rrÚcommitrr r r r r”s zTransaction.commit) Ú__name__Ú __module__Ú __qualname__Ú__doc__rÚpropertyrrrrrÚ __classcell__r r r r rsH    rN)rZgcloud.datastore.batchrrr r r r Ús