sqlalchemy-iris 0.15.5b1__tar.gz → 0.16.0__tar.gz

{sqlalchemy_iris-0.15.5b1/sqlalchemy_iris.egg-info → sqlalchemy_iris-0.16.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: sqlalchemy-iris
-Version: 0.15.5b1
+Version: 0.16.0
 Summary: InterSystems IRIS for SQLAlchemy
 Home-page: https://github.com/caretdev/sqlalchemy-iris
 Maintainer: CaretDev
@@ -23,6 +23,7 @@ Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: SQLAlchemy>=1.3
+Dynamic: requires-dist
 
 sqlalchemy-iris
 ===

{sqlalchemy_iris-0.15.5b1 → sqlalchemy_iris-0.16.0}/intersystems_iris/dbapi/_Column.py

@@ -54,3 +54,6 @@ class _Column(intersystems_iris.dbapi._Descriptor._Descriptor):
                           self.isKeyColumn,
                           self.isRowId]
         return _Column(self.name, self.type, self.precision, self.scale, self.nullable, self.label, self.tableName, self.schema, self.catalog, additionalData, self.slotPosition)
+
+    def __repr__(self) -> str:
+        return f"<Column name='{self.name}' type='{self.type}'>"

{sqlalchemy_iris-0.15.5b1 → sqlalchemy_iris-0.16.0}/intersystems_iris/dbapi/_DBAPI.py

@@ -14,7 +14,7 @@ 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, MultiValuesInsert
+from intersystems_iris.dbapi.preparser._PreParser import StatementType, MultiValuesInsert, InsertWithReturning
 from intersystems_iris._IRISConnection import Feature
 from intersystems_iris._InStream import _InStream
 from intersystems_iris.dbapi._IRISStream import (
@@ -252,6 +252,11 @@ class _BaseCursor:
         self._cleanup()
         try:
             self._preparse()
+        except InsertWithReturning as ex:
+            ids = intersystems_iris._ListWriter._ListWriter()
+            self.execute(ex.insert_query, params)
+            ids._set(self.lastrowid)
+            return self.execute(ex.select_query, bytes(ids._get_buffer()))
         except MultiValuesInsert as ex:
             # convert to executemany
             params = params or ex.params
@@ -269,6 +274,7 @@ class _BaseCursor:
 
         self._execute()
         return self._rowcount
+        # return self.execute(returning_query)
 
     def add_batch(self):
         self._is_alive()
@@ -321,7 +327,17 @@ class _BaseCursor:
         self._cleanup()
         self._is_batch_update = True
 
-        self._preparse()
+        try:
+            self._preparse()
+        except InsertWithReturning as ex:
+            ids = intersystems_iris._ListWriter._ListWriter()
+            for params in seq_of_params:
+                self.execute(ex.insert_query, params)
+                ids._set(self.lastrowid)
+            self.execute(ex.select_query, bytes(ids._get_buffer()))
+            raise
+        except Exception:
+            raise
         self._prepare()
 
         for row_num, param_row in enumerate(seq_of_params):
@@ -389,6 +405,8 @@ class _BaseCursor:
         )
         try:
             pOut = parser.PreParse(self.statement, self._params)
+        except InsertWithReturning:
+            raise
         except MultiValuesInsert:
             raise
         except Exception as e:
@@ -1182,6 +1200,8 @@ class Cursor(_BaseCursor):
         sets = self._parameter_sets or 1
         self.params = list(self.params).copy()
         param_types = [param.type for param in self._params._params_list]
+        if not self.params:
+            return
 
         for i in range(sets):
             params = self._params.collect(i)
@@ -1949,7 +1969,12 @@ class Cursor(_BaseCursor):
         self._closed = True
 
     def executemany(self, operation, seq_of_params):
-        super().executemany(operation, seq_of_params)
+        try:
+            super().executemany(operation, seq_of_params)
+        except InsertWithReturning:
+            return
+        except Exception:
+            raise
         self._rowcount = 0
         for i in range(len(self.params)):
             self._rowcount += self._in_message.wire._get()
