fix: contains filter, add endswith filter

* `__contains` now works in a more intuitive manner (the previous behaviour remains the default for `=` shortcut queries and can be requested explicitly with `__content`)
* `__endswith` is now supported as the logical counterpart to `__startswith`

Thanks to @antonyr for the patch and @sebslomski for code review and testing.

Author: antonyr

AUTHORS

@@ -113,3 +113,4 @@ Thanks to
     * Gilad Beeri (@giladbeeri) for adding retries when updating a backend
     * Arjen Verstoep (@terr) for a patch that allows attribute lookups through Django ManyToManyField relationships
     * Tim Babych (@tymofij) for enabling backend-specific parameters in ``.highlight()``
+    * Antony Raj (@antonyr) for adding endswith input type and fixing contains input type

docs/searchqueryset_api.rst

@@ -817,6 +817,7 @@ Field Lookups
 
 The following lookup types are supported:
 
+* content
 * contains
 * exact
 * gt
@@ -825,6 +826,7 @@ The following lookup types are supported:
 * lte
 * in
 * startswith
+* endswith
 * range
 * fuzzy
 
@@ -843,10 +845,10 @@ The actual behavior of these lookups is backend-specific.
 
 .. warning::
 
-    The ``contains`` filter became the new default filter as of Haystack v2.X
+    The ``content`` filter became the new default filter as of Haystack v2.X
     (the default in Haystack v1.X was ``exact``). This changed because ``exact``
     caused problems and was unintuitive for new people trying to use Haystack.
-    ``contains`` is a much more natural usage.
+    ``content`` is a much more natural usage.
 
     If you had an app built on Haystack v1.X & are upgrading, you'll need to
     sanity-check & possibly change any code that was relying on the default.
@@ -858,7 +860,7 @@ Example::
     SearchQuerySet().filter(content='foo')
 
     # Identical to:
-    SearchQuerySet().filter(content__contains='foo')
+    SearchQuerySet().filter(content__content='foo')
 
     # Phrase matching.
     SearchQuerySet().filter(content__exact='hello world')

haystack/backends/__init__.py

@@ -401,9 +401,8 @@ def split_expression(self, expression):
         """Parses an expression and determines the field and filter type."""
         parts = expression.split(FILTER_SEPARATOR)
         field = parts[0]
-
         if len(parts) == 1 or parts[-1] not in VALID_FILTERS:
-            filter_type = 'contains'
+            filter_type = 'content'
         else:
             filter_type = parts.pop()
 

haystack/backends/elasticsearch_backend.py

