add support for 'startswith' and 'endswith' string comparison, fixes #47

CHANGES.rst

@@ -1,3 +1,9 @@
+0.16.0
+------
+
+* added support for new string-specific comparison operators: ``startswith``,
+  ``not startswith``, ``endswith``, ``not endswith``;
+
 0.15.4
 ------
 

README.rst

@@ -135,8 +135,14 @@ parenthesis. DjangoQL is case-sensitive.
   ``published > False`` will cause an error;
 - logical operators: ``and``, ``or``;
 - comparison operators: ``=``, ``!=``, ``<``, ``<=``, ``>``, ``>=``
-  - work as you expect. ``~`` and ``!~`` - test whether or not a string contains
-  a substring (translated into ``__icontains``);
+  - work as you expect;
+- string-specific comparison operators: ``startswith``, ``not startswith``,
+  ``endswith``, ``not endswith`` - work as you expect. Test whether or not a
+  string contains a substring: ``~`` and ``!~`` (translated into
+  ``__icontains`` under the hood).
+  Example: ``name endswith "peace" or author.last_name ~ "tolstoy"``;
+- date-specific comparison operators, compare by date part: ``~`` and ``!~``.
+  Example: ``date_published ~ "2021-11"`` - find books published in Nov, 2021;
 - test a value vs. list: ``in``, ``not in``. Example:
   ``pk in (2, 3)``.
 

djangoql/lexer.py

@@ -84,6 +84,8 @@ def find_column(self, t):
         'LESS_EQUAL',
         'CONTAINS',
         'NOT_CONTAINS',
+        'STARTSWITH',
+        'ENDSWITH',
     ]
 
     t_COMMA = ','
@@ -137,6 +139,14 @@ def t_NOT(self, t):
     def t_IN(self, t):
         return t
 
+    @TOKEN('startswith' + not_followed_by_name)
+    def t_STARTSWITH(self, t):
+        return t
+
+    @TOKEN('endswith' + not_followed_by_name)
+    def t_ENDSWITH(self, t):
+        return t
+
     @TOKEN('True' + not_followed_by_name)
     def t_TRUE(self, t):
         return t

djangoql/parser.py

@@ -92,7 +92,7 @@ def p_comparison_string(self, p):
         """
         comparison_string : comparison_equality
                           | comparison_greater_less
-                          | comparison_contains
+                          | comparison_string_specific
         """
         p[0] = p[1]
 
@@ -112,12 +112,19 @@ def p_comparison_greater_less(self, p):
         """
         p[0] = Comparison(operator=p[1])
 
-    def p_comparison_contains(self, p):
+    def p_comparison_string_specific(self, p):
         """
-        comparison_contains : CONTAINS
-                            | NOT_CONTAINS
+        comparison_string_specific : CONTAINS
+                                   | NOT_CONTAINS
+                                   | STARTSWITH
+                                   | NOT STARTSWITH
+                                   | ENDSWITH
+                                   | NOT ENDSWITH
         """
-        p[0] = Comparison(operator=p[1])
+        if len(p) == 2:
+            p[0] = Comparison(operator=p[1])
+        else:
+            p[0] = Comparison(operator='%s %s' % (p[1], p[2]))
 
     def p_comparison_in_list(self, p):
         """

djangoql/schema.py

@@ -102,13 +102,17 @@ def get_operator(self, operator):
             '<=': '__lte',
             '~': '__icontains',
             'in': '__in',
+            'startswith': '__istartswith',
+            'endswith': '__iendswith',
         }.get(operator)
         if op is not None:
             return op, False
         op = {
             '!=': '',
             '!~': '__icontains',
             'not in': '__in',
+            'not startswith': '__istartswith',
+            'not endswith': '__iendswith',
         }[operator]
         return op, True
 

djangoql/templates/djangoql/syntax_help.html

@@ -242,6 +242,26 @@ <h2 id="comparison-operators">Comparison operators</h2>
             <td>does not contain a substring</td>
             <td>username !~ "test"</td>
           </tr>
+          <tr>
+            <td>startswith</td>
+            <td>starts with a substring</td>
+            <td>last_name startswith "do"</td>
+          </tr>
+          <tr>
+            <td>not startswith</td>
+            <td>does not start with a substring</td>
+            <td>last_name not startswith "do"</td>
+          </tr>
+          <tr>
+            <td>endswith</td>
+            <td>ends with a substring</td>
+            <td>last_name endswith "oe"</td>
+          </tr>
+          <tr>
+            <td>not endswith</td>
+            <td>does not end with a substring</td>
+            <td>last_name not endswith "oe"</td>
+          </tr>
           <tr>
             <td>&gt;</td>
             <td>greater</td>
