iris-pex-embedded-python 2.3.17__py3-none-any.whl → 2.3.18__py3-none-any.whl

intersystems_iris/dbapi/_DBAPI.py

@@ -1,3 +1,5 @@
+import struct
+import copy
 import enum
 import copy
 import decimal
@@ -10,35 +12,47 @@ from ._ResultSetRow import _ResultSetRow
 import intersystems_iris.dbapi._ParameterCollection
 import intersystems_iris.dbapi.preparser._PreParser
 from intersystems_iris.dbapi._Parameter import ParameterMode
-from intersystems_iris.dbapi.preparser._PreParser import StatementType
+from intersystems_iris.dbapi.preparser._PreParser import StatementType, MultiValuesInsert
 from intersystems_iris._IRISConnection import Feature
 from intersystems_iris._InStream import _InStream
-from intersystems_iris.dbapi._IRISStream import (IRISStream, IRISBinaryStream, )
+from intersystems_iris.dbapi._IRISStream import (
+    IRISStream,
+    IRISBinaryStream,
+)
 from ._SQLType import SQLType
 
 from .._IRISNative import connect as native_connect
 from .._IRISEmbedded import _IRISEmbedded
 
+
 def NotImplementedErrorDBAPI(msg=None):
     import traceback
+
     if msg is None:
         traceback.print_stack()
         msg = "Coming soon to an IRIS DB API near you!"
     return NotImplementedError(msg)
 
-def embedded_connect(*args, hostname = None, port = None,  namespace = None, username = None, password = None, **kw):
+
+def embedded_connect(*args, hostname=None, port=None, namespace=None, username=None, password=None, **kw):
     connection = _IRISEmbedded()
-    connection.connect(hostname, port,  namespace, username, password, **kw)
+    connection.connect(hostname, port, namespace, username, password, **kw)
     return connection
 
-def connect(*args, embedded=False, hostname = None, port = None,  namespace = None, username = None, password = None, **kw):
+
+def connect(*args, embedded=False, hostname=None, port=None, namespace=None, username=None, password=None, **kw):
     try:
         if not embedded:
-            return native_connect(*args, hostname=hostname, port=port, namespace=namespace, username=username, password=password, **kw)
+            return native_connect(
+                *args, hostname=hostname, port=port, namespace=namespace, username=username, password=password, **kw
+            )
         else:
-            return embedded_connect(*args, hostname=hostname, port=port, namespace=namespace, username=username, password=password, **kw)
+            return embedded_connect(
+                *args, hostname=hostname, port=port, namespace=namespace, username=username, password=password, **kw
+            )
     except Exception as e:
-        raise DatabaseError(e)
+        raise OperationalError(e)
+
 
 class ServerReturnType(enum.IntEnum):
     NO_RETURN_VALUE = 0
@@ -46,25 +60,29 @@ class ServerReturnType(enum.IntEnum):
     HAS_RETURN_VALUE = 2
     NULL_RETURN_VALUE = 3
 
+
 class CursorType(enum.IntEnum):
     DEFAULT = 0
     PREPARED = 1
     CALLABLE = 2
 
+
 # api globals, methods, classes, etc.
 # globals
 apilevel = "2.0"
 threadsafety = 0
 paramstyle = "qmark"
 
+
 class _BaseCursor:
     embedded = False
+
     def __init__(self, connection):
         self._connection = connection
-        
+
         self.statement = None
         self._parsed_statement = None
-        
+
         self._columns = None
         self._rowcount = -1
         self.arraysize = 1
@@ -104,7 +122,9 @@ class _BaseCursor:
 
     def __iter__(self):
         if self._result_set == None:
-            raise InterfaceError("Either execute has not yet been called, or the previous call of execute did not return a result set")
+            raise InterfaceError(
+                "Either execute has not yet been called, or the previous call of execute did not return a result set"
+            )
         return self
 
     def __next__(self):
@@ -112,17 +132,17 @@ class _BaseCursor:
         if row:
             return row
         raise StopIteration
-    
+
     # non-api methods and classes
     def isClosed(self):
-        return self._closed 
+        return self._closed
 
     def setinputsizes(self, sizes):
         raise NotImplementedErrorDBAPI()
 
-    def setoutputsize(size, column = None):
+    def setoutputsize(size, column=None):
         raise NotImplementedErrorDBAPI()
-    
+
     @property
     def sqlcode(self):
         if self._closed:
@@ -154,7 +174,7 @@ class _BaseCursor:
         self._params = None
         self._parsed_statement = None
         self._cursor_type = CursorType.DEFAULT
-        self._statementType = StatementType.UPDATE # default
+        self._statementType = StatementType.UPDATE  # default
         self._paramInfo = None
         self.statement = None
         self.statementFeatureOption = Feature.optionNone
@@ -221,12 +241,21 @@ class _BaseCursor:
 
         self.statement = operation
         if params and not isinstance(params, list) and not isinstance(params, tuple):
-            params = (params, )
+            params = (params,)
         self.params = params if params is not None else ()
         self._params.set_input_params(self.params)
 
         self._cleanup()
-        self._preparse()
+        try:
+            self._preparse()
+        except MultiValuesInsert as ex:
+            # convert to executemany
+            params = params or ex.params
+            params_count = int(len(params) / ex.rows)
+            new_params = [params[i : i + params_count] for i in range(0, len(params), params_count)]
+            return self.executemany(ex.query, new_params)
+        except Exception:
+            raise
 
         if self._statementType == StatementType.UPDATE:
             self._cursor_type = CursorType.PREPARED
@@ -239,7 +268,7 @@ class _BaseCursor:
 
     def add_batch(self):
         self._is_alive()
-        
+
         if self._params._array_bound:
             if len(self._params._params_list) > 0:
                 cnt = 0
@@ -252,8 +281,15 @@ class _BaseCursor:
                             self._parameter_sets = cnt
                             first = False
                         elif self._parameter_sets != cnt:
-                            raise Exception("Unmatched columnwise parameter values: " + str(self._parameter_sets) 
-                                            +  " rows expected, but found only " + str(cnt) +" in " + str(i) + " parameter!")
+                            raise Exception(
+                                "Unmatched columnwise parameter values: "
+                                + str(self._parameter_sets)
+                                + " rows expected, but found only "
+                                + str(cnt)
+                                + " in "
+                                + str(i)
+                                + " parameter!"
+                            )
                 if self._parameter_sets > 1:
                     return
         self._parameter_sets = self._parameter_sets + 1
@@ -274,7 +310,7 @@ class _BaseCursor:
             seq_of_params = tuple(seq_of_params)
 
         self.statement = operation
-        self.params = seq_of_params
+        self.params = copy.deepcopy(seq_of_params)
         self._params.set_input_params(self.params)
 
         self._cursor_type = CursorType.PREPARED
@@ -286,12 +322,12 @@ class _BaseCursor:
 
         for row_num, param_row in enumerate(seq_of_params):
             self.add_batch()
-        
+
         if self._parameter_sets == 0:
             for param in self._params._params_list:
-                if param.value == '?':
+                if param.value == "?":
                     raise ValueError("Missing value")
-            self._prepared_update_execute() # similar to executing a statement w/ literals
+            self._prepared_update_execute()  # similar to executing a statement w/ literals
             return
 
         for param in self._params._params_list:
@@ -300,7 +336,7 @@ class _BaseCursor:
                 raise ValueError("INOUT/OUT parameters not permitted")
 
         self._prepared_update_execute()
-
+        
         return self._rowcount
 
     def _process_sqlcode(self, sqlcode, message=None):
@@ -309,11 +345,13 @@ class _BaseCursor:
             return
         if abs(sqlcode) in [108, 119, 121, 122]:
             raise IntegrityError(message)
+        if abs(sqlcode) in [1, 12]:
+            raise OperationalError(message)
         raise DatabaseError(message)
 
     def _preparse(self):
         csql = self._connection._pre_preparse_cache.get(self.statement)
-        if csql != None:
+        if csql is not None:
             self._has_return_value = csql._has_return_value
             self._params = copy.deepcopy(csql._params)
             self._params.set_input_params(self.params)
