Changed how you query for facets and how how they are presented in the facet counts. Allows customization of facet field names in indexes.

Lightly backward-incompatible (git only).

Author: tmc

docs/faceting.rst

@@ -190,8 +190,8 @@ might look like this::
     {% endif %}
 
 Displaying the facets is a matter of looping through the facets you want and
-providing the UI to suit. The ``author_exact.0`` is the facet text from the backend
-and the ``author_exact.1`` is the facet count.
+providing the UI to suit. The ``author.0`` is the facet text from the backend
+and the ``author.1`` is the facet count.
 
 4. Narrowing The Search
 -----------------------

haystack/backends/__init__.py

@@ -1,5 +1,4 @@
 # -*- coding: utf-8 -*-
-import re
 from copy import deepcopy
 from time import time
 from django.conf import settings
@@ -10,7 +9,6 @@
 from django.utils.encoding import force_unicode
 from haystack.constants import VALID_FILTERS, FILTER_SEPARATOR
 from haystack.exceptions import SearchBackendError, MoreLikeThisError, FacetingError
-from haystack.utils import get_facet_field_name
 try:
     set
 except NameError:
@@ -631,7 +629,7 @@ def add_highlight(self):
 
     def add_field_facet(self, field):
         """Adds a regular facet on a field."""
-        self.facets.add(get_facet_field_name(field))
+        self.facets.add(self.backend.site.get_facet_field_name(field))
 
     def add_date_facet(self, field, start_date, end_date, gap_by, gap_amount=1):
         """Adds a date-based facet on a field."""
@@ -644,11 +642,11 @@ def add_date_facet(self, field, start_date, end_date, gap_by, gap_amount=1):
             'gap_by': gap_by,
             'gap_amount': gap_amount,
         }
-        self.date_facets[get_facet_field_name(field)] = details
+        self.date_facets[self.backend.site.get_facet_field_name(field)] = details
 
     def add_query_facet(self, field, query):
         """Adds a query facet on a field."""
-        self.query_facets.append((get_facet_field_name(field), query))
+        self.query_facets.append((self.backend.site.get_facet_field_name(field), query))
 
     def add_narrow_query(self, query):
         """
@@ -661,15 +659,15 @@ def add_narrow_query(self, query):
     def post_process_facets(self, results):
         # Handle renaming the facet fields. Undecorate and all that.
         revised_facets = {}
+        field_data = self.backend.site.all_searchfields()
 
         for facet_type, field_details in results.get('facets', {}).items():
             temp_facets = {}
 
             for field, field_facets in field_details.items():
                 fieldname = field
-                
-                if fieldname.endswith('_exact'):
-                    fieldname = fieldname[:-6]
+                if field in field_data and hasattr(field_data[field], 'get_facet_for_name'):
+                    fieldname = field_data[field].get_facet_for_name()
 
                 temp_facets[fieldname] = field_facets
 

haystack/fields.py

@@ -245,3 +245,6 @@ def __init__(self, **kwargs):
         super(FacetField, self).__init__(**kwargs)
         # Make sure the field is nullable.
         self.null = True
+
+    def get_facet_for_name(self):
+        return self.facet_for or self.instance_name

haystack/sites.py

@@ -19,7 +19,7 @@ class SearchSite(object):
 
     def __init__(self):
         self._registry = {}
-        self._field_mapping = None
+        self._cached_field_mapping = None
 
     def register(self, model, index_class=None):
         """
