sqlalchemy-iris 0.10.6b1__tar.gz → 0.11.0__tar.gz

{sqlalchemy-iris-0.10.6b1 → sqlalchemy-iris-0.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sqlalchemy-iris
-Version: 0.10.6b1
+Version: 0.11.0
 Summary: InterSystems IRIS for SQLAlchemy
 Home-page: https://github.com/caretdev/sqlalchemy-iris
 Maintainer: CaretDev
@@ -22,6 +22,7 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: SQLAlchemy>=1.3
 
 sqlalchemy-iris
 ===

sqlalchemy-iris-0.11.0/intersystems_iris/_IRISOREF.py

@@ -0,0 +1,9 @@
+class _IRISOREF(object):
+    def __init__(self, oref):
+        self._oref = oref
+
+    def __str__(self) -> str:
+        return self._oref
+
+    def __repr__(self) -> str:
+        return f"<IRISOREF ${self._oref}>"

{sqlalchemy-iris-0.10.6b1 → sqlalchemy-iris-0.11.0}/intersystems_iris/dbapi/_DBAPI.py

@@ -1,3 +1,5 @@
+import struct
+import copy
 import enum
 import copy
 import decimal
@@ -17,6 +19,7 @@ from intersystems_iris.dbapi._IRISStream import (
     IRISStream,
     IRISBinaryStream,
 )
+from intersystems_iris._IRISOREF import _IRISOREF
 from ._SQLType import SQLType
 
 from .._IRISNative import connect as native_connect
@@ -308,7 +311,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
@@ -334,7 +337,7 @@ class _BaseCursor:
                 raise ValueError("INOUT/OUT parameters not permitted")
 
         self._prepared_update_execute()
-
+        
         return self._rowcount
 
     def _process_sqlcode(self, sqlcode, message=None):
@@ -646,13 +649,20 @@ class _BaseCursor:
 
     def _update404(self):
         with self._connection._lock:
+            # self._reset_cached_info()
             self._validate_parameters()
+            # self._prepare()
+            # self._validate_prepared_parameters()
+            # self._prepared_update_execute()
             self._send_direct_update_request()
 
     # 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(
@@ -747,6 +757,12 @@ class Cursor(_BaseCursor):
             return True
         else:
             return False
+        
+    def _reset_cached_info(self):
+        if not self._connection._preparedCache or not hasattr(self._connection._preparedCache, "__iter__"):
+            return
+        if self._parsed_statement in self._connection._preparedCache:
+            del self._connection._preparedCache[self._parsed_statement]
 
     def _prepare_cached(self, cached_statement):
         self._statement_id = cached_statement.statement_id
@@ -1158,7 +1174,68 @@ class Cursor(_BaseCursor):
         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 isinstance(value, _IRISOREF):
+            return 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)
+        if full_size < 3 * 1024 * 1024:
+            return 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 _IRISOREF(stream_oref)
+
     def _prepared_update_execute(self):
+        self._update_streams()
+
         # send PU message
         with self._connection._lock:
             # message header
@@ -1776,23 +1853,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):
@@ -2304,8 +2384,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:

{sqlalchemy-iris-0.10.6b1 → sqlalchemy-iris-0.11.0}/intersystems_iris/dbapi/_IRISStream.py

@@ -3,6 +3,7 @@ from .._MessageHeader import _MessageHeader
 from .._InStream import _InStream
 from .._OutStream import _OutStream
 
+
 class IRISStream:
     _handle = None
     _binary = False
@@ -59,5 +60,6 @@ class IRISStream:
 
         return result
 
+
 class IRISBinaryStream(IRISStream):
     _binary = True

{sqlalchemy-iris-0.10.6b1 → sqlalchemy-iris-0.11.0}/intersystems_iris/dbapi/_Parameter.py

@@ -2,6 +2,8 @@ import datetime
 import decimal
 import enum
 import intersystems_iris.dbapi._Descriptor
+from intersystems_iris._IRISOREF import _IRISOREF
+
 
 class ParameterMode(enum.IntEnum):
     UNKNOWN = 0
