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

intersystems_iris/dbapi/_Descriptor.py

@@ -0,0 +1,46 @@
+class _Descriptor:
+    def __init__(self, type = 0, precision = 0, scale = None, nullable = 0):
+        try:
+            type = int(type)
+        except (TypeError, ValueError):
+            raise TypeError("type must be an integer")
+        try:
+            precision = int(precision)
+        except (TypeError, ValueError):
+            raise TypeError("precision must be an integer")
+        try:
+            nullable = int(nullable)
+        except (TypeError, ValueError):
+            raise TypeError("nullable must be an integer")
+
+        self.type = type
+        self.precision = precision
+        self.scale = scale
+        self.nullable = nullable
+        self.name = None
+        self.slotPosition = None
+    
+    @property
+    def scale(self):
+        return self.__scale
+
+    @scale.setter
+    def scale(self, value):
+        if value is not None:
+            try:
+                value = int(value)
+            except (TypeError, ValueError):
+                raise TypeError("scale must be an integer")
+        
+        self.__scale = value
+
+    def cloneMe(self, d):
+        if not isinstance(d, _Descriptor):
+            raise TypeError("Must clone another _Descriptor")
+        
+        self.type = d.type
+        self.precision = d.precision
+        self.scale = d.scale
+        self.nullable = d.nullable
+        self.name = d.name
+        self.slotPosition = d.slotPosition

intersystems_iris/dbapi/_IRISStream.py

@@ -0,0 +1,65 @@
+from . import _Message
+from .._MessageHeader import _MessageHeader
+from .._InStream import _InStream
+from .._OutStream import _OutStream
+
+
+class IRISStream:
+    _handle = None
+    _binary = False
+    _connection = None
+    _embedded = False
+
+    def __init__(self, connection, handle, embedded=False):
+        self._connection = connection
+        self._handle = handle
+        self._embedded = embedded
+        self._locale = connection._connection_info._locale
+        if not self._embedded:
+            self._in_message = _InStream(connection)
+            self._out_message = _OutStream(connection)
+    
+    def fetch_embdedded(self):
+        result = b'' if self._binary else ''
+
+        stream = self._connection.iris.cls('%Stream.Object')._Open(self._handle)
+        while not stream.AtEnd:
+            chunk = stream.Read()
+            result += bytes(chunk, self._locale) if self._binary else chunk
+        
+        return result
+
+    def fetch(self):
+        if self._embedded:
+            return self.fetch_embdedded()
+        result = None
+        if not self._handle:
+            return result
+
+        with self._connection._lock:
+            # message header
+            self._statement_id = self._connection._get_new_statement_id()
+            self._out_message.wire._write_header(_Message.READ_STREAM)
+            _MessageHeader._set_statement_id(self._out_message.wire.buffer, self._statement_id)
+
+            # message body
+            self._out_message.wire._set(self._handle) # stream handle
+            self._out_message.wire._set(-1) # length
+
+            # send message
+            sequence_number = self._connection._get_new_sequence_number()
+            self._out_message._send(sequence_number)
+
+            code = self._in_message._read_message_sql(sequence_number, self._statement_id, _InStream.BYTE_STREAM, 403)
+            if code == 403:
+                return None
+
+            result = self._in_message.wire._get_raw()
+            if not self._binary:
+                result = str(result, self._locale)
+
+        return result
+
+
+class IRISBinaryStream(IRISStream):
+    _binary = True

intersystems_iris/dbapi/_Message.py

