Cuardach téacs iomlánLink to this heading#

An cuardach chuardachLink to this heading#

Bealach coitianta chun cuardach téacs iomlán a úsáid ná téarma amháin a chuardach i gcoinne colún amháin sa bhunachar sonraí. Mar shampla:

>>> Entry.objects.filter(body_text__search="Cheese")
<QuerySet [<Entry: Cheese on Toast recipes>, <Entry: Pizza Recipes>]>

Cruthaíonn sé seo to_tsvector sa bhunachar sonraí ón réimse body_text agus plainto_tsquery ón téarma cuardaigh `Cheise, ag baint úsáide as an gcumraíocht réamhshocraithe cuardaigh bunachar sonraí. Faightear na torthaí tríd an gceist agus an veicteoir a mheaitseáil.

Chun an cuardach search a úsáid, caithfidh django.contrib.postgres' a bheith i d':setting: INSTALLED_APPS.

SearchVectorLink to this heading#

class SearchVector(*expressions, config=None, weight=None)Link to this definition#

Tá sé iontach cuardach i gcoinne réimse amháin ach teorannach. Baineann na cásanna Iontrála atá á chuardach againn le Blog, a bhfuil réimse tagline aige. Chun ceist a dhéanamh i gcoinne an dá réimse, bain úsáid as SearchVector:

>>> from django.contrib.postgres.search import SearchVector
>>> Entry.objects.annotate(
...     search=SearchVector("body_text", "blog__tagline"),
... ).filter(search="Cheese")
<QuerySet [<Entry: Cheese on Toast recipes>, <Entry: Pizza Recipes>]>

Is féidir leis na hargóintí le SearchVector` a bheith aon:class: ~django.db.Models.Expression nó ainm réimse. Déanfar argóintí iolracha a chomhcheangal le chéile ag baint úsáide as spás ionas go gcuimsíonn an doiciméad cuardaigh iad uile

Is féidir rudaí `SearchVector ``a chomhcheangal le chéile, rud a ligeann duit iad a athúsáid. Mar shampla:

>>> Entry.objects.annotate(
...     search=SearchVector("body_text") + SearchVector("blog__tagline"),
... ).filter(search="Cheese")
<QuerySet [<Entry: Cheese on Toast recipes>, <Entry: Pizza Recipes>]>

Féach:ref: postgresql-fts-search-cumraí agus:ref: postgresql-fts-weighting-queries le haghaidh míniú ar na paraiméadair config` agus meách`.

CuardcheisteLink to this heading#

class SearchQuery(value, config=None, search_type='plain')Link to this definition#

Aistríonn SearchQuery na téarmaí a sholáthraíonn an t-úsáideoir ina réad fiosrúcháin cuardaigh a dhéanann an bunachar sonraí comparáid le veicteoir cuardaigh. De réir réamhshocraithe, cuirtear na focail go léir a sholáthraíonn an t-úsáideoir tríd na halgartaim spreagtha, agus ansin féachann sé cluichí do na téarmaí go léir mar thoradh air.

Más é search_type plain', arb é an réamhshocrú, déileálfar leis na téarmaí mar eochairfhocail ar leithligh. Más é search_type frase ', déileáiltear leis na téarmaí mar abairt amháin. Más é search_type raw', ansin is féidir leat ceist cuardaigh formáidithe a sholáthar le téarmaí agus oibreoirí. Más é search_type ``websearch', ansin is féidir leat ceist cuardaigh formáidithe a sholáthar, cosúil leis an gceann a úsáideann innill chuardaigh gréasáin. Éilíonn ``'websearch'` PostgreSQL ≥ 11. Léigh PostgreSQL Doiciméid Cuardaigh Téacs Iomlána chun foghlaim faoi dhifríochtaí agus comhréireacht. Samplaí:

>>> from django.contrib.postgres.search import SearchQuery, Lexeme
>>> SearchQuery("red tomato")  # two keywords
>>> SearchQuery("tomato red")  # same results as above
>>> SearchQuery("red tomato", search_type="phrase")  # a phrase
>>> SearchQuery("tomato red", search_type="phrase")  # a different phrase
>>> SearchQuery("'tomato' & ('red' | 'green')", search_type="raw")  # boolean operators
>>> SearchQuery(
...     "'tomato' ('red' OR 'green')", search_type="websearch"
... )  # websearch operators
>>> SearchQuery(Lexeme("tomato") & (Lexeme("red") | Lexeme("green")))  # Lexeme objects

