Nathanna ceisteannaLink to this heading#

Nathanna ``F () ``Link to this heading#

class FLink to this definition#

Lé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.

Ina á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í.

Déanaimis triail a bhaint as seo le sampla. De ghnáth, d'fhéadfadh duine rud éigin mar seo a dhéanamh:

# Tintin filed a news story!
reporter = Reporters.objects.get(name="Tintin")
reporter.stories_filed += 1
reporter.save()

Anseo, 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

reporter = Reporters.objects.get(name="Tintin")
reporter.stories_filed = F("stories_filed") + 1
reporter.save()

Cé 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.

As well as being used in operations on single instances as above, F() can be used with update() to perform bulk updates on a QuerySet. This reduces the two queries we were using above - the get() and the save() - to just one:

reporter = Reporters.objects.filter(name="Tintin")
reporter.update(stories_filed=F("stories_filed") + 1)

We can also use update() to increment the field value on multiple objects - which could be very much faster than pulling them all into Python from the database, looping over them, incrementing the field value of each one, and saving each one back to the database:

Reporter.objects.update(stories_filed=F("stories_filed") + 1)

Dá bhrí sin is féidir le `F () ``buntáistí feidhmíochta a thairiscint trí:

• an bunachar sonraí a fháil, seachas Python, chun obair a dhéanamh

• laghdú ar líon na gceisteanna a theastaíonn ó oibríochtaí

>>> # Replacing a name with a substring of itself.
>>> writer = Writers.objects.get(name="Priyansh")
>>> writer.name = F("name")[1:5]
>>> writer.save()
>>> writer.name
'riya'

>>> reporter = Reporters.objects.get(name="Tintin")
>>> reporter.stories_filed = F("stories_filed") + 1
>>> reporter.save()
>>> reporter.stories_filed  # This triggers a refresh query on MySQL/MariaDB.
14  # Assuming the database value was 13 when the object was saved.

company = Company.objects.annotate(chairs_needed=F("num_employees") - F("num_chairs"))

from django.db.models import DateTimeField, ExpressionWrapper, F

Ticket.objects.annotate(
    expires=ExpressionWrapper(
        F("active_at") + F("duration"), output_field=DateTimeField()
    )
)

>>> car = Company.objects.annotate(built_by=F("manufacturer"))[0]
>>> car.manufacturer
<Manufacturer: Toyota>
>>> car.built_by
3

from django.db.models import F

Company.objects.order_by(F("last_contacted").desc(nulls_last=True))

from django.db.models import F

Company.objects.update(is_active=~F("is_active"))

Nathanna ``Func () ``Link to this heading#

Is 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

queryset.annotate(field_lower=Func(F("field"), function="LOWER"))

nó is féidir iad a úsáid chun leabharlann feidhmeanna bunachar sonraí a thógáil:

class Lower(Func):
    function = "LOWER"


queryset.annotate(field_lower=Lower("field"))

Ach 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
    ...
    LOWER("db_table"."field") as "field_lower"

See Feidhmeanna Sonraí for a list of built-in database functions.

Is é seo a leanas an API Func`:

class Func(*expressions, **extra)Link to this definition#

functionLink to this definition#

Tré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.

templateLink to this definition#

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) '`.

Má 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í.

arg_joinerLink to this definition#

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 ', '.

arityLink to this definition#

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.

as_sql(compiler, connection, function=None, template=None, arg_joiner=None, **extra_context)Link to this definition#

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:

Python

class ConcatPair(Func):
    ...
    function = "CONCAT"
    ...

    def as_mysql(self, compiler, connection, **extra_context):
        return super().as_sql(
            compiler,
            connection,
            function="CONCAT_WS",
            template="%(function)s('', %(expressions)s)",
            **extra_context
        )

Chun 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`.

Is 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ú.

Nathanna ``Comhiomlán () ``Link to this heading#

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

Company.objects.annotate(
    managers_required=(Count("num_employees") / 4) + Count("num_managers")
)

Is é seo a leanas an API Comhléad:

class Aggregate(*expressions, output_field=None, distinct=False, filter=None, default=None, order_by=None, **extra)Link to this definition#

templateLink to this definition#

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) '`.

functionLink to this definition#

Tré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.

window_compatibleLink to this definition#

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.

allow_distinctLink to this definition#

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.

allow_order_byLink to this definition#

A class attribute determining whether or not this aggregate function allows passing a order_by keyword argument. If set to False (default), TypeError is raised if order_by is passed as a value other than None.

