def update_patient_encounter(patient_encounter: dict):
def insert_documents(transaction_executor, payload: dict):
transaction_executor.execute_statement(
"INSERT INTO PatientEncounter ?", payload)
patient_encounter["action"] = "UPDATE"
qldb_driver = QldbDriver(ledger_name=LEDGER_NAME, region_name="us-west-2")
# pylint: disable=W0108
qldb_driver.execute_lambda(
lambda x: insert_documents(x, patient_encounter))
def get_all_patients():
"""
Retrieve all patient data
"""
def read_documents(transaction_executor):
"""
Internal function used to retrieve all Patient data.
"""
cursor = transaction_executor.execute_statement(
"SELECT * FROM Patient")
return cursor
qldb_driver = QldbDriver(ledger_name=LEDGER_NAME, region_name="us-west-2")
# pylint: disable=W0108
qldb_driver.execute_lambda(lambda x: read_documents(x))
def test_execute_lambda_with_InvalidSessionException(
self, mock_get_session, mock_client):
"""
The test asserts that if an InvalidSessionException is thrown by session.execute_lambda, the
driver calls _get_session
"""
mock_client.return_value = mock_client
mock_lambda = Mock()
mock_session = mock_get_session.return_value.__enter__.return_value
mock_invalid_session_error_message = {
'Error': {
'Code': 'InvalidSessionException',
'Message': MOCK_MESSAGE
}
}
mock_invalid_session_error = ClientError(
mock_invalid_session_error_message, MOCK_MESSAGE)
mock_session._execute_lambda.side_effect = [
mock_invalid_session_error, mock_invalid_session_error,
MOCK_MESSAGE
]
driver = QldbDriver(MOCK_LEDGER_NAME)
result = driver.execute_lambda(mock_lambda, mock_lambda)
self.assertEqual(mock_get_session.call_count, 3)
self.assertEqual(result, MOCK_MESSAGE)
def test_execute_lambda_retryable_error_and_under_retry_limit(
self, mock_get_session, mock_client, mock_retry_sleep,
mock_session, mock_release_session):
mock_client.return_value = mock_client
mock_lambda = Mock()
mock_get_session.return_value = mock_session
inner_error = Exception()
retryable_execute_error = ExecuteError(inner_error, True, False,
DEFAULT_TRANSACTION_ID)
mock_session._execute_lambda.side_effect = [
retryable_execute_error, MOCK_MESSAGE
]
mock_release_session.return_value = True
driver = QldbDriver(MOCK_LEDGER_NAME)
result = driver.execute_lambda(mock_lambda)
self.assertEqual(result, MOCK_MESSAGE)
mock_get_session.assert_has_calls([call(False), call(False)])
mock_release_session.assert_has_calls(
[call(mock_session), call(mock_session)])
mock_retry_sleep.assert_called_once_with(driver._retry_config, 1,
inner_error,
DEFAULT_TRANSACTION_ID)
self.assertEqual(mock_session._execute_lambda.call_count, 2)
def create_new_patient_encounter(patient_encounter: dict):
"""
Create a new, blank patient record.
"""
def insert_documents(transaction_executor, payload: dict):
"""
Internal function handling insertion of new patients.
"""
transaction_executor.execute_statement(
"INSERT INTO PatientEncounter ?", payload)
patient_encounter["action"] = "INSERT"
qldb_driver = QldbDriver(ledger_name=LEDGER_NAME, region_name="us-west-2")
# pylint: disable=W0108
qldb_driver.execute_lambda(
lambda x: insert_documents(x, patient_encounter))
def update_patient(patient: dict):
"""
Update a patient with the provided dataset.
"""
def update_documents(transaction_executor, payload: dict):
"""
Internal function for updating a patient record.
"""
transaction_executor.execute_statement("INSERT INTO Patient ?",
payload)
patient["action"] = "UPDATE"
patient["date_of_birth"] = str(patient["date_of_birth"])
qldb_driver = QldbDriver(ledger_name=LEDGER_NAME, region_name="us-west-2")
# pylint: disable=W0108
qldb_driver.execute_lambda(lambda x: update_documents(x, patient))
def create_tables():
def create_patient_table(transaction_executor):
statement = "CREATE TABLE Patient"
cursor = transaction_executor.execute_statement(statement)
return len(list(cursor))
def create_patient_encounter_table(transaction_executor):
statement = "CREATE TABLE PatientEncounter"
cursor = transaction_executor.execute_statement(statement)
return len(list(cursor))
qldb_driver = QldbDriver(ledger_name=LEDGER_NAME, region_name="us-west-2")
# pylint: disable=W0108
qldb_driver.execute_lambda(lambda x: create_patient_table(x))
# pylint: disable=W0108
qldb_driver.execute_lambda(lambda x: create_patient_encounter_table(x))
def test_return_session_with_invalid_session_exception(
self, execute_lambda_1, execute_lambda_2,
mock_lambda_context_increment_execution_attempt):
"""
The test asserts that a bad session is not returned to the pool.
We add two mock sessions to the pool. mock_session_1._execute_lambda returns an InvalidSessionException
and mock_session_2._execute_lambda succeeds.
After executing driver.execute_lambda we assert if the pool has just one session which should be
mock_session_2.
"""
mock_lambda = Mock()
session_1 = Mock()
session_2 = Mock()
driver = QldbDriver(MOCK_LEDGER_NAME)
session_1 = QldbSession(session_1, driver._read_ahead,
driver._executor, driver._release_session)
session_2 = QldbSession(session_2, driver._read_ahead,
driver._executor, driver._release_session)
mock_invalid_session_error_message = {
'Error': {
'Code': 'InvalidSessionException',
'Message': MOCK_MESSAGE
}
}
mock_invalid_session_error = ClientError(
mock_invalid_session_error_message, MOCK_MESSAGE)
execute_lambda_1.side_effect = mock_invalid_session_error
session_1._execute_lambda = execute_lambda_1
session_1._is_closed = True
execute_lambda_2.return_value = MOCK_MESSAGE
session_2._execute_lambda = execute_lambda_2
session_2._is_closed = False
# adding sessions to the driver pool
driver._pool.put(session_1)
driver._pool.put(session_2)
result = driver.execute_lambda(mock_lambda)
self.assertEqual(session_1._execute_lambda.call_count, 1)
self.assertEqual(session_1._is_closed, True)
self.assertEqual(session_2._execute_lambda.call_count, 1)
self.assertEqual(session_2._is_closed, False)
self.assertEqual(driver._pool_permits._value, 10)
self.assertEqual(driver._pool.qsize(), 1)
self.assertEqual(session_2, driver._pool.get_nowait())
self.assertEqual(
mock_lambda_context_increment_execution_attempt.call_count, 0)
self.assertEqual(result, MOCK_MESSAGE)
def test_execute_lambda(self, mock_get_session, mock_client, mock_session,
mock_release_session):
mock_client.return_value = mock_client
mock_lambda = Mock()
mock_get_session.return_value = mock_session
mock_session._execute_lambda.return_value = MOCK_MESSAGE
driver = QldbDriver(MOCK_LEDGER_NAME)
result = driver.execute_lambda(mock_lambda)
mock_release_session.assert_called_once_with(mock_session)
mock_get_session.assert_called_once_with(False)
mock_session._execute_lambda.assert_called_once_with(mock_lambda)
self.assertEqual(result, MOCK_MESSAGE)
def test_execute_lambda(self, mock_get_session, mock_client,
mock_lambda_context):
mock_client.return_value = mock_client
mock_lambda = Mock()
mock_session = mock_get_session.return_value.__enter__.return_value
mock_session._execute_lambda.return_value = MOCK_MESSAGE
mock_lambda_context.return_value = mock_lambda_context
driver = QldbDriver(MOCK_LEDGER_NAME)
result = driver.execute_lambda(mock_lambda)
mock_get_session.assert_called_once_with()
mock_session._execute_lambda.assert_called_once_with(
mock_lambda, driver._retry_config, mock_lambda_context)
self.assertEqual(result, MOCK_MESSAGE)
def test_execute_lambda_invalid_session_exception_and_0_retry_limit(
self, mock_get_session, mock_client, mock_retry_sleep,
mock_session, mock_release_session):
mock_client.return_value = mock_client
mock_lambda = Mock()
mock_get_session.return_value = mock_session
invalid_session_exception = ExecuteError(Exception(), True, True)
mock_session._execute_lambda.side_effect = [
invalid_session_exception, MOCK_MESSAGE
]
mock_release_session.return_value = True
retryConfig = RetryConfig(retry_limit=0)
driver = QldbDriver(MOCK_LEDGER_NAME, retry_config=retryConfig)
result = driver.execute_lambda(mock_lambda)
self.assertEqual(result, MOCK_MESSAGE)
mock_get_session.assert_has_calls([call(False), call(False)])
mock_release_session.assert_has_calls(
[call(mock_session), call(mock_session)])
mock_retry_sleep.assert_not_called()
self.assertEqual(mock_session._execute_lambda.call_count, 2)
from pyqldb.driver.qldb_driver import QldbDriver
from pyqldb.execution.executor import Executor
qldb_driver = QldbDriver(ledger_name='vehicle-registration')
statement = 'SELECT h.metadata.version, h.data.VIN, h.data.City, h.data.Owners, h.hash FROM history(VehicleRegistration) AS h WHERE h.metadata.id = \'L7S9pXJJaSn3YvTcpNXgTL\''
def query(transaction_executor: Executor, statement: str):
cursor = transaction_executor.execute_statement(statement)
for doc in cursor:
print('Version={version} VIN={vin} City={city}'.format(
version=doc['version'], vin=doc['VIN'], city=doc['City']))
if __name__ == '__main__':
qldb_driver.execute_lambda(lambda executor: query(executor, statement))
