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