empty_result_set_valueLink to this definition#

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.

The filter argument takes a Q object that's used to filter the rows that are aggregated. See Comhiomlánú coinníollach and Scagadh ar anótaí for example usage.

The order_by argument behaves similarly to the field_names input of the order_by() function, accepting a field name (with an optional "-" prefix which indicates descending order) or an expression (or a tuple or list of strings and/or expressions) that specifies the ordering of the elements 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 ``.

Do Feidhmeanna Comhiomlánacha féin aLink to this heading#

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:

from django.db.models import Aggregate


class Sum(Aggregate):
    # Supports SUM(ALL field).
    function = "SUM"
    template = "%(function)s(%(all_values)s%(expressions)s)"
    allow_distinct = False
    arity = 1

    def __init__(self, expression, all_values=False, **extra):
        super().__init__(expression, all_values="ALL " if all_values else "", **extra)

Nathanna ``Luach () ``Link to this heading#

class Value(value, output_field=None)Link to this definition#

Lé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 () ``.

Is 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 the type of the provided value for many common types. For example, passing an instance of datetime.datetime as value defaults output_field to DateTimeField.

Nathanna ``ExpressionWrapper () ``Link to this heading#

class ExpressionWrapper(expression, output_field)Link to this definition#

<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.

JSONNull() expressionLink to this heading#

class JSONNullLink to this definition#

Specialized expression to represent JSON scalar null on a JSONField.

See Stóráil agus fiosrú ar None for usage examples.

Nathanna coinníollachLink to this heading#

Conditional expressions allow you to use if ... elif ... else logic in queries. Django natively supports SQL CASE expressions. For more details see Nathanna Coinníollach.

Nathanna ``Subquest () ``Link to this heading#

class Subquery(queryset, output_field=None)Link to this definition#

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:

>>> from django.db.models import OuterRef, Subquery
>>> newest = Comment.objects.filter(post=OuterRef("pk")).order_by("-created_at")
>>> Post.objects.annotate(newest_commenter_email=Subquery(newest.values("email")[:1]))

Ar PostgreSQL, tá cuma ar an SQL:

SELECT "post"."id", (
    SELECT U0."email"
    FROM "comment" U0
    WHERE U0."post_id" = ("post"."id")
    ORDER BY U0."created_at" DESC LIMIT 1
) AS "newest_commenter_email" FROM "post"

>>> Book.objects.filter(author=OuterRef(OuterRef("pk")))

>>> from datetime import timedelta
>>> from django.utils import timezone
>>> one_day_ago = timezone.now() - timedelta(days=1)
>>> posts = Post.objects.filter(published_at__gte=one_day_ago)
>>> Comment.objects.filter(post__in=Subquery(posts.values("pk")))

>>> subquery = Subquery(newest.values("email")[:1])
>>> Post.objects.annotate(newest_commenter_email=subquery)

>>> from django.db.models import Exists, OuterRef
>>> from datetime import timedelta
>>> from django.utils import timezone
>>> one_day_ago = timezone.now() - timedelta(days=1)
>>> recent_comments = Comment.objects.filter(
...     post=OuterRef("pk"),
...     created_at__gte=one_day_ago,
... )
>>> Post.objects.annotate(recent_comment=Exists(recent_comments))

SELECT "post"."id", "post"."published_at", EXISTS(
    SELECT (1) as "a"
    FROM "comment" U0
    WHERE (
        U0."created_at" >= YYYY-MM-DD HH:MM:SS AND
        U0."post_id" = "post"."id"
    )
    LIMIT 1
) AS "recent_comment" FROM "post"

>>> recent_comments = Comment.objects.filter(...)  # From above
>>> Post.objects.filter(Exists(recent_comments))

>>> from django.db.models import OuterRef, Subquery, Sum
>>> comments = Comment.objects.filter(post=OuterRef("pk")).order_by().values("post")
>>> total_comments = comments.annotate(total=Sum("length")).values("total")
>>> Post.objects.filter(length__gt=Subquery(total_comments))

Nathanna amh SQLLink to this heading#

class RawSQL(sql, params, output_field=None)Link to this definition#

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
>>> queryset.annotate(val=RawSQL("select col from sometable where othercol = %s", (param,)))

B'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.

Is 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,)))

Feidhmeanna fuinnLink to this heading#

Solá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.

Is 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.

class Window(expression, partition_by=None, order_by=None, frame=None, output_field=None)Link to this definition#