@@ -0,0 +1,158 @@
+def expect_response(message_type):
+    if message_type in NO_RESPONSE:
+        return False
+    return True
+
+HANDSHAKE = b'HS'
+CONNECT = b'CN'
+DISCONNECT = b'DC'
+PREPARE = b'PP'
+DIRECT_UPDATE = b'DU'
+DIRECT_QUERY = b'DQ'
+DIRECT_STORED_PROCEDURE = b'DS'
+PREPARE_DIALECT = b'PD'
+DIRECT_EXECUTE_DIALECT = b'DD'
+PREPARED_UPDATE_EXECUTE = b'PU'
+PREPARED_QUERY_EXECUTE = b'PQ'
+FETCH_DATA = b'FD'
+CLOSE_CURSOR = b'CC'
+PREPARE_STORED_PROCEDURE = b'SP'
+STORED_PROCEDURE_UPDATE_EXECUTE = b'SU'
+STORED_PROCEDURE_QUERY_EXECUTE = b'SQ'
+STORED_PROCEDURE_FETCH_DATA = b'SF'
+EXECUTE_MULTIPLE_RESULT_SETS = b'MS'
+MULTIPLE_RESULT_SETS_FETCH_DATA = b'MD'
+GET_MORE_RESULTS = b'MR'
+GET_STREAM_SIZE = b'SS'
+RETRIEVE_STREAM = b'RS'
+OPEN_STREAM = b'OS'
+READ_STREAM = b'JS'
+READ_STREAM_ODBC = b'AS'
+STORE_BINARY_STREAM = b'SB'
+STORE_CHARACTER_STREAM = b'SM'
+STREAM_GET_BYTES  = b'GB'
+STREAM_SET_BYTES  = b'SZ'
+STREAM_TRUNCATE  = b'SX'
+STREAM_GET_POSITION   = b'GP'
+CLOSE_STREAM   = b'CS'
+GET_RESULT_SET_OBJECT = b'FR'
+GET_STRUCT_OBJECT = b'FS'
+COMMIT = b'TC'
+ROLLBACK = b'TR'
+READ_COMMITTED = b'RC'
+READ_UNCOMMITTED = b'RU'
+ISOLATION_LEVEL = b'IL'
+AUTOCOMMIT_OFF = b'AF'
+AUTOCOMMIT_ON = b'AN'
+TOGGLE_SYNCHRONOUS_COMMIT = b'TS'
+GET_AUTO_GENERATED_KEYS = b'GG'
+IN_TRANSACTION = b'IT'
+JDBC_BESTROWID = b'BR'
+JDBC_CATALOGS = b'CA'
+JDBC_COLUMNPRIV = b'CP'
+JDBC_COLUMNS = b'CO'
+JDBC_CROSSREFERENCE = b'CR'
+JDBC_EXPORTEDKEYS = b'EK'
+JDBC_IMPORTEDKEYS = b'IK'
+JDBC_INDEXINFO = b'II'
+JDBC_PRIMARYKEYS = b'PK'
+JDBC_PROCEDURECOL = b'PC'
+JDBC_PROCEDURES = b'PR'
+JDBC_SCHEMAS = b'SC'
+JDBC_TABLEPRIV = b'TP'
+JDBC_TABLES = b'TA'
+JDBC_TABLETYPES = b'TT'
+JDBC_TYPEINFO = b'TI'
+JDBC_VERSIONCOL = b'VC'
+ODBC_BESTROWID = b'br'
+ODBC_CATALOGS = b'ca'
+ODBC_COLUMNPRIV = b'cp'
+ODBC_COLUMNS_35 = b'c3'
+ODBC_CROSSREFERENCE_35 = b'r3'
+ODBC_EXPORTEDKEYS_35 = b'e3'
+ODBC_IMPORTEDKEYS_35 = b'i3'
+ODBC_PROCEDURECOL_35 = b'p3'
+ODBC_TYPEINFO_35 = b't3'
+ODBC_COLUMNS = b'co'
+ODBC_CROSSREFERENCE = b'cr'
+ODBC_EXPORTEDKEYS = b'ek'
+ODBC_IMPORTEDKEYS = b'ik'
+ODBC_INDEXINFO = b'ii'
+ODBC_PRIMARYKEYS = b'pk'
+ODBC_PROCEDURECOL = b'pc'
+ODBC_PROCEDURES = b'pr'
+ODBC_SCHEMAS = b'sc'
+ODBC_STATISTICS = b'st'
+ODBC_TABLEPRIV = b'tp'
+ODBC_TABLES = b'ta'
+ODBC_TABLETYPES = b'tt'
+ODBC_TYPEINFO = b'ti'
+ODBC_VERSIONCOL = b'vc'
+JDBC_UDTS = b'UT'
+JDBC_SUPER_TYPES = b'SY'
+JDBC_SUPER_TABLES = b'SL'
+JDBC_GET_ATTRIBUTES = b'AT'
+JDBC_GET_FUNCTION_COLUMNS  = b'FC'
+JDBC_GET_FUNCTIONS  = b'FN'
+JDBC_CLIENT_INFO_PROPERTIES  = b'CF'
+SET_CLIENT_INFO_PROPERTIES   = b'CG'
+XA_START = b'XS'
+XA_END = b'XE'
+XA_FORGET = b'XF'
+XA_PREPARE = b'XP'
+XA_COMMIT = b'XC'
+XA_ROLLBACK = b'XR'
+XA_RECOVER = b'XV'
+EXECUTE_STATIC_CURSOR = b'EX'
+DIRECT_STATIC_CURSOR = b'DX'
+FETCH_STATIC_CURSOR = b'FX'
+UPDATE_CACHE = b'UC'
+RESET_CONNECTION = b'RN'
+GET_SERVER_ERROR = b'OE'
+EXECUTE_STATEMENT_BATCH = b'EB'
+CLOSE_STATEMENT = b'CU'
+QUICK_LOAD = b'QL'
+QUICK_CHILD_TABLE_LOAD = b'QZ'
+QUICK_CHILD_TABLE_CREATE = b'QX'
+QUICK_CHILD_TABLE_REMOVE = b'QK'
+QUICK_STORE = b'QS'
+QUICK_CREATE = b'QC'
+QUICK_REMOVE = b'QR'
+QUICK_FIND_ROWID_BY_PK = b'Q1'
+QUICK_FIND_ROWID_BY_CONSTRAINT = b'Q2'
+QUICK_FIND_PK_BY_CONSTRAINT = b'Q3'
+QUICK_REMOVE_BY_PK = b'Q4'
+QUICK_CREATE_BY_PK = b'Q5'
+QUICK_STORE_BY_PK = b'Q6'
+QUICK_LOAD_BY_PK = b'Q7'
+QUICK_CHILD_TABLE_REMOVE_BY_PK = b'Q8'
+QUICK_CHILD_TABLE_CREATE_BY_PK = b'Q9'
+QUICK_CHILD_TABLE_LOAD_BY_PK = b'QA'
+QUICK_GET_CHILDREN_PKS = b'QB'
+QUICK_GET_CHILDREN_PKS_BY_PK = b'QD'
+QUICK_FIND_PK_BY_ROWID = b'QE'
+QUICK_BULK_LOAD = b'QM'
+QUICK_BULK_CREATE = b'QN'
+QUICK_BULK_STORE = b'QO'
+QUICK_BULK_SAVE_BY_PK  = b'QW'
+QUICK_QUERY  = b'QQ'
+QUICK_JPA_FLUSH  = b'QF'
+GET_CACHE_INFO = b'CI'
+PING = b'PG'
+PING_TWO = b'P2'
+IS_TWO_FACTOR_ENABLED = b'2E'
+SEND_TWO_FACTOR_TOKEN = b'2F'
+STREAM_SET_PREFETCH_SIZE = b'SN'
+EXTERNAL_INTERUPT = b'EI'
+GET_NAMESPACES_MSG = b'CI'
+GATEWAY_INIT = b'GI'
+
+NO_RESPONSE = [AUTOCOMMIT_OFF,
+               AUTOCOMMIT_ON,
+               READ_COMMITTED,
+               READ_UNCOMMITTED,
+               CLOSE_CURSOR,
+               CLOSE_STREAM,
+               CLOSE_STATEMENT,
+               RESET_CONNECTION,
+               DISCONNECT]

