sqlalchemy-iris 0.15.2__tar.gz → 0.15.3__tar.gz

{sqlalchemy_iris-0.15.2/sqlalchemy_iris.egg-info → sqlalchemy_iris-0.15.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sqlalchemy-iris
-Version: 0.15.2
+Version: 0.15.3
 Summary: InterSystems IRIS for SQLAlchemy
 Home-page: https://github.com/caretdev/sqlalchemy-iris
 Maintainer: CaretDev

{sqlalchemy_iris-0.15.2 → sqlalchemy_iris-0.15.3}/intersystems_iris/dbapi/_DBAPI.py

@@ -1,3 +1,4 @@
+from typing import Union
 import struct
 import copy
 import enum
@@ -43,7 +44,7 @@ def embedded_connect(*args, hostname=None, port=None, namespace=None, username=N
     return connection
 
 
-def connect(*args, embedded=False, hostname=None, port=None, namespace=None, username=None, password=None, **kw) -> _IRISConnection | _IRISEmbedded:
+def connect(*args, embedded=False, hostname=None, port=None, namespace=None, username=None, password=None, **kw) -> Union[_IRISConnection, _IRISEmbedded]:
     try:
         if not embedded:
             return native_connect(

{sqlalchemy_iris-0.15.2 → sqlalchemy_iris-0.15.3}/setup.cfg

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

{sqlalchemy_iris-0.15.2 → sqlalchemy_iris-0.15.3}/sqlalchemy_iris/alembic.py

@@ -7,6 +7,7 @@ from typing import Any
 from sqlalchemy.ext.compiler import compiles
 from sqlalchemy.sql.base import Executable
 from sqlalchemy.sql.elements import ClauseElement
+from sqlalchemy.sql.schema import CheckConstraint
 from sqlalchemy.sql.type_api import TypeEngine
 from sqlalchemy.sql import table
 from sqlalchemy import types
@@ -134,6 +135,12 @@ class IRISImpl(DefaultImpl):
             **kw,
         )
 
+    def add_constraint(self, const: Any) -> None:
+        if isinstance(const, CheckConstraint):
+            # just ignore it
+            return
+        super().add_constraint(const)
+
 
 class _ExecDropForeignKey(Executable, ClauseElement):
     inherit_cache = False

{sqlalchemy_iris-0.15.2 → sqlalchemy_iris-0.15.3}/sqlalchemy_iris/base.py

@@ -591,6 +591,12 @@ class IRISCompiler(sql.compiler.SQLCompiler):
             self.process(binary.right, **kw),
         )
 
+    def visit_concat_func(
+        self, func, **kw
+    ):
+        args = [self.process(clause, **kw) for clause in func.clauses.clauses]
+        return ' || '.join(args)
+
     def visit_mod_binary(self, binary, operator, **kw):
         return (
             self.process(binary.left, **kw) + " # " + self.process(binary.right, **kw)
@@ -955,6 +961,11 @@ There are no access to %Dictionary, may be required for some advanced features,
                 return row[0]
         return None
 
+    def get_isolation_level_values(self, dbapi_connection):
+        levels = set(self._isolation_lookup)
+        levels.add("AUTOCOMMIT")
+        return levels
+
     def get_isolation_level(self, connection):
         try:
             level = int(self._get_option(connection, "IsolationMode"))

{sqlalchemy_iris-0.15.2 → sqlalchemy_iris-0.15.3/sqlalchemy_iris.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sqlalchemy-iris
-Version: 0.15.2
+Version: 0.15.3
 Summary: InterSystems IRIS for SQLAlchemy
 Home-page: https://github.com/caretdev/sqlalchemy-iris
 Maintainer: CaretDev

{sqlalchemy_iris-0.15.2 → sqlalchemy_iris-0.15.3}/tests/test_suite.py

@@ -9,10 +9,11 @@ from sqlalchemy.testing.assertions import eq_
 from sqlalchemy.testing import config
 from sqlalchemy.orm import Session
 from sqlalchemy import testing
-from sqlalchemy import Table, Column, select
+from sqlalchemy import Table, Column, select, func
 from sqlalchemy.types import Integer
 from sqlalchemy.types import String
 from sqlalchemy.types import VARBINARY
+from sqlalchemy.types import TEXT
 from sqlalchemy.types import BINARY
 from sqlalchemy_iris import TINYINT
 from sqlalchemy_iris import INTEGER
@@ -25,6 +26,30 @@ from sqlalchemy.testing.suite import *  # noqa
 
 from sqlalchemy import __version__ as sqlalchemy_version
 
+if sqlalchemy_version.startswith("2."):
+    from sqlalchemy.testing.suite import (
+        BizarroCharacterFKResolutionTest as _BizarroCharacterFKResolutionTest,
+    )
+
+    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
+            )
+
 
 class CompoundSelectTest(_CompoundSelectTest):
     @pytest.mark.skip()
@@ -269,175 +294,195 @@ class IRISEnumTest(fixtures.TablesTest):
         )
 
 
-if sqlalchemy_version.startswith("2."):
-    from sqlalchemy.testing.suite import (
-        BizarroCharacterFKResolutionTest as _BizarroCharacterFKResolutionTest,
-    )
+class IRISListBuildTest(fixtures.TablesTest):
+    __backend__ = True
 
-    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",
+    @classmethod
+    def define_tables(cls, metadata):
+        Table(
+            "data",
+            metadata,
+            Column("val", IRISListBuild(10, float)),
         )
-        def test_fk_ref(
-            self, connection, metadata, use_composite, tablename, columnname
-        ):
-            super().test_fk_ref(
-                connection, metadata, use_composite, tablename, columnname
+
+    @classmethod
+    def fixtures(cls):
+        return dict(
+            data=(
+                ("val",),
+                ([1.0] * 50,),
+                ([1.23] * 50,),
+                ([i for i in range(0, 50)],),
+                (None,),
             )
+        )
 
-    class IRISListBuildTest(fixtures.TablesTest):
-        __backend__ = True
+    def _assert_result(self, select, result):
+        with config.db.connect() as conn:
+            eq_(conn.execute(select).fetchall(), result)
 
-        @classmethod
-        def define_tables(cls, metadata):
-            Table(
-                "data",
-                metadata,
-                Column("val", IRISListBuild(10, float)),
-            )
+    def test_listbuild(self):
+        self._assert_result(
+            select(self.tables.data),
+            [
+                ([1.0] * 50,),
+                ([1.23] * 50,),
+                ([i for i in range(0, 50)],),
+                (None,),
+            ],
+        )
+        self._assert_result(
+            select(self.tables.data).where(self.tables.data.c.val == [1.0] * 50),
+            [
+                ([1.0] * 50,),
+            ],
+        )
 
-        @classmethod
-        def fixtures(cls):
-            return dict(
-                data=(
-                    ("val",),
-                    ([1.0] * 50,),
-                    ([1.23] * 50,),
-                    ([i for i in range(0, 50)],),
-                    (None,),
-                )
-            )
+        self._assert_result(
+            select(
+                self.tables.data,
+                self.tables.data.c.val.func("$listsame", [1.0] * 50).label("same"),
+            ).limit(1),
+            [
+                ([1.0] * 50, 1),
+            ],
+        )
 
-        def _assert_result(self, select, result):
-            with config.db.connect() as conn:
-                eq_(conn.execute(select).fetchall(), result)
 
-        def test_listbuild(self):
-            self._assert_result(
-                select(self.tables.data),
-                [
-                    ([1.0] * 50,),
-                    ([1.23] * 50,),
-                    ([i for i in range(0, 50)],),
-                    (None,),
-                ],
-            )
-            self._assert_result(
-                select(self.tables.data).where(self.tables.data.c.val == [1.0] * 50),
-                [
-                    ([1.0] * 50,),
-                ],
-            )
+class IRISVectorTest(fixtures.TablesTest):
+    __backend__ = True
 
-            self._assert_result(
-                select(
-                    self.tables.data,
-                    self.tables.data.c.val.func("$listsame", [1.0] * 50).label("same"),
-                ).limit(1),
-                [
-                    ([1.0] * 50, 1),
-                ],
+    __requires__ = ("iris_vector",)
+
+    @classmethod
+    def define_tables(cls, metadata):
+        Table(
+            "data",
+            metadata,
+            Column("id", INTEGER),
+            Column("emb", IRISVector(3, float)),
+        )
+
+    @classmethod
+    def fixtures(cls):
+        return dict(
+            data=(
+                (
+                    "id",
+                    "emb",
+                ),
+                (
+                    1,
+                    [1, 1, 1],
+                ),
+                (
+                    2,
+                    [2, 2, 2],
+                ),
+                (
+                    3,
+                    [1, 1, 2],
+                ),
             )
+        )
 
-    class IRISVectorTest(fixtures.TablesTest):
-        __backend__ = True
+    def _assert_result(self, select, result):
+        with config.db.connect() as conn:
+            eq_(conn.execute(select).fetchall(), result)
 
-        __requires__ = ("iris_vector",)
+    def test_vector(self):
+        self._assert_result(
+            select(self.tables.data.c.emb),
+            [
+                ([1, 1, 1],),
+                ([2, 2, 2],),
+                ([1, 1, 2],),
+            ],
+        )
+        self._assert_result(
+            select(self.tables.data.c.id).where(self.tables.data.c.emb == [2, 2, 2]),
+            [
+                (2,),
+            ],
+        )
 
-        @classmethod
-        def define_tables(cls, metadata):
-            Table(
-                "data",
-                metadata,
-                Column("id", INTEGER),
-                Column("emb", IRISVector(3, float)),
-            )
+    def test_cosine(self):
+        self._assert_result(
+            select(
+                self.tables.data.c.id,
+            ).order_by(self.tables.data.c.emb.cosine([1, 1, 1])),
+            [
+                (1,),
+                (2,),
+                (3,),
+            ],
+        )
 
-        @classmethod
-        def fixtures(cls):
-            return dict(
-                data=(
-                    (
-                        "id",
-                        "emb",
-                    ),
-                    (
-                        1,
-                        [1, 1, 1],
-                    ),
-                    (
-                        2,
-                        [2, 2, 2],
-                    ),
-                    (
-                        3,
-                        [1, 1, 2],
-                    ),
-                )
-            )
+    def test_cosine_distance(self):
+        self._assert_result(
+            select(
+                self.tables.data.c.id,
+            ).order_by(1 - self.tables.data.c.emb.cosine_distance([1, 1, 1])),
+            [
+                (1,),
+                (2,),
+                (3,),
+            ],
+        )
 
-        def _assert_result(self, select, result):
-            with config.db.connect() as conn:
-                eq_(conn.execute(select).fetchall(), result)
+    def test_max_inner_product(self):
+        self._assert_result(
+            select(
+                self.tables.data.c.id,
+            ).order_by(self.tables.data.c.emb.max_inner_product([1, 1, 1])),
+            [
+                (1,),
+                (3,),
+                (2,),
+            ],
+        )
 
-        def test_vector(self):
-            self._assert_result(
-                select(self.tables.data.c.emb),
-                [
-                    ([1, 1, 1],),
-                    ([2, 2, 2],),
-                    ([1, 1, 2],),
-                ],
-            )
-            self._assert_result(
-                select(self.tables.data.c.id).where(
-                    self.tables.data.c.emb == [2, 2, 2]
-                ),
-                [
-                    (2,),
-                ],
-            )
 
-        def test_cosine(self):
-            self._assert_result(
-                select(
-                    self.tables.data.c.id,
-                ).order_by(self.tables.data.c.emb.cosine([1, 1, 1])),
-                [
-                    (1,),
-                    (2,),
-                    (3,),
-                ],
-            )
+class ConcatTest(fixtures.TablesTest):
+    __backend__ = True
 
-        def test_cosine_distance(self):
-            self._assert_result(
-                select(
-                    self.tables.data.c.id,
-                ).order_by(1 - self.tables.data.c.emb.cosine_distance([1, 1, 1])),
-                [
-                    (1,),
-                    (2,),
-                    (3,),
-                ],
-            )
+    @classmethod
+    def define_tables(cls, metadata):
+        Table(
+            "data",
+            metadata,
+            Column("sometext", TEXT),
+            Column("testdata", TEXT),
+        )
 
-        def test_max_inner_product(self):
-            self._assert_result(
-                select(
-                    self.tables.data.c.id,
-                ).order_by(self.tables.data.c.emb.max_inner_product([1, 1, 1])),
-                [
-                    (1,),
-                    (3,),
-                    (2,),
-                ],
+    @classmethod
+    def fixtures(cls):
+        return dict(
+            data=(
+                (
+                    "sometext",
+                    "testdata",
+                ),
+                (
+                    "sometestdata",
+                    "test",
+                ),
             )
+        )
+
+    def _assert_result(self, select, result):
+        with config.db.connect() as conn:
+            eq_(conn.execute(select).fetchall(), result)
+
+    def test_concat_func(self):
+        self._assert_result(
+            select(
+                self.tables.data.c.sometext,
+            ).filter(
+                self.tables.data.c.sometext
+                == func.concat("some", self.tables.data.c.testdata, "data")
+            ),
+            [
+                ("sometestdata",),
+            ],
+        )