--- title: "Cuardach téacs iomlán" version: 6.0 locale: ga source: https://docs.djangoproject.com/ga/6.0/ref/contrib/postgres/search/ canonical: https://djangodocs.dev/ga/6.0/ref/contrib/postgres/search/ --- # Cuardach téacs iomlán \< \>Éascaíonn feidhmeanna an bhunachar sonraí sa mhodúl `django.contrib.postgres.search` úsáid PostgreSQL. Maidir leis na samplaí sa doiciméad seo, úsáidfimid na samhlacha atá sainmhínithe in:doc: /topics/db/queries. > **See also** > > Le haghaidh forbhreathnú ardleibhéil ar chuardach, féach an:doc: doiciméadú topaic \. ## An cuardach `chuardach` 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: ```pycon >>> Entry.objects.filter(body_text__search="Cheese") , ]> ``` 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. ## `SearchVector` #### `class SearchVector(*expressions, config=None, weight=None)` 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`: ```pycon >>> from django.contrib.postgres.search import SearchVector >>> Entry.objects.annotate( ... search=SearchVector("body_text", "blog__tagline"), ... ).filter(search="Cheese") , ]> ``` 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: ```pycon >>> Entry.objects.annotate( ... search=SearchVector("body_text") + SearchVector("blog__tagline"), ... ).filter(search="Cheese") , ]> ``` 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\`. ## `Cuardcheiste` #### `class SearchQuery(value, config=None, search_type='plain')` 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](https://www.postgresql.org/docs/current/textsearch-controls.html#TEXTSEARCH-PARSING-QUERIES) chun foghlaim faoi dhifríochtaí agus comhréireacht. Samplaí: ```pycon >>> 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: ```pycon >>> 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`. > **Changed in Django 6.0** > > [`Lexeme`](#django.contrib.postgres.search.Lexeme) objects were added. ## `Searchrank` #### `class SearchRank(vector, query, weights=None, normalization=None, cover_density=False)` 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: ```pycon >>> 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") , ]> ``` 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: ```pycon >>> 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 chuardacha` #### `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)` 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. \Is iad réamhshocruithe PostgreSQL ná \`\` agus .\ 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: ```pycon >>> from django.contrib.postgres.search import SearchHeadline, SearchQuery >>> query = SearchQuery("red tomato") >>> entry = Entry.objects.annotate( ... headline=SearchHeadline( ... "body_text", ... query, ... start_sel="", ... stop_sel="", ... ), ... ).get() >>> print(entry.headline) Sandwich with tomato and red cheese. ``` Féach:ref: postgresql-fts-search-configuration le haghaidh míniú ar an paraiméadar `config`. ## Cumraíocht an chuardaigh a athrú 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 ```pycon >>> from django.contrib.postgres.search import SearchQuery, SearchVector >>> Entry.objects.annotate( ... search=SearchVector("body_text", config="french"), ... ).filter(search=SearchQuery("œuf", config="french")) ]> ``` D'fhéadfaí luach config\` a stóráil i gcolún eile freisin: ```pycon >>> 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"))) ]> ``` ## Fiosruithe meáchain 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: ```pycon >>> 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: ```pycon >>> 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") ``` ## `Lexeme` > **New in Django 6.0** #### `class Lexeme(value, output_field=None, * (Keyword-only parameters separator (PEP 3102)), invert=False, prefix=False, weight=None)` `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: ```pycon >>> 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")) ... ) , ]> ``` ```pycon >>> Entry.objects.annotate(search=vector).filter( ... search=SearchQuery(Lexeme("fruit") & Lexeme("dessert") & ~Lexeme("banana")) ... ) ]> ``` Lexeme objects also support term weighting and prefixes: ```pycon >>> Entry.objects.annotate(search=vector).filter( ... search=SearchQuery(Lexeme("Pizza") | Lexeme("Cheese")) ... ) , ]> >>> Entry.objects.annotate(search=vector).filter( ... search=SearchQuery(Lexeme("Pizza") | Lexeme("Cheese", weight="A")) ... ) ]> >>> Entry.objects.annotate(search=vector).filter( ... search=SearchQuery(Lexeme("za", prefix=True)) ... ) ``` ## feidhmíocht 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é \\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](https://www.postgresql.org/docs/current/textsearch-tables.html#TEXTSEARCH-TABLES-INDEX). ### `SearchVectorField` #### `class SearchVectorField` Má éiríonn an cur chuige seo ró-mhall, is féidir leat `SearchVectorField` a chur le do mhúnla. Beidh ort é a choinneáil daonra le spreagthóirí, mar shampla, mar a thuairiscítear sa doiciméadú [PostgreSQL](https://www.postgresql.org/docs/current/textsearch-features.html#TEXTSEARCH-UPDATE-TRIGGERS). Ansin is féidir leat an réimse a cheistiú amhail is dá mba “SearchVector” anótáilte é: ```pycon >>> Entry.objects.update(search_vector=SearchVector("body_text")) >>> Entry.objects.filter(search_vector="cheese") , ]> ``` ### Using `GeneratedField` An alternative method is to use a [`GeneratedField`](/ga/6.0/ref/models/fields/#django.db.models.GeneratedField), which has PostgreSQL maintain the column rather than a trigger: ``` 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 Trigram 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. \< \>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. ### Trigramchosúlacht \`\` #### `class TrigramSimilarity(expression, string, **extra)` Glacann sé le hainm réimse nó léiriú, agus teaghrán nó abairt. Tugann sé an chosúlacht trigram idir an dá argóint ar ais. Sampla úsáide: ```pycon >>> 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") , ]> ``` ### Tríghrambhóthaíocht \`\` #### `class TrigramWordSimilarity(string, expression, **extra)` Glacann sé le sreang nó abairt, agus ainm réimse nó léiriú. Filleann sé an chosúlacht focal trigram idir an dá argóint. Sampla úsáide: ```pycon >>> 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") ]> ``` ### `TrigramstrictOrdComhoilarity` #### `class TrigramStrictWordSimilarity(string, expression, **extra)` Glacann sé le sreang nó abairt, agus ainm réimse nó léiriú. Filleann sé an trigram cosúlacht dhian focal idir an dá argóint. Cosúil le:class: TrigramwordSimility () \, ach amháin go gcuireann sé teorainneacha méid teorainneacha focal a mheaitseáil. ### `Trigramdistance` #### `class TrigramDistance(expression, string, **extra)` Glacann sé le hainm réimse nó léiriú, agus teaghrán nó abairt. Tugann sé an fad trigram idir an dá argóint ar ais. Sampla úsáide: ```pycon >>> 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") , ]> ``` ### `TrigramWorddistance` #### `class TrigramWordDistance(string, expression, **extra)` Glacann sé le sreang nó abairt, agus ainm réimse nó léiriú. Tugann sé an fad focal trigram idir an dá argóint ar ais. Sampla úsáide: ```pycon >>> 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") ]> ``` ### `TrigramstrictOrdistance` #### `class TrigramStrictWordDistance(string, expression, **extra)` Glacann sé le sreang nó abairt, agus ainm réimse nó léiriú. Filleann sé an fad focal dian trigram idir an dá argóint.