Is féidir téarmaí SearchQuery a chomhcheangal go loighciúil chun níos mó solúbthachta a sholáthar:

>>> from django.contrib.postgres.search import SearchQuery
>>> SearchQuery("meat") & SearchQuery("cheese")  # AND
>>> SearchQuery("meat") | SearchQuery("cheese")  # OR
>>> ~SearchQuery("meat")  # NOT

Féach:ref: postgresql-fts-search-configuration le haghaidh míniú ar an paraiméadar config.

SearchrankLink to this heading#

class SearchRank(vector, query, weights=None, normalization=None, cover_density=False)Link to this definition#

Go dtí seo, tá na torthaí ar ais againn ar a bhfuil aon mheaitseáil idir an veicteoir agus an cheist indéanta. Is dócha gur mhaith leat na torthaí a ordú de réir ábharthachta de chineál éigin. Soláthraíonn PostgreSQL feidhm rangú a chuireann san áireamh cé chomh minic a bhíonn na téarmaí fiosrúcháin le feiceáil sa doiciméad, cé chomh gar dá chéile atá na téarmaí sa doiciméad, agus cé chomh tábhachtach is atá an chuid den doiciméad ina dtarlaíonn siad. An níos fearr an cluiche, is airde luach an chéim. Chun ordú de réir ábharthachta:

>>> from django.contrib.postgres.search import SearchQuery, SearchRank, SearchVector
>>> vector = SearchVector("body_text")
>>> query = SearchQuery("cheese")
>>> Entry.objects.annotate(rank=SearchRank(vector, query)).order_by("-rank")
<QuerySet [<Entry: Cheese on Toast recipes>, <Entry: Pizza recipes>]>

Féach:ref: postgresql-fts-weighting-queries le haghaidh míniú ar an bparaiméadar ``meáchain ``.

Socraigh an paraiméadar cover_density` go True` chun rangú an dlús clúdaigh a chumasú, rud a chiallaíonn go gcuirtear cógasacht na dtéarmaí ceisteanna meaitseála san áireamh.

Cuir sláimhir ar fáil don pharaiméadar ``normalization` chun normalú céim a rialú. Is masc beagán é an sláimhir seo, ionas gur féidir leat iompraíochtaí iolracha a chomhcheangal:

>>> from django.db.models import Value
>>> Entry.objects.annotate(
...     rank=SearchRank(
...         vector,
...         query,
...         normalization=Value(2).bitor(Value(4)),
...     )
... )

Tá tuilleadh sonraí ag doiciméadú PostgreSQL faoi `roghanna normalú céim éagsúla `_.

Ceannlíne chuardachaLink to this heading#

class SearchHeadline(expression, query, config=None, start_sel=None, stop_sel=None, max_words=None, min_words=None, short_word=None, highlight_all=None, max_fragments=None, fragment_delimiter=None)Link to this definition#

Glacann sé le réimse téacs amháin nó abairt, ceist, cumraíocht, agus tacar roghanna. Tuairisceáin aibhsithe ar thorthaí

Socraigh na paraiméadair start_sel agus stop_sel chuig na luachanna teaghrán atá le húsáid chun téarmaí fiosrúcháin aibhsithe sa doiciméad a fhilleadh. <b>Is iad réamhshocruithe PostgreSQL ná ```` agus ````.</b>

Cuir luachanna sláimhir ar fáil do na paraiméadair max_words agus min_words chun na ceannlínte is faide agus is giorra a chinneadh. Is iad réamhshocruithe PostgreSQL ná 35 agus 15.

Cuir luach sláimhir ar fáil don pharaiméadar short_word chun focail den fhad seo nó níos lú a dhiúscairt i ngach ceanncheannlíne. Is é réamhshocrú PostgreSQL 3.

Socraigh an paraiméadar highlight_all go True chun an doiciméad iomlán a úsáid in ionad blúire agus neamhaird a dhéanamh ar pharaiméadair max_words, min_words`, agus short_word. Tá sé sin díchumasaithe de réir réamhshocraithe i PostgreSQL.

Cuir luach sláimhir neamh-nialasach ar fáil don max_fragments chun an líon uasta na mblúirí atá le taispeáint a shocrú. Tá sé sin díchumasaithe de réir réamhshocraithe i PostgreSQL.

