Internal change: further efforts to tighten code looking for the end of

a database request made to Oracle Database 23c.

Author: anthony-tuininga

doc/src/release_notes.rst

@@ -17,6 +17,9 @@ oracledb 2.2.0 (TBD)
 Thin Mode Changes
 +++++++++++++++++
 
+#)  Internal change: further efforts to tighten code looking for the end of a
+    database request made to Oracle Database 23c.
+
 Thick Mode Changes
 ++++++++++++++++++
 

src/oracledb/impl/thin/messages.pyx

@@ -49,15 +49,13 @@ cdef class Message:
         uint8_t function_code
         uint32_t call_status
         uint16_t end_to_end_seq_num
+        bint end_of_response
         bint error_occurred
         bint flush_out_binds
         bint resend
         bint retry
         object warning
 
-    cdef bint _has_more_data(self, ReadBuffer buf):
-        return buf.bytes_left() > 0 and not self.flush_out_binds
-
     cdef int _initialize(self, BaseThinConnImpl conn_impl) except -1:
         """
         Initializes the message to contain the connection and a place to store
@@ -117,7 +115,6 @@ cdef class Message:
         buf.read_ub4(&num_bytes)            # oerrdd (logical rowid)
         if num_bytes > 0:
             buf.skip_raw_bytes_chunked()
-        buf._in_request = False
 
         # batch error codes
         buf.read_ub2(&num_errors)           # batch error codes array
@@ -173,6 +170,9 @@ cdef class Message:
                 info.pos = error_pos
             info.message = buf.read_str(CS_FORM_IMPLICIT).rstrip()
 
+        # an error message always marks the end of a response!
+        self.end_of_response = True
+
     cdef int _process_message(self, ReadBuffer buf,
                               uint8_t message_type) except -1:
         if message_type == TNS_MSG_TYPE_ERROR:
@@ -187,7 +187,7 @@ cdef class Message:
         elif message_type == TNS_MSG_TYPE_SERVER_SIDE_PIGGYBACK:
             self._process_server_side_piggyback(buf)
         elif message_type == TNS_MSG_TYPE_END_OF_REQUEST:
-            buf._in_request = False
+            self.end_of_response = True
         else:
             errors._raise_err(errors.ERR_MESSAGE_TYPE_UNKNOWN,
                               message_type=message_type,
@@ -301,10 +301,10 @@ cdef class Message:
 
     cdef int process(self, ReadBuffer buf) except -1:
         cdef uint8_t message_type
+        self.end_of_response = False
         self.flush_out_binds = False
-        buf._in_request = True
         self._preprocess()
-        while self._has_more_data(buf):
+        while not self.end_of_response:
             buf.save_point()
             buf.read_ub1(&message_type)
             self._process_message(buf, message_type)
@@ -391,9 +391,6 @@ cdef class MessageWithData(Message):
         self.bit_vector = <const char_type*> self.bit_vector_buf.data.as_chars
         memcpy(<void*> self.bit_vector, ptr, num_bytes)
 
-    cdef bint _has_more_data(self, ReadBuffer buf):
-        return buf._in_request and not self.flush_out_binds
-
     cdef bint _is_duplicate_data(self, uint32_t column_num):
         """
         Returns a boolean indicating if the given column contains data
@@ -848,6 +845,7 @@ cdef class MessageWithData(Message):
             self._process_row_data(buf)
         elif message_type == TNS_MSG_TYPE_FLUSH_OUT_BINDS:
             self.flush_out_binds = True
+            self.end_of_response = True
         elif message_type == TNS_MSG_TYPE_DESCRIBE_INFO:
             buf.skip_raw_bytes_chunked()
             self._process_describe_info(buf, self.cursor, self.cursor_impl)
@@ -1929,6 +1927,7 @@ cdef class DataTypesMessage(Message):
             buf.read_uint16(&conv_data_type)
             if conv_data_type != 0:
                 buf.skip_raw_bytes(4)
+        self.end_of_response = True
 
     cdef int _write_message(self, WriteBuffer buf) except -1:
         cdef:
@@ -2225,9 +2224,6 @@ cdef class LobOpMessage(Message):
         bint bool_flag
         object data
 
-    cdef bint _has_more_data(self, ReadBuffer buf):
-        return buf._in_request
-
     cdef int _initialize_hook(self) except -1:
         """
         Perform initialization.
@@ -2367,6 +2363,7 @@ cdef class ProtocolMessage(Message):
                               uint8_t message_type) except -1:
         if message_type == TNS_MSG_TYPE_PROTOCOL:
             self._process_protocol_info(buf)
+            self.end_of_response = True
         else:
             Message._process_message(self, buf, message_type)
 
@@ -2410,27 +2407,23 @@ cdef class FastAuthMessage(Message):
         DataTypesMessage data_types_message
         ProtocolMessage protocol_message
         AuthMessage auth_message
-        bint renegotiate
-
-    cdef bint _has_more_data(self, ReadBuffer buf):
-        return buf._in_request
 
     cdef int _process_message(self, ReadBuffer buf,
                               uint8_t message_type) except -1:
         """
         Processes the messages returned from the server response.
         """
-        if message_type == TNS_MSG_TYPE_RENEGOTIATE:
-            self.renegotiate = True
-        elif message_type == TNS_MSG_TYPE_PROTOCOL:
+        if message_type == TNS_MSG_TYPE_PROTOCOL:
             ProtocolMessage._process_message(self.protocol_message, buf,
                                              message_type)
+            self.end_of_response = False
         elif message_type == TNS_MSG_TYPE_DATA_TYPES:
             DataTypesMessage._process_message(self.data_types_message, buf,
                                               message_type)
+            self.end_of_response = False
         else:
             AuthMessage._process_message(self.auth_message, buf, message_type)
-            buf._in_request = False
+            self.end_of_response = True
 
     cdef int _write_message(self, WriteBuffer buf) except -1:
         """