@@ -802,7 +802,9 @@ def build_query_fragment(self, field, filter_type, value):
             index_fieldname = u'%s:' % connections[self._using].get_unified_index().get_index_fieldname(field)
 
         filter_types = {
-            'contains': u'%s',
+            'content': u'%s',
+            'contains': u'*%s*',
+            'endswith': u'*%s',
             'startswith': u'%s*',
             'exact': u'%s',
             'gt': u'{%s TO *}',
@@ -815,7 +817,7 @@ def build_query_fragment(self, field, filter_type, value):
         if value.post_process is False:
             query_frag = prepared_value
         else:
-            if filter_type in ['contains', 'startswith', 'fuzzy']:
+            if filter_type in ['content', 'contains', 'startswith', 'endswith', 'fuzzy']:
                 if value.input_type_name == 'exact':
                     query_frag = prepared_value
                 else:

haystack/backends/solr_backend.py

@@ -571,7 +571,9 @@ def build_query_fragment(self, field, filter_type, value):
             index_fieldname = u'%s:' % connections[self._using].get_unified_index().get_index_fieldname(field)
 
         filter_types = {
-            'contains': u'%s',
+            'content': u'%s',
+            'contains': u'*%s*',
+            'endswith': u'*%s',
             'startswith': u'%s*',
             'exact': u'%s',
             'gt': u'{%s TO *}',
@@ -584,7 +586,7 @@ def build_query_fragment(self, field, filter_type, value):
         if value.post_process is False:
             query_frag = prepared_value
         else:
-            if filter_type in ['contains', 'startswith', 'fuzzy']:
+            if filter_type in ['content', 'contains', 'startswith', 'endswith', 'fuzzy']:
                 if value.input_type_name == 'exact':
                     query_frag = prepared_value
                 else:

haystack/backends/whoosh_backend.py

@@ -813,7 +813,9 @@ def build_query_fragment(self, field, filter_type, value):
             index_fieldname = u'%s:' % connections[self._using].get_unified_index().get_index_fieldname(field)
 
         filter_types = {
-            'contains': '%s',
+            'content': '%s',
+            'contains': '*%s*',
+            'endswith': "*%s",
             'startswith': "%s*",
             'exact': '%s',
             'gt': "{%s to}",
@@ -826,7 +828,7 @@ def build_query_fragment(self, field, filter_type, value):
         if value.post_process is False:
             query_frag = prepared_value
         else:
-            if filter_type in ['contains', 'startswith', 'fuzzy']:
+            if filter_type in ['content', 'contains', 'startswith', 'endswith', 'fuzzy']:
                 if value.input_type_name == 'exact':
                     query_frag = prepared_value
                 else:

haystack/constants.py

@@ -19,7 +19,8 @@
 FUZZY_MAX_EXPANSIONS = getattr(settings, 'HAYSTACK_FUZZY_MAX_EXPANSIONS', 50)
 
 # Valid expression extensions.
-VALID_FILTERS = set(['contains', 'exact', 'gt', 'gte', 'lt', 'lte', 'in', 'startswith', 'range', 'fuzzy'])
+VALID_FILTERS = set(['contains', 'exact', 'gt', 'gte', 'lt', 'lte', 'in', 'startswith', 'range', 'endswith', 'content', 'fuzzy'])
+
 FILTER_SEPARATOR = '__'
 
 # The maximum number of items to display in a SearchQuerySet.__repr__

test_haystack/elasticsearch_tests/test_elasticsearch_backend.py

@@ -851,7 +851,7 @@ def test_auto_query(self):
         # This will break horrifically if escaping isn't working.
         sqs = self.sqs.auto_query('"pants:rule"')
         self.assertTrue(isinstance(sqs, SearchQuerySet))
-        self.assertEqual(repr(sqs.query.query_filter), '<SQ: AND content__contains="pants:rule">')
+        self.assertEqual(repr(sqs.query.query_filter), '<SQ: AND content__content="pants:rule">')
         self.assertEqual(sqs.query.build_query(), u'("pants\\:rule")')
         self.assertEqual(len(sqs), 0)
 

test_haystack/elasticsearch_tests/test_elasticsearch_query.py

@@ -122,6 +122,16 @@ def test_build_query_fuzzy_filter_types(self):
         self.sq.add_filter(SQ(title__fuzzy='haystack'))
         self.assertEqual(self.sq.build_query(), u'((why) AND title:(haystack~))')
 
+    def test_build_query_with_contains(self):
+        self.sq.add_filter(SQ(content='circular'))
+        self.sq.add_filter(SQ(title__contains='haystack'))
+        self.assertEqual(self.sq.build_query(), u'((circular) AND title:(*haystack*))')
+
+    def test_build_query_with_endswith(self):
+        self.sq.add_filter(SQ(content='circular'))
+        self.sq.add_filter(SQ(title__endswith='haystack'))
+        self.assertEqual(self.sq.build_query(), u'((circular) AND title:(*haystack))')
+
     def test_clean(self):
         self.assertEqual(self.sq.clean('hello world'), 'hello world')
         self.assertEqual(self.sq.clean('hello AND world'), 'hello and world')

test_haystack/solr_tests/test_solr_backend.py

@@ -973,7 +973,7 @@ def test_auto_query(self):
         # This will break horrifically if escaping isn't working.
         sqs = self.sqs.auto_query('"pants:rule"')
         self.assertTrue(isinstance(sqs, SearchQuerySet))
-        self.assertEqual(repr(sqs.query.query_filter), '<SQ: AND content__contains="pants:rule">')
+        self.assertEqual(repr(sqs.query.query_filter), '<SQ: AND content__content="pants:rule">')
         self.assertEqual(sqs.query.build_query(), u'("pants\\:rule")')
         self.assertEqual(len(sqs), 0)
 

test_haystack/solr_tests/test_solr_query.py

@@ -13,7 +13,6 @@
 
 from ..core.models import AnotherMockModel, MockModel
 
-
 class SolrSearchQueryTestCase(TestCase):
     fixtures = ['base_data']
 
@@ -132,6 +131,16 @@ def test_build_query_in_with_set(self):
         else:
             self.assertTrue(u'title:("An Infamous Article" OR "A Famous Paper")' in query)
 
+    def test_build_query_with_contains(self):
+        self.sq.add_filter(SQ(content='circular'))
+        self.sq.add_filter(SQ(title__contains='haystack'))
+        self.assertEqual(self.sq.build_query(), u'((circular) AND title:(*haystack*))')
+
+    def test_build_query_with_endswith(self):
+        self.sq.add_filter(SQ(content='circular'))
+        self.sq.add_filter(SQ(title__endswith='haystack'))
+        self.assertEqual(self.sq.build_query(), u'((circular) AND title:(*haystack))')
+
     def test_build_query_wildcard_filter_types(self):
         self.sq.add_filter(SQ(content='why'))
         self.sq.add_filter(SQ(title__startswith='haystack'))

test_haystack/test_managers.py

@@ -168,12 +168,12 @@ def test_load_all(self):
     def test_auto_query(self):
         sqs = self.search_index.objects.auto_query('test search -stuff')
         self.assertTrue(isinstance(sqs, SearchQuerySet))
-        self.assertEqual(repr(sqs.query.query_filter), '<SQ: AND content__contains=test search -stuff>')
+        self.assertEqual(repr(sqs.query.query_filter), '<SQ: AND content__content=test search -stuff>')
 
         # With keyword argument
         sqs = self.search_index.objects.auto_query('test search -stuff', fieldname='title')
         self.assertTrue(isinstance(sqs, SearchQuerySet))
-        self.assertEqual(repr(sqs.query.query_filter), "<SQ: AND title__contains=test search -stuff>")
+        self.assertEqual(repr(sqs.query.query_filter), "<SQ: AND title__content=test search -stuff>")
 
     def test_autocomplete(self):
         # Not implemented

test_haystack/test_query.py

@@ -32,40 +32,42 @@ class SQTestCase(TestCase):
     def test_split_expression(self):
         sq = SQ(foo='bar')
 
-        self.assertEqual(sq.split_expression('foo'), ('foo', 'contains'))
+        self.assertEqual(sq.split_expression('foo'), ('foo', 'content'))
         self.assertEqual(sq.split_expression('foo__exact'), ('foo', 'exact'))
+        self.assertEqual(sq.split_expression('foo__content'), ('foo', 'content'))
         self.assertEqual(sq.split_expression('foo__contains'), ('foo', 'contains'))
         self.assertEqual(sq.split_expression('foo__lt'), ('foo', 'lt'))
         self.assertEqual(sq.split_expression('foo__lte'), ('foo', 'lte'))
         self.assertEqual(sq.split_expression('foo__gt'), ('foo', 'gt'))
         self.assertEqual(sq.split_expression('foo__gte'), ('foo', 'gte'))
         self.assertEqual(sq.split_expression('foo__in'), ('foo', 'in'))
         self.assertEqual(sq.split_expression('foo__startswith'), ('foo', 'startswith'))
+        self.assertEqual(sq.split_expression('foo__endswith'), ('foo', 'endswith'))
         self.assertEqual(sq.split_expression('foo__range'), ('foo', 'range'))
         self.assertEqual(sq.split_expression('foo__fuzzy'), ('foo', 'fuzzy'))
 
         # Unrecognized filter. Fall back to exact.
-        self.assertEqual(sq.split_expression('foo__moof'), ('foo', 'contains'))
+        self.assertEqual(sq.split_expression('foo__moof'), ('foo', 'content'))
 
     def test_repr(self):
-        self.assertEqual(repr(SQ(foo='bar')), '<SQ: AND foo__contains=bar>')
-        self.assertEqual(repr(SQ(foo=1)), '<SQ: AND foo__contains=1>')
-        self.assertEqual(repr(SQ(foo=datetime.datetime(2009, 5, 12, 23, 17))), '<SQ: AND foo__contains=2009-05-12 23:17:00>')
+        self.assertEqual(repr(SQ(foo='bar')), '<SQ: AND foo__content=bar>')
+        self.assertEqual(repr(SQ(foo=1)), '<SQ: AND foo__content=1>')
+        self.assertEqual(repr(SQ(foo=datetime.datetime(2009, 5, 12, 23, 17))), '<SQ: AND foo__content=2009-05-12 23:17:00>')
 
     def test_simple_nesting(self):
         sq1 = SQ(foo='bar')
         sq2 = SQ(foo='bar')
         bigger_sq = SQ(sq1 & sq2)
-        self.assertEqual(repr(bigger_sq), '<SQ: AND (foo__contains=bar AND foo__contains=bar)>')
+        self.assertEqual(repr(bigger_sq), '<SQ: AND (foo__content=bar AND foo__content=bar)>')
 
         another_bigger_sq = SQ(sq1 | sq2)
-        self.assertEqual(repr(another_bigger_sq), '<SQ: AND (foo__contains=bar OR foo__contains=bar)>')
+        self.assertEqual(repr(another_bigger_sq), '<SQ: AND (foo__content=bar OR foo__content=bar)>')
 
         one_more_bigger_sq = SQ(sq1 & ~sq2)
-        self.assertEqual(repr(one_more_bigger_sq), '<SQ: AND (foo__contains=bar AND NOT (foo__contains=bar))>')
+        self.assertEqual(repr(one_more_bigger_sq), '<SQ: AND (foo__content=bar AND NOT (foo__content=bar))>')
 
         mega_sq = SQ(bigger_sq & SQ(another_bigger_sq | ~one_more_bigger_sq))
-        self.assertEqual(repr(mega_sq), '<SQ: AND ((foo__contains=bar AND foo__contains=bar) AND ((foo__contains=bar OR foo__contains=bar) OR NOT ((foo__contains=bar AND NOT (foo__contains=bar)))))>')
+        self.assertEqual(repr(mega_sq), '<SQ: AND ((foo__content=bar AND foo__content=bar) AND ((foo__content=bar OR foo__content=bar) OR NOT ((foo__content=bar AND NOT (foo__content=bar)))))>')
 
 
 class BaseSearchQueryTestCase(TestCase):
@@ -95,15 +97,15 @@ def test_add_filter(self):
 
         self.bsq.add_filter(SQ(claris='moof'), use_or=True)
 
-        self.assertEqual(repr(self.bsq.query_filter), '<SQ: OR ((foo__contains=bar AND foo__lt=10 AND NOT (claris__contains=moof)) OR claris__contains=moof)>')
+        self.assertEqual(repr(self.bsq.query_filter), '<SQ: OR ((foo__content=bar AND foo__lt=10 AND NOT (claris__content=moof)) OR claris__content=moof)>')
 
         self.bsq.add_filter(SQ(claris='moof'))
 
-        self.assertEqual(repr(self.bsq.query_filter), '<SQ: AND (((foo__contains=bar AND foo__lt=10 AND NOT (claris__contains=moof)) OR claris__contains=moof) AND claris__contains=moof)>')
+        self.assertEqual(repr(self.bsq.query_filter), '<SQ: AND (((foo__content=bar AND foo__lt=10 AND NOT (claris__content=moof)) OR claris__content=moof) AND claris__content=moof)>')
 
         self.bsq.add_filter(SQ(claris='wtf mate'))
 
-        self.assertEqual(repr(self.bsq.query_filter), '<SQ: AND (((foo__contains=bar AND foo__lt=10 AND NOT (claris__contains=moof)) OR claris__contains=moof) AND claris__contains=moof AND claris__contains=wtf mate)>')
+        self.assertEqual(repr(self.bsq.query_filter), '<SQ: AND (((foo__content=bar AND foo__lt=10 AND NOT (claris__content=moof)) OR claris__content=moof) AND claris__content=moof AND claris__content=wtf mate)>')
 
     def test_add_order_by(self):
         self.assertEqual(len(self.bsq.order_by), 0)
@@ -573,37 +575,37 @@ def test_load_all_read_queryset(self):
     def test_auto_query(self):
         sqs = self.msqs.auto_query('test search -stuff')
         self.assertTrue(isinstance(sqs, SearchQuerySet))
-        self.assertEqual(repr(sqs.query.query_filter), '<SQ: AND content__contains=test search -stuff>')
+        self.assertEqual(repr(sqs.query.query_filter), '<SQ: AND content__content=test search -stuff>')
 
         sqs = self.msqs.auto_query('test "my thing" search -stuff')
         self.assertTrue(isinstance(sqs, SearchQuerySet))
-        self.assertEqual(repr(sqs.query.query_filter), '<SQ: AND content__contains=test "my thing" search -stuff>')
+        self.assertEqual(repr(sqs.query.query_filter), '<SQ: AND content__content=test "my thing" search -stuff>')
 
         sqs = self.msqs.auto_query('test "my thing" search \'moar quotes\' -stuff')
         self.assertTrue(isinstance(sqs, SearchQuerySet))
-        self.assertEqual(repr(sqs.query.query_filter), '<SQ: AND content__contains=test "my thing" search \'moar quotes\' -stuff>')
+        self.assertEqual(repr(sqs.query.query_filter), '<SQ: AND content__content=test "my thing" search \'moar quotes\' -stuff>')
 
         sqs = self.msqs.auto_query('test "my thing" search \'moar quotes\' "foo -stuff')
         self.assertTrue(isinstance(sqs, SearchQuerySet))
-        self.assertEqual(repr(sqs.query.query_filter), '<SQ: AND content__contains=test "my thing" search \'moar quotes\' "foo -stuff>')
+        self.assertEqual(repr(sqs.query.query_filter), '<SQ: AND content__content=test "my thing" search \'moar quotes\' "foo -stuff>')
 
         sqs = self.msqs.auto_query('test - stuff')
         self.assertTrue(isinstance(sqs, SearchQuerySet))
-        self.assertEqual(repr(sqs.query.query_filter), "<SQ: AND content__contains=test - stuff>")
+        self.assertEqual(repr(sqs.query.query_filter), "<SQ: AND content__content=test - stuff>")
 
         # Ensure bits in exact matches get escaped properly as well.
         sqs = self.msqs.auto_query('"pants:rule"')
         self.assertTrue(isinstance(sqs, SearchQuerySet))
-        self.assertEqual(repr(sqs.query.query_filter), '<SQ: AND content__contains="pants:rule">')
+        self.assertEqual(repr(sqs.query.query_filter), '<SQ: AND content__content="pants:rule">')
 
         # Now with a different fieldname
         sqs = self.msqs.auto_query('test search -stuff', fieldname='title')
         self.assertTrue(isinstance(sqs, SearchQuerySet))
-        self.assertEqual(repr(sqs.query.query_filter), "<SQ: AND title__contains=test search -stuff>")
+        self.assertEqual(repr(sqs.query.query_filter), "<SQ: AND title__content=test search -stuff>")
 
         sqs = self.msqs.auto_query('test "my thing" search -stuff', fieldname='title')
         self.assertTrue(isinstance(sqs, SearchQuerySet))
-        self.assertEqual(repr(sqs.query.query_filter), '<SQ: AND title__contains=test "my thing" search -stuff>')
+        self.assertEqual(repr(sqs.query.query_filter), '<SQ: AND title__content=test "my thing" search -stuff>')
 
     def test_count(self):
         self.assertEqual(self.msqs.count(), 23)

test_haystack/whoosh_tests/test_whoosh_query.py

@@ -103,6 +103,16 @@ def test_build_query_fuzzy_filter_types(self):
         self.sq.add_filter(SQ(title__fuzzy='haystack'))
         self.assertEqual(self.sq.build_query(), u'((why) AND title:(haystack~))')
 
+    def test_build_query_with_contains(self):
+        self.sq.add_filter(SQ(content='circular'))
+        self.sq.add_filter(SQ(title__contains='haystack'))
+        self.assertEqual(self.sq.build_query(), u'((circular) AND title:(*haystack*))')
+
+    def test_build_query_with_endswith(self):
+        self.sq.add_filter(SQ(content='circular'))
+        self.sq.add_filter(SQ(title__endswith='haystack'))
+        self.assertEqual(self.sq.build_query(), u'((circular) AND title:(*haystack))')
+
     def test_clean(self):
         self.assertEqual(self.sq.clean('hello world'), 'hello world')
         self.assertEqual(self.sq.clean('hello AND world'), 'hello and world')