@@ -13,8 +15,22 @@ class ParameterMode(enum.IntEnum):
     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):
+    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)
@@ -48,23 +64,35 @@ class _Parameter(intersystems_iris.dbapi._Descriptor._Descriptor):
 
     def __repr__(self) -> str:
         if self.mode not in [ParameterMode.UNKNOWN, ParameterMode.INPUT]:
-            return f'<{self.mode.name}>{repr(self.value)}'
+            return f"<{self.mode.name}>{repr(self.value)}"
         else:
-            return f'<{self.mode.name}>'
+            return f"<{self.mode.name}>"
 
-    def Clone(self):
-        clone = _Parameter(self.value, self.mode, self.paramType, self.name, self.execParam, self.bound)
+    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
@@ -72,17 +100,18 @@ class _Parameter(intersystems_iris.dbapi._Descriptor._Descriptor):
     @property
     def value(self):
         _set_switcher = {
-            type(None): lambda v : None,
+            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,
+            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):
@@ -103,9 +132,11 @@ class _Parameter(intersystems_iris.dbapi._Descriptor._Descriptor):
         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)):
+        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:
@@ -115,7 +146,8 @@ class _Parameter(intersystems_iris.dbapi._Descriptor._Descriptor):
             self.mode = ParameterMode.REPLACED_LITERAL
             self.__value = desc.value
             self._values = list()
-            if len(desc._values) > 0: self._values.append(desc._values[0])
+            if len(desc._values) > 0:
+                self._values.append(desc._values[0])
         return
 
     def _bind(self, value, parameter_sets):
@@ -136,4 +168,4 @@ class _Parameter(intersystems_iris.dbapi._Descriptor._Descriptor):
         if self.mode == ParameterMode.OUTPUT or self.mode == ParameterMode.INPUT_OUTPUT:
             self.mode = ParameterMode.INPUT_OUTPUT
         else:
-            self.mode = ParameterMode.INPUT
+            self.mode = ParameterMode.INPUT

{sqlalchemy-iris-0.10.6b1 → sqlalchemy-iris-0.11.0}/intersystems_iris/dbapi/_ParameterCollection.py

@@ -34,7 +34,7 @@ class _ParameterCollection:
             self._array_bound = False
 
     def set_input_params(self, params):
-        self._input_params = params
+        self._input_params = list(params)
 
     def collect(self, i: int = 0) -> list:
         params = list()
@@ -61,6 +61,14 @@ class _ParameterCollection:
 
         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())
 

{sqlalchemy-iris-0.10.6b1 → sqlalchemy-iris-0.11.0}/iris/__init__.py

@@ -1,5 +1,6 @@
 from sys import path as __syspath
 import os
+from .iris_ipm import ipm
 
 # check for install dir in environment
 # environment to check is IRISINSTALLDIR
@@ -15,8 +16,14 @@ __syspath.append(os.path.join(installdir, 'bin'))
 # also append lib/python
 __syspath.append(os.path.join(installdir, 'lib', 'python'))
 
+# save working directory
+__ospath = os.getcwd()
+
 from pythonint import *
 
+# restore working directory
+os.chdir(__ospath)
+
 # TODO: Figure out how to hide __syspath and __ospath from anyone that
 #       imports iris.  Tried __all__ but that only applies to this:
 #           from iris import *

sqlalchemy-iris-0.11.0/iris/iris_ipm.py

@@ -0,0 +1,40 @@
+def ipm(cmd, *args):
+    """
+    Executes shell command with IPM:
+    Parameters
+    ----------
+    cmd : str
+        The command to execute
+    Examples
+    --------
+    `ipm('help')`
+    `ipm('load /home/irisowner/dev -v')`
+    `ipm('install webterminal')`
+    """
+
+    import multiprocessing
+    import iris
+
+    def shell(cmd, status):
+        
+
+        status.put(True)
+
+        res = iris.cls("%ZPM.PackageManager").Shell(cmd)
+        print('')
+        if res != 1:
+            status.get()
+            status.put(False)
+
+    manager = multiprocessing.Manager()
+    status = manager.Queue()
+    process = multiprocessing.Process(
+        target=shell,
+        args=(
+            cmd,
+            status,
+        ),
+    )
+    process.start()
+    process.join()
+    return status.get()