intersystems_iris/dbapi/_Parameter.py

@@ -0,0 +1,169 @@
+import datetime
+import decimal
+import enum
+import intersystems_iris.dbapi._Descriptor
+
+
+class ParameterMode(enum.IntEnum):
+    UNKNOWN = 0
+    INPUT = 1
+    INPUT_OUTPUT = 2
+    UNUSED = 3
+    OUTPUT = 4
+    REPLACED_LITERAL = 5
+    DEFAULT_PARAMETER = 6
+    RETURN_VALUE = 7
+
+
+class _Parameter(intersystems_iris.dbapi._Descriptor._Descriptor):
+    def __init__(
+        self,
+        value=None,
+        mode=ParameterMode.UNKNOWN,
+        paramType="?",
+        name="",
+        execParam=False,
+        bound=False,
+        type=0,
+        precision=0,
+        scale=None,
+        nullable=0,
+        slotPosition=None,
+    ):
+        if not isinstance(mode, ParameterMode):
+            raise TypeError("mode must be a ParameterMode")
+        paramType = str(paramType)
+        if len(paramType) > 1:
+            raise ValueError("paramType must be a single character")
+        name = str(name)
+        execParam = bool(execParam)
+        bound = bool(bound)
+        if slotPosition is not None:
+            try:
+                slotPosition = int(slotPosition)
+            except (TypeError, ValueError):
+                raise TypeError("slotPosition must be an integer")
+            if slotPosition < 0:
+                raise ValueError("slotPosition must be positive")
+
+        super().__init__(type, precision, scale, nullable)
+
+        self.__value = value
+        self.mode = mode
+        self.__paramType = paramType
+        self.name = name
+        self.execParam = execParam
+        self.__bound = bound
+        self.slotPosition = slotPosition
+
+        self._values = list()
+
+        self.parsermatched = False
+        self.matchedParameterList = None
+
+    def __repr__(self) -> str:
+        if self.mode not in [ParameterMode.UNKNOWN, ParameterMode.INPUT]:
+            return f"<{self.mode.name}>{repr(self.value)}"
+        else:
+            return f"<{self.mode.name}>"
+
+    def Clone(self, value=None):
+        clone = _Parameter(
+            value or self.value,
+            self.mode,
+            self.paramType,
+            self.name,
+            self.execParam,
+            self.bound,
+            self.type,
+            self.precision,
+            self.scale,
+            self.nullable,
+            self.slotPosition,
+        )
+        clone.cloneMe(self)
+
+        clone.parsermatched = self.parsermatched
+        clone.matchedParameterList = self.matchedParameterList
+
+        return clone
+
+    @property
+    def bound(self):
+        return self.__bound
+
+    @property
+    def paramType(self):
+        return self.__paramType
+
+    @property
+    def value(self):
+        _set_switcher = {
+            type(None): lambda v: None,
+            # str: lambda v : v or b'\x00',
+            datetime.time: lambda v: v.strftime("%H:%M:%S.%f"),
+            datetime.date: lambda v: v.strftime("%Y-%m-%d"),
+            datetime.datetime: lambda v: v.strftime("%Y-%m-%d %H:%M:%S.%f"),
+            bytes: lambda v: v,
+            bytearray: lambda v: v,
+            bool: lambda v: 1 if v else 0,
+            int: lambda v: v,
+            float: lambda v: v,
+            decimal.Decimal: lambda v: v,
+        }
+        func = None
+        if issubclass(type(self.__value), enum.Enum):
+            value = self.__value.value
+        elif type(self.__value) in _set_switcher:
+            func = _set_switcher[type(self.__value)]
+            value = func(self.__value)
+        else:
+            value = str(self.__value)
+        if self.mode == ParameterMode.REPLACED_LITERAL:
+            if isinstance(value, str) and value.isdigit() and str(int(value)) == value:
+                value = int(value)
+        return value
+
+    def _copy_cached_info(self, desc, copy_replaced):
+        self.type = desc.type
+        self.precision = desc.precision
+        self.scale = desc.scale
+        self.nullable = desc.nullable
+        self.name = desc.name
+        if (
+            (self.mode != ParameterMode.REPLACED_LITERAL)
+            and (desc.mode != ParameterMode.REPLACED_LITERAL)
+            and (desc.mode != ParameterMode.UNKNOWN)
+        ):
+            self.mode = desc.mode
+
+        if not copy_replaced:
+            return
+
+        if desc.mode == ParameterMode.REPLACED_LITERAL:
+            self.mode = ParameterMode.REPLACED_LITERAL
+            self.__value = desc.value
+            self._values = list()
+            if len(desc._values) > 0:
+                self._values.append(desc._values[0])
+        return
+
+    def _bind(self, value, parameter_sets):
+        if isinstance(value, list):
+            self._values = value
+        else:
+            if parameter_sets == 0:
+                self._values = []
+            size = len(self._values)
+            if parameter_sets + 1 < size or size < parameter_sets:
+                raise Exception("Not all parameters bound for this set")
+            elif parameter_sets == size:
+                self._values.append(value)
+            else:
+                # Rebinding
+                self._values[size - 1] = value
+        self.__bound = True
+        if self.mode == ParameterMode.OUTPUT or self.mode == ParameterMode.INPUT_OUTPUT:
+            self.mode = ParameterMode.INPUT_OUTPUT
+        else:
+            self.mode = ParameterMode.INPUT

