Déanann nathanna fiosrúcháin cur síos ar luach nó ar ríomh is féidir a úsáid mar chuid de nuashonrú, cruthú, scagadh, ordú de réir, anótáil nó comhiomlán. Nuair a aschuireann abairt luach boolean, féadfar é a úsáid go díreach i scagairí. Tá roinnt nathanna ionsuite ann (doiciméadaithe thíos) is féidir a úsáid chun cabhrú leat ceisteanna a scríobh. Is féidir nathanna a chomhcheangal, nó i gcásanna áirithe a neadú, chun ríomhanna níos casta a fhoirmiú.
\nTacaíonn Django le diúltú, cur leis, íolrú, iolrú, roinnt, uimhríocht modulo, agus an t-oibreoir cumhachta ar nathanna fiosrúcháin, ag baint úsáide as comhsheasmhainní Python, athróga, agus fiú nathanna eile.
\nTacaíonn go leor de na nathanna doiciméadaithe sa chuid seo le paraiméadar roghnach output_field. Má thugtar, luchtálfaidh Django an luach isteach sa réimse sin tar éis é a aisghabháil ón mbunachar sonraí.
Glacann output_field sampla réimse samhail, mar IntegerField () ``nó ``BooleanField (). De ghnáth, ní theastaíonn aon argóintí ón réimse, cosúil le ``max_length ``, ós rud é go mbaineann argóintí réimse le bailíochtú sonraí nach ndéanfar ar luach aschuir an abairt.
Ní theastaíonn output_field ach amháin nuair nach bhfuil Django in ann cineál réimse an torthaí a chinneadh go huathoibríoch, mar shampla nathanna casta a mheascann cineálacha réimse. Mar shampla, teastaíonn réimse aschuir DecimalField () ``agus ``FloatField () a chur leis, cosúil le ``output_field=floatField () ``.
output_field also allows using custom fields that perform type conversions\noutside a specific model field context. For example, if you frequently need to\nperform date arithmetic with timedelta, you can create a custom field that\nhandles the conversion, ensuring consistent results across databases. See\nConas réimsí samhail saincheaptha a chruthú.
>>> from django.db.models import Count, F, Value\n>>> from django.db.models.functions import Length, Upper\n>>> from django.db.models.lookups import GreaterThan\n\n# Find companies that have more employees than chairs.\n>>> Company.objects.filter(num_employees__gt=F("num_chairs"))\n\n# Find companies that have at least twice as many employees\n# as chairs. Both the querysets below are equivalent.\n>>> Company.objects.filter(num_employees__gt=F("num_chairs") * 2)\n>>> Company.objects.filter(num_employees__gt=F("num_chairs") + F("num_chairs"))\n\n# How many chairs are needed for each company to seat all employees?\n>>> company = (\n... Company.objects.filter(num_employees__gt=F("num_chairs"))\n... .annotate(chairs_needed=F("num_employees") - F("num_chairs"))\n... .first()\n... )\n>>> company.num_employees\n120\n>>> company.num_chairs\n50\n>>> company.chairs_needed\n70\n\n# Create a new company using expressions.\n>>> company = Company.objects.create(name="Google", ticker=Upper(Value("goog")))\n>>> company.ticker\n'GOOG'\n\n# Annotate models with an aggregated value. Both forms\n# below are equivalent.\n>>> Company.objects.annotate(num_products=Count("products"))\n>>> Company.objects.annotate(num_products=Count(F("products")))\n\n# Aggregates can contain complex computations also\n>>> Company.objects.annotate(num_offerings=Count(F("products") + F("services")))\n\n# Expressions can also be used in order_by(), either directly\n>>> Company.objects.order_by(Length("name").asc())\n>>> Company.objects.order_by(Length("name").desc())\n# or using the double underscore lookup syntax.\n>>> from django.db.models import CharField\n>>> from django.db.models.functions import Length\n>>> CharField.register_lookup(Length)\n>>> Company.objects.order_by("name__length")\n\n# Boolean expression can be used directly in filters.\n>>> from django.db.models import Exists, OuterRef\n>>> Company.objects.filter(\n... Exists(Employee.objects.filter(company=OuterRef("pk"), salary__gt=10))\n... )\n\n# Lookup expressions can also be used directly in filters\n>>> Company.objects.filter(GreaterThan(F("num_employees"), F("num_chairs")))\n# or annotations.\n>>> Company.objects.annotate(\n... need_chairs=GreaterThan(F("num_employees"), F("num_chairs")),\n... )\nLéiríonn réad ``F () `luach réimse samhail, luach claochlaithe réimse samhail, nó colún anótaithe. De bharr sé gur féidir tagairt a dhéanamh do luachanna réimse samhail agus oibríochtaí bunachar sonraí a dhéanamh ag baint úsáide as iad gan iad a tharraingt amach as an mbunachar sonraí isteach i gcuimhne Python.
\nIna áit sin, úsáideann Django an réad ``F () `chun abairt SQL a ghiniúint a thugann cur síos ar an oibríocht riachtanach ag leibhéal an bhunachar sonraí.
\nDéanaimis triail a bhaint as seo le sampla. De ghnáth, d'fhéadfadh duine rud éigin mar seo a dhéanamh:
\n# Tintin filed a news story!\nreporter = Reporters.objects.get(name="Tintin")\nreporter.stories_filed += 1\nreporter.save()\nAnseo, tarraingamar luach reporter.stories_filed ón mbunachar sonraí isteach i gcuimhne agus rinneamar é a ionramháil ag baint úsáide as oibreoirí Python eolach, agus ansin shábháil an réad ar ais chuig an mbunachar sonraí. Ach ina ionad sin d'fhéadfaimis a dhéanamh freisin:
from django.db.models import F\n\nreporter = Reporters.objects.get(name="Tintin")\nreporter.stories_filed = F("stories_filed") + 1\nreporter.save()\nCé go bhfuil cuma reporter.stories_filed = F ('stories_filed') + 1 cosúil le gnáthshannadh luach Python le tréith sampla, i ndáiríre is tógáil SQL é ag cur síos ar oibríocht ar an mbunachar sonraí.
Nuair a thagann Django le sampla de F () ``, a sháraíonn sé na hoibreoirí caighdeánacha Python chun abairt SQL cumhdaithe a chruthú; sa chás seo, ceann a thugann treoir don bhunachar sonraí an réimse bunachar sonraí a léiríonn ``reporter.stories_filed a mhéadú.
Cibé luach atá nó a bhí ar reporter.stories_filed`, ní fhaigheann Python eolas faoi riamh - déileálann an bunachar sonraí leis go hiomlán. Is é gach rud a dhéanann Python, trí rang ``F () `Django, an comhréiteach SQL a chruthú chun tagairt a dhéanamh don réimse agus cur síos a dhéanamh ar an oibríocht.
\nAs well as being used in operations on single instances as above, F() can\nbe used with update() to perform bulk updates on a QuerySet. This\nreduces the two queries we were using above - the get() and the\nsave() - to just one:
reporter = Reporters.objects.filter(name="Tintin")\nreporter.update(stories_filed=F("stories_filed") + 1)\nWe can also use update() to increment\nthe field value on multiple objects - which could be very much faster than\npulling them all into Python from the database, looping over them, incrementing\nthe field value of each one, and saving each one back to the database:
Reporter.objects.update(stories_filed=F("stories_filed") + 1)\nDá bhrí sin is féidir le `F () ``buntáistí feidhmíochta a thairiscint trí:
\nan bunachar sonraí a fháil, seachas Python, chun obair a dhéanamh
laghdú ar líon na gceisteanna a theastaíonn ó oibríochtaí
For string-based fields, text-based fields, and\nArrayField, you can use Python's\narray-slicing syntax. The indices are 0-based. The step argument to\nslice and negative indexing are not supported. For example:
>>> # Replacing a name with a substring of itself.\n>>> writer = Writers.objects.get(name="Priyansh")\n>>> writer.name = F("name")[1:5]\n>>> writer.save()\n>>> writer.name\n'riya'\nBuntáiste úsáideach eile a bhaineann le `F () ``ná go seachnaíonn an bunachar sonraí - seachas Python - luach réimse a nuashonrú coinníoll rása.
\nMá fhorghníomhaíonn dhá snáithe Python an cód sa chéad shampla thuas, d'fhéadfadh snáithe amháin luach réimse a aisghabháil, a mhéadú agus a shábháil tar éis don duine eile é a aisghabháil ón mbunachar sonraí. Beidh an luach a shábhálann an dara snáithe bunaithe ar an luach bunaidh; caillfear obair an chéad snáithe.
\nIf the database is responsible for updating the field, the process is more\nrobust: it will only ever update the field based on the value of the field in\nthe database when the save() or update() is executed, rather\nthan based on its value when the instance was retrieved.
F() assignments are refreshed after Model.save()Link to this heading#F() objects assigned to model fields are refreshed from the database on\nsave() on backends that support it without incurring a subsequent\nquery (SQLite, PostgreSQL, and Oracle) and deferred otherwise (MySQL or\nMariaDB). For example:
>>> reporter = Reporters.objects.get(name="Tintin")\n>>> reporter.stories_filed = F("stories_filed") + 1\n>>> reporter.save()\n>>> reporter.stories_filed # This triggers a refresh query on MySQL/MariaDB.\n14 # Assuming the database value was 13 when the object was saved.\nTá F () ``an-úsáideach freisin i scagairí ``QuerySet, áit a ndéanann siad sraith rudaí a scagadh i gcoinne critéir bunaithe ar a luachanna réimse, seachas ar luachanna Python.
<using-f-expressions-in-filters>Tá sé seo doiciméadaithe in:ref: `ag baint úsáide as abairtí F () i gceisteanna `.
\nIs féidir ``F () ``a úsáid chun réimsí dinimiciúla a chruthú ar do mhúnlaí trí réimsí éagsúla a chomhcheangal le huimhríocht:
\ncompany = Company.objects.annotate(chairs_needed=F("num_employees") - F("num_chairs"))\nMá tá na réimsí atá á gcomhcheangal agat de chineálacha éagsúla beidh ort a rá le Django cén cineál réimse a thabharfar ar ais. Tacaíonn an chuid is mó de na nathanna le :ref: output_field <output-field>`don chás seo, ach ós rud é nach ndéanann ``F () `, beidh ort an abairt a fhilleadh le:class: ExpressionWrapper:
\nfrom django.db.models import DateTimeField, ExpressionWrapper, F\n\nTicket.objects.annotate(\n expires=ExpressionWrapper(\n F("active_at") + F("duration"), output_field=DateTimeField()\n )\n)\nNuair a dhéantar tagairt do réimsí coibhneasta mar ForeignKey, tugann F ()` an príomhluach seachas samhail samhail:
>>> car = Company.objects.annotate(built_by=F("manufacturer"))[0]\n>>> car.manufacturer\n<Manufacturer: Toyota>\n>>> car.built_by\n3\nÚsáid F () ``agus an argóint eochairfhocal ``nulls_first nó nulls_last to:meth: .expression.asc nô:meth: ~.expression.desc chun ordú luachanna null réimse a rialú. De réir réamhshocrú, braitheann an t-ordú ar do bhunachar sonraí.
Mar shampla, chun cuideachtaí nár tugadh teagmháil leo a shórtáil (last_contacted is null) tar éis cuideachtaí a ndearnadh teagmháil leo:
from django.db.models import F\n\nCompany.objects.order_by(F("last_contacted").desc(nulls_last=True))\nNathanna F () ``is féidir aschur ``Booleanfield a dhiúltú go loighciúil leis an oibreoir iompaithe ~F (). Mar shampla, chun stádas gníomhachtaithe cuideachtaí a mhalartú:
from django.db.models import F\n\nCompany.objects.update(is_active=~F("is_active"))\nIs iad abairtí Func () ``an bunchineál de na nathanna go léir a mbaineann feidhmeanna bunachar sonraí mar `COALESCE agus LOWER, nó comhiomlánacha mar SUM`. Is féidir iad a úsáid go díreach:
from django.db.models import F, Func\n\nqueryset.annotate(field_lower=Func(F("field"), function="LOWER"))\nnó is féidir iad a úsáid chun leabharlann feidhmeanna bunachar sonraí a thógáil:
\nclass Lower(Func):\n function = "LOWER"\n\n\nqueryset.annotate(field_lower=Lower("field"))\nAch beidh tacar ceisteanna mar thoradh ar an dá chás ina ndéantar anótáil ar gach samhail le tréith breise field_lower a tháirgtear, go garbh, ón SQL seo a leanas:
SELECT\n ...\n LOWER("db_table"."field") as "field_lower"\nSee Feidhmeanna Sonraí for a list of built-in database\nfunctions.
\nIs é seo a leanas an API Func`:
\nTréith aicme a dhéanann cur síos ar an bhfeidhm a ghinteofar. Go sonrach, déanfar an feidhm ``idirphóilte mar shealbhóir an ``feidhmi` laistigh de: attr: teimpléad. Réamhshocraithe go None.
Tréith aicme, mar shreang formáide, a chuireann síos ar an SQL a ghintear don fheidhm seo. Réamhshocraithe go ``'% (function) s (% (expressions) s) '`.
\nMá tá SQL á thógáil agat cosúil le strftime ('%W', 'date') ``agus má theastaíonn carachtar liteartha ``%` sa cheist, é a cheathrú (%%%%%) sa tréith teimpléad toisc go ndéantar an sreang idirphóilte dhá uair: uair amháin le linn an teimpléid in as_sql ()` agus uair amháin san idirpholú SQL leis na paraiméadair iarratais sa chúrsóir bunachar sonraí.
Tréith aicme a léiríonn an carachtar a úsáidtear chun páirt a ghlacadh le liosta léiritheach le chéile. Réamhshocraithe go ', '.
Tréith aicme a léiríonn líon na n-argóintí a nglacann an fheidhm leis. Má shocraítear an tréith seo agus má thugtar an fheidhm le líon difriúil nathanna, ardófar TypeError. Réamhshocraithe go None.
Gineann sé an blúire SQL don fheidhm bhunachar sonraí. Filleann sé tuple (sql, params), áit gurb é sql` an teaghrán SQL, agus params` an liosta nó an tiúpla de pharaiméadair fiosrúcháin.
Ba chóir do na modhanna as_vendor () ``úsáid a bhaint as na paraiméadair feidhm , `teimpléad, arg_joiner`, agus aon pharaiméadair **extra_context eile chun an SQL a shaincheapadh de réir mar is gá. Mar shampla:
django/db/samhlacha/feidhmeanna. pyclass ConcatPair(Func):\n ...\n function = "CONCAT"\n ...\n\n def as_mysql(self, compiler, connection, **extra_context):\n return super().as_sql(\n compiler,\n connection,\n function="CONCAT_WS",\n template="%(function)s('', %(expressions)s)",\n **extra_context\n )\nChun leochaileacht insteallta SQL a sheachaint, ní chóir go mbeadh ionchur úsáideora neamhiontaofa ag extra_context <avoiding-sql-injection-in-query-expressions>`: ref: `mar go ndéantar na luachanna seo a idirphóladh isteach sa sreangán SQL seachas a rith mar pharaiméadair fiosrúcháin, áit a n-éalódh tiománaí bunachar sonraí iad.
Is liosta de na nathanna seasaimh a chuirfear i bhfeidhm ar an bhfeidhm é an argóint * sainráitigh `. Déanfar na nathanna a thiontú go teaghráin, a chur le chéile le arg_joiner`, agus ansin idirphóilfear isteach sa teimpléad ``mar shealbhóir áite ``léirithe`.
\nIs féidir le hargóintí seasaimh a bheith ina nathanna nó luachanna Python. Glactar leis gur tagairtí colún iad na teaghráin agus fillfear iad in abairtí F () ``agus cuirfear luachanna eile fillte in abairtí ``Luach ().
Is iad na kwargs **extra péirí eochair=luach is féidir iad a ionghabháil isteach sa tréith teimpléad ``. Chun leochaileacht insteallta SQL a sheachaint, ní chóir go mbeadh ionchur úsáideora neamhion <avoiding-sql-injection-in-query-expressions>taofa ag ``extra: ref: `mar go ndéantar na luachanna seo a idirphóladh isteach sa sreang SQL seachas a rith mar pharaiméadair cheisteanna, áit a n-éalfadh tiománaí an bunachar sonraí iad.
Is féidir na heochairfhocail feidhm, teimpléad`, agus arg_joiner a úsáid chun tréithe an ainm céanna a chur in ionad gan do rang féin a shainiú. :ref: is féidir `output_field <output-field>`a úsáid chun an cineál tuairisceáin a bhfuil súil leis a shainiú.
Is cás speisialta é abairt comhiomlán de a:ref: Func () abairt <func-expressions>`a chuireann in iúl don cheist go bhfuil clásal ``GROUP BY` ag teastáil. Tá gach ceann de na feidhmeanna:ref: comhiomlán <aggregation-functions>, cosúil le Sum () ``agus ``Count (), oidhreacht ó ``Comhiomlán () ``.
Ós rud é gur abairtí agus nathanna fillte iad Comhiomlán, is féidir leat roinnt ríomhanna casta a léiriú:
from django.db.models import Count\n\nCompany.objects.annotate(\n managers_required=(Count("num_employees") / 4) + Count("num_managers")\n)\nIs é seo a leanas an API Comhléad:
Tréith aicme, mar shreang formáide, a chuireann síos ar an SQL a ghintear don chomhiomlán seo. Réamhshocraithe go ``'% (function) s (% (difriúil) s% (abairtí) s) '`.
\nTréith aicme a dhéanann cur síos ar an bhfeidhm chomhiomlán a ghinteofar. Go sonrach, déanfar an feidhm ``idirphóilte mar shealbhóir an ``feidhmi` laistigh de: attr: teimpléad. Réamhshocraithe go None.
Réamhshocraithe go True ós rud é gur féidir an chuid is mó de na feidhmeanna comhiomlána a úsáid mar an abairt foinse in:class: ~Django.db.Models.Expressions.Window.
Tréith aicme a chinneann cibé an gceadaíonn an fheidhm chomhiomlán seo argóint eochairfhocal “difriúil” a rith nó nach bhfuil. Má tá sé socraithe go False (réamhshocraithe), ardaítear TypeError má chuirtear Distinct=True.
A class attribute determining whether or not this aggregate function\nallows passing a order_by keyword argument. If set to False\n(default), TypeError is raised if order_by is passed as a value\nother than None.
Réamhshocraithe go None ós rud é go mbíonn NULL` mar thoradh ar an gcuid is mó de na feidhmeanna comhiomlána nuair a chuirtear i bhfeidhm ar shraith torthaí folamh.
Is féidir leis na hargóintí seasaimh léiritheach abairtí, claochruithe an réimse samhail, nó ainmneacha réimsí samhail a bheith san áireamh. Déanfar iad a thiontú go sreang agus úsáidfear iad mar shealbhóir áit ``léiritheoir` laistigh den teimpléad.
Cinneann an argóint difriúil ``cibé an gcaithfear an fheidhm chomhiomlán a ghairm nó nach bhfuil i gcás gach luach ar leith ``léiritheach (nó tacar luachanna, le haghaidh iolracha léiritheach). Ní thacaítear leis an argóint ach ar chomhiomláin a bhfuil: attr: ~Aggregate.allow_Distinct socraithe go True.
Tógann an argóint scagair a:class: Q rud `a úsáidtear chun na sraithe <django.db.models.Q>anna atá comhiomlánaithe a scagadh. Féach: ref: `comhiomlánú coinníollach agus:ref: filtering-on-annotations mar shampla úsáid.
The order_by argument behaves similarly to the field_names input of the\norder_by() function, accepting a field name (with an optional\n"-" prefix which indicates descending order) or an expression (or a tuple\nor list of strings and/or expressions) that specifies the ordering of the\nelements in the result.
Glacann an argóint default` luach a chuirfear in éineacht leis an comhiomlán chuig:class: ~Django.db.Models.Functions.Coalesce. Tá sé seo úsáideach chun luach atá le tabhairt ar ais seachas None a shonrú nuair nach bhfuil aon iontrálacha sa tacar fiosrúcháin (nó an ghrúpáil).
Is iad na kwargs **extra péirí eochair=luach is féidir iad a ionghabháil isteach sa tréith ``teimpléad ``.
Is féidir leat do fheidhmeanna comhiomlána féin a chruthú freisin. Ar a laghad, ní mór duit ``feidhm ``a shainiú, ach is féidir leat an SQL a ghintear a shaincheapadh go hiomlán freisin. Seo sampla gairid:
\nfrom django.db.models import Aggregate\n\n\nclass Sum(Aggregate):\n # Supports SUM(ALL field).\n function = "SUM"\n template = "%(function)s(%(all_values)s%(expressions)s)"\n allow_distinct = False\n arity = 1\n\n def __init__(self, expression, all_values=False, **extra):\n super().__init__(expression, all_values="ALL " if all_values else "", **extra)\nLéiríonn réad ``Luach () ``an chomhpháirt is lú is féidir de abairt: luach simplí. Nuair is gá duit luach sláimhir, boolean nó sreang a léiriú laistigh de abairt, is féidir leat an luach sin a fhilleadh laistigh de ``Luach () ``.
\nIs annamh a bheidh ort Luach () ``a úsáid go díreach. Nuair a scríobhann tú an abairt ``F ('field') + 1, fillteann Django an 1 go hinneach i ``Luach () ``, ag ligean luachanna simplí a úsáid i nathanna níos casta. Beidh ort ``Luach () ``a úsáid nuair is mian leat teaghrán a chur chuig abairt. Léirmhíníonn an chuid is mó de na nathanna argóint teaghrán mar ainm réimse, cosúil le ``Lower ('ainm') `.
Déanann an argóint luach cur síos ar an luach atá le cur san áireamh sa abairt, mar shampla `1, True`, nó None. Tá a fhios ag Django conas na luachanna Python seo a thiontú ina gcineál bunachar sonraí comhfhreag
If no output_field is specified, it will be inferred from\nthe type of the provided value for many common types. For example, passing\nan instance of datetime.datetime as value defaults\noutput_field to DateTimeField.
<output-field>Tá ExpressionWrapper timpeall ar abairt eile agus soláthraíonn sé rochtain ar airíonna, mar shampla:ref: output_field `, nach mbeadh ar fáil ar abairtí eile. Tá ``ExpressionWrapper` riachtanach nuair a úsáidtear uimhríocht ar abairtí ``F () ``le cineálacha éagsúla mar a thuairiscítear in:ref: using-f-with-annotations.
Conditional expressions allow you to use if ... elif ...\nelse logic in queries. Django natively supports SQL CASE\nexpressions. For more details see Nathanna Coinníollach.
Is féidir leat fo-cheist sainráite a chur le QuerySet ag baint úsáide as an abairt SubQuery.
Mar shampla, chun gach post a anótáil le seoladh ríomhphoist údar an trácht is nua ar an bpost sin:
\n>>> from django.db.models import OuterRef, Subquery\n>>> newest = Comment.objects.filter(post=OuterRef("pk")).order_by("-created_at")\n>>> Post.objects.annotate(newest_commenter_email=Subquery(newest.values("email")[:1]))\nAr PostgreSQL, tá cuma ar an SQL:
\nSELECT "post"."id", (\n SELECT U0."email"\n FROM "comment" U0\n WHERE U0."post_id" = ("post"."id")\n ORDER BY U0."created_at" DESC LIMIT 1\n) AS "newest_commenter_email" FROM "post"\nÚsáid OuterRef nuair is gá le tacar ceisteanna i Focheiste tagairt a dhéanamh do réimse ón bhfiosrú seachtrach nó a chlaochlú. Feidhmíonn sé cosúil le léiriú: aicme: F ach amháin nach ndéantar an seiceáil chun a fheiceáil an dtagraíonn sé do réimse bailí go dtí go réitear an tacar ceisteanna seachtrach.
Féadfar cásanna OuterRef a úsáid i gcomhar le cásanna neadaithe de Subcheiste chun tagairt a dhéanamh do thacar fiosrúcháin ina bhfuil nach é an tuismitheoir láithreach. Mar shampla, caithfeadh an tacar ceisteanna seo a bheith laistigh de phéire neadaithe cásanna Subcheiste chun réiteach i gceart:
>>> Book.objects.filter(author=OuterRef(OuterRef("pk")))\nTá amanna ann nuair a chaithfear colún amháin a thabhairt ar ais ó Subcheiste, mar shampla, chun Subcheiste a úsáid mar sprioc chuardaigh __in. Chun gach trácht ar phoist a fhoilsíodh laistigh den lá deireanach a thabhairt ar ais:
>>> from datetime import timedelta\n>>> from django.utils import timezone\n>>> one_day_ago = timezone.now() - timedelta(days=1)\n>>> posts = Post.objects.filter(published_at__gte=one_day_ago)\n>>> Comment.objects.filter(post__in=Subquery(posts.values("pk")))\nSa chás seo, ní mór don fho-cheist a úsáid: meth: ~.queryset.values chun colún amháin a thabhairt ar ais: príomh-eochair an phoist.
\nChun fo-cheist a chosc ó iliomad sraitheanna a thabhairt ar ais, úsáidtear slisnas ([:1]) den tacar fiosrúcháin:
>>> subquery = Subquery(newest.values("email")[:1])\n>>> Post.objects.annotate(newest_commenter_email=subquery)\nSa chás seo, ní mór don fho-cheist ach colún aon* agus* sraith amháin a thabhairt ar ais: seoladh ríomhphoist an trácht is déanaí a cruthaíodh.
\n(Teipfeadh ag baint úsáid:Meth: ~.querySet.get in ionad slisnas toisc nach féidir an OuterRef a réiteach go dtí go n-úsáidfear an tacar fiosrúcháin laistigh de Subcheiste.)
Is fo-aicme `Subcheiste é Exists` a úsáideann ráiteas SQL EXISTS. I go leor cásanna feidhmeoidh sé níos fearr ná fo-cheist ós rud é go bhfuil an bunachar sonraí in ann stop a chur le meastóireacht ar an bhfo-cheist nuair a aimsítear an chéad tsraith meaitseála.
Mar shampla, chun gach post a anótáil le cibé an bhfuil trácht aige laistigh den lá deireanach nó nach bhfuil:
\n>>> from django.db.models import Exists, OuterRef\n>>> from datetime import timedelta\n>>> from django.utils import timezone\n>>> one_day_ago = timezone.now() - timedelta(days=1)\n>>> recent_comments = Comment.objects.filter(\n... post=OuterRef("pk"),\n... created_at__gte=one_day_ago,\n... )\n>>> Post.objects.annotate(recent_comment=Exists(recent_comments))\nAr PostgreSQL, tá cuma ar an SQL:
\nSELECT "post"."id", "post"."published_at", EXISTS(\n SELECT (1) as "a"\n FROM "comment" U0\n WHERE (\n U0."created_at" >= YYYY-MM-DD HH:MM:SS AND\n U0."post_id" = "post"."id"\n )\n LIMIT 1\n) AS "recent_comment" FROM "post"\nNí gá iallach ar Exists tagairt a dhéanamh do cholún amháin, ós rud é go ndéantar na colúin a chaitheamh agus cuirtear toradh boolean ar ais. Ar an gcaoi chéanna, ós rud é nach bhfuil ordú tábhachtach laistigh de fhocheistiú SQL EXISTS agus nach ndéanfadh sé ach feidhmíocht a laghdú, baintear é go huathoibríoch.
Is féidir leat ceist a dhéanamh ag baint úsáide as NOT EXISTS le ``~Exists () ``.
Focheist () nó Existents () `Link to this heading#Is féidir Subquery () ``a thugann luach boolean agus ``Existents () a úsáid mar coinníoll in:class: `~django.db.Models.Expressions.When `abairtí, nó chun tacar fiosrúcháin a scagadh go díreach:
>>> recent_comments = Comment.objects.filter(...) # From above\n>>> Post.objects.filter(Exists(recent_comments))\nCinnteoidh sé seo nach gcuirfear an fo-cheist leis na colúin SELECT, rud a d'fhéadfadh feidhmíocht níos fearr a bheith mar thoradh air.
Is féidir comhiomláin a úsáid laistigh de SubQuery, ach teastaíonn teaglaim shonrach uathu de:meth: ~.queryset.filter, :meth: ~.queryset.values, agus:meth: ~.queryset.annotate chun an grúpáil fo-cheisteanna a chur i gceart.
Ag glacadh leis go bhfuil réimse ``fad ``ag an dá mhúnla, chun poist a aimsiú ina bhfuil fad an phoist níos mó ná fad iomlán na dtuairimí comhcheangailte go léir:
\n>>> from django.db.models import OuterRef, Subquery, Sum\n>>> comments = Comment.objects.filter(post=OuterRef("pk")).order_by().values("post")\n>>> total_comments = comments.annotate(total=Sum("length")).values("total")\n>>> Post.objects.filter(length__gt=Subquery(total_comments))\nCuireann an “scagaire (...)” tosaigh teorainn leis an bhfocheistiú go dtí na paraiméadair ábhartha. Baineann order_by () ``an réamhshocraithe:attr: `~Django.db.Models.Options.Ordering` (más ann) ar an tsamhail ``Comment. Comhiomlánann luachanna ('post') ``tuairimí le ``Post. Faoi dheireadh, déanann ``annotate (...) ``an comhiomlánú. Tá an t-ord ina gcuirtear na modhanna ceisteanna seo i bhfeidhm tábhachtach. Sa chás seo, ós rud é go gcaithfear an fo-cheist a bheith teoranta do cholún amháin, tá gá le luachanna ('iomlán') `.
Is é seo an t-aon bhealach chun comhiomlánú a dhéanamh laistigh de SubQuery, mar a úsáideann: meth: ~.queryset.aggregate iarracht an tacar ceisteanna a mheas (agus má tá OuterRef ann, ní féidir é seo a réiteach).
Uaireanta ní féidir le nathanna bunachar sonraí clásal casta WHERE a chur in iúl go héasca. Sna cásanna imeall seo, bain úsáid as an abairt ``Rawsql`. Mar shampla:
>>> from django.db.models.expressions import RawSQL\n>>> queryset.annotate(val=RawSQL("select col from sometable where othercol = %s", (param,)))\nB'fhéidir nach mbeidh na cuardaigh breise seo iniompartha d'innill bhunachar sonraí éagsúla (toisc go bhfuil cód SQL á scríobh go sainráite agat) agus sáraíonn tú prionsabal DRY, mar sin ba cheart duit iad a sheachaint más féidir.
\nIs féidir nathanna Rawsql a úsáid freisin mar sprioc scagairí __in:
>>> queryset.filter(id__in=RawSQL("select id from sometable where col = %s", (param,)))\nSoláthraíonn feidhmeanna fuinneoige bealach chun feidhmeanna a chur i bhfeidhm ar Murab ionann agus gnáthfheidhm chomhiomlánaithe a ríomhaíonn toradh deiridh do gach tacar a shainmhíníonn an grúpa ag, oibríonn feidhmeanna fuinneoige ar:ref: `frámaí <window-frames>`agus deighiltí, agus ríomhaíonn siad an toradh do gach sraith.
\nIs féidir leat fuinneoga iolracha a shonrú san fhiosrúchán céanna a bheadh i Django ORM comhionann le nathanna iolracha a áireamh in a:doc: `Query</topics/db/aggregation> Set.annotate () `glao. Ní úsáideann an ORM fuinneoga ainmnithe, ina ionad sin tá siad mar chuid de na colúin roghnaithe.
\nRéamhshocraithe go % (abairt) s OVER (% (window) s) `. Mura gcuirtear ach an argóint ``léirithe ar fáil, beidh clásal na fuinneoige bán.
Is é an rang Windows ``an príomh-abairt do chlásal ``OVER.
Is é an argóint léirithe a: ref: feidhm fuinneog `<window-functions>, an:ref: `feidhm chomhiomlán, nó abairt atá comhoiriúnach i gclá <aggregation-functions>sal fuinneoige.
The partition_by argument accepts an expression or a sequence of\nexpressions (column names should be wrapped in an F-object) that control\nthe partitioning of the rows. Partitioning narrows which rows are used to\ncompute the result set.
Sonraítear an:ref: `output_field <output-field>`mar argóint nó leis an abairt.
\nGlacann an argóint order_by` le abairt ar féidir leat glao:meth: ~django.db.models.expression.asc agus:meth: ~django.db.models.expression.desc, teaghrán ainm réimse (le réimír roghnach ” -" a léiríonn ord íslitheach), nó liosta teaghráin agus/nó nathanna. Rialaíonn an t-ordú an t-ord ina gcuirtear an abairt i bhfeidhm. Mar shampla, má chuireann tú suim thar na sraitheanna i ndeighilt, is é an chéad toradh luach an chéad shraith, is é an dara ceann suim den chéad agus an dara sraith.
The frame parameter specifies which other rows should be used in the\ncomputation. See Frámaí for details.
Mar shampla, chun anótáil a dhéanamh ar gach scannán leis an meánrátáil do na scannáin ag an stiúideo céanna sa seánra agus sa bhliain scaoilte céanna:
\n>>> from django.db.models import Avg, F, Window\n>>> Movie.objects.annotate(\n... avg_rating=Window(\n... expression=Avg("rating"),\n... partition_by=[F("studio"), F("genre")],\n... order_by="released__year",\n... ),\n... )\nLigeann sé seo duit seiceáil an bhfuil scannán a rátáil níos fearr nó níos measa ná a phiaraí.
\nB'fhéidir gur mhaith leat nathanna iolracha a chur i bhfeidhm thar an bhfuinneog chéanna, ie, an deighilt agus an fráma céanna. Mar shampla, d'fhéadfá an sampla roimhe seo a mhodhnú chun an rátáil is fearr agus is measa a áireamh i ngrúpa gach scannáin (an stiúideo céanna, an seánra agus an bhliain scaoilte céanna) trí fheidhm fuinneoige a úsáid san fhiosrú céanna. Baintear an deighilt agus an t-ordú ón sampla roimhe seo isteach i bhfoclóir chun athrá a laghdú:
\n>>> from django.db.models import Avg, F, Max, Min, Window\n>>> window = {\n... "partition_by": [F("studio"), F("genre")],\n... "order_by": "released__year",\n... }\n>>> Movie.objects.annotate(\n... avg_rating=Window(\n... expression=Avg("rating"),\n... **window,\n... ),\n... best=Window(\n... expression=Max("rating"),\n... **window,\n... ),\n... worst=Window(\n... expression=Min("rating"),\n... **window,\n... ),\n... )\nTacaítear le scagadh i gcoinne feidhmeanna fuinneoige chomh fada agus nach bhfuil cuardaigh díghníomhach (gan úsáid OR` nó XOR mar chónascaire) agus i gcoinne tacar cheisteanna a dhéanann comhiomlánú.
Mar shampla, ní thacaítear le ceist a bhraitheann ar chomhiomlánú agus a bhfuil scagaire Or -ED aige i gcoinne feidhm fuinneoige agus réimse. D'fhéadfadh go gcuirfí sraitheanna a eisiamh ó ghrúpaí de ghnáth a chur san áireamh iar-chomhiomlánú réamhchóga comhcheang
>>> qs = Movie.objects.annotate(\n... category_rank=Window(Rank(), partition_by="category", order_by="-rating"),\n... scenes_count=Count("actors"),\n... ).filter(Q(category_rank__lte=3) | Q(title__contains="Batman"))\n>>> list(qs)\nNotImplementedError: Heterogeneous disjunctive predicates against window functions\nare not implemented when performing conditional aggregation.\nI measc cúltaca bunachar sonraí ionsuite Django, tacaíonn MySQL, PostgreSQL, agus Oracle nathanna fuinneoige. Athraíonn tacaíocht do ghnéithe éagsúla léirithe fuinneoige i measc na mbun Mar shampla, ní fhéadfar tacú leis na roghanna in:meth: ~Django.db.Models.Expression.asc agus:meth: ~Django.db.Models.Expression.desc. Téigh i gcomhairle leis na cáipéisíocht do do bhunachar sonraí
\nMaidir le fráma fuinneoige, is féidir leat seicheamh sraitheanna bunaithe ar raon nó gnáthseicheamh sraitheanna a roghnú.
\nTá an tréith seo socraithe go 'RANGE.
Tá tacaíocht theoranta ag PostgreSQL do ValueRange` agus ní thacaíonn sé ach le húsáid na bpointí tosaigh agus deiridh caighdeánacha, mar shampla CURRENT ROW agus UNBOUNDED FOLLOWING.
Tá an tréith seo socraithe go 'ROWS'.
Tugann an dá rang SQL ar ais leis an teimpléad:
\n%(frame_type)s BETWEEN %(start)s AND %(end)s\nCeadaíonn an argóint ``eisiamh ``sraitheanna (:attr: ~WindowFrameExclusion.current_row), grúpaí (:attr: ~WindowFrameExclusion.group), agus ceangail (:attr: ~WindowFrameExclusion.ties) a eisiamh ó na frámaí fuinneoige ar bhunachar sonraí tacaithe:
\n%(frame_type)s BETWEEN %(start)s AND %(end)s EXCLUDE %(exclusion)s\nCuimsíonn frámaí na sraitheanna a úsáidtear chun an toradh a ríomh. Aistríonn siad ó phointe tosaigh éigin go pointe deiridh sonraithe éigin. Is féidir frámaí a úsáid le deighiltí agus gan deighiltí, ach is minic gur smaoineamh maith é ordú na fuinneoige a shonrú chun toradh cinntitheach a chinntiú. I bhfráma, is é piaraí i bhfráma ina chéile le luach coibhéiseach, nó gach sraitheanna mura bhfuil clásal ordaithe i láthair.
\nIs é an pointe tosaigh réamhshocraithe le haghaidh fráma ná UNBOUNDED PRESEING arb é an chéad tsraith den dheighilt. Cuirtear an pointe deiridh san áireamh go sainráite i gcónaí sa SQL a ghineann an ORM agus de réir réamhshocraithe é “FOLLOWING UNBOUNDED”. Cuimsíonn an fráma réamhshocraithe gach sraitheanna ón deighilt go dtí an tsraith deireanach sa tacar.
Is iad na luachanna a nglactar leis do na hargóintí tús ``agus ``deireadh ná None, sláimhir, nó nialas. Mar thoradh ar shláimhir dhiúltach do tosaithe bíonn N ROIMH ROIMH mar thoradh ar ``None ROIMH `ROIMH NEAMHTHEANNA`. I mód ROWS`, is féidir sláimhir dhearfach a úsáid le haghaidh ``tús ``mar thoradh ar ``N FOLLOWING. Glactar le sláimhreacha dearfacha le haghaidh deireadh ``agus bíonn `N FOLLOWING mar thoradh air. I mód ROWS`, is féidir sláimhir dhiúltach a úsáid le haghaidh ``deireadh ``mar thoradh air sin ``N ROIMH. Maidir le tosa agus deireadh ``araon, fillfidh nialas ``CURRENT ROW.
Tá difríocht ann maidir leis an méid a chuimsíonn CURRENT ROW. Nuair a shonraítear i mód ROWS`, tosaíonn nó críochnaíonn an fráma leis an tsraith reatha. Nuair a shonraítear i mód “RANGE”, tosaíonn nó críochnaíonn an fráma ag an gcéad piara nó an piara deireanach de réir an chlásal ordaithe. Dá bhrí sin, déanann `RANGE CURRENT ROW` measúnú ar an abairt do shraitheanna a bhfuil an luach céanna acu a shonraítear leis an ordú. Toisc go n-áirítear sa teimpléad na pointí ``tosaithe agus ``deireadh ``araon, féadfar é seo a chur in iúl le:
ValueRange(start=0, end=0)\nMá dhéantar cur síos ar “phiaraí” scannáin mar scannáin a d'eisigh an stiúideo céanna sa seánra céanna sa bhliain chéanna, déanann an sampla ``Rowrange` seo anótáil gach scannán le meán-rátáil dhá phiaraí roimhe seo agus beirt phiaraí scannáin seo a leanas:
\n>>> from django.db.models import Avg, F, RowRange, Window\n>>> Movie.objects.annotate(\n... avg_rating=Window(\n... expression=Avg("rating"),\n... partition_by=[F("studio"), F("genre")],\n... order_by="released__year",\n... frame=RowRange(start=-2, end=2),\n... ),\n... )\nMá thacaíonn an bunachar sonraí leis, is féidir leat na pointí tosaigh agus deiridh a shonrú bunaithe ar luachanna léirithe sa dheighilt. Má stóráil réimse scaoil den tsamhail ``Scannán ``mhí scaoilte gach scannáin, déanann an sampla ``ValueRange` seo anótáil gach scannán le meánrátáil piaraí scannáin a eisíodh idir dhá mhí dhéag roimh agus dhá mhí dhá tar éis gach scannán:
>>> from django.db.models import Avg, F, ValueRange, Window\n>>> Movie.objects.annotate(\n... avg_rating=Window(\n... expression=Avg("rating"),\n... partition_by=[F("studio"), F("genre")],\n... order_by="released__year",\n... frame=ValueRange(start=-12, end=12),\n... ),\n... )\nAnseo thíos gheobhaidh tú sonraí feidhme teicniúla a d'fhéadfadh a bheith úsáideach d'údair leabharlainne Cuideoidh an API teicniúil agus na samplaí thíos le nathanna ceisteanna cineálacha a chruthú ar féidir leo an fheidhmiúlacht ionsuite a sholáthraíonn Django
\nCuireann nathanna fiosrúcháin an: ref: `abairt fiosraithe API <query-expression>`i bhfeidhm, ach nochtann roinnt modhanna agus tréithe breise atá liostaithe thíos freisin. Caithfidh gach abairt fiosrúcháin a oidhreacht ó ``Expression () ``nó ó fho-aicme ábhartha.
\nNuair a fhilleann abairt fiosrúcháin abairt eile, tá sé freagrach as na modhanna cuí a ghlaoch ar an abairt fillte.
\nInsíonn sé le Django gur féidir an abairt seo a úsáid in:attr: Field.db_default. Réamhshocraithe go False.
Insíonn sé le Django gur féidir an abairt seo a úsáid le linn bailíochtú srianta. Ní mór ach abairt foinse amháin a bheith ag abhairtí le restricint_validation_compatible atá socraithe go False. Réamhshocraithe go True.
Insíonn sé le Django go bhfuil comhiomlán sa abairt seo agus gur gá clásal `GROUP BY ``a chur leis an gceist.
\nInsíonn sé le Django go bhfuil a: aicme: ~Django.db.Models.Expressions.Window léiriú sa abairt seo. Úsáidtear é, mar shampla, chun nathanna feidhme fuinneoige a dhícheadú i gceisteanna a mhodhnóidh sonraí.
\nInsíonn sé le Django gur féidir tagairt a thabhairt don abairt seo in:meth: .querySet.filter. Réamhshocraithe go True.
Insíonn sé le Django gur féidir an abairt seo a úsáid mar an abairt foinse in:class: ~Django.db.Models.Expressions.Window. Réamhshocraithe go False.
Tells Django which value should be returned when the expression is used\nto apply a function over an empty result set. Defaults to\nNotImplemented which forces the expression to be computed on\nthe database.
Tells Django that this expression contains a set-returning function,\nenforcing subquery evaluation. It's used, for example, to allow some\nPostgres set-returning functions (e.g. JSONB_PATH_QUERY,\nUNNEST, etc.) to skip optimization and be properly evaluated when\nannotations spawn rows themselves. Defaults to False.
Tells Django that this expression allows composite expressions, for\nexample, to support composite primary keys. Defaults to False.
Soláthraíonn sé deis aon réamhphróiseáil nó bailíochtú an abairt a dhéanamh sula gcuirtear é leis an bhfiosrú. Ní mór resolve_expression () ``a ghlaoch freisin ar aon nathanna neadaithe. Ba chóir ``cóip () ``de ``féin a thabhairt ar ais le haon claochlú riachtanach.
Is é fiosraithe cur i bhfeidhm na ceisteanna cúltaca.
Is boolean é allow_joins` a cheadaíonn nó a dhiúltaíonn úsáid comhpháirteanna sa cheist.
\nIs sraith de chomhpháirteanna in-athúsáidte é ``athúsáid` le haghaidh cásanna ilcheangailte.
\nIs boolean é achoimre ``a thugann comharthaíocht, nuair a dhéanann ``True, gur ceist chomhiomlán críochfoirt é an cheist atá á ríomh.
Is boolean é for_save a thugann comharthaíocht, nuair a dhéanann True, go bhfuil an ceist atá á fhorghníomhú ag déanamh cruthú nó nuashonrú.
Tugann liosta ordaithe de nathanna istigh ar ais. Mar shampla:
\n>>> Sum(F("foo")).get_source_expressions()\n[F('foo')]\nTógann sé liosta nathanna agus stóráilíonn sé iad ionas gur féidir le ``get_source_expressions () ``iad a thabhairt ar ais.
\nTugann clón (cóip) de féin ar ais, le haon ainmneacha colún athlipéadaithe. Athainmnítear ainmneacha colún nuair a chruthaítear fo-cheisteanna. Ba chóir ``relabeled_clone () ``a ghlaoch freisin ar aon nathanna neadaithe agus a shannadh don chlón.
Is foclóir é change_map a mhapáil sean-ainmneacha chuig ainmneacha nua.
Sampla:
\ndef relabeled_clone(self, change_map):\n clone = copy.copy(self)\n clone.expression = self.expression.relabeled_clone(change_map)\n return clone\nCrúca a ligeann don abairt “luach” a chur i gcrích níos oiriúnaí.
\nTá léirithe mar an gcéanna le féin.
Responsible for returning the list of columns referenced by\nthis expression. get_group_by_cols() should be called on any\nnested expressions. F() objects, in particular, hold a reference\nto a column.
Filleann sé an abairt atá réidh le sórtáil in ord ardaitheach.
\nSainmhíníonn nulls_first agus nulls_last conas a shórtáiltear luachanna null. Féach:ref: using-f-to-sort-null-values mar shampla úsáid.
Filleann sé an abairt atá réidh le sórtáil in ord íslitheach.
\nSainmhíníonn nulls_first agus nulls_last conas a shórtáiltear luachanna null. Féach:ref: using-f-to-sort-null-values mar shampla úsáid.
Returns self with any modifications required to reverse the sort\norder within an order_by call. As an example, an expression\nimplementing NULLS LAST would change its value to be\nNULLS FIRST. Modifications are only required for expressions that\nimplement sort order like OrderBy. This method is called when\nreverse() is called on a\nqueryset.
Is féidir leat d'aicmí léirithe fiosrúcháin féin a scríobh a úsáideann nathanna fiosrúcháin eile agus is féidir leo comhtháthú leo. <func-expressions>Déanaimis céim trí shampla trí chur i bhfeidhm an fheidhm COALESCE SQL a scríobh, gan na nathanna ionsuite: ref: `Func () `a úsáid.
Sainmhínítear an fheidhm SQL COALESCE` mar liosta de cholúin nó luachanna a ghlacadh. Cuirfidh sé an chéad cholún nó an luach ar ais nach NULL.
Tosóimid tríd an teimpléad atá le húsáid le haghaidh giniúint SQL agus modh ``__init__ () ``a shainiú chun roinnt tréithe a shocrú:
\nfrom django.db.models import Expression\n\n\nclass Coalesce(Expression):\n template = "COALESCE( %(expressions)s )"\n\n def __init__(self, expressions, output_field):\n super().__init__(output_field=output_field)\n if len(expressions) < 2:\n raise ValueError("expressions must have at least 2 elements")\n for expression in expressions:\n if not hasattr(expression, "resolve_expression"):\n raise TypeError("%r is not an Expression" % expression)\n self.expressions = expressions\nDéanaimid roinnt bailíochtú bunúsach ar na paraiméadair, lena n-áirítear 2 cholún nó luach ar a laghad a éileamh, agus a chinntiú gur nathanna iad Táimid ag iarraidh:ref: `output_field <output-field>`anseo ionas go mbeidh a fhios ag Django cén cineál réimse samhail chun an toradh deiridh a shannadh dó.
\nAnois cuirimid an réamhphróiseáil agus bailíochtú i bhfeidhm. Ós rud é nach bhfuil aon cheann dár mbailíochtú féin againn ag an bpointe seo, tarmligimid chuig na nathanna neadaithe:
\ndef resolve_expression(\n self, query=None, allow_joins=True, reuse=None, summarize=False, for_save=False\n):\n c = self.copy()\n c.is_summary = summarize\n for pos, expression in enumerate(self.expressions):\n c.expressions[pos] = expression.resolve_expression(\n query, allow_joins, reuse, summarize, for_save\n )\n return c\nAnsin, scríobhaimid an modh atá freagrach as an SQL a ghiniúint:
\ndef as_sql(self, compiler, connection, template=None):\n sql_expressions, sql_params = [], []\n for expression in self.expressions:\n sql, params = compiler.compile(expression)\n sql_expressions.append(sql)\n sql_params.extend(params)\n template = template or self.template\n data = {"expressions": ",".join(sql_expressions)}\n return template % data, tuple(sql_params)\n\n\ndef as_oracle(self, compiler, connection):\n """\n Example of vendor specific handling (Oracle in this case).\n Let's make the function name lowercase.\n """\n return self.as_sql(compiler, connection, template="coalesce( %(expressions)s )")\nIs féidir le modhanna as_sql () ``tacú le hargóintí saincheaptha eochairfhocal, rud a ligeann do mhodhanna ``as_vendorname () sonraí a úsáidtear chun an teaghrán SQL a ghiniúint a shárú. Is fearr argóintí eochairfhocal as_sql () ``a úsáid le haghaidh saincheaptha ná ``self a athrú laistigh de mhodhanna as_vendorname ()` mar is féidir earráidí a bheith mar thoradh ar an dara ceann agus iad ag rith ar chúlpháirteanna éagsúla bunachar sonraí. Má bhíonn do rang ag brath ar thréithe ranga chun sonraí a shainiú, smaoinigh ar sháraitheanna a cheadú i do mhodh as_sql () `.
Gineann muid an SQL do gach ceann de na “léirithe” tríd an modh ``compiler.compiler.compiler () ``a úsáid, agus cuirimid an toradh in éineacht le camóga. Ansin líontar an teimpléad lenár sonraí agus cuirtear an SQL agus na paraiméadair ar ais.
\nTá cur i bhfeidhm saincheaptha sainmhínithe againn freisin atá sonrach don chúlcheann Oracle. Glaofar an fheidhm as_oracle () ``in ionad ``as_sql () má tá cúltaca Oracle in úsáid.
Faoi dheireadh, cuirimid an chuid eile de na modhanna i bhfeidhm a ligeann dár léiriú ceisteanna imirt go deas le nathanna ceisteanna eile:
\ndef get_source_expressions(self):\n return self.expressions\n\n\ndef set_source_expressions(self, expressions):\n self.expressions = expressions\nFeicfimid conas a oibríonn sé:
\n>>> from django.db.models import F, Value, CharField\n>>> qs = Company.objects.annotate(\n... tagline=Coalesce(\n... [F("motto"), F("ticker_name"), F("description"), Value("No Tagline")],\n... output_field=CharField(),\n... )\n... )\n>>> for c in qs:\n... print("%s: %s" % (c.name, c.tagline))\n...\nGoogle: Do No Evil\nApple: AAPL\nYahoo: Internet Company\nDjango Software Foundation: No Tagline\nÓs rud é go ndéantar argóintí eochairfhocal Func do __init__ () ``(``**extra_context`)`` (**extra_context) idirphóilte isteach sa teaghrán SQL seachas a rith mar pharaiméadair cheistiúcháin (áit a n-éalfadh an tiománaí bunachar sonraí iad), ní mór ionchur úsáideora neamhiontaofa iontu.
Mar shampla, má sholáthraítear foshraithe ón úsáideoir, tá an fheidhm seo leochaileach do instealladh SQL:
from django.db.models import Func\n\n\nclass Position(Func):\n function = "POSITION"\n template = "%(function)s('%(substring)s' in %(expressions)s)"\n\n def __init__(self, expression, substring):\n # substring=substring is an SQL injection vulnerability!\n super().__init__(expression, substring=substring)\nGineann an fheidhm seo teaghrán SQL gan aon pharaiméadair. Ós rud é go gcuirtear foshraithe ar aghaidh chuig ``super (). __init__ () ``mar argóint eochairfhocal, déantar é a idirphóladh isteach sa teaghrán SQL sula seoltar an cheist chuig an mbunachar sonraí.
Seo athscríobh ceartaithe:
\nclass Position(Func):\n function = "POSITION"\n arg_joiner = " IN "\n\n def __init__(self, expression, substring):\n super().__init__(substring, expression)\nLe “foshraitheacht” a rith mar argóint seasaimh ina ionad sin, cuirfear ar aghaidh mar pharaiméadar san fhiosrúchán bunachar sonraí.
\nMá tá cúltaca bunachar sonraí á úsáid agat a úsáideann comhréir SQL difriúil le haghaidh feidhm áirithe, is féidir leat tacaíocht a chur leis trí mhoncaí modh nua a phaiteáil ar rang na feidhme.
\nAbair go bhfuilimid ag scríobh cúltaca do Freastalaí SQL Microsoft a úsáideann an SQL LEN in ionad LENGTH don fheidhme:class: ~functions.LENGTH. Déanfaimid moncaí modh nua ar a dtugtar as_sqlserver () ``a phaisteáil ar an rang ``Length:
from django.db.models.functions import Length\n\n\ndef sqlserver_length(self, compiler, connection):\n return self.as_sql(compiler, connection, function="LEN")\n\n\nLength.as_sqlserver = sqlserver_length\nIs féidir leat an SQL a shaincheapadh freisin ag baint úsáide as an paraiméadar teimpléad de as_sql () `.
Úsáidimid as_sqlserver () ``toisc go bhfilleann ``django.db.connection.vendor sqlserver don chúltaca.
Is féidir le cúltaca tríú páirtí a gcuid feidhmeanna a chlárú i gcomhad __init__.py barr leibhéal an phacáiste cúltaca nó i gcomhad expressions.py barr leibhéal (nó pacáiste) a allmhairítear ón leibhéal barr __init__.py.
<django.apps.AppConfig.ready>Maidir le tionscadail úsáideora atá ag iarraidh an cúltaca atá á úsáid acu a phaiseáil, ba chóir go mbeadh an cód seo i modh: meth: `AppConfig.ready () `.
\n