{sqlalchemy-iris-0.10.6b1 → sqlalchemy-iris-0.11.0}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = sqlalchemy-iris
-version = 0.10.6b1
+version = 0.11.0
 description = InterSystems IRIS for SQLAlchemy
 long_description = file: README.md
 url = https://github.com/caretdev/sqlalchemy-iris

{sqlalchemy-iris-0.10.6b1 → sqlalchemy-iris-0.11.0}/sqlalchemy_iris/base.py

@@ -745,6 +745,9 @@ class IRISTypeCompiler(compiler.GenericTypeCompiler):
     def visit_DOUBLE(self, type_, **kw):
         return "DOUBLE"
 
+    def visit_TINYINT(self, type_, **kw):
+        return "TINYINT"
+
 
 class IRISIdentifierPreparer(sql.compiler.IdentifierPreparer):
     """Install IRIS specific reserved words."""
@@ -1486,7 +1489,7 @@ There are no access to %Dictionary, may be required for some advanced features,
 
             if fkdelrule != "NO ACTION":
                 fkey["options"]["ondelete"] = fkdelrule
-            
+
             if scol not in fkey["constrained_columns"]:
                 fkey["constrained_columns"].append(scol)
             if rcol not in fkey["referred_columns"]:
@@ -1686,7 +1689,7 @@ There are no access to %Dictionary, may be required for some advanced features,
         if view_def:
             return view_def
         raise exc.NoSuchTableError(f"{schema}.{view_name}")
-    
+
     def normalize_name(self, name):
         if self.identifier_preparer._requires_quotes(name):
             return quoted_name(name, quote=True)

{sqlalchemy-iris-0.10.6b1 → sqlalchemy-iris-0.11.0}/sqlalchemy_iris.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sqlalchemy-iris
-Version: 0.10.6b1
+Version: 0.11.0
 Summary: InterSystems IRIS for SQLAlchemy
 Home-page: https://github.com/caretdev/sqlalchemy-iris
 Maintainer: CaretDev
@@ -22,6 +22,7 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: SQLAlchemy>=1.3
 
 sqlalchemy-iris
 ===

{sqlalchemy-iris-0.10.6b1 → sqlalchemy-iris-0.11.0}/sqlalchemy_iris.egg-info/SOURCES.txt

@@ -66,9 +66,7 @@ intersystems_iris/pex/_Message.py
 intersystems_iris/pex/_OutboundAdapter.py
 intersystems_iris/pex/__init__.py
 iris/__init__.py
-iris/iris_site.py
-iris/irisbuiltins.py
-iris/irisloader.py
+iris/iris_ipm.py
 irisnative/_IRISNative.py
 irisnative/__init__.py
 sqlalchemy_iris/__init__.py

{sqlalchemy-iris-0.10.6b1 → sqlalchemy-iris-0.11.0}/tests/test_suite.py

@@ -4,6 +4,9 @@ from sqlalchemy.testing.suite import FetchLimitOffsetTest as _FetchLimitOffsetTe
 from sqlalchemy.testing.suite import CompoundSelectTest as _CompoundSelectTest
 from sqlalchemy.testing.suite import CTETest as _CTETest
 from sqlalchemy.testing.suite import DifficultParametersTest as _DifficultParametersTest
+from sqlalchemy.testing.suite import (
+    BizarroCharacterFKResolutionTest as _BizarroCharacterFKResolutionTest,
+)
 from sqlalchemy.testing import fixtures
 from sqlalchemy.testing.assertions import eq_
 from sqlalchemy.testing import config
@@ -14,6 +17,8 @@ from sqlalchemy.types import Integer
 from sqlalchemy.types import String
 from sqlalchemy.types import VARBINARY
 from sqlalchemy.types import BINARY
+from sqlalchemy_iris import TINYINT
+from sqlalchemy.exc import DatabaseError
 import pytest
 
 from sqlalchemy.testing.suite import *  # noqa
