Do not special-case JSONB contains for scalar keys.

Previously, passing a string/int/bool to BinaryJSONField.contains()
would silently switch to using the EXISTS (?) operator to test for a
key. This is somewhat bad behavior (#2984) and so the special-case is
removed.

For the old behavior of testing for presence of a key/item at the
top-level, you should use the .has_key() method instead.

Author: coleifer

playhouse/postgres_ext.py

@@ -85,10 +85,10 @@ def concat(self, rhs):
         return Expression(self.as_json(True), OP.CONCAT, rhs)
 
     def contains(self, other):
-        clone = self.as_json(True)
-        if isinstance(other, (list, dict)):
-            return Expression(clone, JSONB_CONTAINS, Json(other))
-        return Expression(clone, JSONB_EXISTS, other)
+        return Expression(self.as_json(True), JSONB_CONTAINS, Json(other))
+
+    def contained_by(self, other):
+        return Expression(self.as_json(True), JSONB_CONTAINED_BY, Json(other))
 
     def contains_any(self, *keys):
         return Expression(
@@ -332,11 +332,9 @@ class BinaryJSONField(IndexedFieldMixin, JSONField):
     __hash__ = Field.__hash__
 
     def contains(self, other):
-        if isinstance(other, (list, dict)):
-            return Expression(self, JSONB_CONTAINS, Json(other))
-        elif isinstance(other, JSONField):
+        if isinstance(other, JSONField):
             return Expression(self, JSONB_CONTAINS, other)
-        return Expression(cast_jsonb(self), JSONB_EXISTS, other)
+        return Expression(self, JSONB_CONTAINS, Json(other))
 
     def contained_by(self, other):
         return Expression(cast_jsonb(self), JSONB_CONTAINED_BY, Json(other))

tests/postgres_helpers.py

@@ -207,7 +207,7 @@ def test_subscript_contains(self):
 
         # 'k3' is mapped to another dictioary {'k4': [...]}. Therefore,
         # 'k3' is said to contain 'k4', but *not* ['k4'] or ['k4', 'k5'].
-        self.assertObjects(D['k3'].contains('k4'), 0)
+        self.assertObjects(D['k3'].has_key('k4'), 0)
         self.assertObjects(D['k3'].contains(['k4']))
         self.assertObjects(D['k3'].contains(['k4', 'k5']))
 
@@ -235,7 +235,8 @@ def test_subscript_contains(self):
         self.assertObjects(D['k4'].contains_all('i1', 'i2'), 2)
 
         # Check array indexes.
-        self.assertObjects(D[2].contains('a3'), 1)
+        self.assertObjects(D[2].has_key('a3'), 1)
+        self.assertObjects(D[2].contains('a3'))
         self.assertObjects(D[0].contains('a1'), 1)
         self.assertObjects(D[0].contains('k1'))
 
@@ -244,9 +245,10 @@ def test_contains(self):
         D = self.M.data
 
         # Test for keys. 'k4' is both an object key and an array element.
-        self.assertObjects(D.contains('k4'), 2, 5)
-        self.assertObjects(D.contains('a1'), 1, 2)
-        self.assertObjects(D.contains('k3'), 0)
+        self.assertObjects(D.has_key('k4'), 2, 5)
+        self.assertObjects(D.has_key('a1'), 1, 2)
+        self.assertObjects(D.contains('a1'), 1)
+        self.assertObjects(D.has_key('k3'), 0)
 
         # We can test for multiple top-level keys/indexes.
         self.assertObjects(D.contains_all('a1', 'a2'), 1, 2)
@@ -265,8 +267,9 @@ def test_contains(self):
         self.assertObjects(D.contains([{'a3': 'a4'}]), 1)
 
         # Check for simple keys.
-        self.assertObjects(D.contains('a1'), 1, 2)
-        self.assertObjects(D.contains('k3'), 0)
+        self.assertObjects(D.contains(['a1']), 1)
+        self.assertObjects(D.contains('a1'), 1)
+        self.assertObjects(D.contains('k3'))
 
         # Contains any.
         self.assertObjects(D.contains_any('a1', 'k1'), 0, 1, 2, 5)