---
title: "Feidhmeanna comhiomlánaithe sonracha PostgreSQL"
version: 6.0
locale: ga
source: https://docs.djangoproject.com/ga/6.0/ref/contrib/postgres/aggregates/
canonical: https://djangodocs.dev/ga/6.0/ref/contrib/postgres/aggregates/
---
# Feidhmeanna comhiomlánaithe sonracha PostgreSQL

Tá na feidhmeanna seo ar fáil ón modúl `django.contrib.postgres.aggregates`. \< <https://www.postgresql.org/docs/current/functions-aggregate.html>\>Déantar cur síos níos mionsonraithe orthu sna doiciméid PostgreSQL.

> **Note**
>
> Tagann gach feidhm gan ainmneacha réamhshocraithe, mar sin ní mór duit ceann a sholáthar go sainráite. Mar shampla:
>
> ```pycon
> >>> SomeModel.objects.aggregate(arr=ArrayAgg("somefield"))
> {'arr': [0, 1, 2]}
> ```

> **Roghanna comhiomlán coiti**
>
> \<aggregate-default\>Tá argóint eochairfhocal: ref: filter \<aggregate-filter\>\`ag gach comhiomlán agus tá an argóint eochairfhocal: ref: \`réamhshocraithe ag an gcuid is mó freisin.

## Feidhmeanna comhiomlánchuspóireach

### `Arrayag`

#### `class ArrayAgg(expression, distinct=False, filter=None, default=None, order_by=(), **extra)`

Tugann sé liosta luachanna, lena n-áirítear neamhaill, atá comhcheangailte i sraith, nó `réamhshocraithe` mura bhfuil aon luachanna ann.

#### `distinct`

Argóint boolean roghnach a chinneann an mbeidh luachanna eagar ar leith. Réamhshocraithe go `False`.

#### `order_by`

> **New in Django 5.2**

Sreang roghnach d'ainm réimse (le réimír roghnach `” -"` a léiríonn ord íslitheach) nó abairt (nó liosta teaghráin agus/nó nathanna) a shonraíonn ordú na n-eilimintí sa liosta torthaí.

Samplaí:

```
from django.db.models import F

ArrayAgg("a_field", order_by="-some_field")
ArrayAgg("a_field", order_by=F("some_field").desc())
```