@@ -71,6 +76,39 @@ class FetchLimitOffsetTest(_FetchLimitOffsetTest):
             )
 
 
+class TinyintTest(fixtures.TablesTest):
+    __backend__ = True
+
+    @classmethod
+    def define_tables(cls, metadata):
+        Table(
+            "test_tinyint",
+            metadata,
+            Column("val_tinyint", TINYINT),
+        )
+
+    @testing.fixture
+    def local_connection(self):
+        with testing.db.connect() as conn:
+            yield conn
+
+    def test_commits(self, local_connection):
+        test_tinyint = self.tables.test_tinyint
+        connection = local_connection
+
+        transaction = connection.begin()
+        connection.execute(test_tinyint.insert(), dict(val_tinyint=100))
+        with pytest.raises(DatabaseError):
+            connection.execute(test_tinyint.insert(), dict(val_tinyint=129))
+        with pytest.raises(DatabaseError):
+            connection.execute(test_tinyint.insert(), dict(val_tinyint=-129))
+        transaction.commit()
+
+        result = connection.exec_driver_sql("select * from test_tinyint")
+        assert len(result.fetchall()) == 1
+        connection.close()
+
+
 class TransactionTest(fixtures.TablesTest):
     __backend__ = True
 
@@ -227,3 +265,19 @@ class IRISEnumTest(fixtures.TablesTest):
             select(self.tables.data),
             [(SomeType.FIRST,), (SomeType.SECOND,), (None,)],
         )
+
+
+class BizarroCharacterFKResolutionTest(_BizarroCharacterFKResolutionTest):
+    @testing.combinations(
+        ("id",), ("(3)",), ("col%p",), ("[brack]",), argnames="columnname"
+    )
+    @testing.variation("use_composite", [True, False])
+    @testing.combinations(
+        ("plain",),
+        # ("(2)",), not in IRIS
+        ("per % cent",),
+        ("[brackets]",),
+        argnames="tablename",
+    )
+    def test_fk_ref(self, connection, metadata, use_composite, tablename, columnname):
+        super().test_fk_ref(connection, metadata, use_composite, tablename, columnname)

sqlalchemy-iris-0.10.6b1/intersystems_iris/_IRISOREF.py

@@ -1,4 +0,0 @@
-class _IRISOREF(object):
-
-    def __init__(self, oref):
-        self._oref = oref

sqlalchemy-iris-0.10.6b1/iris/iris_site.py

@@ -1,13 +0,0 @@
-import sys
-from os import sep as __os_sep
-from site import getsitepackages as __sitegetsitepackages
-
-#ubuntu needs dist-packages for pandas to be able to be imported
-#ubu 18 doesnt have os.sep in sys.executable
-def set_site_path(platform_name):
-   if "ubuntu" in platform_name:
-      if __os_sep in sys.executable:
-         __siteprefixes = [__os_sep + sys.executable.split(__os_sep)[1]]
-      else:
-         __siteprefixes = ['/usr']
-      sys.path = sys.path + __sitegetsitepackages(__siteprefixes)

sqlalchemy-iris-0.10.6b1/iris/irisbuiltins.py

