Allow None to be used in dict restrictions.

Author: guzman-raphael

datajoint/condition.py

@@ -21,8 +21,9 @@ def __init__(self, operand):
 
 class AndList(list):
     """
-    A list of conditions to by applied to a query expression by logical conjunction: the conditions are AND-ed.
-    All other collections (lists, sets, other entity sets, etc) are applied by logical disjunction (OR).
+    A list of conditions to by applied to a query expression by logical conjunction: the
+    conditions are AND-ed. All other collections (lists, sets, other entity sets, etc) are
+    applied by logical disjunction (OR).
 
     Example:
     expr2 = expr & dj.AndList((cond1, cond2, cond3))
@@ -49,14 +50,16 @@ def assert_join_compatibility(expr1, expr2):
     the matching attributes in the two expressions must be in the primary key of one or the
     other expression.
     Raises an exception if not compatible.
+
     :param expr1: A QueryExpression object
     :param expr2: A QueryExpression object
     """
     from .expression import QueryExpression, U
 
     for rel in (expr1, expr2):
         if not isinstance(rel, (U, QueryExpression)):
-            raise DataJointError('Object %r is not a QueryExpression and cannot be joined.' % rel)
+            raise DataJointError(
+                'Object %r is not a QueryExpression and cannot be joined.' % rel)
     if not isinstance(expr1, U) and not isinstance(expr2, U):  # dj.U is always compatible
         try:
             raise DataJointError(
@@ -70,9 +73,11 @@ def assert_join_compatibility(expr1, expr2):
 def make_condition(query_expression, condition, columns):
     """
     Translate the input condition into the equivalent SQL condition (a string)
+
     :param query_expression: a dj.QueryExpression object to apply condition
     :param condition: any valid restriction object.
-    :param columns: a set passed by reference to collect all column names used in the condition.
+    :param columns: a set passed by reference to collect all column names used in the
+        condition.
     :return: an SQL condition string or a boolean value.
     """
     from .expression import QueryExpression, Aggregation, U
@@ -102,12 +107,13 @@ def prep_value(k, v):
     # restrict by string
     if isinstance(condition, str):
         columns.update(extract_column_names(condition))
-        return template % condition.strip().replace("%", "%%")  # escape % in strings, see issue #376
+        return template % condition.strip().replace("%", "%%")  # escape %, see issue #376
 
     # restrict by AndList
     if isinstance(condition, AndList):
         # omit all conditions that evaluate to True
-        items = [item for item in (make_condition(query_expression, cond, columns) for cond in condition)
+        items = [item for item in (make_condition(query_expression, cond, columns)
+                 for cond in condition)
                  if item is not True]
         if any(item is False for item in items):
             return negate  # if any item is False, the whole thing is False
@@ -123,18 +129,21 @@ def prep_value(k, v):
     if isinstance(condition, bool):
         return negate != condition
 
-    # restrict by a mapping such as a dict -- convert to an AndList of string equality conditions
+    # restrict by a mapping/dict -- convert to an AndList of string equality conditions
     if isinstance(condition, collections.abc.Mapping):
         common_attributes = set(condition).intersection(query_expression.heading.names)
         if not common_attributes:
             return not negate  # no matching attributes -> evaluates to True
         columns.update(common_attributes)
         return template % ('(' + ') AND ('.join(
-            '`%s`=%s' % (k, prep_value(k, condition[k])) for k in common_attributes) + ')')
+            '`%s`%s' % (k, ' IS NULL' if condition[k] is None
+                        else f'={prep_value(k, condition[k])}')
+            for k in common_attributes) + ')')
 
     # restrict by a numpy record -- convert to an AndList of string equality conditions
     if isinstance(condition, numpy.void):
-        common_attributes = set(condition.dtype.fields).intersection(query_expression.heading.names)
+        common_attributes = set(condition.dtype.fields).intersection(
+            query_expression.heading.names)
         if not common_attributes:
             return not negate   # no matching attributes -> evaluate to True
         columns.update(common_attributes)
@@ -154,7 +163,8 @@ def prep_value(k, v):
     if isinstance(condition, QueryExpression):
         if check_compatibility:
             assert_join_compatibility(query_expression, condition)
-        common_attributes = [q for q in condition.heading.names if q in query_expression.heading.names]
+        common_attributes = [q for q in condition.heading.names
+                             if q in query_expression.heading.names]
         columns.update(common_attributes)
         if isinstance(condition, Aggregation):
             condition = condition.make_subquery()
@@ -176,15 +186,17 @@ def prep_value(k, v):
     except TypeError:
         raise DataJointError('Invalid restriction type %r' % condition)
     else:
-        or_list = [item for item in or_list if item is not False]  # ignore all False conditions
-        if any(item is True for item in or_list):  # if any item is True, the whole thing is True
+        or_list = [item for item in or_list if item is not False]  # ignore False conditions
+        if any(item is True for item in or_list):  # if any item is True, entirely True
             return not negate
-        return template % ('(%s)' % ' OR '.join(or_list)) if or_list else negate  # an empty or list is False
+        return template % ('(%s)' % ' OR '.join(or_list)) if or_list else negate
 
 
 def extract_column_names(sql_expression):
     """
-    extract all presumed column names from an sql expression such as the WHERE clause, for example.
+    extract all presumed column names from an sql expression such as the WHERE clause,
+    for example.
+
     :param sql_expression: a string containing an SQL expression
     :return: set of extracted column names
     This may be MySQL-specific for now.

tests/test_relational_operand.py

@@ -470,3 +470,13 @@ def test_complex_date_restriction():
         q = OutfitLaunch & '`day` between curdate() - interval 30 day and curdate()'
         assert len(q) == 1
         q.delete()
+
+    @staticmethod
+    def test_null_dict_restriction():
+        # https://github.com/datajoint/datajoint-python/issues/824
+        """Test a restriction for null using dict"""
+        F.insert([dict(id=5)])
+        q = F & 'date is NULL'
+        assert len(q) == 1
+        q = F & dict(date=None)
+        assert len(q) == 1