iris-pex-embedded-python 3.4.0b14__py3-none-any.whl → 3.4.1b2__py3-none-any.whl

intersystems_iris/dbapi/_Descriptor.py

@@ -1,46 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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

@@ -1,158 +0,0 @@
-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

@@ -1,171 +0,0 @@
-import datetime
-import decimal
-import enum
-import intersystems_iris.dbapi._Descriptor
-from intersystems_iris._IRISOREF import _IRISOREF
-
-
-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,
-            _IRISOREF: lambda v: str(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

@@ -1,141 +0,0 @@
-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)]