@@ -1,97 +0,0 @@
-from collections import abc
-
-#
-# IRIS Exceptions
-#
-class SQLError(Exception):
-    """Error raised on an invalid IRIS SQL statement
-
-    Attributes:
-        sqlcode -- IRIS SQL error code
-        message -- Error description
-        statement -- Statement that failed
-    """
-
-    def __init__(self,sqlcode,message,statement=None):
-        self.sqlcode = sqlcode
-        self.message = message
-        self.statement = statement
-        super().__init__(self.message)
-
-#
-# Helper to raise a properly formatted AttributeError when we decide that
-# we don't want to handle a last-chance method.
-#
-def _no_such_method(target,method):
-    raise AttributeError(f"'{target.__class__.__name__}' has no attribute '{method}'")
-
-#
-# irisbuiltins:  Implements impedence matching methods for projecting IRIS behavior
-#                over Python objects.
-#
-class irisbuiltins:
-
-    #
-    # Common functions for mapping Python collection behavior to IRIS behavior
-    #
-    # NOTE: With Sequences, the indicies are 0 based for Python and 1 based
-    #       for IRIS.
-    #
-    
-    def Count(self):
-        if isinstance(self,abc.Mapping) or isinstance(self,abc.Sequence):
-           return len(self)
-        _no_such_method(self,"Count")
-
-    def GetAt(self,index):
-        if isinstance(self,abc.Mapping):
-            return self[index]
-        if isinstance(self,abc.Sequence):
-            return self[index-1]
-        _no_such_method(self,"GetAt")
-
-    def SetAt(self,value,index):
-        if isinstance(self,abc.Mapping):
-            self[index] = value
-            return
-        if isinstance(self,abc.Sequence):
-            self[index-1] = value
-            return
-        _no_such_method(self,"SetAt")
-
-    def Insert(self,value):
-        if isinstance(self,abc.Sequence):
-            self.append(value)
-            return
-        _no_such_method(self,"Insert")
-
-    def InsertAt(self,value,index):
-        if isinstance(self,abc.Sequence):
-            self.insert(index-1,value)
-            return
-        _no_such_method(self,"InsertAt")
-
-    def Clear(self):
-        if isinstance(self,abc.Mapping) or isinstance(self,abc.Sequence):
-           self.clear()
-           return
-        _no_such_method(self,"Clear")
-
-    def IsDefined(self,key):
-        if isinstance(self,abc.Mapping):
-            return (key in self)
-        _no_such_method(self,"IsDefined")
-
-    def Find(self,value):
-        if isinstance(self,abc.Sequence):
-            return self.index(value)+1
-        if isinstance(self,abc.Mapping):
-            for (k,v) in self.items():
-                if v == value:
-                    return k
-            return None;
-        _no_such_method(self,"Find")
-
-#
-# End-of-file
-#

sqlalchemy-iris-0.10.6b1/iris/irisloader.py