@@ -140,25 +140,51 @@ def get_index_fieldname(self, fieldname):
         ``SearchIndex`` instead of having to remember & use the overridden
         name.
         """
-        if self._field_mapping is None:
-            self._field_mapping = self._build_field_mapping()
-        
-        # Return what was provided as a fallback instead of an IndexError.
-        return self._field_mapping.get(fieldname, fieldname)
+        if fieldname in self._field_mapping():
+            return self._field_mapping()[fieldname]['index_fieldname']
+        else:
+            return fieldname
 
-    def _build_field_mapping(self):
+    def get_facet_field_name(self, fieldname):
+        """
+        Returns the actual name of the facet field in the index.
+
+        If not found, returns the fieldname provided.
+        """
+        facet_fieldname = None
+        if fieldname in self._field_mapping():
+            facet_fieldname = self._field_mapping()[fieldname]['facet_fieldname']
+
+        if facet_fieldname:
+            return self.get_index_fieldname(facet_fieldname)
+        else:
+            return fieldname
+
+    def _field_mapping(self):
         mapping = {}
 
+        if self._cached_field_mapping:
+            return self._cached_field_mapping
+        
         for model, index in self.get_indexes().items():
             for field_name, field_object in index.fields.items():
-                if field_name in mapping:
-                    # We've already seen this field in the list. Check to ensure
-                    # it uses the same index_fieldname as the previous mention.
-                    if field_object.index_fieldname != mapping[field_name]:
-                        raise SearchFieldError("All uses of the '%s' field need to use the same 'index_fieldname' attribute." % field_name)
+                if field_name in mapping and field_object.index_fieldname != mapping[field_name]['index_fieldname']:
+                    # We've already seen this field in the list. Raise an exception if index_fieldname differs.
+                    raise SearchFieldError("All uses of the '%s' field need to use the same 'index_fieldname' attribute." % field_name)
+
+                facet_fieldname = None
+                if hasattr(field_object, 'facet_for'):
+                    if field_object.facet_for:
+                        facet_fieldname = field_object.facet_for
+                    else:
+                        facet_fieldname = field_object.instance_name
 
-                mapping[field_name] = field_object.index_fieldname
+                mapping[field_name] = {
+                    'index_fieldname': field_object.index_fieldname,
+                    'facet_fieldname': facet_fieldname,
+                }
 
+        self._cached_field_mapping = mapping
         return mapping
 
     def update_object(self, instance):

tests/core/tests/mocks.py

@@ -19,8 +19,8 @@ class MockSearchBackend(BaseSearchBackend):
     mock_search_results = MOCK_SEARCH_RESULTS
 
     def __init__(self, site=None):
+        super(MockSearchBackend, self).__init__(site)
         self.docs = {}
-        self.site = site
 
     def update(self, index, iterable, commit=True):
         for obj in iterable:

tests/core/tests/query.py

@@ -151,34 +151,34 @@ def test_more_like_this(self):
 
     def test_add_field_facet(self):
         self.bsq.add_field_facet('foo')
-        self.assertEqual(self.bsq.facets, set(['foo_exact']))
+        self.assertEqual(self.bsq.facets, set(['foo']))
 
         self.bsq.add_field_facet('bar')
-        self.assertEqual(self.bsq.facets, set(['foo_exact', 'bar_exact']))
+        self.assertEqual(self.bsq.facets, set(['foo', 'bar']))
 
     def test_add_date_facet(self):
         self.bsq.add_date_facet('foo', start_date=datetime.date(2009, 2, 25), end_date=datetime.date(2009, 3, 25), gap_by='day')
-        self.assertEqual(self.bsq.date_facets, {'foo_exact': {'gap_by': 'day', 'start_date': datetime.date(2009, 2, 25), 'end_date': datetime.date(2009, 3, 25), 'gap_amount': 1}})
+        self.assertEqual(self.bsq.date_facets, {'foo': {'gap_by': 'day', 'start_date': datetime.date(2009, 2, 25), 'end_date': datetime.date(2009, 3, 25), 'gap_amount': 1}})
 
         self.bsq.add_date_facet('bar', start_date=datetime.date(2008, 1, 1), end_date=datetime.date(2009, 12, 1), gap_by='month')
-        self.assertEqual(self.bsq.date_facets, {'foo_exact': {'gap_by': 'day', 'start_date': datetime.date(2009, 2, 25), 'end_date': datetime.date(2009, 3, 25), 'gap_amount': 1}, 'bar_exact': {'gap_by': 'month', 'start_date': datetime.date(2008, 1, 1), 'end_date': datetime.date(2009, 12, 1), 'gap_amount': 1}})
+        self.assertEqual(self.bsq.date_facets, {'foo': {'gap_by': 'day', 'start_date': datetime.date(2009, 2, 25), 'end_date': datetime.date(2009, 3, 25), 'gap_amount': 1}, 'bar': {'gap_by': 'month', 'start_date': datetime.date(2008, 1, 1), 'end_date': datetime.date(2009, 12, 1), 'gap_amount': 1}})
 
     def test_add_query_facet(self):
         self.bsq.add_query_facet('foo', 'bar')
-        self.assertEqual(self.bsq.query_facets, [('foo_exact', 'bar')])
+        self.assertEqual(self.bsq.query_facets, [('foo', 'bar')])
 
         self.bsq.add_query_facet('moof', 'baz')
-        self.assertEqual(self.bsq.query_facets, [('foo_exact', 'bar'), ('moof_exact', 'baz')])
+        self.assertEqual(self.bsq.query_facets, [('foo', 'bar'), ('moof', 'baz')])
 
         self.bsq.add_query_facet('foo', 'baz')
-        self.assertEqual(self.bsq.query_facets, [('foo_exact', 'bar'), ('moof_exact', 'baz'), ('foo_exact', 'baz')])
+        self.assertEqual(self.bsq.query_facets, [('foo', 'bar'), ('moof', 'baz'), ('foo', 'baz')])
 
     def test_add_narrow_query(self):
-        self.bsq.add_narrow_query('foo_exact:bar')
-        self.assertEqual(self.bsq.narrow_queries, set(['foo_exact:bar']))
+        self.bsq.add_narrow_query('foo:bar')
+        self.assertEqual(self.bsq.narrow_queries, set(['foo:bar']))
 
-        self.bsq.add_narrow_query('moof_exact:baz')
-        self.assertEqual(self.bsq.narrow_queries, set(['foo_exact:bar', 'moof_exact:baz']))
+        self.bsq.add_narrow_query('moof:baz')
+        self.assertEqual(self.bsq.narrow_queries, set(['foo:bar', 'moof:baz']))
 
     def test_run(self):
         # Stow.

tests/core/tests/sites.py

@@ -2,7 +2,7 @@
 from django.test import TestCase
 from haystack.indexes import *
 from haystack.exceptions import SearchFieldError
-from haystack.fields import CharField
+from haystack.fields import CharField, FacetField
 from haystack.sites import SearchSite, AlreadyRegistered, NotRegistered
 from core.models import MockModel, AnotherMockModel
 
@@ -40,6 +40,13 @@ class AlternateValidSearchIndex(SearchIndex):
     author = CharField(faceted=True)
     title = CharField(faceted=True)
 
+class ExplicitFacetSearchIndex(SearchIndex):
+    text = CharField(document=True)
+    author = CharField(faceted=True)
+    title = CharField()
+    title_facet = FacetField(facet_for='title')
+    bare_facet = FacetField()
+
 
 class MultiValueValidSearchIndex(SearchIndex):
     text = CharField(document=True)
@@ -187,23 +194,70 @@ def test_all_searchfields(self):
         self.assertRaises(SearchFieldError, self.site.all_searchfields)
 
     def test_get_index_fieldname(self):
-        self.assertEqual(self.site._field_mapping, None)
+        self.assertEqual(self.site._cached_field_mapping, None)
 
         self.site.register(MockModel, ValidSearchIndex)
         self.site.register(AnotherMockModel)
-        field = self.site.get_index_fieldname('text')
-        self.assertEqual(self.site._field_mapping, {'text': 'text', 'title': 'title', 'author': 'name'})
+        self.site.get_index_fieldname('text')
+        self.assertEqual(self.site._cached_field_mapping, {
+            'text': {'index_fieldname': 'text', 'facet_fieldname': None},
+            'title': {'index_fieldname': 'title', 'facet_fieldname': None},
+            'author': {'index_fieldname': 'name', 'facet_fieldname': None},
+            })
         self.assertEqual(self.site.get_index_fieldname('text'), 'text')
         self.assertEqual(self.site.get_index_fieldname('author'), 'name')
         self.assertEqual(self.site.get_index_fieldname('title'), 'title')
 
         # Reset the internal state to test the invalid case.
-        self.site._field_mapping = None
-        self.assertEqual(self.site._field_mapping, None)
+        self.site._cached_field_mapping = None
+        self.assertEqual(self.site._cached_field_mapping, None)
 
         self.site.unregister(AnotherMockModel)
         self.site.register(AnotherMockModel, AlternateValidSearchIndex)
         self.assertRaises(SearchFieldError, self.site.get_index_fieldname, 'text')
+
+    def test_basic_get_facet_fieldname(self):
+        self.assertEqual(self.site._cached_field_mapping, None)
+        
+        self.site.register(MockModel, AlternateValidSearchIndex)
+        self.site.register(AnotherMockModel)
+        self.site.get_facet_field_name('text')
+        self.assertEqual(self.site._cached_field_mapping, {
+            'author': {'facet_fieldname': None, 'index_fieldname': 'author'},
+            'author_exact': {'facet_fieldname': 'author',
+            'index_fieldname': 'author_exact'},
+            'text': {'facet_fieldname': None, 'index_fieldname': 'text'},
+            'title': {'facet_fieldname': None, 'index_fieldname': 'title'},
+            'title_exact': {'facet_fieldname': 'title', 'index_fieldname': 'title_exact'},
+        })
+        self.assertEqual(self.site.get_index_fieldname('text'), 'text')
+        self.assertEqual(self.site.get_index_fieldname('author'), 'author')
+        self.assertEqual(self.site.get_index_fieldname('title'), 'title')
+
+        self.assertEqual(self.site.get_facet_field_name('text'), 'text')
+        self.assertEqual(self.site.get_facet_field_name('author'), 'author')
+        self.assertEqual(self.site.get_facet_field_name('title'), 'title')
+
+    def test_more_advanced_get_facet_fieldname(self):
+        self.assertEqual(self.site._cached_field_mapping, None)
+
+        self.site.register(MockModel, ExplicitFacetSearchIndex)
+        self.site.register(AnotherMockModel)
+
+        self.site.get_facet_field_name('text')
+        self.assertEqual(self.site._cached_field_mapping, {
+            'author': {'facet_fieldname': None, 'index_fieldname': 'author'},
+            'author_exact': {'facet_fieldname': 'author', 'index_fieldname': 'author_exact'},
+            'bare_facet': {'facet_fieldname': 'bare_facet', 'index_fieldname': 'bare_facet'},
+            'text': {'facet_fieldname': None, 'index_fieldname': 'text'},
+            'title': {'facet_fieldname': None, 'index_fieldname': 'title'},
+            'title_facet': {'facet_fieldname': 'title', 'index_fieldname': 'title_facet'},
+        })
+        self.assertEqual(self.site.get_facet_field_name('title'), 'title')
+
+        self.assertEqual(self.site.get_facet_field_name('title'), 'title')
+        self.assertEqual(self.site.get_facet_field_name('bare_facet'), 'bare_facet')
+
 
     def test_update_object(self):
         self.site.register(MockModel, FakeSearchIndex)