sqlalchemy-iris 0.17.0__tar.gz → 0.17.1__tar.gz

{sqlalchemy_iris-0.17.0/sqlalchemy_iris.egg-info → sqlalchemy_iris-0.17.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: sqlalchemy-iris
-Version: 0.17.0
+Version: 0.17.1
 Summary: InterSystems IRIS for SQLAlchemy
 Home-page: https://github.com/caretdev/sqlalchemy-iris
 Maintainer: CaretDev
@@ -25,6 +25,7 @@ License-File: LICENSE
 Requires-Dist: SQLAlchemy>=1.3
 Provides-Extra: intersystems
 Requires-Dist: intersystems-irispython==5.1.0; extra == "intersystems"
+Dynamic: license-file
 Dynamic: requires-dist
 
 sqlalchemy-iris
@@ -103,6 +104,60 @@ docker run -d --name iris \
  intersystemsdc/iris-community:preview
 ```
 
+Examples
+===
+
+IRISVector
+---
+
+```python
+from sqlalchemy import Column, MetaData, Table, select
+from sqlalchemy.sql.sqltypes import Integer, UUID
+from sqlalchemy_iris import IRISVector
+from sqlalchemy import create_engine
+from sqlalchemy.orm import DeclarativeBase
+import uuid
+
+DATABASE_URL = "iris://_SYSTEM:SYS@localhost:1972/USER"
+engine = create_engine(DATABASE_URL, echo=False)
+
+# Create a table metadata
+metadata = MetaData()
+
+
+class Base(DeclarativeBase):
+    pass
+
+
+def main():
+    demo_table = Table(
+        "demo_table",
+        metadata,
+        Column("id", Integer, primary_key=True, autoincrement=True),
+        Column("uuid", UUID),
+        Column("embedding", IRISVector(item_type=float, max_items=3)),
+    )
+
+    demo_table.drop(engine, checkfirst=True)
+    demo_table.create(engine, checkfirst=True)
+    with engine.connect() as conn:
+        conn.execute(
+            demo_table.insert(),
+            [
+                {"uuid": uuid.uuid4(), "embedding": [1, 2, 3]},
+                {"uuid": uuid.uuid4(), "embedding": [2, 3, 4]},
+            ],
+        )
+        conn.commit()
+        result = conn.execute(
+            demo_table.select()
+        ).fetchall()
+        print("result", result)
+
+
+main()
+```
+
 _Port 1972 is used for binary communication (this driver, xDBC and so on), and 52773 is for web (Management Portal, IRIS based web-applications and API's)._
 
 The System Management Portal is available by URL: `http://localhost:52773/csp/sys/UtilHome.csp`

{sqlalchemy_iris-0.17.0 → sqlalchemy_iris-0.17.1}/README.md

@@ -74,6 +74,60 @@ docker run -d --name iris \
  intersystemsdc/iris-community:preview
 ```
 
+Examples
+===
+
+IRISVector
+---
+
+```python
+from sqlalchemy import Column, MetaData, Table, select
+from sqlalchemy.sql.sqltypes import Integer, UUID
+from sqlalchemy_iris import IRISVector
+from sqlalchemy import create_engine
+from sqlalchemy.orm import DeclarativeBase
+import uuid
+
+DATABASE_URL = "iris://_SYSTEM:SYS@localhost:1972/USER"
+engine = create_engine(DATABASE_URL, echo=False)
+
+# Create a table metadata
+metadata = MetaData()
+
+
+class Base(DeclarativeBase):
+    pass
+
+
+def main():
+    demo_table = Table(
+        "demo_table",
+        metadata,
+        Column("id", Integer, primary_key=True, autoincrement=True),
+        Column("uuid", UUID),
+        Column("embedding", IRISVector(item_type=float, max_items=3)),
+    )
+
+    demo_table.drop(engine, checkfirst=True)
+    demo_table.create(engine, checkfirst=True)
+    with engine.connect() as conn:
+        conn.execute(
+            demo_table.insert(),
+            [
+                {"uuid": uuid.uuid4(), "embedding": [1, 2, 3]},
+                {"uuid": uuid.uuid4(), "embedding": [2, 3, 4]},
+            ],
+        )
+        conn.commit()
+        result = conn.execute(
+            demo_table.select()
+        ).fetchall()
+        print("result", result)
+
+
+main()
+```
+
 _Port 1972 is used for binary communication (this driver, xDBC and so on), and 52773 is for web (Management Portal, IRIS based web-applications and API's)._
 
 The System Management Portal is available by URL: `http://localhost:52773/csp/sys/UtilHome.csp`

{sqlalchemy_iris-0.17.0 → sqlalchemy_iris-0.17.1}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = sqlalchemy-iris
-version = 0.17.0
+version = 0.17.1
 description = InterSystems IRIS for SQLAlchemy
 long_description = file: README.md
 url = https://github.com/caretdev/sqlalchemy-iris
@@ -33,7 +33,7 @@ intersystems =
 	intersystems-irispython==5.1.0
 
 [tool:pytest]
-addopts = --tb native -v -r fxX --maxfail=25 -p no:warnings
+addopts = --tb native -v -r fxX -p no:warnings
 
 [db]
 default = iris://_SYSTEM:SYS@localhost:1972/USER

{sqlalchemy_iris-0.17.0 → sqlalchemy_iris-0.17.1}/sqlalchemy_iris/base.py

@@ -774,6 +774,9 @@ class IRISTypeCompiler(compiler.GenericTypeCompiler):
     def visit_LONGVARBINARY(self, type_, **kw):
         return "LONGVARBINARY"
 
+    def visit_LONGVARCHAR(self, type_, **kw):
+        return "LONGVARCHAR"
+
     def visit_DOUBLE(self, type_, **kw):
         return "DOUBLE"
 
@@ -971,11 +974,9 @@ There are no access to %Dictionary, may be required for some advanced features,
 
     def _get_option(self, connection, option):
         with connection.cursor() as cursor:
-            cursor.execute("SELECT %SYSTEM_SQL.Util_GetOption(?)", option)
+            cursor.execute("SELECT %SYSTEM_SQL.Util_GetOption(?)", (option, ))
             row = cursor.fetchone()
-            if row:
-                return row[0]
-        return None
+            return row[0] if row else None
 
     def _set_option(self, connection, option, value):
         with connection.cursor() as cursor:
@@ -1091,10 +1092,7 @@ There are no access to %Dictionary, may be required for some advanced features,
         if query.endswith(";"):
             query = query[:-1]
         self._debug(query, params)
-        try:
-            cursor.execute(query, params)
-        except Exception as ex:
-            raise ex
+        cursor.execute(query, params)
 
     def do_executemany(self, cursor, query, params, context=None):
         if query.endswith(";"):

{sqlalchemy_iris-0.17.0 → sqlalchemy_iris-0.17.1}/sqlalchemy_iris/intersystems/__init__.py

@@ -1,12 +1,11 @@
 import re
-import pkg_resources
+from typing import Any
 from ..base import IRISDialect
-from sqlalchemy import text, util
 from ..base import IRISExecutionContext
 from . import dbapi
-from .dbapi import connect, Cursor
-from .cursor import InterSystemsCursorFetchStrategy
+from .dbapi import connect
 from .dbapi import IntegrityError, OperationalError, DatabaseError
+from sqlalchemy.engine.cursor import CursorFetchStrategy
 
 
 def remap_exception(func):
@@ -20,7 +19,7 @@ def remap_exception(func):
             except RuntimeError as ex:
                 # [SQLCODE: <-119>:...
                 message = ex.args[0]
-                if '<LIST ERROR>' in message:
+                if "<LIST ERROR>" in message:
                     # just random error happens in the driver, try again
                     continue
                 sqlcode = re.findall(r"^\[SQLCODE: <(-\d+)>:", message)
@@ -28,27 +27,34 @@ def remap_exception(func):
                     raise Exception(message)
                 sqlcode = int(sqlcode[0])
                 if abs(sqlcode) in [108, 119, 121, 122]:
-                    raise IntegrityError(message)
+                    raise IntegrityError(sqlcode, message)
                 if abs(sqlcode) in [1, 12]:
-                    raise OperationalError(message)
-                raise DatabaseError(message)
+                    raise OperationalError(sqlcode, message)
+                raise DatabaseError(sqlcode, message)
 
     return wrapper
 
 
+class InterSystemsCursorFetchStrategy(CursorFetchStrategy):
+
+    def fetchone(
+        self,
+        result,
+        dbapi_cursor,
+        hard_close: bool = False,
+    ) -> Any:
+        row = dbapi_cursor.fetchone()
+        return tuple(row) if row else None
+
+
 class InterSystemsExecutionContext(IRISExecutionContext):
     cursor_fetch_strategy = InterSystemsCursorFetchStrategy()
 
-    def create_cursor(self):
-        cursor = self._dbapi_connection.cursor()
-        cursor.sqlcode = 0
-        return cursor
-
 
 class IRISDialect_intersystems(IRISDialect):
     driver = "intersystems"
 
-    execution_ctx_cls = InterSystemsExecutionContext
+    # execution_ctx_cls = InterSystemsExecutionContext
 
     supports_statement_cache = True
 
@@ -62,6 +68,8 @@ class IRISDialect_intersystems(IRISDialect):
 
     logfile = None
 
+    server_version = None
+
     def __init__(self, logfile: str = None, **kwargs):
         self.logfile = logfile
         IRISDialect.__init__(self, **kwargs)
@@ -115,27 +123,25 @@ class IRISDialect_intersystems(IRISDialect):
 
         return ([], opts)
 
-    def _get_server_version_info(self, connection):
-        # get the wheel version from iris module
-        try:
-            return tuple(
-                map(
-                    int,
-                    pkg_resources.get_distribution(
-                        "intersystems_irispython"
-                    ).version.split("."),
+    def on_connect(self):
+        super_ = super().on_connect()
+
+        def on_connect(conn):
+            if super_ is not None:
+                super_(conn)
+
+                server_version = dbapi.createIRIS(conn).classMethodValue(
+                    "%SYSTEM.Version", "GetNumber"
+                )
+                server_version = server_version.split(".")
+                self.server_version = tuple(
+                    [int("".join(filter(str.isdigit, v))) for v in server_version]
                 )
-            )
-        except:  # noqa
-            return None
-
-    def _get_option(self, connection, option):
-        with connection.cursor() as cursor:
-            cursor.execute("SELECT %SYSTEM_SQL.Util_GetOption(?)", (option,))
-            row = cursor.fetchone()
-            if row:
-                return row[0]
-        return None
+
+        return on_connect
+
+    def _get_server_version_info(self, connection):
+        return self.server_version
 
     def set_isolation_level(self, connection, level_str):
         if level_str == "AUTOCOMMIT":
@@ -147,6 +153,7 @@ class IRISDialect_intersystems(IRISDialect):
             with connection.cursor() as cursor:
                 cursor.execute("SET TRANSACTION ISOLATION LEVEL " + level_str)
 
+"""
     @remap_exception
     def do_execute(self, cursor, query, params, context=None):
         if query.endswith(";"):
@@ -163,5 +170,6 @@ class IRISDialect_intersystems(IRISDialect):
             params = [param[0] if len(param) else None for param in params]
         cursor.executemany(query, params)
 
+"""
 
 dialect = IRISDialect_intersystems

{sqlalchemy_iris-0.17.0 → sqlalchemy_iris-0.17.1}/sqlalchemy_iris/intersystems/dbapi.py

@@ -15,6 +15,10 @@ def connect(*args, **kwargs):
     return iris.connect(*args, **kwargs)
 
 
+def createIRIS(*args, **kwargs):
+    return iris.createIRIS(*args, **kwargs)
+
+
 # globals
 apilevel = "2.0"
 threadsafety = 0

{sqlalchemy_iris-0.17.0 → sqlalchemy_iris-0.17.1}/sqlalchemy_iris/requirements.py

@@ -960,8 +960,8 @@ class Requirements(SuiteRequirements, AlembicRequirements):
         literal string, e.g. via the TypeEngine.literal_processor() method.
 
         """
-
-        return exclusions.open()
+        # works stable only on Community driver
+        return self.community_driver
 
     @property
     def datetime(self):

{sqlalchemy_iris-0.17.0 → sqlalchemy_iris-0.17.1/sqlalchemy_iris.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: sqlalchemy-iris
-Version: 0.17.0
+Version: 0.17.1
 Summary: InterSystems IRIS for SQLAlchemy
 Home-page: https://github.com/caretdev/sqlalchemy-iris
 Maintainer: CaretDev
@@ -25,6 +25,7 @@ License-File: LICENSE
 Requires-Dist: SQLAlchemy>=1.3
 Provides-Extra: intersystems
 Requires-Dist: intersystems-irispython==5.1.0; extra == "intersystems"
+Dynamic: license-file
 Dynamic: requires-dist
 
 sqlalchemy-iris
@@ -103,6 +104,60 @@ docker run -d --name iris \
  intersystemsdc/iris-community:preview
 ```
 
+Examples
+===
+
+IRISVector
+---
+
+```python
+from sqlalchemy import Column, MetaData, Table, select
+from sqlalchemy.sql.sqltypes import Integer, UUID
+from sqlalchemy_iris import IRISVector
+from sqlalchemy import create_engine
+from sqlalchemy.orm import DeclarativeBase
+import uuid
+
+DATABASE_URL = "iris://_SYSTEM:SYS@localhost:1972/USER"
+engine = create_engine(DATABASE_URL, echo=False)
+
+# Create a table metadata
+metadata = MetaData()
+
+
+class Base(DeclarativeBase):
+    pass
+
+
+def main():
+    demo_table = Table(
+        "demo_table",
+        metadata,
+        Column("id", Integer, primary_key=True, autoincrement=True),
+        Column("uuid", UUID),
+        Column("embedding", IRISVector(item_type=float, max_items=3)),
+    )
+
+    demo_table.drop(engine, checkfirst=True)
+    demo_table.create(engine, checkfirst=True)
+    with engine.connect() as conn:
+        conn.execute(
+            demo_table.insert(),
+            [
+                {"uuid": uuid.uuid4(), "embedding": [1, 2, 3]},
+                {"uuid": uuid.uuid4(), "embedding": [2, 3, 4]},
+            ],
+        )
+        conn.commit()
+        result = conn.execute(
+            demo_table.select()
+        ).fetchall()
+        print("result", result)
+
+
+main()
+```
+
 _Port 1972 is used for binary communication (this driver, xDBC and so on), and 52773 is for web (Management Portal, IRIS based web-applications and API's)._
 
 The System Management Portal is available by URL: `http://localhost:52773/csp/sys/UtilHome.csp`

{sqlalchemy_iris-0.17.0 → sqlalchemy_iris-0.17.1}/sqlalchemy_iris.egg-info/SOURCES.txt

@@ -84,7 +84,6 @@ sqlalchemy_iris.egg-info/entry_points.txt
 sqlalchemy_iris.egg-info/requires.txt
 sqlalchemy_iris.egg-info/top_level.txt
 sqlalchemy_iris/intersystems/__init__.py
-sqlalchemy_iris/intersystems/cursor.py
 sqlalchemy_iris/intersystems/dbapi.py
 tests/test_alembic.py
 tests/test_suite.py

{sqlalchemy_iris-0.17.0 → sqlalchemy_iris-0.17.1}/tests/test_alembic.py

@@ -1,3 +1,6 @@
+from sqlalchemy_iris import LONGVARCHAR
+
+
 try:
     import alembic  # noqa
 except:  # noqa
@@ -93,14 +96,18 @@ else:
         @classmethod
         def insert_data(cls, connection):
             connection.execute(
-                text(
-                    """
-                    insert into tab (col) values
-                        ('some data 1'),
-                        ('some data 2'),
-                        ('some data 3')
-                """
-                )
+                cls.tables.tab.insert(),
+                [
+                    {
+                        "col": "some data 1",
+                    },
+                    {
+                        "col": "some data 2",
+                    },
+                    {
+                        "col": "some data 3",
+                    },
+                ],
             )
 
         def test_str_to_blob(self, connection, ops_context):
@@ -124,3 +131,29 @@ else:
             assert col["name"] == "col"
             assert isinstance(col["type"], LONGVARBINARY)
             assert not col["nullable"]
+
+class TestIRISLONGVARCHAR(TestBase):
+
+    @fixture
+    def tables(self, connection):
+        self.meta = MetaData()
+        self.tbl = Table(
+            "longvarbinary_test",
+            self.meta,
+            Column("id", Integer, primary_key=True),
+            Column("data", LONGVARCHAR),
+        )
+        self.meta.create_all(connection)
+        yield
+        self.meta.drop_all(connection)
+
+    def test_longvarchar(self, connection, tables):
+        connection.execute(
+            self.tbl.insert(),
+            [
+                {"data": "test data"},
+                {"data": "more test data"},
+            ],
+        )
+        result = connection.execute(self.tbl.select()).fetchall()
+        assert result == [(1, "test data"), (2, "more test data")]

{sqlalchemy_iris-0.17.0 → sqlalchemy_iris-0.17.1}/tests/test_suite.py

@@ -22,7 +22,6 @@ from sqlalchemy_iris import INTEGER
 from sqlalchemy_iris import IRISListBuild
 from sqlalchemy_iris import IRISVector
 from sqlalchemy.exc import DatabaseError
-from sqlalchemy.testing.config import requirements
 
 import pytest
 

sqlalchemy_iris-0.17.0/sqlalchemy_iris/intersystems/cursor.py

@@ -1,17 +0,0 @@
-from typing import Any
-from sqlalchemy import CursorResult
-from sqlalchemy.engine.cursor import CursorFetchStrategy
-from sqlalchemy.engine.interfaces import DBAPICursor
-
-
-class InterSystemsCursorFetchStrategy(CursorFetchStrategy):
-
-    def fetchone(
-        self,
-        result: CursorResult[Any],
-        dbapi_cursor: DBAPICursor,
-        hard_close: bool = False,
-    ) -> Any:
-        row = dbapi_cursor.fetchone()
-        return tuple(row) if row else None
-