@@ -328,7 +366,8 @@ class _BaseCursor:
                 if not self._is_batch_update:
                     raise TypeError("Unsupported argument type: " + str(type(item)))
                 for ele in item:
-                    if intersystems_iris._DBList._DBList._set_switcher.get(type(ele), None) == None:
+                    if (not intersystems_iris._DBList._DBList._set_switcher.get(type(ele), None) and not issubclass(
+                            type(ele), enum.Enum)):
                         raise TypeError("Unsupported argument type: " + str(type(ele)))
             elif intersystems_iris._DBList._DBList._set_switcher.get(type(item), None) is None:
                 item = str(item)
@@ -340,9 +379,13 @@ class _BaseCursor:
                 if count != curr_count:
                     raise Exception("Parameter count does not match")
 
-        parser = intersystems_iris.dbapi.preparser._PreParser._PreParser(self._connection._connection_info._delimited_ids, embedded=self.embedded)
+        parser = intersystems_iris.dbapi.preparser._PreParser._PreParser(
+            self._connection._connection_info._delimited_ids, embedded=self.embedded
+        )
         try:
             pOut = parser.PreParse(self.statement, self._params)
+        except MultiValuesInsert:
+            raise
         except Exception as e:
             raise InterfaceError("Error parsing statement '" + self.statement + "':\n" + str(e))
 
@@ -350,22 +393,23 @@ class _BaseCursor:
             item = self.params[0]
             if (isinstance(item, list) or isinstance(item, tuple)) and not self._is_batch_update:
                 raise TypeError("Unsupported argument type: " + str(type(item)))
-        
+
         self._parsed_statement = pOut.sResult
         self._statementType = pOut.p_eStmtType
         self._paramInfo = parser.m_ParamInfo
 
-        if self._statementType == StatementType.CALL: 
+        if self._statementType == StatementType.CALL:
             self._has_return_value = ServerReturnType.NO_RETURN_VALUE
-        elif self._statementType == StatementType.CALLWITHRESULT: 
+        elif self._statementType == StatementType.CALLWITHRESULT:
             self._has_return_value = ServerReturnType.HAS_RETURN_VALUE
 
         self._update_parameters()
         self._connection._add_pre_preparse_cache(self.statement, self)
 
     def _prepare(self):
-        notDDL = bool(self._statementType != StatementType.DDL_ALTER_DROP 
-                                  and self._statementType != StatementType.DDL_OTHER)
+        notDDL = bool(
+            self._statementType != StatementType.DDL_ALTER_DROP and self._statementType != StatementType.DDL_OTHER
+        )
 
         if notDDL and self._get_cached_info():
             return
@@ -373,18 +417,18 @@ class _BaseCursor:
             self._prepare_new()
 
     def _update_parameters(self):
-        count = self._paramInfo._list_data[0] # self._paramInfo.count()
+        count = self._paramInfo._list_data[0]  # self._paramInfo.count()
         if count == 0:
             return
-        
+
         temp_list_data = self._paramInfo._list_data[1:]
-        param_info_count = int(len(temp_list_data)/2)
+        param_info_count = int(len(temp_list_data) / 2)
         if self._is_batch_update:
             unknown_count = replaced_count = 0
             for item in temp_list_data:
-                if item == 'c':
+                if item == "c":
                     replaced_count = replaced_count + 1
-                elif item == '?':
+                elif item == "?":
                     unknown_count = unknown_count + 1
 
             if len(self.params) > 0:
@@ -409,24 +453,30 @@ class _BaseCursor:
                                     param.mode = ParameterMode.OUTPUT
                         i += 1
                 return
-            
+
             if len(temp_list_data) > 0:
                 if count != param_info_count:
                     raise Exception("Parameter mismatch")
 
                 unknown_count = replaced_count = 0
                 for item in temp_list_data:
-                    if item == 'c':
+                    if item == "c":
                         replaced_count = replaced_count + 1
-                    elif item == '?':
+                    elif item == "?":
                         unknown_count = unknown_count + 1
 
                 if unknown_count != len(self.params):
-                    raise Exception(f"Incorrect number of parameters: {unknown_count}/{replaced_count}/{len(self.params)}")
+                    raise Exception(
+                        f"Incorrect number of parameters: {unknown_count}/{replaced_count}/{len(self.params)}"
+                    )
 
     def _is_not_default_or_replaced(self, param):
         mode = param.mode
-        if mode != ParameterMode.REPLACED_LITERAL and mode != ParameterMode.DEFAULT_PARAMETER and mode != ParameterMode.INPUT:
+        if (
+            mode != ParameterMode.REPLACED_LITERAL
+            and mode != ParameterMode.DEFAULT_PARAMETER
+            and mode != ParameterMode.INPUT
+        ):
             raise Exception("Parameters not allowed in Cursor class")
 
     def _validate_parameters(self):
@@ -439,7 +489,10 @@ class _BaseCursor:
         if self._parameter_list_mismatch_exception and not self._params._has_bound_by_param_name:
             raise Exception("Parameter list mismatch")
         i = 0
-        if self._has_return_value == ServerReturnType.IGNORE_RETURN_VALUE or self._has_return_value == ServerReturnType.NULL_RETURN_VALUE:
+        if (
+            self._has_return_value == ServerReturnType.IGNORE_RETURN_VALUE
+            or self._has_return_value == ServerReturnType.NULL_RETURN_VALUE
+        ):
             i = 1
         for param in self._params._params_list:
             if i == 1:
@@ -463,14 +516,14 @@ class _BaseCursor:
             StatementType.STMT_USE: self._execute_update,
             StatementType.UPDATE: self._execute_update,
             StatementType.DDL_OTHER: self._execute_update,
-            StatementType.DDL_ALTER_DROP: self._execute_update
+            StatementType.DDL_ALTER_DROP: self._execute_update,
         }
         exec_func = exec_switcher.get(self._statementType, None)
         if exec_func is None:
-            raise NotImplementedErrorDBAPI(f'StatementType {self._statementType.name} not implemented')
+            raise NotImplementedErrorDBAPI(f"StatementType {self._statementType.name} not implemented")
         else:
             return exec_func()
-    
+
     def _prepare_stored_procedure(self):
         if self._get_cached_info():
             self._prepared_stored_procedure_execute()
@@ -517,20 +570,22 @@ class _BaseCursor:
                 # not found in client side cache - send DQ message
                 self._send_direct_query_request()
         else:
-            if (self._statementType != StatementType.QUERY and
-                self._statementType != StatementType.PREPARED_CALL_QUERY and
-                self._statementType != StatementType.DIRECT_CALL_QUERY):
+            if (
+                self._statementType != StatementType.QUERY
+                and self._statementType != StatementType.PREPARED_CALL_QUERY
+                and self._statementType != StatementType.DIRECT_CALL_QUERY
+            ):
                 raise Exception("Not a query")
-            
+
             if self._exec_params != None:
                 self._bind_exec_params()
             self._validate_prepared_parameters()
-            
+
             if self.statementFeatureOption & Feature.optionFastSelect == Feature.optionFastSelect:
                 self._rsrow = _ResultSetRow(self._connection, self._columns, self.maxRowItemCount)
             else:
                 self._rsrow = _ResultSetRow(self._connection, self._columns, 0)
-            
+
             if self._cursor_type == CursorType.CALLABLE or self._statementType == StatementType.PREPARED_CALL_QUERY:
                 self._stored_procedure_query()
                 return
@@ -558,8 +613,9 @@ class _BaseCursor:
                     raise Exception("Not an update")
                 return
 
-            notDDL = bool(self._statementType != StatementType.DDL_ALTER_DROP 
-                                      and self._statementType != StatementType.DDL_OTHER)
+            notDDL = bool(
+                self._statementType != StatementType.DDL_ALTER_DROP and self._statementType != StatementType.DDL_OTHER
+            )
 
             if notDDL and self._get_cached_info():
                 # found in client side cache - send PU message
@@ -570,19 +626,21 @@ class _BaseCursor:
         else:
             if self._statementType == StatementType.QUERY or self._statementType == StatementType.PREPARED_CALL_QUERY:
                 raise Exception("Not an update")
-            
+
             if self._exec_params != None:
                 self._bind_exec_params()
             self._validate_prepared_parameters()