@@ -2263,13 +2288,21 @@ class EmbdeddedCursor(_BaseCursor):
     def __del__(self):
         try:
             self.close()
-        except:
+        except Exception:
             pass
         return
 
     def _get_cached_info(self):
         return False
 
+    def executemany(self, operation, seq_of_params):
+        try:
+            super().executemany(operation, seq_of_params)
+        except InsertWithReturning:
+            return
+        except Exception:
+            raise
+
     def _get_parameters(self, params_set=0):
         params = self._params.collect(params_set)
         # None = '', '' = b'\x00'
@@ -2394,6 +2427,7 @@ class EmbdeddedCursor(_BaseCursor):
         sqlcode = 0
         message = None
         try:
+            print("!!!! _send_direct_query_request:params", [statement, params])
             self._result_set = self._sql.exec(statement, *params)
             self._rowcount = self._result_set.ResultSet._ROWCOUNT
             self._get_column_info()

{sqlalchemy_iris-0.15.5b1 → sqlalchemy_iris-0.16.0}/intersystems_iris/dbapi/_IRISStream.py

@@ -58,6 +58,8 @@ class IRISStream:
             if not self._binary:
                 result = str(result, self._locale)
 
+        if self._binary:
+            return bytes(result)
         return result
 
 

{sqlalchemy_iris-0.15.5b1 → sqlalchemy_iris-0.16.0}/intersystems_iris/dbapi/_ResultSetRow.py

@@ -162,7 +162,7 @@ class _ResultSetRow:
                 self._list_item.next_offset = self._offsets[key]
                 _DBList._get_list_element(self._list_item)
                 item = _DBList._get(self._list_item, self._locale)
-                _column: _Column = self._columns[idx]
+                _column: _Column = self._columns[key]
                 ctype = _column.type
                 value_type = self._types[ctype] if ctype in self._types else None
                 try:

{sqlalchemy_iris-0.15.5b1 → sqlalchemy_iris-0.16.0}/intersystems_iris/dbapi/preparser/_PreParser.py

@@ -11,6 +11,7 @@ from intersystems_iris.dbapi._Parameter import ParameterMode
 from intersystems_iris.dbapi.preparser._Token import TOKEN
 from intersystems_iris.dbapi.preparser._Scanner import ParseToken
 
+
 class MultiValuesInsert(Exception):
 
     def __init__(self, *args: object, query: str, rows: int, params=None) -> None:
@@ -20,6 +21,15 @@ class MultiValuesInsert(Exception):
         self.params = params
     
 
+class InsertWithReturning(Exception):
+
+    def __init__(self, *args: object, insert_query: str, insert_params, select_query: str) -> None:
+        super().__init__(*args)
+        self.insert_query = insert_query
+        self.insert_params = insert_params
+        self.select_query = select_query
+
+
 # May want to move to its own file eventually
 # SQL Statement Types
 class StatementType(enum.IntEnum):
@@ -480,6 +490,11 @@ class _PreParser(object):
         if found_insert:
             self.Tokenize(t_query)
 
+        _, t_query, t_select_query = self.InsertReturning(t_query)
+        if t_select_query:
+            raise InsertWithReturning(insert_query=t_query, insert_params=p_Parameters, select_query=t_select_query)
+        self.Tokenize(t_query)
+
         #  Resolve the tokens and determine output
         return self.Resolve(t_query, p_Parameters)
 
@@ -549,9 +564,39 @@ class _PreParser(object):
             new_query += _query(False)
             
             return found, new_query
-        except:
+        except Exception:
             return False, query
