Signal handlers

wagtailsearch provides some signal handlers which bind to the save/delete signals of all indexed models. This would automatically add and delete them from all backends you have registered in WAGTAILSEARCH_BACKENDS. These signal handlers are automatically registered when the wagtail.search app is loaded.

In some cases, you may not want your content to be automatically reindexed and instead rely on the update_index command for indexing. If you need to disable these signal handlers, use one of the following methods:

The update_index command

Wagtail also provides a command for rebuilding the index from scratch.

./manage.py update_index

It is recommended to run this command once a week and at the following times:

• whenever any pages have been created through a script (after an import, for example)
• whenever any changes have been made to models or search configuration

The search may not return any results while this command is running, so avoid running it at peak times.

Example

This creates an EventPage model with two fields: description and date. description is indexed as a SearchField and date is indexed as a FilterField.

from wagtail.search import index
from django.utils import timezone

class EventPage(Page):
    description = models.TextField()
    date = models.DateField()

    search_fields = Page.search_fields + [ # Inherit search_fields from Page
        index.SearchField('description'),
        index.FilterField('date'),
    ]


# Get future events which contain the string "Christmas" in the title or description
>>> EventPage.objects.filter(date__gt=timezone.now()).search("Christmas")

index.SearchField

These are used for performing full-text searches on your models, usually for text fields.

index.AutocompleteField

These are used for autocomplete queries which match partial words. For example, a page titled Hello World! will be found if the user only types Hel into the search box.

This takes the exact same options as index.SearchField (with the exception of partial_match, which has no effect).

index.FilterField

These are added to the search index but are not used for full-text searches. Instead, they allow you to run filters on your search results.

index.RelatedFields

This allows you to index fields from related objects. It works on all types of related fields, including their reverse accessors.

For example, if we have a book that has a ForeignKey to its author, we can nest the author’s name and date_of_birth fields inside the book:

from wagtail.search import index

class Book(models.Model, index.Indexed):
    ...

    search_fields = [
        index.SearchField('title'),
        index.FilterField('published_date'),

        index.RelatedFields('author', [
            index.SearchField('name'),
            index.FilterField('date_of_birth'),
        ]),
    ]

This will allow you to search for books by their author’s name.

It works the other way around as well. You can index an author’s books, allowing an author to be searched for by the titles of books they’ve published:

from wagtail.search import index

class Author(models.Model, index.Indexed):
    ...

    search_fields = [
        index.SearchField('name'),
        index.FilterField('date_of_birth'),

        index.RelatedFields('books', [
            index.SearchField('title'),
            index.FilterField('published_date'),
        ]),
    ]

Indexing callables and other attributes

Search/filter fields do not need to be Django model fields. They can also be any method or attribute on your model class.

One use for this is indexing the get_*_display methods Django creates automatically for fields with choices.

from wagtail.search import index

class EventPage(Page):
    IS_PRIVATE_CHOICES = (
        (False, "Public"),
        (True, "Private"),
    )

    is_private = models.BooleanField(choices=IS_PRIVATE_CHOICES)

    search_fields = Page.search_fields + [
        # Index the human-readable string for searching.
        index.SearchField('get_is_private_display'),

        # Index the boolean value for filtering.
        index.FilterField('is_private'),
    ]

Callables also provide a way to index fields from related models. In the example from Inline Panels and Model Clusters, to index each BookPage by the titles of its related_links:

class BookPage(Page):
    # ...
    def get_related_link_titles(self):
        # Get list of titles and concatenate them
        return '\n'.join(self.related_links.all().values_list('name', flat=True))

    search_fields = Page.search_fields + [
        # ...
        index.SearchField('get_related_link_titles'),
    ]