templateLink to this definition#

Ré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 expressions (column names should be wrapped in an F-object) that control the partitioning of the rows. Partitioning narrows which rows are used to compute the result set.

Sonraítear an:ref: `output_field <output-field>`mar argóint nó leis an abairt.

Glacann 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 computation. 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:

>>> from django.db.models import Avg, F, Window
>>> Movie.objects.annotate(
...     avg_rating=Window(
...         expression=Avg("rating"),
...         partition_by=[F("studio"), F("genre")],
...         order_by="released__year",
...     ),
... )

Ligeann sé seo duit seiceáil an bhfuil scannán a rátáil níos fearr nó níos measa ná a phiaraí.

B'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ú:

>>> from django.db.models import Avg, F, Max, Min, Window
>>> window = {
...     "partition_by": [F("studio"), F("genre")],
...     "order_by": "released__year",
... }
>>> Movie.objects.annotate(
...     avg_rating=Window(
...         expression=Avg("rating"),
...         **window,
...     ),
...     best=Window(
...         expression=Max("rating"),
...         **window,
...     ),
...     worst=Window(
...         expression=Min("rating"),
...         **window,
...     ),
... )

Tacaí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(
...     category_rank=Window(Rank(), partition_by="category", order_by="-rating"),
...     scenes_count=Count("actors"),
... ).filter(Q(category_rank__lte=3) | Q(title__contains="Batman"))
>>> list(qs)
NotImplementedError: Heterogeneous disjunctive predicates against window functions
are not implemented when performing conditional aggregation.

I 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í

%(frame_type)s BETWEEN %(start)s AND %(end)s

%(frame_type)s BETWEEN %(start)s AND %(end)s EXCLUDE %(exclusion)s

ValueRange(start=0, end=0)

>>> from django.db.models import Avg, F, RowRange, Window
>>> Movie.objects.annotate(
...     avg_rating=Window(
...         expression=Avg("rating"),
...         partition_by=[F("studio"), F("genre")],
...         order_by="released__year",
...         frame=RowRange(start=-2, end=2),
...     ),
... )

>>> from django.db.models import Avg, F, ValueRange, Window
>>> Movie.objects.annotate(
...     avg_rating=Window(
...         expression=Avg("rating"),
...         partition_by=[F("studio"), F("genre")],
...         order_by="released__year",
...         frame=ValueRange(start=-12, end=12),
...     ),
... )

API léiriúLink to this heading#

Cuireann 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.

Nuair a fhilleann abairt fiosrúcháin abairt eile, tá sé freagrach as na modhanna cuí a ghlaoch ar an abairt fillte.

class ExpressionLink to this definition#

allowed_defaultLink to this definition#

Insíonn sé le Django gur féidir an abairt seo a úsáid in:attr: Field.db_default. Réamhshocraithe go False.

constraint_validation_compatibleLink to this definition#

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.

contains_aggregateLink to this definition#

Insíonn sé le Django go bhfuil comhiomlán sa abairt seo agus gur gá clásal `GROUP BY ``a chur leis an gceist.

contains_over_clauseLink to this definition#

Insí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í.

filterableLink to this definition#

Insíonn sé le Django gur féidir tagairt a thabhairt don abairt seo in:meth: .querySet.filter. Réamhshocraithe go True.

window_compatibleLink to this definition#

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.

empty_result_set_valueLink to this definition#

Tells Django which value should be returned when the expression is used to apply a function over an empty result set. Defaults to NotImplemented which forces the expression to be computed on the database.

set_returningLink to this definition#

Tells Django that this expression contains a set-returning function, enforcing subquery evaluation. It's used, for example, to allow some Postgres set-returning functions (e.g. JSONB_PATH_QUERY, UNNEST, etc.) to skip optimization and be properly evaluated when annotations spawn rows themselves. Defaults to False.

allows_composite_expressionsLink to this definition#

Tells Django that this expression allows composite expressions, for example, to support composite primary keys. Defaults to False.

resolve_expression(query=None, allow_joins=True, reuse=None, summarize=False, for_save=False)Link to this definition#

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.

Is sraith de chomhpháirteanna in-athúsáidte é ``athúsáid` le haghaidh cásanna ilcheangailte.

Is 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ú.

get_source_expressions()Link to this definition#

Tugann liosta ordaithe de nathanna istigh ar ais. Mar shampla:

Python console

>>> Sum(F("foo")).get_source_expressions()
[F('foo')]