-        
+
+    def InsertReturning(self, query):
+        plain_query = ''
+
+        tokens = self.m_Tokens.GetEnumerator()
+        keywords = list(self.s_StatementTable.keys()) + list(self.s_ParsedStatements.keys()) + list(self.s_TransactionStatements.keys())
+        while tokens.MoveNext() and not tokens.Current().UpperOnOf(keywords):
+            plain_query += tokens.Current().Lexeme + ' '
+        if tokens.AtEnd() or not tokens.Current().UpperEquals("INSERT"):
+            return False, query, None
+
+        if not tokens.MoveNext() or not tokens.Current().UpperEquals("INTO"):
+            return False, query, None
+        plain_query += 'INSERT INTO '
+        table_name = ""
+        while tokens.MoveNext() and not tokens.Current().UpperOnOf(["(", "SET", "VALUES", "DEFAULT"]):
+            table_name += tokens.Current().Lexeme + ' '
+        plain_query += table_name + ' ' + tokens.Current().Lexeme + ' '
+        while tokens.MoveNext() and not tokens.Current().UpperEquals("RETURNING"):
+            plain_query += tokens.Current().Lexeme + ' '
+
+        select_query = None
+        if not tokens.AtEnd():
+            select_query = 'SELECT '
+            while tokens.MoveNext():
+                select_query += tokens.Current().Lexeme + ' '
+            select_query += "FROM " + table_name
+            select_query += " WHERE %ID %INLIST ?"
+
+        return False, plain_query, select_query
+
     def InsertMultiValues(self, query):
         new_query = ''
         values_list = []
@@ -580,7 +625,10 @@ class _PreParser(object):
                     break
                 if token.TokenType is TOKEN.CONSTANT:
                     values += '?'
-                    params += [token.Lexeme] 
+                    param = token.Lexeme
+                    if param.__len__ and param[0] == "'" and param[0] == param[-1]:
+                        param = param[1: -1]
+                    params += [param]
                 else:    
                     values += token.Lexeme
                 values += ' '
@@ -1047,6 +1095,7 @@ class _PreParser(object):
                     nParamIndex += 1
                     if nParamIndex == length + 1:
                         break
+
         return pOut
 
     # '?' represents a parameter; adds a parameter to p_Parameters if none were provided

{sqlalchemy_iris-0.15.5b1 → sqlalchemy_iris-0.16.0}/intersystems_iris/dbapi/preparser/_Token.py

@@ -76,6 +76,9 @@ It records the classification of the token as well as retaining the original str
     def UpperEquals(self, p_str):
         return self.UpperLexeme == p_str
 
+    def UpperOnOf(self, p_str_list):
+        return self.UpperLexeme in p_str_list
+
     def UpperContains(self, p_str):
         return p_str in self.UpperLexeme
 

{sqlalchemy_iris-0.15.5b1 → sqlalchemy_iris-0.16.0}/intersystems_iris/dbapi/preparser/_TokenList.py

@@ -216,6 +216,9 @@ class LinkedListEnumerator(ITokenEnumerator):
     def Current(self):
         return self.m_Current.GetValue()
 
+    def AtEnd(self):
+        return self.m_bEOF
+
     def MoveNext(self):
         if self.m_bEOF:
             return False

{sqlalchemy_iris-0.15.5b1 → sqlalchemy_iris-0.16.0}/setup.cfg

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

{sqlalchemy_iris-0.15.5b1 → sqlalchemy_iris-0.16.0}/sqlalchemy_iris/base.py

@@ -653,6 +653,20 @@ class IRISDDLCompiler(sql.compiler.DDLCompiler):
     def visit_check_constraint(self, constraint, **kw):
         pass
 
+    def create_table_constraints(self, table, **kw):
+        description = ""
+        comment = table.comment
+        if comment:
+            # hack to keep \r, kind of
+            comment = comment.replace('\r', '\n\t')
+            literal = self.sql_compiler.render_literal_value(comment, sqltypes.String())
+            description = "%DESCRIPTION " + literal
+
+        constraints = super().create_table_constraints(table, **kw)
+        if constraints and description:
+            description = ", \n\t" + description
+        return constraints + description
+
     def visit_add_constraint(self, create, **kw):
         if isinstance(create.element, schema.CheckConstraint):
             raise exc.CompileError("Can't add CHECK constraint")
@@ -701,6 +715,7 @@ class IRISDDLCompiler(sql.compiler.DDLCompiler):
 
         comment = column.comment
         if comment is not None:
+            comment = comment.replace('\r', '\n\t')
             literal = self.sql_compiler.render_literal_value(comment, sqltypes.String())
             colspec.append("%DESCRIPTION " + literal)
 
@@ -883,6 +898,12 @@ class IRISDialect(default.DefaultDialect):
     type_compiler = IRISTypeCompiler
     execution_ctx_cls = IRISExecutionContext
 
+    insert_returning = True
+    insert_executemany_returning = True
+    insert_executemany_returning_sort_by_parameter_order = True
+    update_executemany_returning = False
+    delete_executemany_returning = False
+
     construct_arguments = [
         (schema.Index, {"include": None}),
     ]
@@ -1105,6 +1126,38 @@ There are no access to %Dictionary, may be required for some advanced features,
             return "SQLUser"
         return schema
 
+    @reflection.cache
+    def get_table_options(self, connection, table_name, schema=None, **kw):
+        if not self.has_table(connection=connection, table_name=table_name, schema=schema):
+            raise exc.NoSuchTableError(
+                f"{schema}.{table_name}" if schema else table_name
+            ) from None
+        return {}
+
+    @reflection.cache
+    def get_table_comment(self, connection, table_name, schema=None, **kw):
+        if not self.has_table(connection=connection, table_name=table_name, schema=schema):
+            raise exc.NoSuchTableError(
+                f"{schema}.{table_name}" if schema else table_name
+            ) from None
+
+        tables = ischema.tables
+        schema_name = self.get_schema(schema)
+
+        s = sql.select(tables.c.description).where(
+            sql.and_(
+                tables.c.table_schema == str(schema_name),
+                tables.c.table_name == str(table_name),
+            )
+        )
+        comment = connection.execute(s).scalar()
+        if comment:
+            # make it as \r
+            comment = comment.replace(' \t\t\t\t', '\r')
+            # restore \n
+            comment = comment.replace(' \t\t\t', '\n')
+        return {"text": comment}
+
     @reflection.cache
     def get_schema_names(self, connection, **kw):
         s = sql.select(ischema.schemata.c.schema_name).order_by(
@@ -1131,7 +1184,7 @@ There are no access to %Dictionary, may be required for some advanced features,
         return table_names
 
     @reflection.cache
-    def get_temp_table_names(self, connection, dblink=None, **kw):
+    def get_temp_table_names(self, connection, **kw):
         tables = ischema.tables
         s = (
             sql.select(tables.c.table_name)
@@ -1598,6 +1651,7 @@ There are no access to %Dictionary, may be required for some advanced features,
                 columns.c.column_default,
                 columns.c.collation_name,
                 columns.c.auto_increment,
+                columns.c.description,
             )
             .select_from(columns)
             .where(
@@ -1650,7 +1704,12 @@ There are no access to %Dictionary, may be required for some advanced features,
                 sqlComputeCode = row[property.c.SqlComputeCode]
                 calculated = row[property.c.Calculated]
                 transient = row[property.c.Transient]
-            # description = row[columns.c.description]
+            comment = row[columns.c.description]
+            if comment:
+                # make it as \r
+                comment = comment.replace(' \t\t\t\t', '\r')
+                # restore \n
+                comment = comment.replace(' \t\t\t', '\n')
 
             coltype = self.ischema_names.get(type_, None)
 
@@ -1696,7 +1755,7 @@ There are no access to %Dictionary, may be required for some advanced features,
                 "nullable": nullable,
                 "default": default,
                 "autoincrement": autoincrement,
-                # "comment": description,
+                "comment": comment,
             }
             if sqlComputeCode and "set {*} = " in sqlComputeCode.lower():
                 sqltext = sqlComputeCode

{sqlalchemy_iris-0.15.5b1 → sqlalchemy_iris-0.16.0}/sqlalchemy_iris/information_schema.py

@@ -44,6 +44,7 @@ tables = Table(
     Column("TABLE_NAME", String, key="table_name"),
     Column("TABLE_TYPE", String, key="table_type"),
     Column("CLASSNAME", String, key="classname"),
+    Column("DESCRIPTION", String, key="description"),
     schema="INFORMATION_SCHEMA",
 )
 
@@ -69,7 +70,7 @@ columns = Table(
     Column("AUTO_INCREMENT", YESNO, key="auto_increment"),
     Column("UNIQUE_COLUMN", YESNO, key="unique_column"),
     Column("PRIMARY_KEY", YESNO, key="primary_key"),
-    Column("DESCIPTION", String, key="desciption"),
+    Column("DESCRIPTION", String, key="description"),
     schema="INFORMATION_SCHEMA",
 )
 property_definition = Table(

{sqlalchemy_iris-0.15.5b1 → sqlalchemy_iris-0.16.0}/sqlalchemy_iris/requirements.py

@@ -58,6 +58,22 @@ class Requirements(SuiteRequirements, AlembicRequirements):
 
         return exclusions.open()
 
+    @property
+    def reflect_table_options(self):
+        return exclusions.open()
+
+    @property
+    def comment_reflection(self):
+        return exclusions.open()
+
+    @property
+    def insert_returning(self):
+        return exclusions.open()
+
+    @property
+    def unusual_column_name_characters(self):
+        return exclusions.open()
+
     @property
     def computed_columns(self):
         "Supports computed columns"

{sqlalchemy_iris-0.15.5b1 → sqlalchemy_iris-0.16.0/sqlalchemy_iris.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: sqlalchemy-iris
-Version: 0.15.5b1
+Version: 0.16.0
 Summary: InterSystems IRIS for SQLAlchemy
 Home-page: https://github.com/caretdev/sqlalchemy-iris
 Maintainer: CaretDev
@@ -23,6 +23,7 @@ Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: SQLAlchemy>=1.3
+Dynamic: requires-dist
 
 sqlalchemy-iris
 ===

{sqlalchemy_iris-0.15.5b1 → sqlalchemy_iris-0.16.0}/sqlalchemy_iris.egg-info/SOURCES.txt

@@ -65,12 +65,6 @@ intersystems_iris/pex/_InboundAdapter.py
 intersystems_iris/pex/_Message.py
 intersystems_iris/pex/_OutboundAdapter.py
 intersystems_iris/pex/__init__.py
-iris/__init__.py
-iris/__init__.pyi
-iris/_cli.py
-iris/iris_ipm.py
-iris/iris_ipm.pyi
-iris/iris_utils.py
 irisnative/_IRISNative.py
 irisnative/__init__.py
 sqlalchemy_iris/__init__.py

{sqlalchemy_iris-0.15.5b1 → sqlalchemy_iris-0.16.0}/sqlalchemy_iris.egg-info/top_level.txt

@@ -1,4 +1,3 @@
 intersystems_iris
-iris
 irisnative
 sqlalchemy_iris

{sqlalchemy_iris-0.15.5b1 → sqlalchemy_iris-0.16.0}/tests/test_alembic.py

@@ -70,7 +70,9 @@ else:
             self.meta.drop_all(connection)
 
         def test_drop_col_with_fk(self, ops_context, connection, tables):
-            ops_context.drop_column("round_trip_table", "oid_fk", schema=self.meta.schema)
+            ops_context.drop_column(
+                "round_trip_table", "oid_fk", schema=self.meta.schema
+            )
             insp = inspect(connection)
             eq_(insp.get_foreign_keys("round_trip_table", schema=self.meta.schema), [])
 
@@ -112,9 +114,9 @@ else:
 
             result = connection.execute(text("select col from tab")).all()
             assert result == [
-                (bytearray(b"'some data 1'"),),
-                (bytearray(b"'some data 2'"),),
-                (bytearray(b"'some data 3'"),),
+                (b"some data 1",),
+                (b"some data 2",),
+                (b"some data 3",),
             ]
 
             insp = inspect(connection)

{sqlalchemy_iris-0.15.5b1 → sqlalchemy_iris-0.16.0}/tests/test_suite.py

@@ -2,6 +2,8 @@ from enum import Enum
 
 from sqlalchemy.testing.suite import FetchLimitOffsetTest as _FetchLimitOffsetTest
 from sqlalchemy.testing.suite import CompoundSelectTest as _CompoundSelectTest
+from sqlalchemy.testing.suite import TableDDLTest as _TableDDLTest
+from sqlalchemy.testing.suite import FutureTableDDLTest as _FutureTableDDLTest
 from sqlalchemy.testing.suite import CTETest as _CTETest
 from sqlalchemy.testing.suite import DifficultParametersTest as _DifficultParametersTest
 from sqlalchemy.testing import fixtures
@@ -63,9 +65,19 @@ class CTETest(_CTETest):
         pass
 
 
-@pytest.mark.skip()
 class DifficultParametersTest(_DifficultParametersTest):
-    pass
+
+    tough_parameters = _DifficultParametersTest.tough_parameters
+
+    @tough_parameters
+    def test_round_trip_same_named_column(
+        self, paramname, connection, metadata
+    ):
+        if paramname == 'dot.s':
+            # not supported
+            pytest.skip()
+            return
+        super().test_round_trip_same_named_column(paramname, connection, metadata)
 
 
 class FetchLimitOffsetTest(_FetchLimitOffsetTest):
@@ -486,3 +498,21 @@ class ConcatTest(fixtures.TablesTest):
                 ("sometestdata",),
             ],
         )
+
+
+class TableDDLTest(_TableDDLTest):
+    # IRIS does not want to update comments on the fly
+    def test_add_table_comment(self, connection):
+        pass
+
+    def test_drop_table_comment(self, connection):
+        pass
+
+
+class FutureTableDDLTest(_FutureTableDDLTest):
+    # IRIS does not want to update comments on the fly
+    def test_add_table_comment(self, connection):
+        pass
+
+    def test_drop_table_comment(self, connection):
+        pass

sqlalchemy_iris-0.15.5b1/iris/__init__.py

@@ -1,66 +0,0 @@
-import os
-import sys
-import importlib
-
-from .iris_ipm import ipm
-from .iris_utils import update_dynalib_path
-
-# check for install dir in environment
-# environment to check is IRISINSTALLDIR
-# if not found, raise exception and exit
-# ISC_PACKAGE_INSTALLDIR - defined by default in Docker images
-installdir = os.environ.get('IRISINSTALLDIR') or os.environ.get('ISC_PACKAGE_INSTALLDIR')
-if installdir is None:
-        raise Exception("""Cannot find InterSystems IRIS installation directory
-    Please set IRISINSTALLDIR environment variable to the InterSystems IRIS installation directory""")
-
-__sysversion_info = sys.version_info
-__syspath = sys.path
-__osname = os.name
-
-# join the install dir with the bin directory
-__syspath.append(os.path.join(installdir, 'bin'))
-# also append lib/python
-__syspath.append(os.path.join(installdir, 'lib', 'python'))
-
-# update the dynalib path
-update_dynalib_path(os.path.join(installdir, 'bin'))
-
-# save working directory
-__ospath = os.getcwd()
-
-__irispythonint = None
-
-if __osname=='nt':
-    if __sysversion_info.minor==9:
-        __irispythonint = 'pythonint39'
-    elif __sysversion_info.minor==10:
-        __irispythonint = 'pythonint310'
-    elif __sysversion_info.minor==11:
-        __irispythonint = 'pythonint311'
-    elif __sysversion_info.minor==12:
-        __irispythonint = 'pythonint312'
-    elif __sysversion_info.minor==13:
-        __irispythonint = 'pythonint313'
-else:
-    __irispythonint = 'pythonint'
-
-if __irispythonint is not None:
-    # equivalent to from pythonint import *
-    try:
-        __irispythonintmodule = importlib.import_module(__irispythonint)
-    except ImportError:
-        __irispythonint = 'pythonint'
-        __irispythonintmodule = importlib.import_module(__irispythonint)
-    globals().update(vars(__irispythonintmodule))
-
-# 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 *
-
-#
-# End-of-file
-#