-            
-            if (self._cursor_type == CursorType.CALLABLE or 
-                self._statementType == StatementType.PREPARED_CALL_UPDATE or
-                self._statementType == StatementType.DIRECT_CALL_UPDATE):
+
+            if (
+                self._cursor_type == CursorType.CALLABLE
+                or self._statementType == StatementType.PREPARED_CALL_UPDATE
+                or self._statementType == StatementType.DIRECT_CALL_UPDATE
+            ):
                 self._stored_procedure_update()
                 return
 
             self._prepared_update_execute()
-        
+
     def _query404(self):
         with self._connection._lock:
             self._validate_parameters()
@@ -596,36 +654,46 @@ class _BaseCursor:
     # api properties and methods
     @property
     def description(self):
-        if self._columns == None:
+        if self._statementType is StatementType.UPDATE:
+            return None
+        
+        if self._columns is None:
             return None
 
-        Column = namedtuple("Column", [
-            'name',
-            'type_code',
-            'display_size',
-            'internal_size',
-            'precision',
-            'scale',
-            'null_ok',
-        ])
+        Column = namedtuple(
+            "Column",
+            [
+                "name",
+                "type_code",
+                "display_size",
+                "internal_size",
+                "precision",
+                "scale",
+                "null_ok",
+            ],
+        )
 
         sequence = []
-        for column in self._columns: sequence.append(Column(
-            column.name,
-            column.type,
-            None,
-            None,
-            column.precision,
-            column.scale,
-            column.nullable,
-        ))
+        for column in self._columns:
+            sequence.append(
+                Column(
+                    column.name,
+                    column.type,
+                    None,
+                    None,
+                    column.precision,
+                    column.scale,
+                    column.nullable,
+                )
+            )
         return tuple(sequence)
-    
+
     # currently doesn't work for queries
     @property
     def rowcount(self):
         return self._rowcount
 
+
 # Cursor class
 class Cursor(_BaseCursor):
     def __init__(self, connection):
@@ -646,7 +714,7 @@ class Cursor(_BaseCursor):
         self._cursor_ptr = 0
         self._scroll_flag = False
         self._warehouse = list()
-        
+
         self._warehouse_dict = dict()
         self._last_row_in_warehouse_dict = -1
         self._warehouse_dict_keys = list()
@@ -677,7 +745,7 @@ class Cursor(_BaseCursor):
         super()._process_sqlcode(sqlcode, self._get_error_info(sqlcode))
 
     def _get_cached_info(self):
-        if not self._connection._preparedCache or not hasattr(self._connection._preparedCache, '__iter__'):
+        if not self._connection._preparedCache or not hasattr(self._connection._preparedCache, "__iter__"):
             return False
         if self._parsed_statement in self._connection._preparedCache:
             self._prepare_cached(self._connection._preparedCache[self._parsed_statement])
@@ -690,17 +758,21 @@ class Cursor(_BaseCursor):
 
         if self._statementType == StatementType.CALL or self._statementType == StatementType.CALLWITHRESULT:
             if len(self._params._params_list) != len(cached_statement._params._params_list):
-                if (self._statementType == StatementType.CALL and
-                    self._has_return_value == 0 and
-                    cached_statement._has_return_value == 1 and
-                    len(self._params._params_list) + 1 == len(cached_statement._params._params_list)):
-                    self._params._params_list.insert(0, intersystems_iris.dbapi._Parameter._Parameter(None, ParameterMode.OUTPUT, 'c'))
+                if (
+                    self._statementType == StatementType.CALL
+                    and self._has_return_value == 0
+                    and cached_statement._has_return_value == 1
+                    and len(self._params._params_list) + 1 == len(cached_statement._params._params_list)
+                ):
+                    self._params._params_list.insert(
+                        0, intersystems_iris.dbapi._Parameter._Parameter(None, ParameterMode.OUTPUT, "c")
+                    )
                 else:
                     if len(self._params._params_list) == 0 or len(self._params._params_list) == 1:
                         self._params._clear()
                     else:
                         return False
-            
+
             if cached_statement._statementType == StatementType.QUERY:
                 self._statementType = StatementType.PREPARED_CALL_QUERY
             else:
@@ -713,8 +785,10 @@ class Cursor(_BaseCursor):
             self._multiple_result_sets = cached_statement.multiple_result_sets
             self._mrs_done = False
 
-            if (not self._multiple_result_sets and 
-                (self._statementType in [StatementType.QUERY, StatementType.PREPARED_CALL_QUERY, StatementType.DIRECT_CALL_QUERY])):
+            if not self._multiple_result_sets and (
+                self._statementType
+                in [StatementType.QUERY, StatementType.PREPARED_CALL_QUERY, StatementType.DIRECT_CALL_QUERY]
+            ):
                 self._columns = []
                 for column in cached_statement.columns:
                     self._columns.append(column.Clone())
@@ -741,19 +815,21 @@ class Cursor(_BaseCursor):
             self.maxRowItemCount = cached_statement.maxRowItemCount
         if hasattr(cached_statement, "_params"):
             self._params._update_param_info(cached_statement._params)
-    
+
     def _prepare_new(self):
         # send PP message
         with self._connection._lock:
             # message header
             self._statement_id = self._connection._get_new_statement_id()
             self._out_message.wire._write_header(_Message.PREPARE)
-            intersystems_iris._MessageHeader._MessageHeader._set_statement_id(self._out_message.wire.buffer, self._statement_id)
+            intersystems_iris._MessageHeader._MessageHeader._set_statement_id(
+                self._out_message.wire.buffer, self._statement_id
+            )
 
             # message body
-            self._out_message.wire._set(1) # number of statement chunks
-            self._out_message.wire._set(self._parsed_statement) # statement itself
-            self._out_message.wire._set_raw_bytes(self._paramInfo.getBuffer()) # paramInfo (from _PreParser)
+            self._out_message.wire._set(1)  # number of statement chunks
+            self._out_message.wire._set(self._parsed_statement)  # statement itself
+            self._out_message.wire._set_raw_bytes(self._paramInfo.getBuffer())  # paramInfo (from _PreParser)
 
             # send message
             sequence_number = self._connection._get_new_sequence_number()
@@ -789,7 +865,7 @@ class Cursor(_BaseCursor):
         with self._connection._lock:
             self._out_message.wire._write_header(_Message.GET_SERVER_ERROR)
             self._out_message.wire._set(sqlcode)
-            
+
             sequence_number = self._connection._get_new_sequence_number()
             self._out_message._send(sequence_number)
 
@@ -798,7 +874,10 @@ class Cursor(_BaseCursor):
 
     def _check_statement_feature(self, wire):
         self.statementFeatureOption = wire._get()
-        if self.statementFeatureOption == Feature.optionFastSelect or self.statementFeatureOption == Feature.optionFastInsert:
+        if (
+            self.statementFeatureOption == Feature.optionFastSelect
+            or self.statementFeatureOption == Feature.optionFastInsert
+        ):
             self.maxRowItemCount = wire._get()
         else:
             self.maxRowItemCount = 0
@@ -819,15 +898,33 @@ class Cursor(_BaseCursor):
             if catalog == 0:
                 catalog = None
             additionalData = wire._get().encode()
-            slotPosition = wire._get() if self.statementFeatureOption & Feature.optionFastSelect == Feature.optionFastSelect else i + 1
-            self._columns.append(intersystems_iris.dbapi._Column._Column(name, type, precision, scale, nullable, label, tableName, schema, catalog, additionalData, slotPosition))
+            slotPosition = (
+                wire._get()
+                if self.statementFeatureOption & Feature.optionFastSelect == Feature.optionFastSelect
+                else i + 1
+            )
+            self._columns.append(
+                intersystems_iris.dbapi._Column._Column(
+                    name,
+                    type,
+                    precision,
+                    scale,
+                    nullable,
+                    label,
+                    tableName,
+                    schema,
+                    catalog,
+                    additionalData,
+                    slotPosition,
+                )
+            )
 
     def _get_parameter_info(self, wire):
         count = wire._get()
         if count != len(self._params._params_list):
             raise Exception("Invalid number of parameters")
         self._read_parameter_data(wire, count, False)
-        
+
         addToCache = bool(wire._get())
         return addToCache
 
