def unlink_datasets_from_upload(neo4j_driver, upload_uuid, dataset_uuids_list):
# Join the list of uuids and wrap each string in single quote
joined_str = ', '.join("'{0}'".format(dataset_uuid) for dataset_uuid in dataset_uuids_list)
# Format a string to be used in Cypher query.
# E.g., ['fb6757b606ac35be7fa85062fde9c2e1', 'ku0gd44535be7fa85062fde98gt5']
dataset_uuids_list_str = '[' + joined_str + ']'
try:
with neo4j_driver.session() as session:
tx = session.begin_transaction()
logger.info("Delete relationships between the target Upload and the given Datasets")
query = (f"MATCH (s:Upload)<-[r:IN_UPLOAD]-(d:Dataset) "
f"WHERE s.uuid = '{upload_uuid}' AND d.uuid IN {dataset_uuids_list_str} "
f"DELETE r")
logger.info("======unlink_datasets_from_upload() query======")
logger.info(query)
tx.run(query)
tx.commit()
except TransactionError as te:
msg = f"TransactionError from calling unlink_datasets_from_upload(): {te.value}"
# Log the full stack trace, prepend a line with our message
logger.exception(msg)
if tx.closed() == False:
logger.info("Failed to commit unlink_datasets_from_upload() transaction, rollback")
tx.rollback()
raise TransactionError(msg)
def update_dataset_and_ancestors_data_access_level(neo4j_driver, uuid, data_access_level):
query = (f"MATCH (e:Entity)-[:ACTIVITY_INPUT|ACTIVITY_OUTPUT*]->(d:Dataset) "
f"WHERE e.entity_type IN ['Donor', 'Sample'] AND d.uuid='{uuid}' "
f"SET e.data_access_level = '{data_access_level}', d.data_access_level = '{data_access_level}' "
# We don't really use the returned value
f"RETURN COUNT(e) AS {record_field_name}")
logger.info("======update_dataset_and_ancestors_data_access_level() query======")
logger.info(query)
try:
with neo4j_driver.session() as session:
tx = session.begin_transaction()
tx.run(query)
tx.commit()
except TransactionError as te:
msg = "TransactionError from calling update_dataset_and_ancestors_data_access_level(): "
# Log the full stack trace, prepend a line with our message
logger.exception(msg)
if tx.closed() == False:
# Log the full stack trace, prepend a line with our message
logger.info("Failed to commit update_dataset_ancestors_data_access_level() transaction, rollback")
tx.rollback()
raise TransactionError(msg)
def link_entity_to_direct_ancestors(neo4j_driver, entity_uuid, direct_ancestor_uuids, activity_data_dict):
try:
with neo4j_driver.session() as session:
tx = session.begin_transaction()
# First delete all the old linkages and Activity node between this entity and its direct ancestors
_delete_activity_node_and_linkages_tx(tx, entity_uuid)
# Get the activity uuid
activity_uuid = activity_data_dict['uuid']
# Create the Acvitity node
_create_activity_tx(tx, activity_data_dict)
# Create relationship from this Activity node to the target entity node
_create_relationship_tx(tx, activity_uuid, entity_uuid, 'ACTIVITY_OUTPUT', '->')
# Create relationship from each ancestor entity node to this Activity node
for direct_ancestor_uuid in direct_ancestor_uuids:
_create_relationship_tx(tx, direct_ancestor_uuid, activity_uuid, 'ACTIVITY_INPUT', '->')
tx.commit()
except TransactionError as te:
msg = "TransactionError from calling link_entity_to_direct_ancestors(): "
# Log the full stack trace, prepend a line with our message
logger.exception(msg)
if tx.closed() == False:
# Log the full stack trace, prepend a line with our message
logger.info("Failed to commit link_entity_to_direct_ancestors() transaction, rollback")
tx.rollback()
raise TransactionError(msg)
def run(self, query, parameters=None, **kwparameters):
""" Run a Cypher query within the context of this transaction.
The query is sent to the server lazily, when its result is
consumed. To force the query to be sent to the server, use
the :meth:`.Transaction.sync` method.
Cypher is typically expressed as a query template plus a
set of named parameters. In Python, parameters may be expressed
through a dictionary of parameters, through individual parameter
arguments, or as a mixture of both. For example, the `run`
queries below are all equivalent::
>>> query = "CREATE (a:Person { name: $name, age: $age })"
>>> result = tx.run(query, {"name": "Alice", "age": 33})
>>> result = tx.run(query, {"name": "Alice"}, age=33)
>>> result = tx.run(query, name="Alice", age=33)
Parameter values can be of any type supported by the Neo4j type
system. In Python, this includes :class:`bool`, :class:`int`,
:class:`str`, :class:`list` and :class:`dict`. Note however that
:class:`list` properties must be homogenous.
:param query: cypher query
:type query: str
:param parameters: dictionary of parameters
:type parameters: dict
:param kwparameters: additional keyword parameters
:returns: a new :class:`neo4j.Result` object
:rtype: :class:`neo4j.Result`
:raise TransactionError: if the transaction is already closed
"""
from neo4j.work.simple import Query
if isinstance(query, Query):
raise ValueError("Query object is only supported for session.run")
if self._closed:
raise TransactionError("Transaction closed")
if (self._results
and self._connection.supports_multiple_results is False):
# Bolt 3 Support
# Buffer up all records for the previous Result because it does not
# have any qid to fetch in batches.
self._results[-1]._buffer_all()
result = Result(
self._connection, DataHydrator(), self._fetch_size,
self._result_on_closed_handler,
self._result_on_network_error_handler
)
self._results.append(result)
result._tx_ready_run(query, parameters, **kwparameters)
return result
def rollback(self):
"""Mark this transaction as unsuccessful and close in order to trigger a ROLLBACK.
:raise TransactionError: if the transaction is already closed
"""
if self._closed:
raise TransactionError("Transaction closed")
metadata = {}
if not self._connection._is_reset:
self._consume_results(
) # DISCARD pending records then do a rollback.
self._connection.rollback(on_success=metadata.update)
self._connection.send_all()
self._connection.fetch_all()
self._closed = True
self._on_closed()
def begin_transaction(self, bookmark=None, metadata=None, timeout=None):
""" Create a new :class:`.Transaction` within this session.
Calling this method with a bookmark is equivalent to
:param bookmark: a bookmark to which the server should
synchronise before beginning the transaction
:param metadata:
:param timeout:
:returns: new :class:`.Transaction` instance.
:raise: :class:`.TransactionError` if a transaction is already open
"""
if self.has_transaction():
raise TransactionError("Explicit transaction already open")
self._open_transaction(metadata=metadata, timeout=timeout)
return self._transaction
def rollback_transaction(self):
""" Rollback the current transaction.
:raise: :class:`.TransactionError` if no transaction is currently open
"""
if not self._transaction:
raise TransactionError("No transaction to rollback")
cx = self._connection
if cx:
metadata = {}
try:
cx.rollback(on_success=metadata.update)
cx.send_all()
cx.fetch_all()
finally:
self._disconnect()
self._transaction = None
def commit(self):
"""Mark this transaction as successful and close in order to trigger a COMMIT.
:raise TransactionError: if the transaction is already closed
"""
if self._closed:
raise TransactionError("Transaction closed")
metadata = {}
try:
self._consume_results() # DISCARD pending records then do a commit.
self._connection.commit(on_success=metadata.update)
self._connection.send_all()
self._connection.fetch_all()
self._bookmark = metadata.get("bookmark")
finally:
self._closed = True
self._on_closed()
return self._bookmark
def link_entity_to_previous_revision(neo4j_driver, entity_uuid, previous_revision_entity_uuid):
try:
with neo4j_driver.session() as session:
tx = session.begin_transaction()
# Create relationship from ancestor entity node to this Activity node
_create_relationship_tx(tx, entity_uuid, previous_revision_entity_uuid, 'REVISION_OF', '->')
tx.commit()
except TransactionError as te:
msg = "TransactionError from calling link_entity_to_previous_revision(): "
# Log the full stack trace, prepend a line with our message
logger.exception(msg)
if tx.closed() == False:
# Log the full stack trace, prepend a line with our message
logger.info("Failed to commit link_entity_to_previous_revision() transaction, rollback")
tx.rollback()
raise TransactionError(msg)
def begin_transaction(self, metadata=None, timeout=None):
""" Begin a new unmanaged transaction. Creates a new :class:`.Transaction` within this session.
At most one transaction may exist in a session at any point in time.
To maintain multiple concurrent transactions, use multiple concurrent sessions.
:param metadata:
:param timeout:
:returns: A new transaction instance.
:rtype: :class:`neo4j.Transaction`
:raises TransactionError: :class:`neo4j.exceptions.TransactionError` if a transaction is already open.
"""
# TODO: Implement TransactionConfig consumption
if self.has_transaction():
raise TransactionError("Explicit transaction already open")
self._open_transaction(access_mode=self._config.default_access_mode, database=self._config.database, metadata=metadata, timeout=timeout)
return self._transaction
def begin_transaction(self, metadata=None, timeout=None):
""" Begin a new unmanaged transaction. Creates a new :class:`.Transaction` within this session.
At most one transaction may exist in a session at any point in time.
To maintain multiple concurrent transactions, use multiple concurrent sessions.
Note: For auto-transaction (Session.run) this will trigger an consume for the current result.
:param metadata:
a dictionary with metadata.
Specified metadata will be attached to the executing transaction and visible in the output of ``dbms.listQueries`` and ``dbms.listTransactions`` procedures.
It will also get logged to the ``query.log``.
This functionality makes it easier to tag transactions and is equivalent to ``dbms.setTXMetaData`` procedure, see https://neo4j.com/docs/operations-manual/current/reference/procedures/ for procedure reference.
:type metadata: dict
:param timeout:
the transaction timeout in milliseconds.
Transactions that execute longer than the configured timeout will be terminated by the database.
This functionality allows to limit query/transaction execution time.
Specified timeout overrides the default timeout configured in the database using ``dbms.transaction.timeout`` setting.
Value should not represent a duration of zero or negative duration.
:type timeout: int
:returns: A new transaction instance.
:rtype: :class:`neo4j.Transaction`
:raises TransactionError: :class:`neo4j.exceptions.TransactionError` if a transaction is already open.
"""
# TODO: Implement TransactionConfig consumption
if self._autoResult:
self._autoResult.consume()
if self._transaction:
raise TransactionError("Explicit transaction already open")
self._open_transaction(access_mode=self._config.default_access_mode,
database=self._config.database,
metadata=metadata,
timeout=timeout)
return self._transaction
def commit(self):
"""Mark this transaction as successful and close in order to trigger a COMMIT.
:raise TransactionError: if the transaction is already closed
"""
if self._closed:
raise TransactionError("Transaction closed")
metadata = {}
self._consume_results() # DISCARD pending records then do a commit.
try:
self._connection.commit(on_success=metadata.update)
self._connection.send_all()
self._connection.fetch_all()
except BoltIncompleteCommitError:
self._closed = True
self._on_closed()
raise ServiceUnavailable("Connection closed during commit")
self._bookmark = metadata.get("bookmark")
self._closed = True
self._on_closed()
return self._bookmark
def commit_transaction(self):
""" Commit the current transaction.
:returns: the bookmark returned from the server, if any
:raise: :class:`.TransactionError` if no transaction is currently open
"""
if not self._transaction:
raise TransactionError("No transaction to commit")
metadata = {}
try:
self._connection.commit(on_success=metadata.update)
self._connection.send_all()
self._connection.fetch_all()
except IncompleteCommitError:
raise ServiceUnavailable("Connection closed during commit")
finally:
self._disconnect()
self._transaction = None
bookmark = metadata.get("bookmark")
self._bookmarks_in = tuple([bookmark])
self._bookmark_out = bookmark
return bookmark
def _assert_open(self):
if self._closed:
raise TransactionError("Transaction closed")