SQLAlchemy DQL: Use CrateDB's native ILIKE operator only on >= 4.1.0

src/crate/client/sqlalchemy/compiler.py

@@ -248,7 +248,10 @@ def visit_ilike_case_insensitive_operand(self, element, **kw):
  """
  Use native `ILIKE` operator, like PostgreSQL's `PGCompiler`.
  """
- return element.element._compiler_dispatch(self, **kw)
+ if self.dialect.has_ilike_operator():
+ return element.element._compiler_dispatch(self, **kw)
+ else:
+ return super().visit_ilike_case_insensitive_operand(element, **kw)
 
  def visit_ilike_op_binary(self, binary, operator, **kw):
  """
@@ -259,10 +262,13 @@ def visit_ilike_op_binary(self, binary, operator, **kw):
  """
  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),
- )
+ if self.dialect.has_ilike_operator():
+ return "%s ILIKE %s" % (
+ self.process(binary.left, **kw),
+ self.process(binary.right, **kw),
+ )
+ else:
+ return super().visit_ilike_op_binary(binary, operator, **kw)
 
  def visit_not_ilike_op_binary(self, binary, operator, **kw):
  """
@@ -273,10 +279,13 @@ def visit_not_ilike_op_binary(self, binary, operator, **kw):
  """
  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),
- )
+ if self.dialect.has_ilike_operator():
+ return "%s NOT ILIKE %s" % (
+ self.process(binary.left, **kw),
+ self.process(binary.right, **kw),
+ )
+ else:
+ return super().visit_not_ilike_op_binary(binary, operator, **kw)
 
  def limit_clause(self, select, **kw):
  """

src/crate/client/sqlalchemy/dialect.py

@@ -356,6 +356,13 @@ def _create_column_info(self, row):
  def _resolve_type(self, type_):
  return TYPES_MAP.get(type_, sqltypes.UserDefinedType)
 
+ def has_ilike_operator(self):
+ """
+ Only CrateDB 4.1.0 and higher implements the `ILIKE` operator.
+ """
+ server_version_info = self.server_version_info
+ return server_version_info is not None and server_version_info >= (4, 1, 0)
+
 
 class DateTrunc(functions.GenericFunction):
  name = "date_trunc"

src/crate/client/sqlalchemy/tests/__init__.py

@@ -2,6 +2,7 @@
 
 from ..compat.api13 import monkeypatch_amend_select_sa14, monkeypatch_add_connectionfairy_driver_connection
 from ..sa_version import SA_1_4, SA_VERSION
+from ...test_util import ParametrizedTestCase
 
 # `sql.select()` of SQLAlchemy 1.3 uses old calling semantics,
 # but the test cases already need the modern ones.
@@ -32,6 +33,9 @@ def test_suite_unit():
  tests.addTest(makeSuite(SqlAlchemyDictTypeTest))
  tests.addTest(makeSuite(SqlAlchemyDateAndDateTimeTest))
  tests.addTest(makeSuite(SqlAlchemyCompilerTest))
+ tests.addTest(ParametrizedTestCase.parametrize(SqlAlchemyCompilerTest, param={"server_version_info": None}))
+ tests.addTest(ParametrizedTestCase.parametrize(SqlAlchemyCompilerTest, param={"server_version_info": (4, 0, 12)}))
+ tests.addTest(ParametrizedTestCase.parametrize(SqlAlchemyCompilerTest, param={"server_version_info": (4, 1, 10)}))
  tests.addTest(makeSuite(SqlAlchemyUpdateTest))
  tests.addTest(makeSuite(SqlAlchemyMatchTest))
  tests.addTest(makeSuite(SqlAlchemyCreateTableTest))

src/crate/client/sqlalchemy/tests/compiler_test.py

@@ -19,7 +19,7 @@
 # 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 unittest import mock, skipIf
 
 from crate.client.sqlalchemy.compiler import crate_before_execute
 
@@ -28,12 +28,16 @@
 
 from crate.client.sqlalchemy.sa_version import SA_VERSION, SA_1_4, SA_2_0
 from crate.client.sqlalchemy.types import ObjectType
+from crate.client.test_util import ParametrizedTestCase
 
 
-class SqlAlchemyCompilerTest(TestCase):
+class SqlAlchemyCompilerTest(ParametrizedTestCase):
 
  def setUp(self):
  self.crate_engine = sa.create_engine('crate://')
+ if isinstance(self.param, dict) and "server_version_info" in self.param:
+ server_version_info = self.param["server_version_info"]
+ self.crate_engine.dialect.server_version_info = server_version_info
  self.sqlite_engine = sa.create_engine('sqlite://')
  self.metadata = sa.MetaData()
  self.mytable = sa.Table('mytable', self.metadata,
@@ -71,25 +75,32 @@ def test_bulk_update_on_builtin_type(self):
 
  self.assertFalse(hasattr(clauseelement, '_crate_specific'))
 
- def test_select_with_ilike(self):
+ def test_select_with_ilike_no_escape(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
+ if self.crate_engine.dialect.has_ilike_operator():
+ self.assertEqual(statement, dedent("""
+ SELECT mytable.name, mytable.data 
+ FROM mytable 
+ WHERE mytable.name ILIKE ?
+ """).strip()) # noqa: W291
+ else:
+ self.assertEqual(statement, dedent("""
+ SELECT mytable.name, mytable.data 
+ FROM mytable 
+ WHERE lower(mytable.name) LIKE lower(?)
+ """).strip()) # noqa: W291
 
- def test_select_with_not_ilike(self):
+ def test_select_with_not_ilike_no_escape(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:
+ if SA_VERSION < SA_1_4 or not self.crate_engine.dialect.has_ilike_operator():
  self.assertEqual(statement, dedent("""
  SELECT mytable.name, mytable.data 
  FROM mytable 

src/crate/client/test_util.py

@@ -18,6 +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.
+import unittest
 
 
 class ClientMocked(object):
@@ -42,3 +43,27 @@ def set_next_server_infos(self, server, server_name, version):
 
  def close(self):
  pass
+
+
+class ParametrizedTestCase(unittest.TestCase):
+ """
+ TestCase classes that want to be parametrized should
+ inherit from this class.
+
+ https://eli.thegreenplace.net/2011/08/02/python-unit-testing-parametrized-test-cases
+ """
+ def __init__(self, methodName="runTest", param=None):
+ super(ParametrizedTestCase, self).__init__(methodName)
+ self.param = param
+
+ @staticmethod
+ def parametrize(testcase_klass, param=None):
+ """ Create a suite containing all tests taken from the given
+ subclass, passing them the parameter 'param'.
+ """
+ testloader = unittest.TestLoader()
+ testnames = testloader.getTestCaseNames(testcase_klass)
+ suite = unittest.TestSuite()
+ for name in testnames:
+ suite.addTest(testcase_klass(name, param=param))
+ return suite