@@ -282,6 +302,11 @@ <h2 id="comparison-operators">Comparison operators</h2>
           string and date/datetime fields. A date/datetime field will be handled
           as a string one (ex., <code>payment_date ~ "2020-12-01"</code>)
         </li>
+        <li>
+          <code>startswith</code>, <code>not startswith</code>,
+          <code>endswith</code>, and <code>not endswith</code> can be applied
+          to string fields only;
+        </li>
         <li>
           <code>True</code>, <code>False</code> and <code>None</code> values can
           be combined only with <code>=</code> and <code>!=</code>;

test_project/core/tests/test_lexer.py

@@ -53,11 +53,12 @@ def test_entity_props(self):
             pass
 
     def test_reserved_words(self):
-        reserved = ('True', 'False', 'None', 'or', 'and', 'in')
+        reserved = ('True', 'False', 'None', 'or', 'and', 'in', 'not',
+                    'startswith', 'endswith')
         for word in reserved:
             self.assert_output(self.lexer.input(word), [(word.upper(), word)])
         # A word made of reserved words should be treated as a name
-        for word in ('True_story', 'not_None', 'inspect'):
+        for word in ('True_story', 'not_None', 'inspect', 'startswith_in'):
             self.assert_output(self.lexer.input(word), [('NAME', word)])
 
     def test_int(self):

test_project/core/tests/test_parser.py

@@ -42,6 +42,32 @@ def test_comparisons(self):
             self.parser.parse('job.best.title > "none"'),
         )
 
+    def test_string_comparisons(self):
+        self.assertEqual(
+            Expression(Name('name'), Comparison('~'), Const('gav')),
+            self.parser.parse('name ~ "gav"'),
+        )
+        self.assertEqual(
+            Expression(Name('name'), Comparison('!~'), Const('gav')),
+            self.parser.parse('name !~ "gav"'),
+        )
+        self.assertEqual(
+            Expression(Name('name'), Comparison('startswith'), Const('gav')),
+            self.parser.parse('name startswith "gav"'),
+        )
+        self.assertEqual(
+            Expression(Name('name'), Comparison('not startswith'), Const('rr')),
+            self.parser.parse('name not startswith "rr"'),
+        )
+        self.assertEqual(
+            Expression(Name('name'), Comparison('endswith'), Const('gav')),
+            self.parser.parse('name endswith "gav"'),
+        )
+        self.assertEqual(
+            Expression(Name('name'), Comparison('not endswith'), Const('gav')),
+            self.parser.parse('name not endswith "gav"'),
+        )
+
     def test_escaped_chars(self):
         self.assertEqual(
             Expression(Name('name'), Comparison('~'),
@@ -91,7 +117,17 @@ def test_logical(self):
         )
 
     def test_invalid_comparison(self):
-        for expr in ('foo > None', 'b <= True', 'c in False', '1 = 1', 'a > b'):
+        invalid_comparisons = (
+            'foo > None',
+            'b <= True',
+            'c in False',
+            '1 = 1',
+            'a > b',
+            'lol ~ None',
+            'gav endswith 1',
+            'nor not startswith False',
+        )
+        for expr in invalid_comparisons:
             self.assertRaises(DjangoQLParserError, self.parser.parse, expr)
 
     def test_entity_props(self):

test_project/core/tests/test_queryset.py

@@ -55,6 +55,26 @@ def test_datetime_like_query(self):
             where_clause,
         )
 
+    def test_advanced_string_comparison(self):
+        qs = Book.objects.djangoql('name ~ "war"')
+        where_clause = str(qs.query).split('WHERE')[1].strip()
+        self.assertEqual(
+            '"core_book"."name" LIKE %war% ESCAPE \'\\\'',
+            where_clause,
+        )
+        qs = Book.objects.djangoql('name startswith "war"')
+        where_clause = str(qs.query).split('WHERE')[1].strip()
+        self.assertEqual(
+            '"core_book"."name" LIKE war% ESCAPE \'\\\'',
+            where_clause,
+        )
+        qs = Book.objects.djangoql('name not endswith "peace"')
+        where_clause = str(qs.query).split('WHERE')[1].strip()
+        self.assertEqual(
+            'NOT ("core_book"."name" LIKE %peace ESCAPE \'\\\')',
+            where_clause,
+        )
+
     def test_apply_search(self):
         qs = User.objects.all()
         try: