Merge pull request datastax#942 from datastax/python-968-2

PYTHON-968: Support IS NOT NULL operator in cqlengine

Author: beltran

CHANGELOG.rst

@@ -6,6 +6,7 @@ Features
 * Add one() function to the ResultSet API (PYTHON-947)
 * Create an utility function to fetch concurrently many keys from the same replica (PYTHON-647)
 * Allow filter queries with fields that have an index managed outside of cqlengine (PYTHON-966)
+* Support IS NOT NULL operator in cqlengine (PYTHON-968)
 
 Other
 -----

cassandra/cqlengine/operators.py

@@ -98,3 +98,8 @@ class ContainsOperator(EqualsOperator):
 class LikeOperator(EqualsOperator):
     symbol = "LIKE"
     cql_symbol = 'LIKE'
+
+
+class IsNotNullOperator(EqualsOperator):
+    symbol = "IS NOT NULL"
+    cql_symbol = 'IS NOT NULL'

cassandra/cqlengine/statements.py

@@ -21,7 +21,7 @@
 from cassandra.cqlengine import columns
 from cassandra.cqlengine import UnicodeMixin
 from cassandra.cqlengine.functions import QueryValue
-from cassandra.cqlengine.operators import BaseWhereOperator, InOperator, EqualsOperator
+from cassandra.cqlengine.operators import BaseWhereOperator, InOperator, EqualsOperator, IsNotNullOperator
 
 
 class StatementException(Exception):
@@ -138,6 +138,24 @@ def update_context(self, ctx):
             self.query_value.update_context(ctx)
 
 
+class IsNotNullClause(WhereClause):
+    def __init__(self, field):
+        super(IsNotNullClause, self).__init__(field, IsNotNullOperator(), '')
+
+    def __unicode__(self):
+        field = ('"{0}"' if self.quote_field else '{0}').format(self.field)
+        return u'{0} {1}'.format(field, self.operator)
+
+    def update_context(self, ctx):
+        pass
+
+    def get_context_size(self):
+        return 0
+
+# alias for convenience
+IsNotNull = IsNotNullClause
+
+
 class AssignmentClause(BaseClause):
     """ a single variable st statement """
 

docs/cqlengine/queryset.rst

@@ -199,6 +199,14 @@ In addition to simple equal to queries, cqlengine also supports querying with ot
 
         q = Automobile.objects.filter(model__like='%Civic%').allow_filtering()
 
+:attr:`IS NOT NULL (IsNotNull(column_name)) <query.QueryOperator.IsNotNullOperator>`
+
+    The IS NOT NULL operator is not yet supported for C*.
+
+    .. code-block:: python
+
+        q = Automobile.objects.filter(IsNotNull('model'))
+
     Limitations:
     - Currently, cqlengine does not support SASI index creation. To use this feature,
       you need to create the SASI index using the core driver.

tests/integration/cqlengine/operators/__init__.py

@@ -11,3 +11,10 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+
+from cassandra.cqlengine.operators import BaseWhereOperator
+
+
+def check_lookup(test_case, symbol, expected):
+    op = BaseWhereOperator.get_operator(symbol)
+    test_case.assertEqual(op, expected)

tests/integration/cqlengine/operators/test_where_operators.py

@@ -12,30 +12,41 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from unittest import TestCase
+try:
+    import unittest2 as unittest
+except ImportError:
+    import unittest  # noqa
+
 from cassandra.cqlengine.operators import *
 
+from uuid import uuid4
+
+from cassandra.cqlengine.management import sync_table, drop_table
+from cassandra.cqlengine.operators import IsNotNullOperator
+from cassandra.cqlengine.statements import IsNotNull
+from cassandra import InvalidRequest
+
+from tests.integration.cqlengine.base import TestQueryUpdateModel, BaseCassEngTestCase
+from tests.integration.cqlengine.operators import check_lookup
+from tests.integration import greaterthanorequalcass30
+
 import six
 
 
-class TestWhereOperators(TestCase):
+class TestWhereOperators(unittest.TestCase):
 
     def test_symbol_lookup(self):
         """ tests where symbols are looked up properly """
 
-        def check_lookup(symbol, expected):
-            op = BaseWhereOperator.get_operator(symbol)
-            self.assertEqual(op, expected)
-
-        check_lookup('EQ', EqualsOperator)
-        check_lookup('NE', NotEqualsOperator)
-        check_lookup('IN', InOperator)
-        check_lookup('GT', GreaterThanOperator)
-        check_lookup('GTE', GreaterThanOrEqualOperator)
-        check_lookup('LT', LessThanOperator)
-        check_lookup('LTE', LessThanOrEqualOperator)
-        check_lookup('CONTAINS', ContainsOperator)
-        check_lookup('LIKE', LikeOperator)
+        check_lookup(self, 'EQ', EqualsOperator)
+        check_lookup(self, 'NE', NotEqualsOperator)
+        check_lookup(self, 'IN', InOperator)
+        check_lookup(self, 'GT', GreaterThanOperator)
+        check_lookup(self, 'GTE', GreaterThanOrEqualOperator)
+        check_lookup(self, 'LT', LessThanOperator)
+        check_lookup(self, 'LTE', LessThanOrEqualOperator)
+        check_lookup(self, 'CONTAINS', ContainsOperator)
+        check_lookup(self, 'LIKE', LikeOperator)
 
     def test_operator_rendering(self):
         """ tests symbols are rendered properly """
@@ -48,3 +59,56 @@ def test_operator_rendering(self):
         self.assertEqual("<=", six.text_type(LessThanOrEqualOperator()))
         self.assertEqual("CONTAINS", six.text_type(ContainsOperator()))
         self.assertEqual("LIKE", six.text_type(LikeOperator()))
+
+
+class TestIsNotNull(BaseCassEngTestCase):
+    def test_is_not_null_to_cql(self):
+        """
+        Verify that IsNotNull is converted correctly to CQL
+
+        @since 2.5
+        @jira_ticket PYTHON-968
+        @expected_result the strings match
+
+        @test_category cqlengine
+        """
+
+        check_lookup(self, 'IS NOT NULL', IsNotNullOperator)
+
+        # The * is not expanded because there are no referred fields
+        self.assertEqual(
+            str(TestQueryUpdateModel.filter(IsNotNull("text")).limit(2)),
+            'SELECT * FROM cqlengine_test.test_query_update_model WHERE "text" IS NOT NULL LIMIT 2'
+        )
+
+        # We already know partition so cqlengine doesn't query for it
+        self.assertEqual(
+            str(TestQueryUpdateModel.filter(IsNotNull("text"), partition=uuid4())),
+            ('SELECT "cluster", "count", "text", "text_set", '
+             '"text_list", "text_map" FROM cqlengine_test.test_query_update_model '
+             'WHERE "text" IS NOT NULL AND "partition" = %(0)s LIMIT 10000')
+        )
+
+    @greaterthanorequalcass30
+    def test_is_not_null_execution(self):
+        """
+        Verify that CQL statements have correct syntax when executed
+        If we wanted them to return something meaningful and not a InvalidRequest
+        we'd have to create an index in search for the column we are using
+        IsNotNull
+
+        @since 2.5
+        @jira_ticket PYTHON-968
+        @expected_result InvalidRequest is arisen
+
+        @test_category cqlengine
+        """
+        sync_table(TestQueryUpdateModel)
+        self.addCleanup(drop_table, TestQueryUpdateModel)
+
+        # Raises InvalidRequest instead of dse.protocol.SyntaxException
+        with self.assertRaises(InvalidRequest):
+            list(TestQueryUpdateModel.filter(IsNotNull("text")))
+
+        with self.assertRaises(InvalidRequest):
+            list(TestQueryUpdateModel.filter(IsNotNull("text"), partition=uuid4()))