@@ -851,7 +948,7 @@ class Cursor(_BaseCursor):
 
                 if self.statementFeatureOption & Feature.optionFastInsert == Feature.optionFastInsert:
                     param.slotPosition = wire._get()
-                    self.rowOfDefaultValues = wire._get() # needs to be processed
+                    self.rowOfDefaultValues = wire._get()  # needs to be processed
                 else:
                     param.slotPosition = i + r
 
@@ -868,7 +965,6 @@ class Cursor(_BaseCursor):
         if self._parameter_sets == 0 and not self._multiple_result_sets:
             self._rowcount = self._in_message.wire._get()
 
-
     class prepared_statement(intersystems_iris._IRISConnection.CachedSQL):
         def __init__(self, cursor):
             if not isinstance(cursor, Cursor):
@@ -896,8 +992,8 @@ class Cursor(_BaseCursor):
     def _write_parameters(self):
         sets = self._parameter_sets or 1
 
-        self._out_message.wire._set(sets) # nParamSets
-        self._out_message.wire._set(len(self._params._params_list)) # nParams
+        self._out_message.wire._set(sets)  # nParamSets
+        self._out_message.wire._set(len(self._params._params_list))  # nParams
         for i in range(sets):
             param_index = 0
             param_counter = i
@@ -926,12 +1022,14 @@ class Cursor(_BaseCursor):
         with self._connection._lock:
             # message header
             self._out_message.wire._write_header(_Message.PREPARED_QUERY_EXECUTE)
-            intersystems_iris._MessageHeader._MessageHeader._set_statement_id(self._out_message.wire.buffer, self._statement_id)
+            intersystems_iris._MessageHeader._MessageHeader._set_statement_id(
+                self._out_message.wire.buffer, self._statement_id
+            )
 
             # message body
             self._write_parameters()
-            self._out_message.wire._set(0) # query timeout
-            self._out_message.wire._set(0) # maxRows (0 = all rows)
+            self._out_message.wire._set(0)  # query timeout
+            self._out_message.wire._set(0)  # maxRows (0 = all rows)
 
             # send
             sequence_number = self._connection._get_new_sequence_number()
@@ -948,7 +1046,7 @@ class Cursor(_BaseCursor):
         self._current_wire = self._in_message.wire
         self._result_set = [self._current_wire]
         self._rs_index = 0
-        
+
         self._rowcount = -1
 
     def _send_direct_stored_procedure_request(self):
@@ -958,13 +1056,15 @@ class Cursor(_BaseCursor):
             # message header
             self._statement_id = self._connection._get_new_statement_id()
             self._out_message.wire._write_header(_Message.DIRECT_STORED_PROCEDURE)
-            intersystems_iris._MessageHeader._MessageHeader._set_statement_id(self._out_message.wire.buffer, self._statement_id)
+            intersystems_iris._MessageHeader._MessageHeader._set_statement_id(
+                self._out_message.wire.buffer, self._statement_id
+            )
 
             # message body
-            self._out_message.wire._set(self._parsed_statement) # statement itself
-            self._out_message.wire._set(0) # resultSetType != ResultSet.TYPE_SCROLL_INSENSITIVE
-            self._out_message.wire._set(0) # query timeout
-            self._out_message.wire._set(0) # maxRows (0 = all rows)
+            self._out_message.wire._set(self._parsed_statement)  # statement itself
+            self._out_message.wire._set(0)  # resultSetType != ResultSet.TYPE_SCROLL_INSENSITIVE
+            self._out_message.wire._set(0)  # query timeout
+            self._out_message.wire._set(0)  # maxRows (0 = all rows)
             self._write_stored_procedure_parameters()
 
             # send
@@ -985,21 +1085,26 @@ class Cursor(_BaseCursor):
 
                 self._cache_prepared_statement()
 
-                if self._statementType in [StatementType.UPDATE, StatementType.DIRECT_CALL_UPDATE, StatementType.PREPARED_CALL_UPDATE]:
+                if self._statementType in [
+                    StatementType.UPDATE,
+                    StatementType.DIRECT_CALL_UPDATE,
+                    StatementType.PREPARED_CALL_UPDATE,
+                ]:
                     return False
 
             except IndexError:
                 raise DatabaseError("Server response message terminated prematurely")
             except TypeError:
                 raise DatabaseError("Unexpected server response message format")
-    
+
     def _prepared_stored_procedure_execute(self):
         # send SU message
         with self._connection._lock:
             # message header
             self._out_message.wire._write_header(_Message.PREPARED_UPDATE_EXECUTE)
-            intersystems_iris._MessageHeader._MessageHeader._set_statement_id(self._out_message.wire.buffer, self._statement_id)
-
+            intersystems_iris._MessageHeader._MessageHeader._set_statement_id(
+                self._out_message.wire.buffer, self._statement_id
+            )
 
     def _send_direct_query_request(self):
         # send DQ message
@@ -1007,15 +1112,17 @@ class Cursor(_BaseCursor):
             # message header
             self._statement_id = self._connection._get_new_statement_id()
             self._out_message.wire._write_header(_Message.DIRECT_QUERY)
-            intersystems_iris._MessageHeader._MessageHeader._set_statement_id(self._out_message.wire.buffer, self._statement_id)
+            intersystems_iris._MessageHeader._MessageHeader._set_statement_id(
+                self._out_message.wire.buffer, self._statement_id
+            )
 
             # message body
-            self._out_message.wire._set(1) # number of statement chunks
-            self._out_message.wire._set(self._parsed_statement) # statement itself
-            self._out_message.wire._set_raw_bytes(self._paramInfo.getBuffer()) # paramInfo (from _PreParser)
+            self._out_message.wire._set(1)  # number of statement chunks
+            self._out_message.wire._set(self._parsed_statement)  # statement itself
+            self._out_message.wire._set_raw_bytes(self._paramInfo.getBuffer())  # paramInfo (from _PreParser)
             self._write_parameters()
-            self._out_message.wire._set(0) # query timeout
-            self._out_message.wire._set(0) # maxRows (0 = all rows)
+            self._out_message.wire._set(0)  # query timeout
+            self._out_message.wire._set(0)  # maxRows (0 = all rows)
 
             # send
             sequence_number = self._connection._get_new_sequence_number()
@@ -1049,24 +1156,83 @@ class Cursor(_BaseCursor):
         self._current_wire = self._in_message.wire
         self._result_set = [self._current_wire]
         self._rs_index = 0
-        
+
         self._rowcount = -1
         if self.statementFeatureOption & Feature.optionFastSelect == Feature.optionFastSelect:
             self._rsrow = _ResultSetRow(self._connection, self._columns, self.maxRowItemCount)
         else:
             self._rsrow = _ResultSetRow(self._connection, self._columns, 0)
+
+    def _update_streams(self):
+        sets = self._parameter_sets or 1
+        self.params = list(self.params).copy()
+        param_types = [param.type for param in self._params._params_list]
         
+        for i in range(sets):
+            params = self._params.collect(i)
+            for pi, param in enumerate(params):
+                if param_types[pi] in (SQLType.LONGVARBINARY, SQLType.LONGVARCHAR) and param is not None:
+                    stream_oref = self._send_stream(param_types[pi], param)
+                    if isinstance(self.params[i], tuple):
+                        self.params[i] = list(self.params[i])
+                    if isinstance(self.params[i], list):
+                        self.params[i][pi] = stream_oref
+                    else:
+                        self.params[pi] = stream_oref
+
+    def _send_stream(self, param_type, value):
+        if not isinstance(value, str) and not isinstance(value, bytes):
+            raise Exception(f"Invalid value type for stream, got {type(value).__name__}, expected str or bytes")
+        stream_oref = None
+        offset = 0
+        full_size = len(value)
+        with self._connection._lock:
+            while True:
+                size = full_size
+                if size == 0:
+                    break
+                size = 4096 if size > 4096 else size
+                chunk = value[offset:offset + size]
+                if not isinstance(chunk, bytes):
+                    chunk = bytes(chunk, "utf-8")
+                offset += size
+                full_size -= size
+
+                # message header
+                code = _Message.STORE_BINARY_STREAM if param_type == SQLType.LONGVARBINARY else _Message.STORE_CHARACTER_STREAM
+                self._out_message.wire._write_header(code)
+                intersystems_iris._MessageHeader._MessageHeader._set_statement_id(
+                    self._out_message.wire.buffer, self._statement_id
+                )
+                # message body
+                self._out_message.wire._set(stream_oref or "0")
+                self._out_message.wire._set_raw_bytes(struct.pack("<i", size))
+                self._out_message.wire._set_raw_bytes(chunk)
+
+                # send
+                sequence_number = self._connection._get_new_sequence_number()
+                self._out_message._send(sequence_number)
+
+                self._in_message._read_message_sql(sequence_number, self._statement_id, 0)
+                stream_oref = self._sqlcode = self._in_message.wire._get()
+
+        return stream_oref
+
     def _prepared_update_execute(self):
