A common task for web applications is to search some data in the database with\nuser input. In a simple case, this could be filtering a list of objects by a\ncategory. A more complex use case might require searching with weighting,\ncategorization, highlighting, multiple languages, and so on. This document\nexplains some of the possible use cases and the tools you can use.
\nWe’ll refer to the same models used in 쿼리 만들기.
\nText-based fields have a selection of matching operations. For example, you may\nwish to allow lookup up an author like so:
\n>>> Author.objects.filter(name__contains='Terry')\n[<Author: Terry Gilliam>, <Author: Terry Jones>]\nThis is a very fragile solution as it requires the user to know an exact\nsubstring of the author’s name. A better approach could be a case-insensitive\nmatch (icontains), but this is only marginally better.
If you’re using PostgreSQL, Django provides a selection of database\nspecific tools to allow you to leverage more\ncomplex querying options. Other databases have different selections of tools,\npossibly via plugins or user-defined functions. Django doesn’t include any\nsupport for them at this time. We’ll use some examples from PostgreSQL to\ndemonstrate the kind of functionality databases may have.
\n\nIn the above example, we determined that a case insensitive lookup would be\nmore useful. When dealing with non-English names, a further improvement is to\nuse unaccented comparison:
>>> Author.objects.filter(name__unaccent__icontains='Helen')\n[<Author: Helen Mirren>, <Author: Helena Bonham Carter>, <Author: Hélène Joy>]\nThis shows another issue, where we are matching against a different spelling of\nthe name. In this case we have an asymmetry though - a search for Helen\nwill pick up Helena or Hélène, but not the reverse. Another option\nwould be to use a trigram_similar comparison, which compares\nsequences of letters.
예시:
\n>>> Author.objects.filter(name__unaccent__lower__trigram_similar='Hélène')\n[<Author: Helen Mirren>, <Author: Hélène Joy>]\nNow we have a different problem - the longer name of “Helena Bonham Carter”\ndoesn’t show up as it is much longer. Trigram searches consider all\ncombinations of three letters, and compares how many appear in both search and\nsource strings. For the longer name, there are more combinations that don’t\nappear in the source string, so it is no longer considered a close match.
\nThe correct choice of comparison functions here depends on your particular data\nset, for example the language(s) used and the type of text being searched. All\nof the examples we’ve seen are on short strings where the user is likely to\nenter something close (by varying definitions) to the source data.
\nStandard database operations stop being a useful approach when you start\nconsidering large blocks of text. Whereas the examples above can be thought of\nas operations on a string of characters, full text search looks at the actual\nwords. Depending on the system used, it’s likely to use some of the following\nideas:
\nIgnoring “stop words” such as “a”, “the”, “and”.
Stemming words, so that “pony” and “ponies” are considered similar.
Weighting words based on different criteria such as how frequently they\nappear in the text, or the importance of the fields, such as the title or\nkeywords, that they appear in.
There are many alternatives for using searching software, some of the most\nprominent are Elastic and Solr. These are full document-based search\nsolutions. To use them with data from Django models, you’ll need a layer which\ntranslates your data into a textual document, including back-references to the\ndatabase ids. When a search using the engine returns a certain document, you\ncan then look it up in the database. There are a variety of third-party\nlibraries which are designed to help with this process.
\nPostgreSQL has its own full text search implementation built-in. While not as\npowerful as some other search engines, it has the advantage of being inside\nyour database and so can easily be combined with other relational queries such\nas categorization.
\nThe django.contrib.postgres module provides some helpers to make these\nqueries. For example, a query might select all the blog entries which mention\n“cheese”:
>>> Entry.objects.filter(body_text__search='cheese')\n[<Entry: Cheese on Toast recipes>, <Entry: Pizza recipes>]\nYou can also filter on a combination of fields and on related models:
\n>>> Entry.objects.annotate(\n... search=SearchVector('blog__tagline', 'body_text'),\n... ).filter(search='cheese')\n[\n <Entry: Cheese on Toast recipes>,\n <Entry: Pizza Recipes>,\n <Entry: Dairy farming in Argentina>,\n]\nSee the contrib.postgres Full text search document for\ncomplete details.