SQLAlchemy DQL: Use CrateDB's native ILIKE operator

amotl · amotl · commit 4de4c9f5a6d6 · 2023-07-17T10:13:46.000-07:00
Instead of using SA's generic implementation `lower() LIKE lower()`, use
CrateDB's native one.
diff --git a/CHANGES.txt b/CHANGES.txt
@@ -8,6 +8,9 @@ Unreleased
 - SQLAlchemy: Rename leftover occurrences of ``Object``. The new symbol to represent
   CrateDB's ``OBJECT`` column type is now ``ObjectType``.
 
+- SQLAlchemy DQL: Use CrateDB's native ``ILIKE`` operator instead of using SA's
+  generic implementation ``lower() LIKE lower()``. Thanks, @hlcianfagna.
+
 
 2023/07/06 0.32.0
 =================
diff --git a/src/crate/client/sqlalchemy/compiler.py b/src/crate/client/sqlalchemy/compiler.py
@@ -244,6 +244,40 @@ def visit_any(self, element, **kw):
             self.process(element.right, **kw)
         )
 
+    def visit_ilike_case_insensitive_operand(self, element, **kw):
+        """
+        Use native `ILIKE` operator, like PostgreSQL's `PGCompiler`.
+        """
+        return element.element._compiler_dispatch(self, **kw)
+
+    def visit_ilike_op_binary(self, binary, operator, **kw):
+        """
+        Use native `ILIKE` operator, like PostgreSQL's `PGCompiler`.
+
+        Do not implement the `ESCAPE` functionality, because it is not
+        supported by CrateDB.
+        """
+        if binary.modifiers.get("escape", None) is not None:
+            raise NotImplementedError("Unsupported feature: ESCAPE is not supported")
+        return "%s ILIKE %s" % (
+            self.process(binary.left, **kw),
+            self.process(binary.right, **kw),
+        )
+
+    def visit_not_ilike_op_binary(self, binary, operator, **kw):
+        """
+        Use native `ILIKE` operator, like PostgreSQL's `PGCompiler`.
+
+        Do not implement the `ESCAPE` functionality, because it is not
+        supported by CrateDB.
+        """
+        if binary.modifiers.get("escape", None) is not None:
+            raise NotImplementedError("Unsupported feature: ESCAPE is not supported")
+        return "%s NOT ILIKE %s" % (
+            self.process(binary.left, **kw),
+            self.process(binary.right, **kw),
+        )
+
     def limit_clause(self, select, **kw):
         """
         Generate OFFSET / LIMIT clause, PostgreSQL-compatible.
diff --git a/src/crate/client/sqlalchemy/tests/compiler_test.py b/src/crate/client/sqlalchemy/tests/compiler_test.py
@@ -18,7 +18,7 @@
 # However, if you have executed another commercial license agreement
 # with Crate these terms will supersede the license and you may use the
 # software solely pursuant to the terms of the relevant commercial agreement.
-
+from textwrap import dedent
 from unittest import mock, TestCase, skipIf
 
 from crate.client.sqlalchemy.compiler import crate_before_execute
@@ -71,6 +71,58 @@ def test_bulk_update_on_builtin_type(self):
 
         self.assertFalse(hasattr(clauseelement, '_crate_specific'))
 
+    def test_select_with_ilike(self):
+        """
+        Verify the compiler uses CrateDB's native `ILIKE` method.
+        """
+        selectable = self.mytable.select().where(self.mytable.c.name.ilike("%foo%"))
+        statement = str(selectable.compile(bind=self.crate_engine))
+        self.assertEqual(statement, dedent("""
+            SELECT mytable.name, mytable.data 
+            FROM mytable 
+            WHERE mytable.name ILIKE ?
+        """).strip())  # noqa: W291
+
+    def test_select_with_not_ilike(self):
+        """
+        Verify the compiler uses CrateDB's native `ILIKE` method.
+        """
+        selectable = self.mytable.select().where(self.mytable.c.name.notilike("%foo%"))
+        statement = str(selectable.compile(bind=self.crate_engine))
+        if SA_VERSION < SA_1_4:
+            self.assertEqual(statement, dedent("""
+                SELECT mytable.name, mytable.data 
+                FROM mytable 
+                WHERE lower(mytable.name) NOT LIKE lower(?)
+            """).strip())  # noqa: W291
+        else:
+            self.assertEqual(statement, dedent("""
+                SELECT mytable.name, mytable.data 
+                FROM mytable 
+                WHERE mytable.name NOT ILIKE ?
+            """).strip())  # noqa: W291
+
+    def test_select_with_ilike_and_escape(self):
+        """
+        Verify the compiler fails when using CrateDB's native `ILIKE` method together with `ESCAPE`.
+        """
+
+        selectable = self.mytable.select().where(self.mytable.c.name.ilike("%foo%", escape='\\'))
+        with self.assertRaises(NotImplementedError) as cmex:
+            selectable.compile(bind=self.crate_engine)
+        self.assertEqual(str(cmex.exception), "Unsupported feature: ESCAPE is not supported")
+
+    @skipIf(SA_VERSION < SA_1_4, "SQLAlchemy 1.3 and earlier do not support native `NOT ILIKE` compilation")
+    def test_select_with_not_ilike_and_escape(self):
+        """
+        Verify the compiler fails when using CrateDB's native `ILIKE` method together with `ESCAPE`.
+        """
+
+        selectable = self.mytable.select().where(self.mytable.c.name.notilike("%foo%", escape='\\'))
+        with self.assertRaises(NotImplementedError) as cmex:
+            selectable.compile(bind=self.crate_engine)
+        self.assertEqual(str(cmex.exception), "Unsupported feature: ESCAPE is not supported")
+
     def test_select_with_offset(self):
         """
         Verify the `CrateCompiler.limit_clause` method, with offset.