Socraigh an paraiméadar teaghrán fragment_delimiter` chun an teorannaitheoir idir blúirí a chumrú. Is é réamhshocrú PostgreSQL ná ”... “.

Tá tuilleadh sonraí ag doiciméadú PostgreSQL maidir le `aird a tharraingt ar thorthaí cuardaigh `_.

Sampla úsáide:

>>> from django.contrib.postgres.search import SearchHeadline, SearchQuery
>>> query = SearchQuery("red tomato")
>>> entry = Entry.objects.annotate(
...     headline=SearchHeadline(
...         "body_text",
...         query,
...         start_sel="<span>",
...         stop_sel="</span>",
...     ),
... ).get()
>>> print(entry.headline)
Sandwich with <span>tomato</span> and <span>red</span> cheese.

Féach:ref: postgresql-fts-search-configuration le haghaidh míniú ar an paraiméadar config.

Cumraíocht an chuardaigh a athrúLink to this heading#

Is féidir leat an tréith config a shonrú le a:class: searchVector agus:class: searchQuery chun cumraíocht cuardaigh difriúil a úsáid. Ligeann sé seo parsálaí agus foclóirí teanga éagsúla a úsáid mar a shainmhíníonn an bunachar

>>> from django.contrib.postgres.search import SearchQuery, SearchVector
>>> Entry.objects.annotate(
...     search=SearchVector("body_text", config="french"),
... ).filter(search=SearchQuery("œuf", config="french"))
<QuerySet [<Entry: Pain perdu>]>

D'fhéadfaí luach config` a stóráil i gcolún eile freisin:

>>> from django.db.models import F
>>> Entry.objects.annotate(
...     search=SearchVector("body_text", config=F("blog__language")),
... ).filter(search=SearchQuery("œuf", config=F("blog__language")))
<QuerySet [<Entry: Pain perdu>]>

Fiosruithe meáchainLink to this heading#

B'fhéidir nach mbeidh an t-ábharthacht chéanna ag gach réimse i gceist, ionas gur féidir leat meáchain veicteoirí éagsúla a shocrú sula gcomhcheanglaíonn tú iad:

>>> from django.contrib.postgres.search import SearchQuery, SearchRank, SearchVector
>>> vector = SearchVector("body_text", weight="A") + SearchVector(
...     "blog__tagline", weight="B"
... )
>>> query = SearchQuery("cheese")
>>> Entry.objects.annotate(rank=SearchRank(vector, query)).filter(rank__gte=0.3).order_by(
...     "rank"
... )

Ba chóir go mbeadh an meáchan ar cheann de na litreacha seo a leanas: D, C, B, A. De réir réamhshocraithe, tagraíonn na meáchain seo do na huimhreacha 0.1, 0.2`, 0.4`, agus 1.0, faoi seach. Más mian leat iad a mheáchan ar bhealach difriúil, cuir liosta de cheithre snámh chuig: class: searchRank mar Weights san ord céanna thuas:

>>> rank = SearchRank(vector, query, weights=[0.2, 0.4, 0.6, 0.8])
>>> Entry.objects.annotate(rank=rank).filter(rank__gte=0.3).order_by("-rank")

LexemeLink to this heading#

class Lexeme(value, output_field=None, *, invert=False, prefix=False, weight=None)Link to this definition#

Lexeme objects allow search operators to be safely used with strings from an untrusted source. The content of each lexeme is escaped so that any operators that may exist in the string itself will not be interpreted.

You can combine lexemes with other lexemes using the & and | operators and also negate them with the ~ operator. For example:

>>> from django.contrib.postgres.search import SearchQuery, SearchVector, Lexeme
>>> vector = SearchVector("body_text", "blog__tagline")
>>> Entry.objects.annotate(search=vector).filter(
...     search=SearchQuery(Lexeme("fruit") & Lexeme("dessert"))
... )
<QuerySet [<Entry: Apple Crumble Recipes>, <Entry: Banana Split Recipes>]>

>>> Entry.objects.annotate(search=vector).filter(
...     search=SearchQuery(Lexeme("fruit") & Lexeme("dessert") & ~Lexeme("banana"))
... )
<QuerySet [<Entry: Apple Crumble Recipes>]>

Lexeme objects also support term weighting and prefixes:

>>> Entry.objects.annotate(search=vector).filter(
...     search=SearchQuery(Lexeme("Pizza") | Lexeme("Cheese"))
... )
<QuerySet [<Entry: Cheese on Toast recipes>, <Entry: Pizza recipes>]>
>>> Entry.objects.annotate(search=vector).filter(
...     search=SearchQuery(Lexeme("Pizza") | Lexeme("Cheese", weight="A"))
... )
<QuerySet [<Entry: Pizza recipes>]>
>>> Entry.objects.annotate(search=vector).filter(
...     search=SearchQuery(Lexeme("za", prefix=True))
... )
<QuerySet []>