set_source_expressions(expressions)Link to this definition#

Tógann sé liosta nathanna agus stóráilíonn sé iad ionas gur féidir le ``get_source_expressions () ``iad a thabhairt ar ais.

relabeled_clone(change_map)Link to this definition#

Tugann 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:

Code

def relabeled_clone(self, change_map):
    clone = copy.copy(self)
    clone.expression = self.expression.relabeled_clone(change_map)
    return clone

convert_value(value, expression, connection)Link to this definition#

Crúca a ligeann don abairt “luach” a chur i gcrích níos oiriúnaí.

Tá léirithe mar an gcéanna le féin.

get_group_by_cols()Link to this definition#

Responsible for returning the list of columns referenced by this expression. get_group_by_cols() should be called on any nested expressions. F() objects, in particular, hold a reference to a column.

asc(nulls_first=None, nulls_last=None)Link to this definition#

Filleann sé an abairt atá réidh le sórtáil in ord ardaitheach.

Sainmhí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.

desc(nulls_first=None, nulls_last=None)Link to this definition#

Filleann sé an abairt atá réidh le sórtáil in ord íslitheach.

Sainmhí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.

reverse_ordering()Link to this definition#

Returns self with any modifications required to reverse the sort order within an order_by call. As an example, an expression implementing NULLS LAST would change its value to be NULLS FIRST. Modifications are only required for expressions that implement sort order like OrderBy. This method is called when reverse() is called on a queryset.

Scríobh do chuid Nathanna FiosrúcháinLink to this heading#

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ú:

from django.db.models import Expression


class Coalesce(Expression):
    template = "COALESCE( %(expressions)s )"

    def __init__(self, expressions, output_field):
        super().__init__(output_field=output_field)
        if len(expressions) < 2:
            raise ValueError("expressions must have at least 2 elements")
        for expression in expressions:
            if not hasattr(expression, "resolve_expression"):
                raise TypeError("%r is not an Expression" % expression)
        self.expressions = expressions

Dé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ó.

Anois 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:

def resolve_expression(
    self, query=None, allow_joins=True, reuse=None, summarize=False, for_save=False
):
    c = self.copy()
    c.is_summary = summarize
    for pos, expression in enumerate(self.expressions):
        c.expressions[pos] = expression.resolve_expression(
            query, allow_joins, reuse, summarize, for_save
        )
    return c

Ansin, scríobhaimid an modh atá freagrach as an SQL a ghiniúint:

def as_sql(self, compiler, connection, template=None):
    sql_expressions, sql_params = [], []
    for expression in self.expressions:
        sql, params = compiler.compile(expression)
        sql_expressions.append(sql)
        sql_params.extend(params)
    template = template or self.template
    data = {"expressions": ",".join(sql_expressions)}
    return template % data, tuple(sql_params)


def as_oracle(self, compiler, connection):
    """
    Example of vendor specific handling (Oracle in this case).
    Let's make the function name lowercase.
    """
    return self.as_sql(compiler, connection, template="coalesce( %(expressions)s )")

Is 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.

Tá 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:

def get_source_expressions(self):
    return self.expressions


def set_source_expressions(self, expressions):
    self.expressions = expressions

Feicfimid conas a oibríonn sé:

>>> from django.db.models import F, Value, CharField
>>> qs = Company.objects.annotate(
...     tagline=Coalesce(
...         [F("motto"), F("ticker_name"), F("description"), Value("No Tagline")],
...         output_field=CharField(),
...     )
... )
>>> for c in qs:
...     print("%s: %s" % (c.name, c.tagline))
...
Google: Do No Evil
Apple: AAPL
Yahoo: Internet Company
Django Software Foundation: No Tagline

from django.db.models import Func


class Position(Func):
    function = "POSITION"
    template = "%(function)s('%(substring)s' in %(expressions)s)"

    def __init__(self, expression, substring):
        # substring=substring is an SQL injection vulnerability!
        super().__init__(expression, substring=substring)

class Position(Func):
    function = "POSITION"
    arg_joiner = " IN "

    def __init__(self, expression, substring):
        super().__init__(substring, expression)

Tacaíocht a chur i gcúltaca bunachar sonraí tríúLink to this heading#

Má 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.

Abair 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


def sqlserver_length(self, compiler, connection):
    return self.as_sql(compiler, connection, function="LEN")


Length.as_sqlserver = sqlserver_length

Is 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 () `.