+        self._update_streams()
+
         # send PU message
         with self._connection._lock:
             # message header
             self._out_message.wire._write_header(_Message.PREPARED_UPDATE_EXECUTE)
-            intersystems_iris._MessageHeader._MessageHeader._set_statement_id(self._out_message.wire.buffer, self._statement_id)
+            intersystems_iris._MessageHeader._MessageHeader._set_statement_id(
+                self._out_message.wire.buffer, self._statement_id
+            )
 
             # message body
             self._lastrowid = None
-            self._out_message.wire._set(-1) # autoGeneratedKeyColumn
-            self._out_message.wire._set(0) # statement timeout always 0 for non-queries
+            self._out_message.wire._set(-1)  # autoGeneratedKeyColumn
+            self._out_message.wire._set(0)  # statement timeout always 0 for non-queries
             self._write_parameters()
 
             # send
@@ -1087,15 +1253,17 @@ class Cursor(_BaseCursor):
             self._statement_id = self._connection._get_new_statement_id()
             # message header
             self._out_message.wire._write_header(_Message.DIRECT_UPDATE)
-            intersystems_iris._MessageHeader._MessageHeader._set_statement_id(self._out_message.wire.buffer, self._statement_id)
+            intersystems_iris._MessageHeader._MessageHeader._set_statement_id(
+                self._out_message.wire.buffer, self._statement_id
+            )
 
             # message body
             self._lastrowid = None
-            self._out_message.wire._set(1) # number of statement chunks
-            self._out_message.wire._set(self._parsed_statement) # statement itself
-            self._out_message.wire._set_raw_bytes(self._paramInfo.getBuffer()) # paramInfo (from _PreParser)
-            self._out_message.wire._set(-1) # autoGeneratedKeyColumn
-            self._out_message.wire._set(0) # statement timeout always 0 for non-queries
+            self._out_message.wire._set(1)  # number of statement chunks
+            self._out_message.wire._set(self._parsed_statement)  # statement itself
+            self._out_message.wire._set_raw_bytes(self._paramInfo.getBuffer())  # paramInfo (from _PreParser)
+            self._out_message.wire._set(-1)  # autoGeneratedKeyColumn
+            self._out_message.wire._set(0)  # statement timeout always 0 for non-queries
             self._write_parameters()
 
             # send
@@ -1109,9 +1277,11 @@ class Cursor(_BaseCursor):
                 self._process_sqlcode(self._sqlcode)
 
                 addToCache = self._get_parameter_info(self._in_message.wire)
-                
-                notDDL = bool(self._statementType != StatementType.DDL_ALTER_DROP 
-                                  and self._statementType != StatementType.DDL_OTHER)
+
+                notDDL = bool(
+                    self._statementType != StatementType.DDL_ALTER_DROP
+                    and self._statementType != StatementType.DDL_OTHER
+                )
                 if notDDL and addToCache:
                     self._cache_prepared_statement()
 
@@ -1125,12 +1295,14 @@ class Cursor(_BaseCursor):
             # message header
             self._statement_id = self._connection._get_new_statement_id()
             self._out_message.wire._write_header(_Message.PREPARE_STORED_PROCEDURE)
-            intersystems_iris._MessageHeader._MessageHeader._set_statement_id(self._out_message.wire.buffer, self._statement_id)
+            intersystems_iris._MessageHeader._MessageHeader._set_statement_id(
+                self._out_message.wire.buffer, self._statement_id
+            )
 
             # message body
-            #self._out_message.wire._set(1) # number of statement chunks
-            self._out_message.wire._set(self._parsed_statement) # statement itself
-            
+            # self._out_message.wire._set(1) # number of statement chunks
+            self._out_message.wire._set(self._parsed_statement)  # statement itself
+
             # send message
             sequence_number = self._connection._get_new_sequence_number()
             self._out_message._send(sequence_number)
@@ -1209,11 +1381,20 @@ class Cursor(_BaseCursor):
                 self._has_return_value = ServerReturnType.HAS_RETURN_VALUE
             elif not server_has_return and self._has_return_value == ServerReturnType.NO_RETURN_VALUE:
                 self._has_return_value = ServerReturnType.NO_RETURN_VALUE
-            elif (size == 1 and count == 1 
-                  and (self._params._params_list[0].mode == ParameterMode.DEFAULT_PARAMETER 
-                       and self._has_return_value == ServerReturnType.NO_RETURN_VALUE and server_has_return) 
-                  or (self._params._params_list[0].mode == ParameterMode.UNKNOWN 
-                      and self._has_return_value == ServerReturnType.IGNORE_RETURN_VALUE and server_has_return)):
+            elif (
+                size == 1
+                and count == 1
+                and (
+                    self._params._params_list[0].mode == ParameterMode.DEFAULT_PARAMETER
+                    and self._has_return_value == ServerReturnType.NO_RETURN_VALUE
+                    and server_has_return
+                )
+                or (
+                    self._params._params_list[0].mode == ParameterMode.UNKNOWN
+                    and self._has_return_value == ServerReturnType.IGNORE_RETURN_VALUE
+                    and server_has_return
+                )
+            ):
                 self._params._params_list.pop(0)
                 self._params._params_list.insert(0, intersystems_iris.dbapi._Parameter._Parameter())
                 self._has_return_value = ServerReturnType.IGNORE_RETURN_VALUE
@@ -1245,7 +1426,9 @@ class Cursor(_BaseCursor):
                 self._params._params_list.insert(0, intersystems_iris.dbapi._Parameter._Parameter())
                 self._has_return_value = ServerReturnType.IGNORE_RETURN_VALUE
             else:
-                self._params._params_list.append(intersystems_iris.dbapi._Parameter._Parameter(ParameterMode.DEFAULT_PARAMETER, 'c'))
+                self._params._params_list.append(
+                    intersystems_iris.dbapi._Parameter._Parameter(ParameterMode.DEFAULT_PARAMETER, "c")
+                )
         else:
             self._parameter_list_mismatch_exception = True
             if server_has_return and self._has_return_value == ServerReturnType.NO_RETURN_VALUE:
@@ -1255,7 +1438,9 @@ class Cursor(_BaseCursor):
                 self._params._params_list.insert(0, param)
                 size = size + 1
             while size < count:
-                self._params._params_list.append(intersystems_iris.dbapi._Parameter._Parameter(ParameterMode.DEFAULT_PARAMETER, 'c'))
+                self._params._params_list.append(
+                    intersystems_iris.dbapi._Parameter._Parameter(ParameterMode.DEFAULT_PARAMETER, "c")
+                )
                 size = size + 1
         self._read_parameter_data(wire, count, True)
         return True
@@ -1287,12 +1472,14 @@ class Cursor(_BaseCursor):
         with self._connection._lock:
             # message header
             self._out_message.wire._write_header(_Message.STORED_PROCEDURE_UPDATE_EXECUTE)
-            intersystems_iris._MessageHeader._MessageHeader._set_statement_id(self._out_message.wire.buffer, self._statement_id)
+            intersystems_iris._MessageHeader._MessageHeader._set_statement_id(
+                self._out_message.wire.buffer, self._statement_id
+            )
 
             # message body
-            self._out_message.wire._set(0) # isStatic should always be 0 for non-queries
-            self._out_message.wire._set(0) # query timeout
-            self._out_message.wire._set(0) # maxRows (0 = all rows)
+            self._out_message.wire._set(0)  # isStatic should always be 0 for non-queries
+            self._out_message.wire._set(0)  # query timeout
+            self._out_message.wire._set(0)  # maxRows (0 = all rows)
             self._write_stored_procedure_parameters()
 
             # send