src/oracledb/impl/thin/packet.pyx

@@ -66,7 +66,12 @@ cdef class Packet:
         ptr = cpython.PyBytes_AS_STRING(self.buf)
         flags = unpack_uint16(<const char_type*> &ptr[PACKET_HEADER_SIZE],
                               BYTE_ORDER_MSB)
-        return flags & TNS_DATA_FLAGS_END_OF_REQUEST
+        if flags & TNS_DATA_FLAGS_END_OF_REQUEST:
+            return True
+        if self.packet_size == PACKET_HEADER_SIZE + 3 \
+                and ptr[PACKET_HEADER_SIZE + 2] == TNS_MSG_TYPE_END_OF_REQUEST:
+            return True
+        return False
 
 
 @cython.final
@@ -200,7 +205,7 @@ cdef class ReadBuffer(Buffer):
         Transport _transport
         list _saved_packets
         Capabilities _caps
-        bint _in_request
+        bint _check_request_boundary
         object _waiter
         object _loop
 
@@ -340,8 +345,7 @@ cdef class ReadBuffer(Buffer):
             self._saved_packets.append(packet)
             notify_waiter[0] = \
                     packet.packet_type != TNS_PACKET_TYPE_DATA \
-                    or not self._in_request \
-                    or not self._caps.supports_end_of_request \
+                    or not self._check_request_boundary \
                     or packet.has_end_of_request()
 
     cdef int _read_raw_bytes_and_length(self, const char_type **ptr,

src/oracledb/impl/thin/protocol.pyx

@@ -374,7 +374,7 @@ cdef class Protocol(BaseProtocol):
         try:
             self._read_buf.reset_packets()
             message.send(self._write_buf)
-            self._receive_packet(message)
+            self._receive_packet(message, check_request_boundary=True)
             message.process(self._read_buf)
         except socket.timeout:
             try:
@@ -440,12 +440,16 @@ cdef class Protocol(BaseProtocol):
                 self._process_message(message)
         message.postprocess()
 
-    cdef int _receive_packet(self, Message message) except -1:
+    cdef int _receive_packet(self, Message message,
+                             bint check_request_boundary=False) except -1:
         cdef:
             ReadBuffer buf = self._read_buf
             uint16_t refuse_message_len
             const char_type* ptr
+        buf._check_request_boundary = \
+                check_request_boundary and self._caps.supports_end_of_request
         buf.wait_for_packets_sync()
+        buf._check_request_boundary = False
         if buf._current_packet.packet_type == TNS_PACKET_TYPE_MARKER:
             self._reset(message)
         elif buf._current_packet.packet_type == TNS_PACKET_TYPE_REFUSE:
@@ -784,7 +788,7 @@ cdef class BaseAsyncProtocol(BaseProtocol):
         """
         self._read_buf.reset_packets()
         message.send(self._write_buf)
-        await self._receive_packet(message)
+        await self._receive_packet(message, check_request_boundary=True)
         while True:
             try:
                 message.process(self._read_buf)
@@ -812,12 +816,16 @@ cdef class BaseAsyncProtocol(BaseProtocol):
         self._break_in_progress = False
         errors._raise_err(errors.ERR_CALL_TIMEOUT_EXCEEDED, timeout=timeout)
 
-    async def _receive_packet(self, Message message):
+    async def _receive_packet(self, Message message,
+                              bint check_request_boundary=False):
         cdef:
             ReadBuffer buf = self._read_buf
             uint16_t refuse_message_len
             const char_type* ptr
+        buf._check_request_boundary = \
+                check_request_boundary and self._caps.supports_end_of_request
         await buf.wait_for_packets_async()
+        buf._check_request_boundary = False
         if buf._current_packet.packet_type == TNS_PACKET_TYPE_MARKER:
             await self._reset()
         elif buf._current_packet.packet_type == TNS_PACKET_TYPE_REFUSE:
@@ -843,7 +851,6 @@ cdef class BaseAsyncProtocol(BaseProtocol):
                     break
             await self._read_buf.wait_for_packets_async()
 
-
         # send reset marker and then read error packet; first skip as many
         # marker packets as may be sent by the server; if the server doesn't
         # handle out-of-band breaks properly, some quit immediately and others