> **Deprecated since Django 5.2**
>
> Deprecated since version 5.2: The `ordering` keyword argument is deprecated. Use
> [`ArrayAgg.order_by`](#django.contrib.postgres.aggregates.ArrayAgg.order_by) instead.

### `Bitand`

#### `class BitAnd(expression, filter=None, default=None, **extra)`

Filleann sé `int` de ghiotán `AND` de na luachanna ionchuir neamh-null go léir, nó `default` má tá na luachanna go léir neall.

### `Bitor`

#### `class BitOr(expression, filter=None, default=None, **extra)`

Filleann sé `int` den OR\` bitwise de na luachanna ionchuir neamh-null go léir, nó `default` má tá na luachanna go léir niall.

### `Bitxor`

#### `class BitXor(expression, filter=None, default=None, **extra)`

Filleann sé `int` den XOR\` bitwise de na luachanna ionchuir neamh-null go léir, nó `default` má tá na luachanna go léir niall. Éilíonn sé PostgreSQL 14 +.

### `Booland`

#### `class BoolAnd(expression, filter=None, default=None, **extra)`

Tugann sé `True`, má tá na luachanna ionchuir go léir fíor, `default` má tá na luachanna go léir null nó mura bhfuil aon luachanna ann, ar shlí eile `False`.

Sampla úsáide:

```
class Comment(models.Model):
    body = models.TextField()
    published = models.BooleanField()
    rank = models.IntegerField()
```

```pycon
>>> from django.db.models import Q
>>> from django.contrib.postgres.aggregates import BoolAnd
>>> Comment.objects.aggregate(booland=BoolAnd("published"))
{'booland': False}
>>> Comment.objects.aggregate(booland=BoolAnd(Q(rank__lt=100)))
{'booland': True}
```

### `Boolor`

#### `class BoolOr(expression, filter=None, default=None, **extra)`

Tugann sé `True` má tá luach ionchuir amháin ar a laghad fíor, `default` má tá na luachanna go léir niall nó mura bhfuil aon luachanna ann, ar shlí eile `False`.

Sampla úsáide:

```
class Comment(models.Model):
    body = models.TextField()
    published = models.BooleanField()
    rank = models.IntegerField()
```

```pycon
>>> from django.db.models import Q
>>> from django.contrib.postgres.aggregates import BoolOr
>>> Comment.objects.aggregate(boolor=BoolOr("published"))
{'boolor': True}
>>> Comment.objects.aggregate(boolor=BoolOr(Q(rank__gt=2)))
{'boolor': False}
```

### `Jsonbag`

#### `class JSONBAgg(expressions, distinct=False, filter=None, default=None, order_by=(), **extra)`

Tugann na luachanna ionchuir ar ais mar shraith `JSON`, nó `default` mura bhfuil aon luachanna ann. \<jsonfield.key\>Is féidir leat an toradh a cheistiú ag baint úsáid:lookup: eochair agus innéacs cuardaigh .

#### `distinct`

Argóint boolean roghnach a chinneann an mbeidh luachanna eagar ar leith. Réamhshocraithe go `False`.

#### `order_by`

> **New in Django 5.2**

Sreang roghnach d'ainm réimse (le réimír roghnach `” -"` a léiríonn ord íslitheach) nó abairt (nó liosta teaghráin agus/nó nathanna) a shonraíonn ordú na n-eilimintí sa liosta torthaí.

Examples are the same as for [`ArrayAgg.order_by`](#django.contrib.postgres.aggregates.ArrayAgg.order_by).

Sampla úsáide:

```
class Room(models.Model):
    number = models.IntegerField(unique=True)

class HotelReservation(models.Model):
    room = models.ForeignKey("Room", on_delete=models.CASCADE)
    start = models.DateTimeField()
    end = models.DateTimeField()
    requirements = models.JSONField(blank=True, null=True)
```

```pycon
>>> from django.contrib.postgres.aggregates import JSONBAgg
>>> Room.objects.annotate(
...     requirements=JSONBAgg(
...         "hotelreservation__requirements",
...         order_by="-hotelreservation__start",
...     )
... ).filter(requirements__0__sea_view=True).values("number", "requirements")
<QuerySet [{'number': 102, 'requirements': [
    {'parking': False, 'sea_view': True, 'double_bed': False},
    {'parking': True, 'double_bed': True}
]}]>
```

> **Deprecated since Django 5.2**
>
> Deprecated since version 5.2: The `ordering` keyword argument is deprecated. Use
> [`JSONBAgg.order_by`](#django.contrib.postgres.aggregates.JSONBAgg.order_by) instead.

### `Stringag`

#### `class StringAgg(expression, delimiter, distinct=False, filter=None, default=None, order_by=())`

> **Deprecated since Django 6.0**
>
> Deprecated since version 6.0: The PostgreSQL `StringAgg` class is deprecated in favor of the
> generally available [`StringAgg`](/ga/6.0/ref/models/querysets/#django.db.models.StringAgg) class.

Filleann sé na luachanna ionchuir atá comhcheangailte i sreang, scartha leis an teaghrán `delimiter`, nó `default` mura bhfuil aon luachanna ann.

#### `delimiter`

Required argument. A string, [`Value`](/ga/6.0/ref/models/expressions/#django.db.models.Value), or
expression representing the string for separating values. For example,
`Value(",")`.

> **New in Django 6.0**
>
> Support for providing a `Value` or expression rather than a
> string was added.

> **Deprecated since Django 6.0**
>
> Deprecated since version 6.0: Support for providing a string is deprecated.

#### `distinct`

Argóint roghnach boolean a chinneann an mbeidh luachanna comhtháite ar leith. Réamhshocraithe go `False`.

#### `order_by`

> **New in Django 5.2**

Sreang roghnach d'ainm réimse (le réimír roghnach `” -"` a léiríonn ord íslitheach) nó abairt (nó liosta teaghráin agus/nó nathanna) a shonraíonn ordú na n-eilimintí sa sreangán torthaí.

Examples are the same as for [`ArrayAgg.order_by`](#django.contrib.postgres.aggregates.ArrayAgg.order_by).

Sampla úsáide:

```
class Publication(models.Model):
    title = models.CharField(max_length=30)

class Article(models.Model):
    headline = models.CharField(max_length=100)
    publications = models.ManyToManyField(Publication)
```

```pycon
>>> article = Article.objects.create(headline="NASA uses Python")
>>> article.publications.create(title="The Python Journal")
<Publication: Publication object (1)>
>>> article.publications.create(title="Science News")
<Publication: Publication object (2)>
>>> from django.contrib.postgres.aggregates import StringAgg
>>> Article.objects.annotate(
...     publication_names=StringAgg(
...         "publications__title",
...         delimiter=", ",
...         order_by="publications__title",
...     )
... ).values("headline", "publication_names")
<QuerySet [{
    'headline': 'NASA uses Python', 'publication_names': 'Science News, The Python Journal'
}]>
```

> **Deprecated since Django 5.2**
>
> Deprecated since version 5.2: The `ordering` keyword argument is deprecated. Use
> [`StringAgg.order_by`](#django.contrib.postgres.aggregates.StringAgg.order_by) instead.

## Feidhmeanna comhiomlána le

### `y` agus `x`

Is féidir leis na hargóintí `y` agus `x` do na feidhmeanna seo go léir a bheith ina ainm réimse nó abairt ar ais sonraí uimhriúla. Tá an dá cheann ag teastáil.

### `Corr`

#### `class Corr(y, x, filter=None, default=None)`

Tugann an comhéifeacht comhghaoil ar ais mar `snám`, nó `réamhshocraithe` mura bhfuil aon sraitheanna meaitseála ann.

### `Covarpop`

#### `class CovarPop(y, x, sample=False, filter=None, default=None)`

Tugann an comhathracht daonra ar ais mar `snám`, nó `réamhshocraithe` mura bhfuil aon sraitheanna meaitseála ann.

#### `sample`

Roghnach. De réir réamhshocraithe filleann `Covarpop` an coathraitheacht ghinearálta daonra. Mar sin féin, má tá `sample=True`, is é an luach tuairisceáin an coathraitheacht daonra samplach.

### `RegraVGX`

#### `class RegrAvgX(y, x, filter=None, default=None)`

Tugann sé meán an athróg neamhspleách (`sum (x) /N`) ar ais mar ```snám`, nó ``réamhshocraithe``` mura bhfuil aon sraitheanna meaitseála ann.

### `Regravgi`

#### `class RegrAvgY(y, x, filter=None, default=None)`

Tugann sé meán an athróg cleithiúnach (`sum (y) /N`) ar ais mar ```snám`, nó ``réamhshocraithe``` mura bhfuil aon sraitheanna meaitseála ann.

### `RegrCount`

#### `class RegrCount(y, x, filter=None)`

Filleann sé int de líon na sraitheanna ionchuir nach bhfuil an dá abairt neall.

> **Note**
>
> Ní thacaítear leis an argóint `réamhshocraithe`.

### `RegRintercept`

#### `class RegrIntercept(y, x, filter=None, default=None)`

Tugann sé an t-idirghabháil y den chothromóid líneach is lú atá oiriúnach cearnach arna chinneadh ag na péirí `(x, y)` mar `snáth`, nó `réamhshocraithe` mura bhfuil aon sraitheanna meaitseála ann.

### `RegRr2`

#### `class RegrR2(y, x, filter=None, default=None)`

Tugann cearnóg an chomhéifeacht comhghaoil ar ais mar ```snám`, nó ``réamhshocraithe``` mura bhfuil aon sraitheanna meaitseála ann.

### `RegrSlope`

#### `class RegrSlope(y, x, filter=None, default=None)`

Tugann fána an chothromóid líneach is lú atá oiriúnach cearnach a chinneadh ag na péirí `(x, y)` mar ```snámh ``, nó ``réamhshocraithe``` mura bhfuil aon sraitheanna meaitseála ann.

### `RegRsXX`

#### `class RegrSXX(y, x, filter=None, default=None)`

Tugann `sum (x ^ 2) - suim (x) ^2/N` (“suim na gcearnóga” den athróg neamhspleách) mar `snám`, nó réamhshocraithe\` mura bhfuil aon sraitheanna meaitseála ann.

### `RegrsXY`

#### `class RegrSXY(y, x, filter=None, default=None)`

Tuairisceáin `suim (x*y) - suim (x) * suim (y) /N` (“suim táirgí” d'athróg neamhspleách ag brath ar amanna) mar `snám`, nó `réamhshocraithe` mura bhfuil aon sraitheanna meaitseála ann.

### `Regrsyy`

#### `class RegrSYY(y, x, filter=None, default=None)`

Tuairisceann `sum (y ^ 2) - suim (y) ^2/N` (“suim na gcearnóga” den athróg cleithiúnach) mar `snám`, nó `réamhshocraithe` mura bhfuil aon sraitheanna meaitseála ann.

## Samplaí úsáide

Úsáidfimid an tábla sampla seo:

```text
| FIELD1 | FIELD2 | FIELD3 |
|--------|--------|--------|
|    foo |      1 |     13 |
|    bar |      2 | (null) |
|   test |      3 |     13 |
```

Seo roinnt samplaí de chuid de na feidhmeanna comhiomlánaithe ginearálchuspóireach:

```pycon
>>> TestModel.objects.aggregate(result=StringAgg("field1", delimiter=";"))
{'result': 'foo;bar;test'}
>>> TestModel.objects.aggregate(result=ArrayAgg("field2"))
{'result': [1, 2, 3]}
>>> TestModel.objects.aggregate(result=ArrayAgg("field1"))
{'result': ['foo', 'bar', 'test']}
```

Taispeánann an chéad sampla eile úsáid feidhmeanna comhiomlán staitistiúla. \< [https://en.wikipedia.org/wiki/Regression\_analysis](https://en.wikipedia.org/wiki/Regression_analysis)\>Ní dhéanfar cur síos ar an mhatamaitic bhunúsach (is féidir leat léamh faoi seo, mar shampla, ag [wikipedia](#wikipedia)):

```pycon
>>> TestModel.objects.aggregate(count=RegrCount(y="field3", x="field2"))
{'count': 2}
>>> TestModel.objects.aggregate(
...     avgx=RegrAvgX(y="field3", x="field2"), avgy=RegrAvgY(y="field3", x="field2")
... )
{'avgx': 2, 'avgy': 13}
```