@@ -1316,12 +1503,14 @@ class Cursor(_BaseCursor):
         with self._connection._lock:
             # message header
             self._out_message.wire._write_header(_Message.STORED_PROCEDURE_QUERY_EXECUTE)
-            intersystems_iris._MessageHeader._MessageHeader._set_statement_id(self._out_message.wire.buffer, self._statement_id)
+            intersystems_iris._MessageHeader._MessageHeader._set_statement_id(
+                self._out_message.wire.buffer, self._statement_id
+            )
 
             # message body
-            self._out_message.wire._set(0) # ResultSet.TYPE_SCROLL_INSENSITIVE
-            self._out_message.wire._set(0) # query timeout
-            self._out_message.wire._set(0) # maxRows (0 = all rows)
+            self._out_message.wire._set(0)  # ResultSet.TYPE_SCROLL_INSENSITIVE
+            self._out_message.wire._set(0)  # query timeout
+            self._out_message.wire._set(0)  # maxRows (0 = all rows)
             self._write_stored_procedure_parameters()
 
             # send
@@ -1354,8 +1543,8 @@ class Cursor(_BaseCursor):
             self._validate_parameters()
         with self._connection._lock:
             self._out_message.wire._write_header(_Message.EXECUTE_MULTIPLE_RESULT_SETS)
-            self._out_message.wire._set(0) # resultSetType != ResultSet.TYPE_SCROLL_INSENSITIVE
-            self._out_message.wire._set(0) # query timeout
+            self._out_message.wire._set(0)  # resultSetType != ResultSet.TYPE_SCROLL_INSENSITIVE
+            self._out_message.wire._set(0)  # query timeout
             self._write_stored_procedure_parameters()
 
             # send
@@ -1378,7 +1567,7 @@ class Cursor(_BaseCursor):
             self._rs_index = 0
 
             results = self._in_message.wire._get()
-            if results >= 0 :
+            if results >= 0:
                 self._update_cnt = results
                 return False
             elif results == -1:
@@ -1386,7 +1575,7 @@ class Cursor(_BaseCursor):
             elif results == -2:
                 self._update_cnt = -1
                 self._mrs_done = True
-                #self._rsrow._is_after_last = True
+                # self._rsrow._is_after_last = True
                 return False
             else:
                 raise Exception("Invalid result type value")
@@ -1435,7 +1624,11 @@ class Cursor(_BaseCursor):
             if i == 1:
                 i = 0
                 continue
-            if param.mode == ParameterMode.INPUT_OUTPUT or param.mode == ParameterMode.OUTPUT or param.mode == ParameterMode.RETURN_VALUE:
+            if (
+                param.mode == ParameterMode.INPUT_OUTPUT
+                or param.mode == ParameterMode.OUTPUT
+                or param.mode == ParameterMode.RETURN_VALUE
+            ):
                 wire._next_unless_undefined()
             else:
                 wire._next()
@@ -1445,7 +1638,9 @@ class Cursor(_BaseCursor):
         else:
             self._output_parameter_list = wire._get_output_parameter_list(beg, False)
         if self._statementType not in [StatementType.DIRECT_CALL_UPDATE]:
-            self._params._prep_list_index(False, self._output_parameter_list) # fast select not supported for stored procedures
+            self._params._prep_list_index(
+                False, self._output_parameter_list
+            )  # fast select not supported for stored procedures
         return
 
     def _handle_error_504(self, error):
@@ -1464,7 +1659,11 @@ class Cursor(_BaseCursor):
     def stored_results(self):
         if self._closed:
             raise InterfaceError("Cursor is closed")
-        if self._statementType not in [StatementType.QUERY, StatementType.DIRECT_CALL_QUERY, StatementType.PREPARED_CALL_QUERY]:
+        if self._statementType not in [
+            StatementType.QUERY,
+            StatementType.DIRECT_CALL_QUERY,
+            StatementType.PREPARED_CALL_QUERY,
+        ]:
             return None
         # getResultSet()
         if self._multiple_result_sets:
@@ -1492,16 +1691,21 @@ class Cursor(_BaseCursor):
                 raise InterfaceError("Cursor is closed")
             if self._connection == None or self._connection.isClosed():
                 raise InterfaceError("Connection not open")
-            if (self._mrs_done or not self._multiple_result_sets or 
-                (self._statementType != StatementType.PREPARED_CALL_QUERY and 
-                 self._statementType != StatementType.DIRECT_CALL_QUERY and
-                 self._statementType != StatementType.CALL and
-                 self._statementType != StatementType.CALLWITHRESULT and
-                 not (self._statementType == StatementType.QUERY and self._cursor_type == CursorType.CALLABLE))):
+            if (
+                self._mrs_done
+                or not self._multiple_result_sets
+                or (
+                    self._statementType != StatementType.PREPARED_CALL_QUERY
+                    and self._statementType != StatementType.DIRECT_CALL_QUERY
+                    and self._statementType != StatementType.CALL
+                    and self._statementType != StatementType.CALLWITHRESULT
+                    and not (self._statementType == StatementType.QUERY and self._cursor_type == CursorType.CALLABLE)
+                )
+            ):
                 return False
             with self._connection._lock:
                 self._out_message.wire._write_header(_Message.GET_MORE_RESULTS)
-                self._out_message.wire._set(1) # current = CLOSE_CURRENT_RESULT
+                self._out_message.wire._set(1)  # current = CLOSE_CURRENT_RESULT
 
                 # send
                 sequence_number = self._connection._get_new_sequence_number()
@@ -1515,7 +1719,7 @@ class Cursor(_BaseCursor):
                 self._rs_index = 0
 
                 results = self._in_message.wire._get()
-                if results >= 0 :
+                if results >= 0:
                     self._update_cnt = results
                     return False
                 elif results == -1:
@@ -1543,11 +1747,11 @@ class Cursor(_BaseCursor):
     def _get_result_set(self, oref):
         if oref == None:
             return None
-        
+
         with self._connection._lock:
             self._out_message.wire._write_header(_Message.GET_RESULT_SET_OBJECT)
             self._out_message.wire._set(oref)
-            self._out_message.wire._set(0) # IRISResultSet.GET_RESULT_SET_OBJECT_INIT
+            self._out_message.wire._set(0)  # IRISResultSet.GET_RESULT_SET_OBJECT_INIT
 
             # send
             sequence_number = self._connection._get_new_sequence_number()
@@ -1573,16 +1777,16 @@ class Cursor(_BaseCursor):
             self.params = params
 
         self._params.set_input_params(self.params)
-        
+
         self._cursor_type = CursorType.CALLABLE
         self._cleanup()
         self._preparse()
         self._stored_results = []
-        
+
         if not self._get_cached_info():
             self._prepare_stored_procedure()
 
-        #execute() in IrisPreparedStatement
+        # execute() in IrisPreparedStatement
         if self._multiple_result_sets:
             return self._execute_multiple_result_sets(True)
         if self._statementType == StatementType.QUERY or self._statementType == StatementType.PREPARED_CALL_QUERY:
@@ -1603,12 +1807,12 @@ class Cursor(_BaseCursor):
             if param.mode in [ParameterMode.RETURN_VALUE, ParameterMode.OUTPUT, ParameterMode.INPUT]:
                 offset = self._params._get_user_list_offset(i + 1)
                 val = self._output_parameter_list._get_at_offset(offset)
-                if param.type == -51: # RESULT_SET_TYPE
+                if param.type == -51:  # RESULT_SET_TYPE
                     self._get_result_set(val)
                     self.nextset()
                     return_args.append(self._stored_results[0])
                 else:
-                    if val == '\x01': # Either represents the number 1 or a null/None value
+                    if val == "\x01":  # Either represents the number 1 or a null/None value
                         # maybe move this to _grab_ascii_string in DBList?
                         off = self._output_parameter_list.list_item.data_offset
                         buf = self._output_parameter_list.list_item.buffer
@@ -1617,7 +1821,7 @@ class Cursor(_BaseCursor):
                     else:
                         return_args.append(val)
         if len(return_args) > 0:
-            if any(i != None for i in return_args): 
+            if any(i != None for i in return_args):
                 return return_args
             else:
                 return
@@ -1634,23 +1838,26 @@ class Cursor(_BaseCursor):
         if self._connection == None or self._connection.isClosed():
             return None
 
-        if self._statementType is not StatementType.UPDATE:
+        if self._statementType is not StatementType.UPDATE or self._rowcount < 1:
             return None
-        
-        # In multivalue inserts it returns the first inserted value, not the last one
-        # with self._connection._lock:
-        #     self._out_message.wire._write_header(_Message.GET_AUTO_GENERATED_KEYS)
-        #     sequence_number = self._connection._get_new_sequence_number()
-        #     self._out_message._send(sequence_number)
-        #     self._in_message._read_message_sql(sequence_number)
-        #     self._sqlcode = self._in_message.wire.header._get_function_code()
-        #     if self._sqlcode != 100:
-        #         raise DatabaseError(self._get_error_info(self._sqlcode))
-        #     self._get_column_info(self._in_message.wire)
-        #     self._lastrowid = self._in_message.wire._get()
-
-        self.execute('SELECT LAST_IDENTITY()')
-        self._lastrowid = self.fetchone()[0]
+
+        if self._rowcount > 1:
+            with self._connection.cursor() as cursor:
+                cursor.execute("SELECT LAST_IDENTITY()")
+                self._lastrowid = cursor.fetchone()[0]
+            return self._lastrowid
+
+        # In multiple rows inserted it returns the first inserted value, not the last one
+        with self._connection._lock:
+            self._out_message.wire._write_header(_Message.GET_AUTO_GENERATED_KEYS)
+            sequence_number = self._connection._get_new_sequence_number()
+            self._out_message._send(sequence_number)
+            self._in_message._read_message_sql(sequence_number)
+            self._sqlcode = self._in_message.wire.header._get_function_code()
+            if self._sqlcode != 100:
+                raise DatabaseError(self._get_error_info(self._sqlcode))
+            self._get_column_info(self._in_message.wire)
+            self._lastrowid = self._in_message.wire._get()
         return self._lastrowid
 
     def _cleanup(self):
@@ -1696,7 +1903,7 @@ class Cursor(_BaseCursor):
         self._params = None
         self._parsed_statement = None
         self._cursor_type = CursorType.DEFAULT
-        self._statementType = StatementType.UPDATE # default
+        self._statementType = StatementType.UPDATE  # default
         self._paramInfo = None
         self.statement = None
         self.statementFeatureOption = Feature.optionNone
@@ -1726,15 +1933,15 @@ class Cursor(_BaseCursor):
         return self._rowcount
 
     def scroll(self, value, mode):
-        if mode == None or mode == '':
-            mode = 'relative'
+        if mode == None or mode == "":
+            mode = "relative"
         mode = mode.lower()
-        if mode != 'absolute' and mode != 'relative':
+        if mode != "absolute" and mode != "relative":
             raise ValueError("This mode is not supported - use 'relative' or 'absolute'.")
 
         # Backward Scrolling
         if value < 0:
-            if mode == 'relative':
+            if mode == "relative":
                 self._rownumber = self._cursor_ptr + value - 1
             else:
                 raise ValueError("Negative values with absolute scrolling are not allowed.")
@@ -1753,13 +1960,13 @@ class Cursor(_BaseCursor):
                         return self._warehouse[self._rownumber - self._last_row_in_warehouse_dict - 1]
         # Forward Scrolling
         else:
-            if mode == 'absolute':
+            if mode == "absolute":
                 self._cursor_ptr = 0
             self._scroll_flag = True
             self._rownumber = self._cursor_ptr + value - 1
             if self._rs_index == 0:
                 if self._rownumber >= len(self._warehouse):
-                    if mode == 'absolute':
+                    if mode == "absolute":
                         self._cursor_ptr = len(self._warehouse)
                     return self.fetchone()
                 else:
@@ -1781,7 +1988,7 @@ class Cursor(_BaseCursor):
                         self._cursor_ptr = self._rownumber + 1
                         return self._warehouse[self._rownumber - self._last_row_in_warehouse_dict - 1]
                     else:
-                        if mode == 'absolute':
+                        if mode == "absolute":
                             self._cursor_ptr = rows_available + 1
                         return self.fetchone()
 
@@ -1797,7 +2004,9 @@ class Cursor(_BaseCursor):
         if self._sqlcode == 0:
             with self._connection._lock:
                 self._out_message.wire._write_header(_Message.FETCH_DATA)
-                intersystems_iris._MessageHeader._MessageHeader._set_statement_id(self._out_message.wire.buffer, self._statement_id)
+                intersystems_iris._MessageHeader._MessageHeader._set_statement_id(
+                    self._out_message.wire.buffer, self._statement_id
+                )
 
                 sequence_number = self._connection._get_new_sequence_number()
                 self._out_message._send(sequence_number)
@@ -1831,7 +2040,7 @@ class Cursor(_BaseCursor):
             list_item = self._current_wire.list_item
             buffer = list_item.buffer
             length = list_item.list_buffer_end
-                
+
             if self._rsrow._new_buffer:
                 prev_offset = list_item.next_offset
                 self._rsrow._new_buffer = False
@@ -1848,10 +2057,10 @@ class Cursor(_BaseCursor):
                 intersystems_iris._DBList._DBList._get_list_element(list_item)
                 length = list_item.next_offset
                 prev_offset = list_item.data_offset
-                if list_item.data_length == 0: #
+                if list_item.data_length == 0:  #
                     for j in range(self._rsrow.colCount):
                         rowItems[j] = -1
-                    self._rsrow._offsets = self._rsrow.update(rowItems) # ???
+                    self._rsrow._offsets = self._rsrow.update(rowItems)  # ???
                     return True
             else:
                 if self._rsrow.rowItems != None:
@@ -1878,10 +2087,12 @@ class Cursor(_BaseCursor):
 
         self._cursor_ptr += 1
         return row_indexing
-            
+
     def fetchone(self):
         if self._result_set == None:
-            raise InterfaceError("Either execute has not yet been called, or the previous call of execute did not return a result set")
+            raise InterfaceError(
+                "Either execute has not yet been called, or the previous call of execute did not return a result set"
+            )
 
         if self._current_wire == None and self._cursor_ptr > self._last_row_in_warehouse_dict:
             return None
@@ -1920,9 +2131,11 @@ class Cursor(_BaseCursor):
         return retval.as_tuple()
         # return tuple(retval[:])
 
-    def fetchmany(self, size = None):
+    def fetchmany(self, size=None):
         if self._result_set == None:
-            raise InterfaceError("Either execute has not yet been called, or the previous call of execute did not return a result set")
+            raise InterfaceError(
+                "Either execute has not yet been called, or the previous call of execute did not return a result set"
+            )
 
         if self._current_wire == None:
             if self._cursor_ptr > self._last_row_in_warehouse_dict:
@@ -1950,7 +2163,7 @@ class Cursor(_BaseCursor):
                         break
                     self._cursor_ptr += 1
                 return rows
-        
+
         if size is None:
             size = self.arraysize
 
@@ -1964,8 +2177,10 @@ class Cursor(_BaseCursor):
 
     def fetchall(self):
         if self._result_set == None:
-            raise InterfaceError("Either execute has not yet been called, or the previous call of execute did not return a result set")
-        
+            raise InterfaceError(
+                "Either execute has not yet been called, or the previous call of execute did not return a result set"
+            )
+
         if self._current_wire == None:
             if self._cursor_ptr > self._last_row_in_warehouse_dict:
                 return []
@@ -1990,15 +2205,17 @@ class Cursor(_BaseCursor):
                         break
                     self._cursor_ptr += 1
                 return rows
-        
+
         rows = []
         while self._current_wire is not None:
             row = self.fetchone()
-            if not row: break
+            if not row:
+                break
             rows.append(row)
-        
+
         return rows
 
+
 class EmbdeddedCursor(_BaseCursor):
     embedded = True
     _result_set = None