intersystems_iris/dbapi/_ParameterCollection.py

@@ -0,0 +1,141 @@
+import intersystems_iris.dbapi._ResultSetRow
+from intersystems_iris.dbapi._Parameter import _Parameter
+from intersystems_iris.dbapi._Parameter import ParameterMode
+
+class _ParameterCollection:
+    def __init__(self, param_coll = None, shallow_copy = False):
+        self._params_list = list() # contains elements of type _Parameter
+        self._has_bound_by_param_name = False
+
+        self._user_index = list()
+        self._user_param_cnt = 0
+
+        self._param_names = None
+        self._array_bound = False
+
+        self._input_params = list()
+
+        if param_coll != None:
+            if shallow_copy:
+                self._params_list = param_coll._params_list
+            else:
+                self._params_list = list()
+                for param in param_coll._params_list:
+                    new_param = _Parameter()
+                    new_param._copy_cached_info(param, True)
+                    self._params_list.append(new_param)
+
+            self._user_param_cnt = param_coll._user_param_cnt
+            self._user_index = param_coll._user_index
+            
+            if param_coll._has_named_parameters():
+                self._update_names()
+            self._has_bound_by_param_name = False
+            self._array_bound = False
+
+    def set_input_params(self, params):
+        self._input_params = list(params)
+
+    def collect(self, i: int = 0) -> list:
+        params = list()
+                
+        param_index = 0
+        param_counter = i
+        for param in self._params_list:
+            mode = param.mode
+            if mode == ParameterMode.REPLACED_LITERAL:
+                params.append(_Parameter(param.value).value)
+            elif not mode == ParameterMode.INPUT:
+                params.append(_Parameter(param._values[i]).value)
+            elif self._input_params:
+                item = self._input_params[param_counter]
+                if isinstance(item, tuple) or isinstance(item, list):
+                    value = item[param_index]
+                    param_index = param_index + 1
+                else:
+                    value = item
+                    param_counter = param_counter + 1
+                params.append(_Parameter(value).value)
+            else:
+                raise Exception("Missing value")
+
+        return params
+
+    def update(self, set_index, param_index, value):
+        if isinstance(self._input_params[set_index], tuple):
+            self._input_params[set_index] = list(self._input_params[set_index])
+        if isinstance(self._input_params[set_index], list):
+            self._input_params[set_index][param_index] = value
+        else:
+            self._input_params[param_index] = value
+
+    def __repr__(self) -> str:
+        return repr(self.collect())
+
+    def _add_user_param(self, param):
+        self._user_param_cnt = self._user_param_cnt + 1
+        #self._params_list.append(param)
+        return
+
+    def _user_parameters_size(self):
+        if self._user_index == None:
+            return len(self._params_list)
+        return self._user_param_cnt
+
+    def _has_named_parameters(self):
+        return self._param_names != None and len(self._params_list) != 0
+    
+    def _update_names(self):
+        self._param_names = {}
+        for i in range(len(self._params_list)):
+            key = self._params_list[i].name.upper()
+            self._param_names[key] = i
+        return
+
+    def _get_user_param_index(self, user_parameter_number):
+        actual_index = self._user_index[user_parameter_number]
+        if actual_index == -1:
+            raise IndexError("Invalid parameter number: " + str(user_parameter_number))
+        return actual_index
+
+    def _get_user_param(self, user_parameter_number):
+        if user_parameter_number >= len(self._user_index):
+            raise IndexError("Invalid parameter number: " + str(user_parameter_number))
+        actual_index = self._get_user_param_index(user_parameter_number)
+        return self._params_list[actual_index]
+
+    def _update_param_info(self, from_param_coll):
+        try:
+            for i, param in enumerate(from_param_coll._params_list):
+                self._params_list[i]._copy_cached_info(param, False)
+
+            if self._user_param_cnt != len(from_param_coll._params_list):
+                self._user_param_cnt = from_param_coll._user_param_cnt
+                self._user_index = from_param_coll._user_index
+
+            if from_param_coll._has_named_parameters():
+                self._update_names()
+
+        except Exception:
+            # need to handle exceptions properly
+            if len(from_param_coll._params_list) != len(self._params_list):
+                raise LookupError("Parameter mismatch")
+            raise Exception
+
+    def _clear(self):
+        self._params_list.clear()
+        if self._param_names != None:
+            self._param_names.clear()
+        self._has_bound_by_param_name = False
+        self._array_bound = False
+
+    def _prep_list_index(self, is_fast_select, output_parameter_list):
+        self._param_row = intersystems_iris.dbapi._ResultSetRow._ResultSetRow(rowcount = len(self._params_list))
+        self._param_row._fast_select = is_fast_select
+        self._param_row.indexRow(output_parameter_list.list_item)
+        return
+
+    def _get_user_list_offset(self, user_parameter_number):
+        if user_parameter_number >= len(self._user_index):
+            raise IndexError("Invalid parameter number: " + str(user_parameter_number))
+        return self._param_row.rowItems[self._get_user_param_index(user_parameter_number)]