Return None if no query stats from SDK (#44)

Author: byronlin13

docs/source/reference/session/base_qldb_session.rst

@@ -40,18 +40,20 @@ def __next__(self):
 
     def get_consumed_ios(self):
         """
-        Return a dictionary containing the total amount of IO requests for a statement's execution.
+        Return a dictionary containing the total amount of IO requests for a statement execution. Return None if there
+        were no read IOs for a statement execution.
 
-        :rtype: dict
-        :return: The amount of read IO requests for a statement's execution.
+        :rtype: dict/None
+        :return: The amount of read IO requests for a statement execution.
         """
         return self._consumed_ios
 
     def get_timing_information(self):
         """
-        Return a dictionary containing the total amount of processing time for a statement's execution.
+        Return a dictionary containing the total amount of processing time for a statement execution. Return None if
+        there was no timing information for a statement execution.
 
-        :rtype: dict
-        :return: The amount of processing time in milliseconds for a statement's execution.
+        :rtype: dict/None
+        :return: The amount of processing time in milliseconds for a statement execution.
         """
         return self._timing_information

docs/source/reference/session/pooled_qldb_session.rst

@@ -26,7 +26,7 @@ class ReadAheadCursor(StreamCursor):
     size `read_ahead` and fetch results asynchronously to fill the queue.
 
     :type statement_result: dict
-    :param statement_result: The initial result set data dictionary of the statement's execution.
+    :param statement_result: The initial result set data dictionary of the statement execution.
 
     :type session: :py:class:`pyqldb.communication.session_client.SessionClient`
     :param session: The parent session that represents the communication channel to QLDB.

pyqldb/cursor/buffered_cursor.py

@@ -18,7 +18,7 @@ class StreamCursor:
     An iterable class representing a stream cursor on a statement's result set.
 
     :type statement_result: dict
-    :param statement_result: The initial result set data dictionary of the statement's execution.
+    :param statement_result: The initial result set data dictionary of the statement execution.
 
     :type session: :py:class:`pyqldb.communication.session_client.SessionClient`
     :param session: The parent session that represents the communication channel to QLDB.
@@ -78,21 +78,24 @@ def close(self):
 
     def get_consumed_ios(self):
         """
-        Return a dictionary containing the accumulated amount of IO requests for a statement's execution.
+        Return a dictionary containing the accumulated amount of IO requests for a statement execution. Return None if
+        there were no read IOs for a statement execution.
 
-        :rtype: dict
-        :return: The amount of read IO requests for a statement's execution.
+        :rtype: dict/None
+        :return: The amount of read IO requests for a statement execution.
         """
-        return {'ReadIOs': self._read_ios}
+        return None if self._read_ios is None else {'ReadIOs': self._read_ios}
 
     def get_timing_information(self):
         """
-        Return a dictionary containing the accumulated amount of processing time for a statement's execution.
+        Return a dictionary containing the accumulated amount of processing time for a statement execution. Return None
+        if there was no timing information for a statement execution.
 
-        :rtype: dict
-        :return: The amount of processing time in milliseconds for a statement's execution.
+        :rtype: dict/None
+        :return: The amount of processing time in milliseconds for a statement execution.
         """
-        return {'ProcessingTimeMilliseconds': self._processing_time_milliseconds}
+        return None if self._processing_time_milliseconds is None else {'ProcessingTimeMilliseconds':
+                                                                            self._processing_time_milliseconds}
 
     def _are_there_more_results(self):
         """

pyqldb/cursor/read_ahead_cursor.py

@@ -88,7 +88,7 @@ class QldbDriver:
 
     :raises TypeError: When config is not an instance of :py:class:`botocore.config.Config`.
                        When boto3_session is not an instance of :py:class:`boto3.session.Session`.
-                       When retry_config is not an instance of :py:class:pyqldb.config.retry_config.RetryConfig.
+                       When retry_config is not an instance of :py:class:`pyqldb.config.retry_config.RetryConfig`.
 
     :raises ValueError: When `max_concurrent_transactions` exceeds the limit set by the client.
                         When `max_concurrent_transactions` is negative.

pyqldb/cursor/stream_cursor.py

@@ -11,9 +11,9 @@
 
 from unittest.mock import MagicMock
 
-from pyqldb.cursor.buffered_cursor import BufferedCursor
 from pyqldb.cursor.stream_cursor import StreamCursor
 
+
 def generate_statement_result(read_io, write_io, processing_time, next_page_token, is_first_page,
                               values=[{'IonBinary': 1}]):
     """
@@ -35,21 +35,27 @@ def generate_statement_result(read_io, write_io, processing_time, next_page_toke
     return statement_result
 
 
-def assert_query_stats(class_instance, buffered_cursor, read_ios_assert, write_ios_assert, timing_information_assert):
+def assert_query_stats(test_case, buffered_cursor, read_ios_assert, write_ios_assert, timing_information_assert):
     """
     Asserts the query statistics returned by the cursor.
     """
     consumed_ios = buffered_cursor.get_consumed_ios()
-    class_instance.assertIsNotNone(consumed_ios)
-    read_ios = consumed_ios.get('ReadIOs')
+    if read_ios_assert is not None:
+        test_case.assertIsNotNone(consumed_ios)
+        read_ios = consumed_ios.get('ReadIOs')
 
-    class_instance.assertEqual(read_ios, read_ios_assert)
+        test_case.assertEqual(read_ios, read_ios_assert)
+    else:
+        test_case.assertEqual(consumed_ios, None)
 
     timing_information = buffered_cursor.get_timing_information()
-    class_instance.assertIsNotNone(timing_information)
-    processing_time_milliseconds = timing_information.get('ProcessingTimeMilliseconds')
+    if timing_information_assert is not None:
+        test_case.assertIsNotNone(timing_information)
+        processing_time_milliseconds = timing_information.get('ProcessingTimeMilliseconds')
 
-    class_instance.assertEqual(processing_time_milliseconds, timing_information_assert)
+        test_case.assertEqual(processing_time_milliseconds, timing_information_assert)
+    else:
+        test_case.assertEqual(timing_information_assert, None)
 
 
 def create_stream_cursor(mock_session, mock_statement_result_execute, mock_statement_result_fetch):