EXISTS with columns

Author: daimor

sqlalchemy_iris/base.py

@@ -394,6 +394,12 @@ def check_constraints(cls):
 class IRISCompiler(sql.compiler.SQLCompiler):
     """IRIS specific idiosyncrasies"""
 
+    def visit_exists_unary_operator(self, element, operator, within_columns_clause=False, **kw):
+        if within_columns_clause:
+            return "(SELECT 1 WHERE EXISTS(%s))" % self.process(element.element, **kw)
+        else:
+            return "EXISTS(%s)" % self.process(element.element, **kw)
+
     def limit_clause(self, select, **kw):
         return ""
 
@@ -556,16 +562,6 @@ def order_by_clause(self, select, **kw):
         else:
             return ""
 
-    def visit_column(self, column, within_columns_clause=False, **kwargs):
-        text = super().visit_column(
-            column, within_columns_clause=within_columns_clause, **kwargs
-        )
-        if within_columns_clause:
-            return text
-        # if isinstance(column.type, sqltypes.Text):
-        #     text = "CONVERT(VARCHAR, %s)" % (text,)
-        return text
-
     def visit_concat_op_binary(self, binary, operator, **kw):
         return "STRING(%s, %s)" % (
             self.process(binary.left, **kw),

tests/test_suite.py

@@ -3,6 +3,7 @@
 from sqlalchemy.testing.suite import CTETest as _CTETest
 from sqlalchemy.testing.suite import DifficultParametersTest as _DifficultParametersTest
 from sqlalchemy.testing import fixtures
+from sqlalchemy.orm import Session
 from sqlalchemy import testing
 from sqlalchemy import Table, Column, Integer, String, select
 import pytest
@@ -28,7 +29,6 @@ class DifficultParametersTest(_DifficultParametersTest):
 
 
 class FetchLimitOffsetTest(_FetchLimitOffsetTest):
-
     def test_simple_offset_no_order(self, connection):
         table = self.tables.some_table
         self._assert_result(
@@ -55,37 +55,14 @@ def test_simple_limit_offset_no_order(self, connection, cases):
         assert_data = [(1, 1, 2), (2, 2, 3), (3, 3, 4), (4, 4, 5), (5, 4, 6)]
 
         for limit, offset in cases:
-            expected = assert_data[offset: offset + limit]
+            expected = assert_data[offset : offset + limit]
             self._assert_result(
                 connection,
                 select(table).limit(limit).offset(offset),
                 expected,
             )
 
 
-# class MiscTest(AssertsExecutionResults, AssertsCompiledSQL, fixtures.TablesTest):
-
-#     __backend__ = True
-
-#     __only_on__ = "iris"
-
-#     @classmethod
-#     def define_tables(cls, metadata):
-#         Table(
-#             "some_table",
-#             metadata,
-#             Column("id", Integer, primary_key=True),
-#             Column("x", Integer),
-#             Column("y", Integer),
-#             Column("z", String(50)),
-#         )
-
-#     # def test_compile(self):
-#     #     table = self.tables.some_table
-
-#     #     stmt = select(table.c.id, table.c.x).offset(20).limit(10)
-
-
 class TransactionTest(fixtures.TablesTest):
     __backend__ = True
 
@@ -134,3 +111,42 @@ def test_rollback(self, local_connection):
         transaction.rollback()
         result = connection.exec_driver_sql("select * from users")
         assert len(result.fetchall()) == 0
+
+
+class IRISExistsTest(fixtures.TablesTest):
+    __backend__ = True
+
+    @classmethod
+    def define_tables(cls, metadata):
+        Table(
+            "users",
+            metadata,
+            Column("user_id", Integer, primary_key=True),
+            Column("user_name", String(20)),
+            test_needs_acid=True,
+        )
+
+    @classmethod
+    def insert_data(cls, connection):
+        connection.execute(
+            cls.tables.users.insert(),
+            [
+                {"user_id": 1, "user_name": "admin"},
+            ],
+        )
+
+    def test_exists(self):
+        with config.db.connect() as conn:
+            with Session(conn) as s:
+                assert s.query(
+                    select(self.tables.users)
+                    .where(self.tables.users.c.user_name == "admin")
+                    .exists()
+                ).scalar()
+
+                assert not s.query(
+                    select(self.tables.users)
+                    .where(self.tables.users.c.user_name == "nope")
+                    .exists()
+                ).scalar()
+