remove None exception in IN

Fixed SQL composition bug which impacted caching where using a ``None``
value inside of an ``in_()`` expression would bypass the usual "expanded
bind parameter" logic used by the IN construct, which allows proper caching
to take place.

Fixes: #12314
References: #12312
Change-Id: I0d2fc4e15c73407379ba368dd4ee32660fc66259
(cherry picked from commit 79505b03b61f622615be2d2bc1434671c29b0cc5)

diff --git a/doc/build/changelog/unreleased_20/12314.rst b/doc/build/changelog/unreleased_20/12314.rst
new file mode 100644 (file)
index 0000000..6d5e83a
--- /dev/null
+++ b/doc/build/changelog/unreleased_20/12314.rst
@@ -0,0 +1,9 @@
+.. change::
+    :tags: bug, sql
+    :tickets: 12314
+
+    Fixed SQL rendering bug which impacted caching where using a ``None`` value
+    inside of an ``in_()`` expression would bypass the usual "expanded bind
+    parameter" logic used by the IN construct, which allows proper caching to
+    take place.
+

diff --git a/lib/sqlalchemy/sql/coercions.py b/lib/sqlalchemy/sql/coercions.py
index 123b5c556e1b8310302ccfa74053f3e2cb39599e..802ce75700ba13926fc673df12fbe0c8160e1249 100644 (file)
--- a/lib/sqlalchemy/sql/coercions.py
+++ b/lib/sqlalchemy/sql/coercions.py
@@ -859,8 +859,6 @@ class InElementImpl(RoleImpl):
 
                     else:
                         non_literal_expressions[o] = o
-                elif o is None:
-                    non_literal_expressions[o] = elements.Null()
 
             if non_literal_expressions:
                 return elements.ClauseList(

diff --git a/test/dialect/mssql/test_compiler.py b/test/dialect/mssql/test_compiler.py
index 59b13b91e0b5be53616b2cf4f449ec366d16bd02..eb4dba0a079683ea06ed3f7a20fc7e395adf2aff 100644 (file)
--- a/test/dialect/mssql/test_compiler.py
+++ b/test/dialect/mssql/test_compiler.py
@@ -393,7 +393,11 @@ class CompileTest(fixtures.TestBase, AssertsCompiledSQL):
                 "check_post_param": {},
             },
         ),
-        (lambda t: t.c.foo.in_([None]), "sometable.foo IN (NULL)", {}),
+        (
+            lambda t: t.c.foo.in_([None]),
+            "sometable.foo IN (__[POSTCOMPILE_foo_1])",
+            {},
+        ),
     )
     def test_strict_binds(self, expr, compiled, kw):
         """test the 'strict' compiler binds."""

diff --git a/test/sql/test_compare.py b/test/sql/test_compare.py
index 88ac3c315ed5960e7699945fd066e0800e54c32f..1adfdbf14d7320dda434d77c98f66f481bbd8d4d 100644 (file)
--- a/test/sql/test_compare.py
+++ b/test/sql/test_compare.py
@@ -1248,6 +1248,23 @@ class CacheKeyTest(fixtures.CacheKeyFixture, CoreFixtures, fixtures.TestBase):
         is_true(c1._generate_cache_key() != c3._generate_cache_key())
         is_false(c1._generate_cache_key() == c3._generate_cache_key())
 
+    def test_in_with_none(self):
+        """test #12314"""
+
+        def fixture():
+            elements = list(
+                random_choices([1, 2, None, 3, 4], k=random.randint(1, 7))
+            )
+
+            # slight issue.  if the first element is None and not an int,
+            # the type of the BindParameter goes from Integer to Nulltype.
+            # but if we set the left side to be Integer then it comes from
+            # that side, and the vast majority of in_() use cases come from
+            # a typed column expression, so this is fine
+            return (column("x", Integer).in_(elements),)
+
+        self._run_cache_key_fixture(fixture, False)
+
     def test_cache_key(self):
         for fixtures_, compare_values in [
             (self.fixtures, True),

diff --git a/test/sql/test_operators.py b/test/sql/test_operators.py
index 8afe091925ae7f21a4b4ba708eea4287a29fdd82..8ef260a179fb268f173a326df5b17a724982a593 100644 (file)
--- a/test/sql/test_operators.py
+++ b/test/sql/test_operators.py
@@ -2330,8 +2330,23 @@ class InTest(fixtures.TestBase, testing.AssertsCompiledSQL):
         )
 
     def test_in_28(self):
+        """revised to test #12314"""
         self.assert_compile(
-            self.table1.c.myid.in_([None]), "mytable.myid IN (NULL)"
+            self.table1.c.myid.in_([None]),
+            "mytable.myid IN (__[POSTCOMPILE_myid_1])",
+        )
+
+    @testing.combinations(
+        [1, 2, None, 3],
+        [None, None, None],
+        [None, 2, 3, 3],
+    )
+    def test_in_null_combinations(self, expr):
+        """test #12314"""
+
+        self.assert_compile(
+            self.table1.c.myid.in_(expr),
+            "mytable.myid IN (__[POSTCOMPILE_myid_1])",
         )
 
     @testing.combinations(True, False)