@@ -1,199 +0,0 @@
-from importlib.abc import MetaPathFinder
-from importlib.abc import Loader
-import importlib
-from types import ModuleType
-import math
-import marshal
-import sys
-import iris
-
-sources=iris.gref("^ROUTINE")
-binaries=iris.gref("^rPYC")
-MAX_STRING_SIZE=3800000
-
-def getFromDirectory(directory, path):
-	level=len(path)
-	if level == 1:
-		return directory[path[0]]
-	elif level == 2:
-		return directory[path[0],path[1]]
-	elif level == 3:
-		return directory[path[0],path[1],path[2]]
-	elif level == 4:
-		return directory[path[0],path[1],path[2],path[3]]
-	elif level == 5:
-		return directory[path[0],path[1],path[2],path[3],path[4]]	
-	elif level == 6:
-		return directory[path[0],path[1],path[2],path[3],path[4],path[5]]	
-	elif level == 7:
-		return directory[path[0],path[1],path[2],path[3],path[4],path[5],path[6]]	
-	elif level == 8:
-		return directory[path[0],path[1],path[2],path[3],path[4],path[5],path[6],path[7]]	
-	elif level == 9:
-		return directory[path[0],path[1],path[2],path[3],path[4],path[5],path[6],path[7],path[8]]	
-
-#name is name of rtn with .py
-def getSourceCode(name):
-	currentP = [name] + [0,0]
-	length = getFromDirectory(sources, currentP)
-	currentP.pop()
-	if not length or length == 0:
-		return None
-	code = ""
-	for i in range(1,int(length)+1):
-		currentP.append(i)
-		code += getFromDirectory(sources, currentP)
-		code += "\r\n"
-		currentP.pop()
-	return code
-
-def getCodeFromBinary(name):
-	length = binaries.get([name],0)
-	if (length < 1):
-		return None
-	codeBytes = binaries.getAsBytes([name,1])
-	for i in range(1,int(length)):
-		codeBytes += binaries.getAsBytes([name,i+1])
-	return marshal.loads(codeBytes)
-
-# def checkCode(directory, path):
-# 	currentP = [p for p in path] + [0,0]
-# 	length = getFromDirectory(directory, currentP)
-# 	currentP.pop()
-# 	if not length or length == 0:
-# 		return None
-# 	return length
-
-def checkCode(name):
-	#code exist for module
-
-	if binaries.get([name],0) > 0:
-		return True
-	sub = binaries.order([name+"."])
-	#there exists some subpackage
-	if (sub and sub[:len(name)] == name):
-		return True
-	return False
-
-def compileCode(name):
-	path = name.split(".")
-	classname = path[-1]
-	code = getSourceCode(name+".py")
-	if code:
-		codeobj = compile(code,classname,"exec")
-		compiledpython = marshal.dumps(codeobj)
-
-		#store in database
-		length=len(compiledpython)
-		chunks = math.ceil(length / MAX_STRING_SIZE)
-		binaries[name] = chunks
-		for i in range(chunks):
-			binaries[name,i+1] = compiledpython[i*MAX_STRING_SIZE:min(MAX_STRING_SIZE*(i+1),length)]
-
-		#delete old version of this module 
-		# if name in sys.modules:
-		# 	del sys.modules[name]
-		return 1
-	return 0
-
-#
-# Impedence matcher prototype
-#
-
-def mapping_GetAt(self,key):
-	return self[key]
-
-def mapping_SetAt(self,value,key):
-	self[key] = value
-
-def sequence_GetAt(self,index):
-	return self[index-1]
-
-def sequence_SetAt(self,value,index):
-	self[index-1] = value
-
-def materialize(obj):
-	if isinstance(obj,collections.abc.Mapping):
-		obj.Count = obj.__len__
-		obj.GetAt = mapping_GetAt
-		obj.SetAt = mapping_SetAt
-		return True
-	if isinstance(obj,collections.abc.Sequence):
-		obj.Count = obj.__len__
-		obj.GetAt = sequence_GetAt
-		obj.SetAt = sequence_SetAt
-		return True
-	return False
-
-class MyLoader(Loader):
-	def create_module(self,spec):
-		
-		module = ModuleType(spec.name)
-		module.__spec__=spec
-		module.__loader__ = self
-		module.__path__ = spec.__path__
-		return module
-
-	def exec_module(self, module):
-		#path = [p+".py" for p in module.__path__]
-		name = ""
-		code = None
-		for n in module.__path__:
-			name += n
-			name += "."
-		if name:
-			code = getCodeFromBinary(name[:len(name)-1])
-
-		#this is a class or has code by itself
-		if code:
-			#print(marshal.loads(bytes(code,"utf-8")))
-			#print(type(code))
-			exec(code,module.__dict__)
-		#this is a module
-		# ismodule = getFromDirectory(path+["catalog"])
-		# if ismodule:
-		# 	for s in ismodule.split(","):
-		# 		code = getFromDirectory(path+[s])
-		# 		if code:
-		# 			exec(code,module.__dict__)
-
-
-class MyFinder(MetaPathFinder):
-	def __init__(self):
-		return
-
-	def find_spec(self,fullname,path,target=None):
-			
-			#print("importing1: "+fullname)
-			ans = fullname.split(".")
-			currentName=ans[-1]
-			for i in range(len(ans)):
-				ans[i] += ".py"
-			#validate existance from globals
-			#this might be wrong
-			if not checkCode(fullname):
-				return None
-			spec = importlib.machinery.ModuleSpec(fullname, MyLoader())
-			#update path
-			if path:
-				spec.__path__ = path + [currentName]
-			else:
-				spec.__path__ = [currentName]
-			# set parent
-			if len(ans) == 1:
-				if path:
-					spec.__parent__=path[-1]
-				else:
-					spec.__parent__= None
-			else:
-				spec.__parent__=ans[-1]
-
-			return spec
-
-
-sys.meta_path.append(MyFinder())
-#del sys
-#test:
-#s imp = ##class(%SYS.Python).Import("customImport")
-#s xx = ##class(%SYS.Python).Import("User")
-