Fixed bug when using asyncio and calling a stored procedure with data

that exceeds 32767 bytes in length (#441).

Author: anthony-tuininga

doc/src/release_notes.rst

@@ -42,6 +42,9 @@ Thin Mode Changes
     doesn't support the end of response flag.
 #)  Fixed hang when using asyncio and a connection is unexpectedly closed by
     the database.
+#)  Fixed bug when using :ref:`asyncio <concurrentprogramming>` and calling a
+    stored procedure with data that exceeds 32767 bytes in length
+    (`issue 441 <https://github.com/oracle/python-oracledb/issues/441>`__).
 #)  Error ``DPY-6002: The distinguished name (DN) on the server certificate
     does not match the expected value: "{expected_dn}"`` now shows the expected
     value.

src/oracledb/impl/thin/cursor.pyx

@@ -1,5 +1,5 @@
 #------------------------------------------------------------------------------
-# Copyright (c) 2020, 2024, Oracle and/or its affiliates.
+# Copyright (c) 2020, 2025, Oracle and/or its affiliates.
 #
 # This software is dual-licensed to you under the Universal Permissive License
 # (UPL) 1.0 as shown at https://oss.oracle.com/licenses/upl and Apache License
@@ -269,13 +269,30 @@ cdef class AsyncThinCursorImpl(BaseThinCursorImpl):
             message = self._create_message(FetchMessage, cursor)
         await self._conn_impl._protocol._process_single_message(message)
 
+    async def _preprocess_execute_async(self, object conn):
+        """
+        Performs the necessary steps required before actually executing the
+        statement associated with the cursor.
+        """
+        cdef:
+            ThinVarImpl var_impl
+            BindInfo bind_info
+            ssize_t idx
+        self._preprocess_execute(conn)
+        for bind_info in self._statement._bind_info_list:
+            var_impl = bind_info._bind_var_impl
+            if var_impl._coroutine_indexes is not None:
+                for idx in var_impl._coroutine_indexes:
+                    var_impl._values[idx] = await var_impl._values[idx]
+                var_impl._coroutine_indexes = None
+
     async def execute(self, cursor):
         cdef:
             object conn = cursor.connection
             BaseAsyncProtocol protocol
             MessageWithData message
         protocol = <BaseAsyncProtocol> self._conn_impl._protocol
-        self._preprocess_execute(conn)
+        await self._preprocess_execute_async(conn)
         message = self._create_message(ExecuteMessage, cursor)
         message.num_execs = 1
         await protocol._process_single_message(message)
@@ -294,7 +311,7 @@ cdef class AsyncThinCursorImpl(BaseThinCursorImpl):
 
         # set up message to send
         protocol = <BaseAsyncProtocol> self._conn_impl._protocol
-        self._preprocess_execute(cursor.connection)
+        await self._preprocess_execute_async(cursor.connection)
         message = self._create_message(ExecuteMessage, cursor)
         message.num_execs = num_execs
         message.batcherrors = batcherrors

src/oracledb/impl/thin/var.pyx

@@ -32,6 +32,7 @@
 cdef class ThinVarImpl(BaseVarImpl):
     cdef:
         object _last_raw_value
+        list _coroutine_indexes
 
     cdef int _bind(self, object conn, BaseCursorImpl cursor_impl,
                    uint32_t num_execs, object name, uint32_t pos) except -1:
@@ -44,10 +45,11 @@ cdef class ThinVarImpl(BaseVarImpl):
             ssize_t idx, num_binds, num_vars
             BindInfo bind_info
             str normalized_name
-            object value, lob
+            bint is_async
+            object value
 
         # for PL/SQL blocks, if the size of a string or bytes object exceeds
-        # 32,767 bytes it must be converted to a BLOB/CLOB; and out converter
+        # 32,767 bytes it must be converted to a BLOB/CLOB; an out converter
         # needs to be established as well to return the string in the way that
         # the user expects to get it
         if stmt._is_plsql and metadata.max_size > 32767:
@@ -67,13 +69,18 @@ cdef class ThinVarImpl(BaseVarImpl):
             self.outconverter = converter
 
         # for variables containing LOBs, create temporary LOBs, if needed
+        is_async = thin_cursor_impl._conn_impl._protocol._transport._is_async
         if metadata.dbtype._ora_type_num == ORA_TYPE_NUM_CLOB \
                 or metadata.dbtype._ora_type_num == ORA_TYPE_NUM_BLOB:
             for idx, value in enumerate(self._values):
                 if value is not None \
                         and not isinstance(value, (PY_TYPE_LOB,
                                                    PY_TYPE_ASYNC_LOB)):
                     self._values[idx] = conn.createlob(metadata.dbtype, value)
+                    if is_async:
+                        if self._coroutine_indexes is None:
+                            self._coroutine_indexes = []
+                        self._coroutine_indexes.append(idx)
 
         # bind by name
         if name is not None:

tests/sql/create_schema.sql

@@ -1,5 +1,5 @@
 /*-----------------------------------------------------------------------------
- * Copyright (c) 2020, 2024, Oracle and/or its affiliates.
+ * Copyright (c) 2020, 2025, Oracle and/or its affiliates.
  *
  * This software is dual-licensed to you under the Universal Permissive License
  * (UPL) 1.0 as shown at https://oss.oracle.com/licenses/upl and Apache License
@@ -1417,3 +1417,39 @@ create or replace package body &main_user..pkg_SessionCallback as
 
 end;
 /
+
+create or replace package &main_user..pkg_TestLOBs as
+
+    procedure GetSize(
+        a_BLOB                          blob,
+        a_Size                          out number
+    );
+
+    procedure GetSize(
+        a_CLOB                          clob,
+        a_Size                          out number
+    );
+
+end;
+/
+
+create or replace package body &main_user..pkg_TestLOBs as
+
+    procedure GetSize(
+        a_BLOB                          blob,
+        a_Size                          out number
+    ) is
+    begin
+        a_Size := dbms_lob.getlength(a_BLOB);
+    end;
+
+    procedure GetSize(
+        a_CLOB                          clob,
+        a_Size                          out number
+    ) is
+    begin
+        a_Size := dbms_lob.getlength(a_CLOB);
+    end;
+
+end;
+/

tests/test_4100_cursor_callproc.py

@@ -1,5 +1,5 @@
 # -----------------------------------------------------------------------------
-# Copyright (c) 2020, 2024, Oracle and/or its affiliates.
+# Copyright (c) 2020, 2025, Oracle and/or its affiliates.
 #
 # This software is dual-licensed to you under the Universal Permissive License
 # (UPL) 1.0 as shown at https://oss.oracle.com/licenses/upl and Apache License
@@ -444,6 +444,20 @@ def test_4124(self):
         with self.assertRaisesFullCode("ORA-06550"):
             self.cursor.callproc("func_Test2", ("hello", 5, True))
 
+    def test_4125(self):
+        "4125 - test calling a procedure with a string > 32767 characters"
+        data = "4125" * 16000
+        size_var = self.cursor.var(int)
+        self.cursor.callproc("pkg_TestLobs.GetSize", [data, size_var])
+        self.assertEqual(size_var.getvalue(), len(data))
+
+    def test_4126(self):
+        "4125 - test calling a procedure with raw data > 32767 bytes"
+        data = b"4126" * 16250
+        size_var = self.cursor.var(int)
+        self.cursor.callproc("pkg_TestLobs.GetSize", [data, size_var])
+        self.assertEqual(size_var.getvalue(), len(data))
+
 
 if __name__ == "__main__":
     test_env.run_test_cases()

tests/test_6200_cursor_callproc_async.py

@@ -1,5 +1,5 @@
 # -----------------------------------------------------------------------------
-# Copyright (c) 2023, 2024, Oracle and/or its affiliates.
+# Copyright (c) 2023, 2025, Oracle and/or its affiliates.
 #
 # This software is dual-licensed to you under the Universal Permissive License
 # (UPL) 1.0 as shown at https://oss.oracle.com/licenses/upl and Apache License
@@ -119,6 +119,20 @@ async def test_6208(self):
                 "func_Test", oracledb.NUMBER, [], kwargs
             )
 
+    async def test_6209(self):
+        "6209 - test calling a procedure with a string > 32767 characters"
+        data = "6209" * 16000
+        size_var = self.cursor.var(int)
+        await self.cursor.callproc("pkg_TestLobs.GetSize", [data, size_var])
+        self.assertEqual(size_var.getvalue(), len(data))
+
+    async def test_6210(self):
+        "6210 - test calling a procedure with raw data > 32767 bytes"
+        data = b"6210" * 16250
+        size_var = self.cursor.var(int)
+        await self.cursor.callproc("pkg_TestLobs.GetSize", [data, size_var])
+        self.assertEqual(size_var.getvalue(), len(data))
+
 
 if __name__ == "__main__":
     test_env.run_test_cases()