feidhmíochtLink to this heading#

Ní gá cumraíocht bunachar sonraí speisialta chun aon cheann de na feidhmeanna seo a úsáid, áfach, má tá níos mó ná cúpla céad taifead á chuardach agat, is dócha go mbeidh fadhbanna feidhmíochta ort. Is próiseas níos déine é cuardach téacs iomlán ná comparáid a dhéanamh idir méid sláimhir, mar shampla.

Sa chás go bhfuil na réimsí go léir a bhfuil tú ag fiosrú orthu laistigh de mhúnla áirithe amháin, is féidir leat inné <django.contrib.postgres.indexes.GinIndex><django.contrib.postgres.indexes.GistIndex>acs feidhmiúil:class: GIN `nó: class: `GIST a chruthú a oireann leis an veicteoir cuardaigh is mian leat a úsáid. Mar shampla:

GinIndex(
    SearchVector("body_text", "headline", config="english"),
    name="search_vector_idx",
)

The PostgreSQL docs has details on creating indexes for full text search.

>>> Entry.objects.update(search_vector=SearchVector("body_text"))
>>> Entry.objects.filter(search_vector="cheese")
<QuerySet [<Entry: Cheese on Toast recipes>, <Entry: Pizza recipes>]>

from django.contrib.postgres.indexes import GinIndex
from django.contrib.postgres.search import SearchVector, SearchVectorField
from django.db import models


class Entry(models.Model):
    headline = models.CharField(max_length=255)
    body_text = models.TextField()

    search_vector = models.GeneratedField(
        expression=SearchVector("headline", weight="A", config="english")
        + SearchVector("body_text", weight="B", config="english"),
        output_field=SearchVectorField(),
        db_persist=True,
    )

    class Meta:
        indexes = [GinIndex(fields=["search_vector"])]

Cosúlacht TrigramLink to this heading#

Cur chuige eile maidir le cuardach is ea cosúlacht trigram. Is grúpa de thrí charachtar as a chéile é trigram. Chomh maith leis na:lookup: trigram_similar, :lookup: trigram_word_similar, agus:lookup: trigram_strict_word_similar cuardaigh, is féidir leat cúpla abairt eile a úsáid.

< https://www.postgresql.org/docs/current/pgtrgm.html>Chun iad a úsáid, ní mór duit an síneadh pg_trgm `_ a ghníomhachtú ar PostgreSQL. Is féidir leat é a shuiteáil ag baint úsáide as an oibríocht imirce:class: `~django.contrib.postgres.operations.TrigramExtension.

>>> from django.contrib.postgres.search import TrigramSimilarity
>>> Author.objects.create(name="Katy Stevens")
>>> Author.objects.create(name="Stephen Keats")
>>> test = "Katie Stephens"
>>> Author.objects.annotate(
...     similarity=TrigramSimilarity("name", test),
... ).filter(
...     similarity__gt=0.3
... ).order_by("-similarity")
<QuerySet [<Author: Katy Stevens>, <Author: Stephen Keats>]>

>>> from django.contrib.postgres.search import TrigramWordSimilarity
>>> Author.objects.create(name="Katy Stevens")
>>> Author.objects.create(name="Stephen Keats")
>>> test = "Kat"
>>> Author.objects.annotate(
...     similarity=TrigramWordSimilarity(test, "name"),
... ).filter(
...     similarity__gt=0.3
... ).order_by("-similarity")
<QuerySet [<Author: Katy Stevens>]>

>>> from django.contrib.postgres.search import TrigramDistance
>>> Author.objects.create(name="Katy Stevens")
>>> Author.objects.create(name="Stephen Keats")
>>> test = "Katie Stephens"
>>> Author.objects.annotate(
...     distance=TrigramDistance("name", test),
... ).filter(
...     distance__lte=0.7
... ).order_by("distance")
<QuerySet [<Author: Katy Stevens>, <Author: Stephen Keats>]>

>>> from django.contrib.postgres.search import TrigramWordDistance
>>> Author.objects.create(name="Katy Stevens")
>>> Author.objects.create(name="Stephen Keats")
>>> test = "Kat"
>>> Author.objects.annotate(
...     distance=TrigramWordDistance(test, "name"),
... ).filter(
...     distance__lte=0.7
... ).order_by("distance")
<QuerySet [<Author: Katy Stevens>]>