@@ -2008,7 +2225,7 @@ class EmbdeddedCursor(_BaseCursor):
         self._sql = connection.iris.sql
         self._iris = connection.iris
         self._closed = False
-        
+
         # $System.SQL.SetSelectMode(1 /* ODBC */)
         # $System.SQL.Util.SetOption("SelectMode", 1 /* ODBC */)
         connection.iris.system.SQL.SetSelectMode(1)
@@ -2016,12 +2233,12 @@ class EmbdeddedCursor(_BaseCursor):
     def _get_cached_info(self):
         return False
 
-    def _get_parameters(self, params_set = 0):
+    def _get_parameters(self, params_set=0):
         params = self._params.collect(params_set)
         # None = '', '' = b'\x00'
         _conv = {
-            type(None): lambda v: '',
-            str: lambda v: v or b'\x00',
+            type(None): lambda v: "",
+            str: lambda v: v or b"\x00",
             decimal.Decimal: lambda v: float(v),
         }
         params = [_conv[type(v)](v) if type(v) in _conv else v for v in params]
@@ -2031,9 +2248,9 @@ class EmbdeddedCursor(_BaseCursor):
         self._columns = []
         if self._result_set is None:
             return
-        
+
         metadata = self._result_set.ResultSet._GetMetadata()
-        count = metadata.columnCount if metadata != '' and metadata is not None else 0
+        count = metadata.columnCount if metadata != "" and metadata is not None else 0
         for i in range(count):
             slotPosition = i + 1
             _column_info = metadata.columns.GetAt(slotPosition)
@@ -2065,7 +2282,21 @@ class EmbdeddedCursor(_BaseCursor):
                 _column_info.isKeyColumn,
                 _column_info.isRowId,
             ]
-            self._columns.append(intersystems_iris.dbapi._Column._Column(name, odbctype, precision, scale, nullable, label, tableName, schema, catalog, additionalData, slotPosition))
+            self._columns.append(
+                intersystems_iris.dbapi._Column._Column(
+                    name,
+                    odbctype,
+                    precision,
+                    scale,
+                    nullable,
+                    label,
+                    tableName,
+                    schema,
+                    catalog,
+                    additionalData,
+                    slotPosition,
+                )
+            )
 
     @property
     def lastrowid(self):
@@ -2138,8 +2369,22 @@ class EmbdeddedCursor(_BaseCursor):
         self._rowcount = 0
         self._lastrowid = None
         sets = self._parameter_sets or 1
+        metadata = self._statement.Statement._Metadata.parameters
+        param_types = [metadata.GetAt(i + 1).ODBCType for i in range(metadata.Size)]
+        
+        stream_chunk_size = 32000
+
         for i in range(sets):
             params = self._get_parameters(i)
+            for ip, param in enumerate(params):
+                if param_types[ip] in (SQLType.LONGVARBINARY, SQLType.LONGVARCHAR):
+                    stream_class = '%Stream.GlobalBinary' if param_types[ip] == SQLType.LONGVARBINARY else '%Stream.GlobalCharacter'
+                    stream = self._iris.cls(stream_class)._New()
+                    while param:
+                        stream.Write(param[:stream_chunk_size])
+                        param = param[stream_chunk_size:]
+                    params[ip] = stream
+
             sqlcode = 0
             message = None
             try:
@@ -2155,8 +2400,8 @@ class EmbdeddedCursor(_BaseCursor):
         sqlproc = self._parsed_statement
         self._rowcount = 0
         params = self._get_parameters()
-        params_marks = ', '.join(['?'] * len(params))
-        statement = f'CALL {sqlproc} ({params_marks})'
+        params_marks = ", ".join(["?"] * len(params))
+        statement = f"CALL {sqlproc} ({params_marks})"
 
         sqlcode = 0
         message = None
@@ -2172,29 +2417,34 @@ class EmbdeddedCursor(_BaseCursor):
     @property
     def rowcount(self):
         return self._rowcount
-        
+
     def fetchone(self):
         if self._result_set == None:
-            raise InterfaceError("Either execute has not yet been called, or the previous call of execute did not return a result set")
-        
+            raise InterfaceError(
+                "Either execute has not yet been called, or the previous call of execute did not return a result set"
+            )
+
         try:
             values = self._result_set.__next__()
         except:
             return None
 
-        values = [None if v == '' else '' if v == '\x00' else v for v in values]
-        row = namedtuple('Row', [col.name for col in self._columns], rename=True)
+        values = [None if v == "" else "" if v == "\x00" else v for v in values]
+        row = namedtuple("Row", [col.name for col in self._columns], rename=True)
 
         _types = {
             SQLType.BIGINT: int,
             SQLType.BINARY: bytes,
+            SQLType.VARBINARY: bytes,
             SQLType.BIT: bool,
+            SQLType.FLOAT: float,
+            SQLType.NUMERIC: decimal.Decimal,
             SQLType.INTEGER: int,
             SQLType.VARCHAR: str,
             SQLType.LONGVARBINARY: IRISBinaryStream,
             SQLType.LONGVARCHAR: IRISStream,
         }
-        
+
         if self._columns:
             for _column in self._columns:
                 value = values[_column.slotPosition - 1]
@@ -2202,12 +2452,15 @@ class EmbdeddedCursor(_BaseCursor):
                 ctype = _column.type
                 value_type = _types[ctype] if ctype in _types else None
                 try:
-                    if type(value) == float:
-                        value = decimal.Decimal(str(value))
-                    elif not _column.tableName and not _column.schema:
-                        pass
+                    if not _column.tableName and not _column.schema:
+                        if type(value) == float:
+                            value = decimal.Decimal(str(value))
                     elif value is None or value_type is None:
                         pass
+                    elif value_type is bytes:
+                        value = bytes(map(ord, value))
+                    elif value_type is decimal.Decimal:
+                        value = decimal.Decimal(str(value))
                     elif issubclass(value_type, IRISStream):
                         stream = value_type(self._connection, value, embedded=True)
                         value = stream.fetch()
@@ -2221,18 +2474,23 @@ class EmbdeddedCursor(_BaseCursor):
 
     def fetchall(self):
         if self._result_set == None:
-            raise InterfaceError("Either execute has not yet been called, or the previous call of execute did not return a result set")
+            raise InterfaceError(
+                "Either execute has not yet been called, or the previous call of execute did not return a result set"
+            )
 
         rows = []
         while True:
             row = self.fetchone()
-            if not row: break
+            if not row:
+                break
             rows.append(row)
         return rows
-    
-    def fetchmany(self, size = None):
+
+    def fetchmany(self, size=None):
         if self._result_set == None:
-            raise InterfaceError("Either execute has not yet been called, or the previous call of execute did not return a result set")
+            raise InterfaceError(
+                "Either execute has not yet been called, or the previous call of execute did not return a result set"
+            )
 
         if size is None:
             size = self.arraysize
@@ -2253,21 +2511,27 @@ class EmbdeddedCursor(_BaseCursor):
 def Date(year, month, day):
     raise NotImplementedErrorDBAPI()
 
+
 def Time(hour, minutes, second):
     raise NotImplementedErrorDBAPI()
 
+
 def Timestamp(year, month, day, hour, minute, second):
     raise NotImplementedErrorDBAPI()
 
+
 def DateFromTicks(ticks):
     raise NotImplementedErrorDBAPI()
 
+
 def TimeFromTicks(ticks):
     raise NotImplementedErrorDBAPI()
 
+
 def TimestampFromTicks(ticks):
     raise NotImplementedErrorDBAPI()
 
+
 # def Binary(string):
 #     return string
 
@@ -2281,33 +2545,43 @@ ROWID = str
 
 # still needs type singletons (?)
 
+
 # Exception architecture
 class Error(Exception):
     pass
 
+
 class Warning(Exception):
-     pass
+    pass
+
 
 class InterfaceError(Error):
     pass
 
+
 class DatabaseError(Error):
     pass
 
+
 class InternalError(DatabaseError):
     pass
 
+
 class OperationalError(DatabaseError):
     pass
 
+
 class ProgrammingError(DatabaseError):
     pass
 
+
 class IntegrityError(DatabaseError):
     pass
 
+
 class DataError(DatabaseError):
     pass
 
+
 class NotSupportedError(DatabaseError):
     pass