Panduan topik pada Django's database-abstraction API menggambarkan cara dimana anda dapat menggunakan permintaan Django yang membuat, mengambil, memperbaharui dan menghapus obyek tersendiri. Bagaimanapun, terkadang anda akan butuh mengambil nilai yang berasal oleh meringkas atau*mengumpulkan* kumpulan dari obyek. Topik panduan ini menggambarkan cara yang mengumpulkan nilai-nilai dapat dibangkitkan dan dikembalikan menggunakan permintaan Django.
\nSepanjang panduan ini, kami akan mengacu ke model berikut. Model-model ini digunakan untuk melacak inventaris untuk rangkaian dari toko buku daring:
\nfrom django.db import models\n\n\nclass Author(models.Model):\n name = models.CharField(max_length=100)\n age = models.IntegerField()\n\n\nclass Publisher(models.Model):\n name = models.CharField(max_length=300)\n\n\nclass Book(models.Model):\n name = models.CharField(max_length=300)\n pages = models.IntegerField()\n price = models.DecimalField(max_digits=10, decimal_places=2)\n rating = models.FloatField()\n authors = models.ManyToManyField(Author)\n publisher = models.ForeignKey(Publisher, on_delete=models.CASCADE)\n pubdate = models.DateField()\n\n\nclass Store(models.Model):\n name = models.CharField(max_length=300)\n books = models.ManyToManyField(Book)\nTerburu-buru? Ini adalah bagaimana melakukan permintaan pengumpulan umum, menganggap model diatas:
\n# Total number of books.\n>>> Book.objects.count()\n2452\n\n# Total number of books with publisher=BaloneyPress\n>>> Book.objects.filter(publisher__name="BaloneyPress").count()\n73\n\n# Average price across all books, provide default to be returned instead\n# of None if no books exist.\n>>> from django.db.models import Avg\n>>> Book.objects.aggregate(Avg("price", default=0))\n{'price__avg': 34.35}\n\n# Max price across all books, provide default to be returned instead of\n# None if no books exist.\n>>> from django.db.models import Max\n>>> Book.objects.aggregate(Max("price", default=0))\n{'price__max': Decimal('81.20')}\n\n# Difference between the highest priced book and the average price of all books.\n>>> from django.db.models import FloatField\n>>> Book.objects.aggregate(\n... price_diff=Max("price", output_field=FloatField()) - Avg("price")\n... )\n{'price_diff': 46.85}\n\n# All the following queries involve traversing the Book<->Publisher\n# foreign key relationship backwards.\n\n# Each publisher, each with a count of books as a "num_books" attribute.\n>>> from django.db.models import Count\n>>> pubs = Publisher.objects.annotate(num_books=Count("book"))\n>>> pubs\n<QuerySet [<Publisher: BaloneyPress>, <Publisher: SalamiPress>, ...]>\n>>> pubs[0].num_books\n73\n\n# Each publisher, with a separate count of books with a rating above and below 5\n>>> from django.db.models import Q\n>>> above_5 = Count("book", filter=Q(book__rating__gt=5))\n>>> below_5 = Count("book", filter=Q(book__rating__lte=5))\n>>> pubs = Publisher.objects.annotate(below_5=below_5).annotate(above_5=above_5)\n>>> pubs[0].above_5\n23\n>>> pubs[0].below_5\n12\n\n# The top 5 publishers, in order by number of books.\n>>> pubs = Publisher.objects.annotate(num_books=Count("book")).order_by("-num_books")[:5]\n>>> pubs[0].num_books\n1323\nQuerySetLink to this heading#Django provides two ways to generate aggregates. The first way is to generate\nsummary values over an entire QuerySet. For example, say you wanted to\ncalculate the average price of all books available for sale. Django's query\nsyntax provides a means for describing the set of all books:
>>> Book.objects.all()\nWhat we need is a way to calculate summary values over the objects that\nbelong to this QuerySet. This is done by appending an aggregate()\nclause onto the QuerySet:
>>> from django.db.models import Avg\n>>> Book.objects.all().aggregate(Avg("price"))\n{'price__avg': 34.35}\nThe all() is redundant in this example, so this could be simplified to:
>>> Book.objects.aggregate(Avg("price"))\n{'price__avg': 34.35}\nArgumen pada klausa aggregate() menggambarkan nilai pengumpulan yang kami ingin hitung - dalam kasus ini, rata-rata dari bidang price pada model Book. Sebuah daftar dari fungsi pengumpulan yang tersedia dapat ditemukan di QuerySet reference.
aggregate() is a terminal clause for a QuerySet that, when invoked,\nreturns a dictionary of name-value pairs. The name is an identifier for the\naggregate value; the value is the computed aggregate. The name is\nautomatically generated from the name of the field and the aggregate function.\nIf you want to manually specify a name for the aggregate value, you can do so\nby providing that name when you specify the aggregate clause:
>>> Book.objects.aggregate(average_price=Avg("price"))\n{'average_price': 34.35}\nIf you want to generate more than one aggregate, you add another argument to\nthe aggregate() clause. So, if we also wanted to know the maximum and\nminimum price of all books, we would issue the query:
>>> from django.db.models import Avg, Max, Min\n>>> Book.objects.aggregate(Avg("price"), Max("price"), Min("price"))\n{'price__avg': 34.35, 'price__max': Decimal('81.20'), 'price__min': Decimal('12.99')}\nQuerySetLink to this heading#The second way to generate summary values is to generate an independent\nsummary for each object in a QuerySet. For example, if you are\nretrieving a list of books, you may want to know how many authors contributed\nto each book. Each Book has a many-to-many relationship with the Author; we\nwant to summarize this relationship for each book in the QuerySet.
Per-object summaries can be generated using the\nannotate() clause. When an annotate() clause is\nspecified, each object in the QuerySet will be annotated with the\nspecified values.
The syntax for these annotations is identical to that used for the\naggregate() clause. Each argument to annotate() describes\nan aggregate that is to be calculated. For example, to annotate books with the\nnumber of authors:
# Build an annotated queryset\n>>> from django.db.models import Count\n>>> q = Book.objects.annotate(Count("authors"))\n# Interrogate the first object in the queryset\n>>> q[0]\n<Book: The Definitive Guide to Django>\n>>> q[0].authors__count\n2\n# Interrogate the second object in the queryset\n>>> q[1]\n<Book: Practical Django Projects>\n>>> q[1].authors__count\n1\nAs with aggregate(), the name for the annotation is automatically derived\nfrom the name of the aggregate function and the name of the field being\naggregated. You can override this default name by providing an alias when you\nspecify the annotation:
>>> q = Book.objects.annotate(num_authors=Count("authors"))\n>>> q[0].num_authors\n2\n>>> q[1].num_authors\n1\nTidak seperti aggregate(), annotate() adalah bukan klausa terminal. Keluaran dari klausa annotate() adalah sebuah QuerySet; QuerySet ini dapat dirubah menggunakan apapun selain operasi QuerySet, termasuk filter(), order_by(), atau bahkan tambahan panggilan pada annotate().
Combining multiple aggregations with annotate() will yield the\nwrong results because joins are used instead of subqueries:
>>> book = Book.objects.first()\n>>> book.authors.count()\n2\n>>> book.store_set.count()\n3\n>>> q = Book.objects.annotate(Count("authors"), Count("store"))\n>>> q[0].authors__count\n6\n>>> q[0].store__count\n6\nUntuk kebanyakan pengumpulan, tidak ada jalan menghindari masalah ini, bagaimanapun, pengumpulan Count mempunai sebuah parameter distinct yang mungkin membantu:
>>> q = Book.objects.annotate(\n... Count("authors", distinct=True), Count("store", distinct=True)\n... )\n>>> q[0].authors__count\n2\n>>> q[0].store__count\n3\nSejauh ini, kami telah berurusan dengan pengumpulan terhadap bidang yang milik ke model sedang diminta. Bagaimanapun, terkadang nilai anda ingin kumpulkan akan milik ke model yang terkait ke model anda sedang meminta.
\nKetika anda menentukan bidang untuk dikumpulkan dalam sebuah fungsi pengumpulan, Django akan mengizinkan anda menggunakan double underscore notation sama yang digunakan ketika mengacu ke bidang terkait dalam penyaring. Django akan kemudian menangani gabungan table apapun yang dibutuhkan untuk mengambil dan mengumpulkan nilai terkait.
\nFor example, to find the price range of books offered in each store,\nyou could use the annotation:
\n>>> from django.db.models import Max, Min\n>>> Store.objects.annotate(min_price=Min("books__price"), max_price=Max("books__price"))\nIni memberitahu Django untuk mengambil model Store, gabung (melalui hubungan many-to-many) dengan model Book, dan dikumpulkan pada bidang harga dari model buku untuk menghasilkan sebuah nilai minimal dan maksimal.
The same rules apply to the aggregate() clause. If you wanted to\nknow the lowest and highest price of any book that is available for sale\nin any of the stores, you could use the aggregate:
>>> Store.objects.aggregate(min_price=Min("books__price"), max_price=Max("books__price"))\nJoin chains can be as deep as you require. For example, to extract the\nage of the youngest author of any book available for sale, you could\nissue the query:
\n>>> Store.objects.aggregate(youngest_age=Min("books__authors__age"))\nDalam sebuah cara mirip pada Pencarian yang menjangkau hubungan, pengumpulan dan catatan pada bidang dari model atau model yang terkait ke satu anda sedang meminta dapat menyertakan lintasan hubungan "reverse". Nama huruf kecil dari model terkait dan garis bawah ganda digunakan disini juga.
\nFor example, we can ask for all publishers, annotated with their respective\ntotal book stock counters (note how we use 'book' to specify the\nPublisher -> Book reverse foreign key hop):
>>> from django.db.models import Avg, Count, Min, Sum\n>>> Publisher.objects.annotate(Count("book"))\n(Setiap Publisher dalam menghasilkan QuerySet akan mempunyai sebuah atribut tambahan disebut book__count.)
We can also ask for the oldest book of any of those managed by every publisher:
\n>>> Publisher.objects.aggregate(oldest_pubdate=Min("book__pubdate"))\n(Hasil kamus akan mempunyai sebuah kunci dipanggil 'oldest_pubdate'. Jika tidak ada nama lain seperti itu telah ditentukan, itu akan agak panjang 'book__pubdate__min'.)
This doesn't apply just to foreign keys. It also works with many-to-many\nrelations. For example, we can ask for every author, annotated with the total\nnumber of pages considering all the books the author has (co-)authored (note\nhow we use 'book' to specify the Author -> Book reverse\nmany-to-many hop):
>>> Author.objects.annotate(total_pages=Sum("book__pages"))\n(Setiap Author dalam menghasilkan QuerySet akan mempunyai sebuah atribut tambahan dipanggil total_pages. Jika tidak ada nama lain itu, itu akan menjadi agak panjang book__pages__sum.)
Or ask for the average rating of all the books written by author(s) we have on\nfile:
\n>>> Author.objects.aggregate(average_rating=Avg("book__rating"))\n(Hasil kamus akan mempunyai sebuah kunci dipanggil 'average_rating'. Jika tidak ada nama lain seperti itu telah ditentukan, itu akan agak panjang 'book__rating__avg'.)
QuerySet lainLink to this heading#filter() dan exclude()Link to this heading#Pengumpulan dapat juga ikut serta dalam penyaring. filter() (atau``exclude()``) apapun berlaku pada bidang model biasa akan mempunyai pengaruh dari membatasi obyek yang dianggap untuk pengumpulan.
When used with an annotate() clause, a filter has the effect of\nconstraining the objects for which an annotation is calculated. For example,\nyou can generate an annotated list of all books that have a title starting\nwith "Django" using the query:
>>> from django.db.models import Avg, Count\n>>> Book.objects.filter(name__startswith="Django").annotate(num_authors=Count("authors"))\nWhen used with an aggregate() clause, a filter has the effect of\nconstraining the objects over which the aggregate is calculated.\nFor example, you can generate the average price of all books with a\ntitle that starts with "Django" using the query:
>>> Book.objects.filter(name__startswith="Django").aggregate(Avg("price"))\nNilai dicatat dapat juga disaring. Nama lain untuk catatan dapat digunaan dalam klausa filter() dan exclude() di cara sama seperti bidang model lainnya apapun.
For example, to generate a list of books that have more than one author,\nyou can issue the query:
\n>>> Book.objects.annotate(num_authors=Count("authors")).filter(num_authors__gt=1)\nPermintaan ini membangkitkan sebuah kumpulan hasil keterangan, dan kemudian membangkitkan sebuah penyaring berdasarkan pada keterangan itu.
\nIf you need two annotations with two separate filters you can use the\nfilter argument with any aggregate. For example, to generate a list of\nauthors with a count of highly rated books:
>>> highly_rated = Count("book", filter=Q(book__rating__gte=7))\n>>> Author.objects.annotate(num_books=Count("book"), highly_rated_books=highly_rated)\nEach Author in the result set will have the num_books and\nhighly_rated_books attributes. See also Pengumpulan bersyarat.
annotate() dan filter()Link to this heading#Ketika mengembangkan sebuah permintaan rumit yang melibatkan kedua klausa annotate() dan filter(), berikan perhatian khusus pada urutan dimana klausa diberlakukan pada QuerySet.
Ketika sebuah klausa annotate() diberlakukan pada sebuah permintaan, catatan dihitung terhadap keadaan dari permintaan sampai titik dimana catatan diminta. Impliaksi praktik dari ini adalah bahwa filter() dan annotate() bukan operasi komutatif.
Diberikan:
\nPenerbit A mempunyai dua buku dengan nilai 4 dan 5.
Penerbit B mempunyai dua buku dengan nilai 1 dan 4.
Penerbit C mempunyai satu buku dengan penilaian 1.
Berikut adalah contoh dengan kumpulan Count:
>>> a, b = Publisher.objects.annotate(num_books=Count("book", distinct=True)).filter(\n... book__rating__gt=3.0\n... )\n>>> a, a.num_books\n(<Publisher: A>, 2)\n>>> b, b.num_books\n(<Publisher: B>, 2)\n\n>>> a, b = Publisher.objects.filter(book__rating__gt=3.0).annotate(num_books=Count("book"))\n>>> a, a.num_books\n(<Publisher: A>, 2)\n>>> b, b.num_books\n(<Publisher: B>, 1)\nKedua permintaan mengembalikan sebuah daftar dari penerbit yang mempunyai setidaknya satu buku dengan penilaian melebihi 3.0, karenanya penerbit C tidak disertakan.
\nDalam permintaan pertama, catatan mendahului penyaring, jadi penyaring tidak mempunyai pengaruh pada catatan. distinct=True dibutuhkan untuk menghindari query bug.
Permintaan kedua menghitung jumlah buku yang mempunyai nilai melebihi 3.0 untuk setiap penerbit. Penyaring ini mendahului catatan, jadi batasan penyaring obyek dianggap ketika menghitung catatan.
\nBerikut contoh lain dengan kumpulan Rata-Rata:
>>> a, b = Publisher.objects.annotate(avg_rating=Avg("book__rating")).filter(\n... book__rating__gt=3.0\n... )\n>>> a, a.avg_rating\n(<Publisher: A>, 4.5) # (5+4)/2\n>>> b, b.avg_rating\n(<Publisher: B>, 2.5) # (1+4)/2\n\n>>> a, b = Publisher.objects.filter(book__rating__gt=3.0).annotate(\n... avg_rating=Avg("book__rating")\n... )\n>>> a, a.avg_rating\n(<Publisher: A>, 4.5) # (5+4)/2\n>>> b, b.avg_rating\n(<Publisher: B>, 4.0) # 4/1 (book with rating 1 excluded)\nPermintaan pertama meminta untuk rata-rata penilaian dari semua penerbit buku untuk penerbit yang mempunyai setidaknya satu buku ketika penilaian melebihi 3.0. Permintaan kedua meminta untuk rata-rata dari penilaian buku penerbit untuk hanya mereka penilaian melebihi 3.0.
\nItu adalah sangat sulit memahami bahwa ORM akan menterjemahkan queryset rumit kedalam permintaan SQL ketika dalam keraguan, periksa SQL dengan str(queryset.query) dan tulis jumlah besar percobaan.
order_by()Link to this heading#Catatan dapat digunakan sebagai dasar untuk pengurutan. Ketika anda menentukan sebuah klausa order_by(), pengumpulan anda sediakan dapat mengacu nama lain apapun ditentukan sebagai bagian dari sebuah klausa annotate() dalam permintaan.
Misalnya, untuk mengurutkan QuerySet buku berdasarkan jumlah penulis yang berkontribusi pada buku, anda dapat menggunakan permintaan berikut:
>>> Book.objects.annotate(num_authors=Count("authors")).order_by("num_authors")\nvalues()Link to this heading#Biasanya, catatan dibangkitkan pada dasar per-obyek - sebuah QuerySet dicatat akan mengembalikan satu hasil untuk setiap obyek dalam QuerySet asli. Bagaimanapun, ketika sebuah klausa values() digunakan untuk membatasi kolom yang dikembalikan dalam kumpulan hasil, metode untuk menilai catatan adak sedikit berbeda. Sebagai gantinya mengembalikan sebuah hasil dicatat untuk setiap hasil dalam QuerySet asli, hasil asli dikelompokkan menurut pada perpaduan unik dari bidang-bidang ditentukan dalam klausa values(). Sebuah catatam kemudian disediakan untuk setiap kelompok unik; catatan dihitung terhadap semua anggota dari kelompok.
Untuk setiap contoh, pertimbangkan sebuah permintaan penulis yang berusaha menemukan rata-rata penilaian dari buku ditulis oleh setiap penulis.
\n>>> Author.objects.annotate(average_rating=Avg("book__rating"))\nIni akan mengembalikan satu hasil untuk setiap penulis di basisdata, diberikan keterangan dengan nilai buku rata-rata mereka.
\nNamun, hasilnya akan sedikit berbeda jika anda menggunakan klausa values():
>>> Author.objects.values("name").annotate(average_rating=Avg("book__rating"))\nDalam contoh ini, penulis akan dikelompokkan berdasarkan nama, jadi anda akan hanya mendapatkan sebuah hasil dicatata untuk setiap nama penulis unik. Ini berarti jika anda mempunyai dua penulis dengan nama sama, hasil mereka akan digabung kedalam hasil tunggal di keluaran dari permintaan; rata-rata akan dihitung sebagai rata-rata terhadap buku ditulis oleh kedua penulis.
\nannotate() dan values()Link to this heading#Seperti klausa filter(), urutan dimana klausa annotate() dan values() diberlakukan pada sebuah permintaan adalah signifikan. Jika klausa values() mendahului annotated(), catatan akan dihitung menggunakan pengelomppokan digambarkan oleh klausa values().
Bagaimanapun, jika klausa annotate() mendahului klausa values(), catatan akan dibangkitkan terhadap keseluruhan kumpulan permintaan. Dalam kasus ini, klausa values() hanya membatasi bidang yang dibangkitkan pada keluaran.
Misalnya, jika kita membalikkan urutan klausa values() dan annotate() dari contoh kita sebelumnya:
>>> Author.objects.annotate(average_rating=Avg("book__rating")).values(\n... "name", "average_rating"\n... )\nIni akan sekarang menghasilkan hasil unik untuk setiap penulis; bagaimanapun, hanya nama penulis dan catatan average_rating akan dikembalikan dalam data keluaran.
Anda harus juga catat bahwa average_rating telah jelas disertakan dalam daftar dari nilai-nilai untuk dikembalikan. Ini dibutuhkan karena dari urutan dari klausa values() dan annotate().
Jika klausa values() mendahului klausa annotate(), setiap catatan akan otomatis ditambahkan ke kumpulan hasil. Bagaimanapun, jika klausa values() diberlakukan setelah klausa annotate(), anda butuh jelas menyertakan kolom pengumpulan.
order_by()Link to this heading#Bidang yang disebutkan di bagian order_by() dari kumpulan permintaan digunakan saat memilih data keluaran, bahkan jika bidang tersebut tidak ditentukan lain dalam panggilan values(). Bidang tambahan ini digunakan untuk mengelompokkan hasil "suka" bersama-sama dan mereka dapat membuat baris hasil identik tampak terpisah. Ini muncul, terutama, saat menghitung sesuatu.
Berdasarkan cara contoh, seharusnya anda mempunyai model seperti ini:
\nfrom django.db import models\n\n\nclass Item(models.Model):\n name = models.CharField(max_length=10)\n data = models.IntegerField()\nIf you want to count how many times each distinct data value appears in an\nordered queryset, you might try this:
items = Item.objects.order_by("name")\n# Warning: not quite correct!\nitems.values("data").annotate(Count("id"))\n...which will group the Item objects by their common data values and\nthen count the number of id values in each group. Except that it won't\nquite work. The ordering by name will also play a part in the grouping, so\nthis query will group by distinct (data, name) pairs, which isn't what you\nwant. Instead, you should construct this queryset:
items.values("data").annotate(Count("id")).order_by()\n...membersihkan pengurutan apapun di permintaan. Anda dapat juga mengurutkan berdasarkan, katakan, data tanpa pengaruh berbahaya apapun, sejak itu sudah bermain sebuah peran dalam permintaan.
Perilaku ini adalah sama seperti dicatat dalam dokumentasi queryset untuk distinct() dan aturan umum adalah sama: biasanya anda tidak ingin kolom tambahan bermain bagian dalam hasil, jadi bersihkan pengurutan, atau setidaknya pastikan itu terbatas hanya bidang-bidang tersebut anda juga pilih dalam sebuah panggilan values().
Anda dapat juga membangkitkan sebuah pengumpulan pada hasil dari sebuah catatan. Ketika anda menentukan sebuah klausa aggregate(), pengumpulan anda sediakan dapat mengacu setiap nama lain ditentukan sebagai bagian dari sebuah klausa annotated() dalam permintaan.
For example, if you wanted to calculate the average number of authors per\nbook you first annotate the set of books with the author count, then\naggregate that author count, referencing the annotation field:
\n>>> from django.db.models import Avg, Count\n>>> Book.objects.annotate(num_authors=Count("authors")).aggregate(Avg("num_authors"))\n{'num_authors__avg': 1.66}\nWhen an aggregation is applied to an empty queryset or grouping, the result\ndefaults to its default parameter, typically\nNone. This behavior occurs because aggregate functions return NULL when\nthe executed query returns no rows.
You can specify a return value by providing the default argument for most aggregations. However, since\nCount does not support the default argument, it will always return 0 for empty querysets\nor groups.
For example, assuming that no book contains web in its name, calculating the\ntotal price for this book set would return None since there are no matching\nrows to compute the Sum aggregation on:
>>> from django.db.models import Sum\n>>> Book.objects.filter(name__contains="web").aggregate(Sum("price"))\n{"price__sum": None}\nHowever, the default argument can be set when\ncalling Sum to return a different default value if\nno books can be found:
>>> Book.objects.filter(name__contains="web").aggregate(Sum("price", default=0))\n{"price__sum": Decimal("0")}\nUnder the hood, the default argument is implemented\nby wrapping the aggregate function with\nCoalesce.
ONLY_FULL_GROUP_BY enabledLink to this heading#When using the values() clause to group query results for annotations in\nMySQL with the ONLY_FULL_GROUP_BY SQL mode enabled, you may need to apply\nAnyValue if the annotation includes a mix of\naggregate and non-aggregate expressions.
Take the following example:
\n>>> from django.db.models import F, Count, Greatest\n>>> Book.objects.values(greatest_pages=Greatest("pages", 600)).annotate(\n... num_authors=Count("authors"),\n... pages_per_author=F("greatest_pages") / F("num_authors"),\n... ).aggregate(Avg("pages_per_author"))\nThis creates groups of books based on the SQL column GREATEST(pages, 600).\nOne unique group consists of books with 600 pages or less, and other unique\ngroups will consist of books with the same pages. The pages_per_author\nannotation is composed of aggregate and non-aggregate expressions,\nnum_authors is an aggregate expression while greatest_page isn't.
Since the grouping is based on the greatest_pages expression, MySQL may be\nunable to determine that greatest_pages (used in the pages_per_author\nexpression) is functionally dependent on the grouped column. As a result, it\nmay raise an error like:
OperationalError: (1055, "Expression #2 of SELECT list is not in GROUP BY\nclause and contains nonaggregated column 'book_book.pages' which is not\nfunctionally dependent on columns in GROUP BY clause; this is incompatible\nwith sql_mode=only_full_group_by")\nTo avoid this, you can wrap the non-aggregate expression with\nAnyValue.
>>> from django.db.models import AnyValue, F, Count, Greatest\n>>> Book.objects.values(\n... greatest_pages=Greatest("pages", 600),\n... ).annotate(\n... num_authors=Count("authors"),\n... pages_per_author=AnyValue(F("greatest_pages")) / F("num_authors"),\n... ).aggregate(Avg("pages_per_author"))\n{'pages_per_author__avg': 532.57143333}\nOther supported databases do not encounter the OperationalError in the\nexample above because they can detect the functional dependency. In general,\nAnyValue is useful when dealing with select list columns that involve\nnon-aggregate functions or complex expressions not recognized by the database\nas functionally dependent on the columns in the grouping clause.