Sql агрегирующие функции: Использование агрегирующих функций языка SQL

5 cпособов осуществить агрегацию строк в MS SQL / Хабр

Иногда возникает необходимость осуществить агрегацию строк в SQL запросе, то есть, по такому набору данных:

получить примерно такой:

MySQL, например, для таких целей обладает встроенной функцией GROUP_CONCAT():

SELECT GroupId, GROUP_CONCAT(Item SEPARATOR ",") AS ItemList
FROM Items

В MS SQL Server’e такой функции нету, поэтому приходится извращаться. Перед тем, как приступить, сделаем скрипт для создания тестовой таблицы:

CREATE TABLE Items(GroupId INT, Item NVARCHAR(10))

INSERT INTO Items(GroupId, Item)
SELECT 1 AS GroupId, 'AAA' AS Item
  UNION ALL
SELECT 2, 'IS'
  UNION ALL
SELECT 5, 'OMG'
  UNION ALL
SELECT 2, 'WHAT'
  UNION ALL
SELECT 2, 'THE'
  UNION ALL
SELECT 1, 'This'

Итак, начнем.

Самый тупой прямолинейный способ — создать временную таблицу и собирать в нее промежуточные результаты агрегации, пробегая по таблице Items курсором. Этот способ очень медленно работает и код его страшен. Любуйтесь:

DECLARE @Aggregated TABLE (GroupId INT, ItemList NVARCHAR(100))

DECLARE ItemsCursor CURSOR READ_ONLY
FOR SELECT GroupId, Item
    FROM Items

DECLARE @CurrentGroupId INT
DECLARE @CurrentItem NVARCHAR(10)
DECLARE @CurrentItemList NVARCHAR(100)

OPEN ItemsCursor

FETCH NEXT FROM ItemsCursor
INTO @CurrentGroupId, @CurrentItem

WHILE @@FETCH_STATUS = 0
BEGIN
    SET @CurrentItemList = (SELECT ItemList
                            FROM @Aggregated
                            WHERE GroupId = @CurrentGroupId)

    IF @CurrentItemList IS NULL
        INSERT INTO @Aggregated(GroupId, ItemList)
        VALUES(@CurrentGroupId, @CurrentItem)
    ELSE
        UPDATE @Aggregated
        SET ItemList = ItemList + ',' + @CurrentItem
        WHERE GroupId = @CurrentGroupId

    FETCH NEXT FROM ItemsCursor
    INTO @CurrentGroupId, @CurrentItem
END

CLOSE ItemsCursor
DEALLOCATE ItemsCursor

SELECT GroupId, ItemList
FROM @Aggregated

Есть более красивый способ, не использующий временных таблиц. Он основан на трюке SELECT var = var + ‘,’ + col FROM smwhere. Да, так можно и это работает:

CREATE FUNCTION ConcatItems(@GroupId INT)
   RETURNS NVARCHAR(100)
AS
BEGIN
    DECLARE @ItemList varchar(8000)
    SET @ItemList = ''

    SELECT @ItemList = @ItemList + ',' + Item
    FROM Items
    WHERE GroupId = @GroupId

    RETURN SUBSTRING(@ItemList, 2, 100)
END

GO

SELECT GroupId, dbo.ConcatItems(GroupId) ItemList
FROM Items
GROUP BY GroupId

Немного лучше, но все же костылевато. В случае, когда нам известно, что максимальное количество агрегируемых строк ограничего, можно использовать следующий способ (этот запрос основан на предположении, что не существует группы с более чем четырьмя элементами в ней):

SELECT GroupId,
       CASE Item2 WHEN '' THEN Item1
           ELSE CASE Item3 WHEN '' THEN Item1 + ',' + Item2
           ELSE CASE Item4 WHEN '' THEN Item1 + ',' + Item2 + ',' + Item3
           ELSE Item1 + ',' + Item2 + ',' + Item3 + ',' + Item4
       END END END AS ItemList
FROM (
  SELECT GroupId,
       MAX(CASE ItemNo WHEN 1 THEN Item ELSE '' END) AS Item1,
       MAX(CASE ItemNo WHEN 2 THEN Item ELSE '' END) AS Item2,
       MAX(CASE ItemNo WHEN 3 THEN Item ELSE '' END) AS Item3,
       MAX(CASE ItemNo WHEN 4 THEN Item ELSE '' END) AS Item4
  FROM (
    SELECT GroupId,
         Item,
         ROW_NUMBER() OVER (PARTITION BY GroupId ORDER BY Item) ItemNo
    FROM Items
  ) AS OrderedItems
  GROUP BY GroupId
) AS AlmostAggregated

Да, много кода. Но зато ни одного лишнего объекта в БД — просто один чистый селект. Это иногда важно.

Тем не менее, существует способ обойти и ограничение на размер группы, оставшись при этом в рамках одного запроса. Мы будем собирать все элементы группы в XML-поле, которое затем сконвертим к строковому типу и заменим теги между элементами на запятые:

SELECT GroupId,
       REPLACE(SUBSTRING(ItemListWithTags, 4, LEN(ItemListWithTags)-7),
               '<a>',
               ',') AS ItemList
FROM (
  SELECT GroupId,
       CAST(XmlItemList AS NVARCHAR(200)) ItemListWithTags
  FROM (
    SELECT GroupId,
         (SELECT Item AS A
        FROM Items ii
        WHERE ii.GroupId = GroupIds.GroupId
        FOR XML PATH('')) AS XmlItemList
    FROM (SELECT DISTINCT GroupId FROM Items) AS GroupIds
  ) AS subq1
) AS subq2

В общем, работает не очень шустро, зато всегда. И, конечно, нужен SQL Server не ниже 2000.

Да, еще есть способ агрегировать строки через CLR Aggregate Functions, но это вообще мрачный ужас, ибо вусмерть медленно и несообразно сложности задачи. Если возникнет достаточный спрос на такую статью, напишу её позже.

Жду с нетерпением комментариев и критики. И ещё: если кто-нибудь знает, как можно сделать такую подсветку кода, как я сделал у себя дома — подскажите. Я, кроме как вставить скриншоты, другого способа пока не вижу.

Агрегирование и группировка данных

Агрегирование и группировка данных

В данном разделе рассматривается применение в запросе агрегирующих функций- функций
вычисляющих результат по набору значений группы, либо всех записей БД. Например, функция
sum возвращает сумму значений заданного поля, а функция
count — общее число записей.

Агрегирующая функция может применяться ко всем записям БД слоя, к выборке по заданным
условиям и, кроме того, возможно группирование записей слоя в несколько групп, и применение
агрегирующей функции к каждой группе («Группировка записей»).

Применяемые агрегирующие функции записываются после ключевого слова
SELECT. Также допускается использовать агрегирующие функции в составе
выражений, включающих функции, арифметические и побитовые операции. В одном запросе может
перечисляться несколько выражений с агрегирующими функциями. Не допускается в запросе
одновременно с агрегирующими функциями запрашивать значения полей записей БД, либо
использовать в аргументах неагрегирующих функций обращения к полям записей БД . Например,
запрос вида SELECT SQRT(Area), SUM(Perimeter) FROM Здания не допускается,
поскольку аргументом функции SQRT является название поля данных.

Общая запись агрегирующих функций:

<Функция>([DISTINCT]<выражение>)

В качестве аргумента агрегирующей функции обычно используется название поля, над
значениями которого проводятся вычисления. Также допускается в качестве аргумента
использовать выражения, включающие в себя произвольную комбинацию названий полей, констант,
функций и подзапросов, объединенных арифметическими и побитовыми операциями.

Остальная часть запроса задается стандартным образом.

Перед аргументом функции (кроме функций MAX и
MIN)может указываться ключевое слово DISTINCT. В этом
случае итоговое значение вычисляется только для различающихся значений аргумента. При
использовании ключевого слова DISTINCT в качестве аргумента агрегирующей
функции нельзя использовать арифметические выражения, — только названия полей.

В языке SQL используются следующие агрегирующие функции:

SUM([DISTINCT]
<выражение>)

Выводит в итоговой таблице сумму значений для выражения по полям выборки. Выражение
должно возвращать числовое значение.

AVG([DISTINCT]
<выражение>)

Среднее значение для выражения. Выражение должно возвращать числовое значение.

COUNT([DISTINCT]
<выражение> |*)

Подсчитывает число записей, в который выражение не имеет значение Null
(поля имеют значение Null, когда никакое значение для них не задано).
Выражение может возвращать произвольное значение.

При используемом формате функции COUNT(*) возвращает общее количество
записей в БД слоя.

MAX( <выражение>)

Возвращает максимальное значение выражения для выборки.

MIN(<выражение>)

Возвращает минимальное значение выражения из выборки.

Применение агрегирующих
функций

Простой пример

SELECT SUM(Perimeter) FROM Здания

Выводит сумму периметров зданий.

Одновременное применение нескольких функций

SELECT AVG(Area), Count(*) FROM Здания

Выводит среднюю площадь здания и общее количество зданий.

Применение функций совместно с условиями отбора

SELECT SUM(Area) FROM Здания WHERE Улица='Нахимова'

Возвращает сумму площадей зданий расположенных на улице Нахимова.

Применение выражений в качестве аргументов агрегирующих
функций

SELECT SUM(Area/Perimeter*2) FROM Здания 

Для каждого здания рассчитывается величина равная Площадь/Периметр*2 и
суммируется.

Применение агрегирующих функций в составе
выражений

SELECT SQRT(SUM(Area)), "Общий периметр" + SUM(Perimeter) FROM Здания 

Возвращает квадратный корень от суммарной площади всех зданий и фразу вида «Общий
периметр XXX», где XXX — суммарный периметр всех зданий.

Использование ключевого слова
DISTINCT

SELECT COUNT(DISTINCT Улица) FROM Здания 

Возвращает количество разных названий улиц в БД
слоя.

Агрегирующие функции

Агрегирующие функции

Агрегирующие
функции Функции, обрабатывающие набор строк для подсчета
и возвращения одного значения
используются для получения обобщающих значений. Их можно
применять ко
всем строкам таблицы, строкам, определенным в предложении WHERE или к
группам
строк в предложении GROUP BY. В любом случае, независимо от структуры
набора
строк, для каждого из них получается единственное значение.

Для выполнения
агрегирующих операций используются
следующие функции:

• COUNT определяет количество строк
  или значений поля, выбранных посредством запроса и не являющихся
  NULL-значениями;

  
  




• SUM вычисляет сумму всех выбранных значений данного поля;




• AVG вычисляет среднее значение для всех выбранных значений
  данного поля;




• МАХ вычисляет наибольшее из всех выбранных значений данного
  поля;




• MIN вычисляет наименьшее из всех выбранных значений данного
  поля.

В качестве
аргументов агрегирующих функций в большинстве случаев используются
названия
полей таблицы, но также допускаются константы, функции и любые их
комбинации с
арифметическими операторами.

Общая
форма агрегирующей функции имеет следующий вид:

aggregate_function
(<expr>)

Примеры

Найти средную стоимсть услуг:

SQL:


SELECT AVG(price) FROM tbl_service

В
результате выполнения запроса получим одно значение:

С
помощью следующего оператора можно найти среднюю стоимость всех услуг в
случае удвоения их
цены:

SQL:


SELECT AVG(price*2) FROM tbl_service

Если в
столбце, к которому применяется агрегирующая функция, имеются нулевые
(NULL)
значения, то они просто игнорируются.

Исключением является функция
COUNT(*), которая всегда подсчитывает общее количество строк,
независимо от
наличия в них нулевых значений.

Примеры

Подсчитать количество расторгнутых
договоров:

SQL:
SELECT COUNT(retire_date)
FROM tbl_contract

Результат:

Поскольку поле retire_date
содержит дату расторжения договора и значение NULL в
случае, если договор не был расторгнут, функция COUNT не учитывает
строки, содержащие значения NULL в поле retire_date.

SQL:


SELECT
COUNT(*) FROM tbl_contract

В результате выполнения данного запроса будет получено количество
записей в таблице tbl_contract:

Для
ограничения
числа строк, участвующих в агрегирующих вычислениях, можно использовать
предложение WHERE. В этом случае сначала выполняется предложение WHERE,
в
результате чего находятся все записи, удовлетворяющие заданным
условиям, а
затем к выбранным строкам применяются агрегирующие функции.

Если
условиям запроса не удовлетворяет ни одна строка, агрегирующие функции
возвращают значение NULL. Исключение составляет функции COUNT, которая
возвращает нуль.

Пример

Подсчитать количество клиентов мужского пола:

SQL:



SELECT COUNT(*) FROM tbl_clients WHERE sex=’m’

агрегирование и группировка GROUP BY

На этом занятии
рассмотрим агрегирующие функции, используемые в языке SQL и поговорим о
возможности группировки записей по определенному полю. Все эти операции
доступны в команде SELECT, о которой мы уже говорили на
предыдущих занятиях.

Агрегирующие функции в SELECT

Чтобы лучше
понять что такое агрегирующие функции, рассмотрим пример подсчета числа записей
таблицы games, которые были
сыграны игроком с user_id = 1.

Для этого
создадим вот такой SQL-запрос:

SELECT count(user_id) FROM games WHERE user_id = 1

Здесь count(название
столбца) – это агрегирующая функция, которая подсчитывает число выбранных
записей. Результатом будет одна запись со значением 3:

Почему мы
указали столбец user_id? В действительности, можно указать любой
другой, разницы не будет, так как число записей для любых столбцов будет равно
трем. Можно даже ничего не указывать и просто записать count(). Также
обратите внимание, на название столбца: count(user_id). Использовать
такое имя в дальнейшем не очень удобно. Для таких случаев придумали такую вещь
как алиас (синоним), который можно указать так:

SELECT count() as count FROM games WHERE user_id = 1

Теперь столбец
называется просто count и на выходе мы его и видим:

Причем, во всех
примерах функция count выполнялась в последнюю очередь, то
есть, после полного формирования выборки. Поэтому ее действие связано только с
выбранными записями из таблицы. По такому принципу работают все агрегирующие
функции.

В общем случае в
команде SELECT можно
использовать следующие наиболее распространенные агрегирующие функции:

• 
  count() – подсчет числа
  записей;
  
• 
  sum() – подсчет
  суммы указанного поля по всем записям выборки;
  
• 
  avr() – вычисление
  среднего арифметического указанного поля;
  
• 
  min() – нахождение
  минимального значения для указанного поля;
  
• 
  max() – нахождение
  максимального значения для указанного поля.

Давайте для
примера подсчитаем в таблице games число уникальных игроков. Для этого запишем вот такой SQL-запрос:

SELECT count(DISTINCT user_id) as count FROM games

Смотрите, мы
здесь перед полем user_id указали ключевое слово DISTINCT, которое
указывает СУБД выбирать записи с уникальными user_id. Затем, с
помощью агрегирующей функции count мы вычисляем
число таких записей и получаем количество уникальных игроков. Чтобы все это
было понятнее, можно выполнить запрос без агрегирующей функции:

SELECT DISTINCT user_id FROM games

Получим
следующую выборку:

Далее,
предположим, что нам нужно подсчитать суммарное число очков, которое набрал
игрок с user_id = 1 за все
игры. Такой
запрос будет выглядеть так:

SELECT sum(score) as sum FROM games WHERE user_id = 1

И на выходе
получим значение 900. Действительно, суммируя очки из таблицы games для первого
игрока, получаем значение 900.

Также можно
брать максимальное или минимальное число очков:

SELECT max(score) FROM games WHERE user_id = 1
SELECT min(score) FROM games WHERE user_id = 1

И так далее. По
такому принципу можно применять все агрегирующие функции в команде SELECT.

Группировка GROUP BY

Язык SQL позволяет
вызывать агрегирующие функции не для всех записей в выборке, а локально для
указанных групп. Например, мы хотим на основе нашей таблицы games создать список
ТОП лучших игроков. Для этого нужно вызвать функции sum для каждого
уникального user_id.

Это делается с
помощью оператора

GROUP BY <имя поля>

который
группирует записи по указанному столбцу. В этом случае агрегирующие функции
будут работать в пределах каждой группы:

SELECT user_id, sum(score) as sum 
FROM games 
GROUP BY user_id

На выходе
получим таблицу:

Но нам нужно еще
отсортировать ее по убыванию очков, поэтому в конец запроса добавим оператор:

После выполнения
запроса получим таблицу с отсортированными записями:

Добавим еще
фильтр для выбора записей с числом очков более 300:

SELECT user_id, sum(score) as sum 
FROM games
WHERE score > 300
GROUP BY user_id
ORDER BY sum DESC

Получим
результат:

Обратите
внимание на порядок записи операторов в команде SELECT и порядок их
работы. Сначала будут отобраны все записи с числом очков более 300, затем, они
сгруппируются и отсортированы по убыванию очков. Именно поэтому теперь для user_id = 2 число очков
стало 1100 (было 1400), а для user_id = 1 число очков
равно 400.

Наконец, если
нужно задать ограничение по числу отбираемых записей, то в последнюю очередь
записывается оператор LIMIT:

Вот такую более
сложную структуру мы получили для команды SELECT. На следующем
занятии мы продолжим о ней говорить и посмотрим как создается сводная выборка
из нескольких таблиц.

MySQL. Урок 10. Агрегатные функции. — floppyy blog

Агрегатные функции — это функции, применяемые к набору каких-то столбцов и возвращающие по ним одно значение.  Это может быть сумма всех значений по выбранному столбцу или наименьшее значение, хранимое в данном поле по всем записям. С помощью агрегатных функций удобно также получать различные статистические показатели. К данным функциям относятся:

Первый простейший пример возвратит количество записей в таблице:

SELECT SUM(price) FROM books;

Данный запрос возвратит нам стоимость всех книг, имеющихся в нашей таблице. В качестве аргумента функция принимает наименование столбца, к которому она применяется.

Точно также мы могли бы узнать, сколько стоит самая дорогая книга в нашей библиотеке и вместе со стоимостью вывести ее наименование:

SELECT title, MAX(price) FROM books;

Хм, Евгений Онегин. Наверно справедливо, Пушкин все же! Вообще все функции, кроме MAX() и MIN() можно применять только к числовым полям. Последние две применимы к строковым значениям. Они возвращают соответствующий значения с учетом лексикографического порядка.

В нашей таблице может быть несколько книг с одним и тем же названием, но разным годом издания. Как нам получить сколько у нас имеется уникальных книг? Агрегатные функции можно использовать совместно с ключевым словом DISTINCT:

SELECT COUNT(DISTINCT title) FROM books;

Не так уж и много. Наверное, кто-то не сдал книжки назад:D

Для получения общего количества записей в таблице можно также воспользоваться функцией COUNT(*). Символ звездочки * означает, что функция должна быть применена ко всем записям.

SELECT COUNT(*) FROM books;

В своих запросах вы точно также можете использовать выражения WHERE. Допустим, что мы хотим подсчитать количество книг в библиотеке, дата издания которых позже, чем 1 января 2014 года:

SELECT COUNT(*) FROM books
WHERE year > ‘2014-01-01’;

Агрегатные функции можно применять и группам полей, образованным при помощи выражения GROUP BY. То есть те же самые значения мы можем использовать для получения информации по каждой группе. Как вы уже знаете, книги в нашей библиотеке могут иметь одно и то же название, но год издания их может различаться. Очевидно, мы можем выполнить группировку. Давайте для примера узнаем стоимость самой дорогой книги из каждой такой группы и помимо названия и стоимости выведем ее год издания:

SELECT title, year, MAX(price)
FROM books
GROUP BY title;

Язык SQL:использование агрегатных функций и вычисляемых полей.

⇐ ПредыдущаяСтр 7 из 8Следующая ⇒

1.Получить общее количество поставщиков (ключевое слово COUNT):

SELECT COUNT(*) AS N

FROM P;

2.В результате получим таблицу с одним столбцом и одной строкой, содержащей количество строк из таблицы P.

Получить общее, максимальное, минимальное и среднее количества поставляемых деталей (ключевые слова SUM, MAX, MIN, AVG):

SELECT

SUM(PD.VOLUME) AS SM,

MAX(PD.VOLUME) AS MX,

MIN(PD.VOLUME) AS MN,

AVG(PD.VOLUME) AS AV

FROM PD;

3.Для каждой детали получить суммарное поставляемое количество (ключевое слово GROUP BY…):

SELECT

PD.DNUM,

SUM(PD.VOLUME) AS SM

GROUPBYPD.DNUM;

Этот запрос будет выполняться следующим образом. Сначала строки исходной таблицы будут сгруппированы так, чтобы в каждую группу попали строки с одинаковыми значениями DNUM. Потом внутри каждой группы будет просуммировано поле VOLUME. От каждой группы в результатирующую таблицу будет включена одна строка.

4.Получить номера деталей, суммарное поставляемое количество которых превосходит 400 (ключевое слово HAVING…):

Условие, что суммарное поставляемое количество должно быть больше 400 не может быть сформулировано в разделе WHERE, т.к. в этом разделе нельзя использовать агрегатные функции. Условия, использующие агрегатные функции должны быть размещены в специальном разделе HAVING:

SELECT

PD.DNUM,

SUM(PD.VOLUME) AS SM

GROUP BY PD.DNUM

HAVING SUM(PD.VOLUME) > 400;

Язык SQL:группировкастрок

Группировка данных в операторе SELECT осуществляется с помощью ключевого слова GROUP BYи ключевого слова HAVING, с помощью которого задаются условия разбиения записей на группы.

GROUP BY неразрывно связано с агрегирующими функциями, без них оно практически не используется. GROUP BY разделяет таблицу на группы, а агрегирующая функция вычисляет для каждой из них итоговое значение. Определим для примера количество книг каждего издательства в нашей базе данных:

SELECT таб1.поле1, count(таб2.поле2)

FROM таб2,таб1

WHERE таб1.поле=таб2.поле

GROUP BY таб1.поле1;

Kлючевое слово HAVING работает следующим образом: сначала GROUP BY разбивает строки на группы, затем на полученные наборы накладываются условия HAVING.

Включить в результат только те поля, данные которых оканчивается на подстроку «Press»:

SELECT таб1.поле, count(таб2.поле2)

FROM таб1,таб2

WHERE таб1.поле1=таб2.поле1

GROUPBY таб1.поле

HAVING таб1.поле LIKE ‘%Press’;

Язык SQL:соединение таблиц.

Выборка из двух таблиц путем их внутреннего соединения по столбцу КодРегиона

SELECT Поставщик.ИмяПоставщика, Регион.Город, Регион.Факс, Поставщик.КодПоставщика

FROM Регион

INNER JOIN Поставщик ON Регион.КодРегиона =

Поставщик.КодРегиона

ORDERBYПоставщик.ИмяПоставщика

Язык SQL:внешнее соединение таблиц.

Строки из таблицы, присоединенной внешним образом (на внешнее

соединение указывает ключевое слово OUTER) будут выбираться не

смотря на то, удовлетворяют они условиям WHERE предложения или

нет. В некоторых случаях это полезно, когда у вас есть главная

таблица и есть вспомогательная, и данные из главной таблицы вам

нужно получить в любом случае. Примервнешнегосоединения:

———————————————————

SELECT company, order_num

FROM customer c, OUTER orders o

WHERE c.customer_num=o.customer_num

———————————————————

Запрос находит названия компаний и номера ордеров, которые они

послали. Если же компания ордеров не присылала, то ее название

все равно будет выбрано, а номер ордера в этой строке будет ра-

вен NULL. (А если бы мы запустили запрос без параметра OUTER,

то названия этих компаний вообще бы не попали в выборку.)

Язык SQL:использование подзапросов.

Допустим нам необходимо найти сотрудников, которые получают больше чем сотрудник Smith. Решение данной задачи усложняется ввиду того, что для нахождения подобных сотрудников нам необходимо:

1. Узнать зарплату сотрудника Smith

2. Вытащить всех чья зарплата выше? чем зарплата полученная в предедущем шаге.

На языке SQL это решение будет выглядитьввиде двух запросов, при этом один из запросов будет вложен в другой запрос. Запрос находящийся внутри другого запроса называеться – подзапросом. Подзапрос возвращает значение, которое будет использоваться в основном запросе. Использования подзапросов, есть использования по очереди двух запросов, сперва получаем данные из подзапроса, а затем используем эти данные в качестве данных основного запроса.

Синтаксис и свойства подзапросов

Синтаксис простого подзапроса выглядит так:

SELECT select_list

FROM table

WHERE expr operator

(SELECT select_list

FROM table)

Здесь в качестве оператора может играть роль такие операторы сравнения как >;>=;<;<=;OR;IN при работе с запросами возравщающие ровно одно значение, а также для решения задач запросами возвращающие множество строк используйте в качестве операторов IN; ANY; ALL.

При этом сперва выполняется подзапрос (внутренней запрос), а результат операции будет передан основному запросу. Подзапрос – есть операция SELECT которая передает свое значения другому основному запросу. При этом возможности подзапроса велики, поэтому использования подзапросов открывает перед вами большие возможности. При этом возможно использовать подзапросы в следующих частях оператора SELECT:

• В разделе SELECT
• В качестве таблицы в разделе FROM
• В разделе WHERE
• В условиях HAVING
• В разделе ORDER BY

Рассмотрим список правил, которые необходимо соблюдать во время построение подзапроса:

• Подзапрос должен быть включен внутрь круглых скобок
• Подзапрос необходимо ставить правую часть от оператора сравнения
• Необходимости в упорядочения вывода подзапроса нет необходимости за исключением слючаев когда необходимо получить запроса типа Топ – n
• Используйте однострочные операторы сравнения при работе с запрос возражающий однозначение и наоборот используйте только многострочные операторы сравнения при работе с запросом возвращающим множество строк.

Типы подзапросов

Как уже вы наверное понили из описания подзапросов существует два типа подзапросов:

• Подзапросы возражающие один результат
• Подзапросы возражающие множество строк в качестве результата.

Схема подзапроса возражающей одно значение:

Схема подзапроса возражающей множество строк, хотя схематично изображено всего две строки, но на самом деле их может быть от двух и более.

Подзапросы возражающие один результат

Начнем разбирать все свойства, а также примеры подзапросов возражающих один результат. Конечно при работе с подзапросами мы используем операторы сравнения. Для работы с этим типом подзапросов используеться следующие операторы сравнения.

Пример запроса – вывести всех сотрудников, чьи зарплаты больше зарплаты сотрудника SMITH :

SELECT *

FROM emp

WHERE sal> (SELECT sal

FROM emp

WHERE ename = ‘SMITH’)

Мы рассмотрели простой пример подзапроса, немного усложним логику запроса и получим:

SELECT *

FROM emp

WHERE job = (SELECT job

FROM emp

WHERE ename = ‘SMITH’

)

AND sal> (SELECT MIN (sal)

FROM emp

)

Как можно заметить из примера в запросе можно использовать несколько подзапросов. В таком случаи результат будет получен сперва из подзапросов по очереди, а затем все данные полученные из подзапросов будут проставлены в качестве значений в основной запрос.

Хотя в примерах указаны подзапросы берущие значения из одной таблицы, но подзапросы также могут брать значения из других таблиц. Также как вы заметили в данном примере, мы использовали одну из групповых функций.

До сих пор мы рассмотрели примеры подзапросов работающих в условии WHERE, но на практике бывает необходимость использования подзапросов в разделе HAVING. Подзапрос в этом случаи будет выполнен и результат будет направлен в условия HAVING.

Рассмотрим пример, где без подзапроса в разделе HAVING не обойтись. Допустим нам необходимо вычислить какой из отделов получает самую низкую среднеарифметичускую зарплату среди всех отделов компании.

SELECT job, avg(sal)

FROM emp

GROUP BY job

HAVING AVG(sal) = (SELECT MIN(AVG(sal))

FROM emp

GROUP BY job)

Язык SQL:операторы EXISTS, ANY, ALL в командах с подзапросом.



PostgreSQL : Документация: 9.6: 9.20. Агрегатные функции : Компания Postgres Professional

9.20. Агрегатные функции

Агрегатные функции получают единственный результат из набора входных значений. Встроенные обычные агрегатные функции перечислены в Таблице 9.51 и Таблице 9.52, а сортирующие агрегатные функции — в Таблице 9.53 и Таблице 9.54. Операции группирования, тесно связанные с агрегатными функциями, перечислены в Таблице 9.55. Особенности синтаксиса агрегатных функций разъясняются в Подразделе 4.2.7. За дополнительной вводной информацией обратитесь к Разделу 2.7.

Таблица 9.51. Агрегатные функции общего назначения

Следует заметить, что за исключением count, все эти функции возвращают NULL, если для них не была выбрана ни одна строка. В частности, функция sum, не получив строк, возвращает NULL, а не 0, как можно было бы ожидать, и array_agg в этом случае возвращает NULL, а не пустой массив. Если необходимо, подставить в результат 0 или пустой массив вместо NULL можно с помощью функции coalesce.

Агрегатные функции, поддерживающие частичный режим, являются кандидатами на участие в различных оптимизациях, например, в параллельном агрегировании.

Примечание

Булевы агрегатные функции bool_and и bool_or соответствуют стандартным SQL-агрегатам every и any или some. Что касается any и some, по стандарту их синтаксис допускает некоторую неоднозначность:

SELECT b1 = ANY((SELECT b2 FROM t2 ...)) FROM t1 ...;

Здесь ANY можно рассматривать и как объявление подзапроса, и как агрегатную функцию, если этот подзапрос возвращает одну строку с булевым значением. Таким образом, этим агрегатным функциям нельзя было дать стандартные имена.

Примечание

Пользователи с опытом использования других СУБД SQL могут быть недовольны скоростью агрегатной функции count, когда она применяется ко всей таблице. Подобный запрос:

SELECT count(*) FROM sometable;

потребует затрат в количестве, пропорциональном размеру таблицы: PostgreSQL придётся полностью просканировать либо всю таблицу, либо один из индексов, включающий все её строки.

Агрегатные функции array_agg, json_agg, jsonb_agg, json_object_agg, jsonb_object_agg, string_agg и xmlagg так же, как и подобные пользовательские агрегатные функции, выдают разные по содержанию результаты в зависимости от порядка входных значений. По умолчанию порядок не определён, но его можно задать, дополнив вызов агрегатной функции предложением ORDER BY, как описано в Подразделе 4.2.7. Обычно нужного результата также можно добиться, передав для агрегирования результат подзапроса с сортировкой. Например:

SELECT xmlagg(x) FROM (SELECT x FROM test ORDER BY y DESC) AS tab;

Но учтите, что этот подход может не работать, если на внешнем уровне запроса выполняется дополнительная обработка, например, соединение, так как при этом результат подзапроса может быть переупорядочен перед вычислением агрегатной функции.

В Таблице 9.52 перечислены агрегатные функции, обычно применяемые в статистическом анализе. (Они выделены просто для того, чтобы не загромождать список наиболее популярных агрегатных функций.) В их описании под N подразумевается число входных строк, для которых входные выражения не равны NULL. Все эти функции возвращают NULL во всех случаях, когда вычисление бессмысленно, например, когда N равно 0.

Таблица 9.52. Агрегатные функции для статистических вычислений

В Таблице 9.53 показаны некоторые агрегатные функции, использующие синтаксис сортирующих агрегатных функций. Иногда такие функции функциями называют функциями «обратного распределения».

Таблица 9.53. Сортирующие агрегатные функции

Все агрегатные функции, перечисленные в Таблице 9.53, игнорируют значения NULL при сортировке данных. Для функций, принимающих параметр дробь, значение этого параметра должно быть о

SQL Aggregate Functions

Summary : в этом руководстве вы узнаете об агрегатных функциях SQL, включая AVG () , COUNT () , MIN () , MAX () и SUM () .

Агрегатная функция SQL вычисляет набор значений и возвращает одно значение. Например, функция среднего значения ( AVG ) принимает список значений и возвращает среднее значение.

Поскольку агрегатная функция работает с набором значений, она часто используется с предложением GROUP BY оператора SELECT .Предложение GROUP BY делит набор результатов на группы значений, а агрегатная функция возвращает одно значение для каждой группы.

Ниже показано, как агрегатная функция используется с предложением GROUP BY :

 
  SELECT c1, aggregate_function (c2)
ИЗ таблицы
ГРУППА ПО c1;  
 

Ниже приведены наиболее часто используемые агрегатные функции SQL:

• AVG () — возвращает среднее значение набора.
• COUNT () — возвращает количество элементов в наборе.
• MAX () — возвращает максимальное значение в наборе.
• MIN () — возвращает минимальное значение в наборе
• SUM () — возвращает сумму всех или отдельных значений в наборе

За исключением функции COUNT () , агрегатных функций SQL игнорировать нуль.

Агрегатные функции можно использовать как выражения только в следующих случаях:

• Список выбора оператора SELECT , будь то подзапрос или внешний запрос.
• A HAVING clause

AVG

Функция AVG () возвращает средние значения в наборе. Ниже показан синтаксис функции AVG () :

 
  AVG (ALL | DISTINCT)  
 

Ключевое слово ALL указывает функции AVG () вычислить среднее всех значений, в то время как DISTINCT ключевое слово заставляет функцию работать только с отдельными значениями.По умолчанию используется опция ALL .

В следующем примере показано, как использовать функцию AVG () для расчета средней заработной платы каждого отдела:

 
  SELECT
    название_отдела, КРУГЛЫЙ (СРЕДН. (зарплата), 0) средн_зарплата
ОТ
    сотрудники
        ВНУТРЕННЕЕ СОЕДИНЕНИЕ
    отделы ИСПОЛЬЗУЕМ (Department_id)
ГРУППА ПО имя_отдела
ЗАКАЗАТЬ ПО название_отдела;  
 

MIN

Функция MIN () возвращает минимальное значение набора.Ниже показан синтаксис функции MIN () :

 
  MIN (столбец | выражение)  
 

Например, следующий оператор возвращает минимальную зарплату сотрудников в каждом отделе:

 
  SELECT
    название_отдела, MIN (зарплата) min_salary
ОТ
    сотрудники
        ВНУТРЕННЕЕ СОЕДИНЕНИЕ
    отделы ИСПОЛЬЗУЕМ (Department_id)
ГРУППА ПО имя_отдела
ЗАКАЗАТЬ ПО название_отдела;  
 

MAX

Функция MAX () возвращает максимальное значение набора.Функция MAX () имеет следующий синтаксис:

 
  MAX (столбец | выражение)  
 

Например, следующий оператор возвращает самую высокую зарплату сотрудников в каждом отделе:

 
  SELECT
    название_отдела, МАКС (зарплата) наивысшая_заплата
ОТ
    сотрудники
        ВНУТРЕННЕЕ СОЕДИНЕНИЕ
    отделы ИСПОЛЬЗУЕМ (Department_id)
ГРУППА ПО имя_отдела
ЗАКАЗАТЬ ПО название_отдела;  
 

COUNT

Функция COUNT () возвращает количество элементов в наборе.Ниже показан синтаксис функции COUNT () :

 
  COUNT ([ALL | DISTINCT] column | выражение | *)  
 

. Например, в следующем примере используется функция COUNT (*) для возврата количества сотрудников каждого отдела:

 
  SELECT
    имя_отдела, COUNT (*) штат
ОТ
    сотрудники
        ВНУТРЕННЕЕ СОЕДИНЕНИЕ
    отделы ИСПОЛЬЗУЕМ (Department_id)
ГРУППА ПО имя_отдела
ЗАКАЗАТЬ ПО название_отдела;  
 

СУММ

Функция СУММ () возвращает сумму всех значений.Ниже показан синтаксис функции SUM () :

 
  SUM (столбец ALL | DISTINCT)  
 

Например, следующий оператор возвращает общую зарплату всех сотрудников в каждом отделе:

 
  ВЫБРАТЬ
    Department_id, SUM (зарплата)
ОТ
    сотрудники
ГРУППА ПО идентификатору отдела;
  
 

В этом руководстве вы узнали о наиболее часто используемых агрегатных функциях SQL, включая функции AVG () , COUNT () , MIN () , MAX () и SUM () . .

.

Агрегатные функции SQL

Резюме : в этом руководстве мы познакомим вас с концепциями агрегатных функций и общими агрегатными функциями SQL.

Введение в агрегатные функции SQL

Агрегатная функция позволяет выполнять вычисление набора значений для возврата одного скалярного значения. Мы часто используем агрегатные функции с предложениями GROUP BY и HAVING оператора SELECT.

Ниже перечислены наиболее часто используемые агрегатные функции SQL:

• AVG — вычисляет среднее значение набора значений.
• COUNT — подсчитывает строки в указанной таблице или представлении.
• MIN — получает минимальное значение из набора значений.
• MAX — получает максимальное значение из набора значений.
• СУММ — вычисляет сумму значений.

Обратите внимание, что все вышеперечисленные агрегатные функции игнорируют значения NULL , за исключением функции COUNT .

Синтаксис агрегатных функций SQL

Для вызова агрегатной функции используется следующий синтаксис:

Давайте рассмотрим синтаксис выше более подробно:

• Сначала укажите агрегатную функцию, которую вы хотите использовать e.г., MIN , MAX , AVG , SUM или COUNT .
• Во-вторых, поместите модификатор DISTINCT или ALL , за которым следует выражение в круглых скобках. Если вы явно используете модификатор DISTINCT , агрегатная функция игнорирует повторяющиеся значения и учитывает только уникальные значения. Если вы используете модификатор ALL , агрегатная функция использует все значения для расчета или оценки. Модификатор ALL используется по умолчанию, если вы не указываете какой-либо модификатор явно.

Примеры агрегатных функций SQL

Давайте рассмотрим несколько примеров использования агрегатных функций SQL.

Пример функции COUNT

Чтобы получить количество продуктов в таблице продуктов , используйте функцию COUNT следующим образом:

Дополнительная информация о функции СЧЁТ.

Пример функции AVG

Чтобы вычислить среднее количество единиц на складе продуктов, используйте функцию AVG следующим образом:

Для расчета единиц на складе по категории продукта используйте функцию AVG с предложением GROUP BY следующим образом:

Дополнительная информация о функции AVG.

Пример функции СУММ

Чтобы вычислить сумму единиц на складе по категории продукта, используйте функцию СУММ с предложением GROUP BY в виде следующего запроса:

Ознакомьтесь с руководством по функции СУММ для получения дополнительной информации о том, как использовать функцию СУММ .

Пример функции MIN

Чтобы получить минимальное количество единиц на складе продуктов в таблице продуктов, используйте функцию MIN следующим образом:

Дополнительная информация о функции MIN.

Пример функции MAX

Чтобы получить максимальное количество единиц на складе продуктов в таблице продуктов, вы используете функцию MAX , как показано в следующем запросе:

Дополнительные сведения см. В руководстве по функциям MAX.

В этом руководстве мы познакомили вас с агрегатными функциями SQL, включая наиболее часто используемые функции: AVG , COUNT , MIN , MAX и SUM .

• Было ли это руководство полезным?
• Да Нет

.

Изучение SQL: агрегированные функции

SQL имеет много интересных функций, и агрегатные функции, безусловно, являются одной из этих функций, фактически функций. Хотя они не являются специфическими для SQL, они используются часто. Они являются частью оператора SELECT , и это позволяет нам использовать все преимущества SELECT (объединение таблиц, фильтрация только необходимых нам строк и столбцов),
в сочетании с мощью этих функций.

Модель

Прежде чем мы начнем говорить об агрегатных функциях, мы кратко прокомментируем модель данных, которую мы будем использовать.

Это та же модель, которую мы использовали в нескольких прошлых статьях. Я не буду вдаваться в подробности, а упомяну, что все
6 таблиц в модели содержат данные. На некоторые записи в таблицах есть ссылки в других, а на некоторые нет. Например.
у нас есть страны, в которых нет связанных городов, и есть города, в которых нет связанных клиентов. Мы прокомментируем это в статье, где это будет важно.

Простейшая функция агрегирования

Мы, конечно же, начнем с простейшей агрегатной функции.Но прежде чем мы это сделаем, давайте проверим
содержимое двух таблиц, которые мы будем использовать в этой статье. Есть таблицы , страна и
город . Мы будем использовать следующие утверждения:

Результат вы можете увидеть на картинке ниже:

В этом нет ничего нового и неожиданного.Мы только что перечислили все, что есть в наших таблицах («*» в запросе будет
приведет к возврату всех столбцов / атрибутов при отсутствии какого-либо условия / WHERE части запроса
приведет к возврату всех строк).

Единственное, что я хотел бы отметить, это то, что таблица country имеет 7 строк и что
город таблица имеет 6 строк. Теперь давайте рассмотрим следующие запросы и их результат:

Мы можем заметить, что для каждого запроса в результате мы получили одну строку, а возвращенное число представляет количество строк в каждой из этих двух таблиц.Вот что делает агрегатная функция COUNT . Он берет то, что вернет запрос без COUNT , а затем возвращает количество строк в этом результате. Еще одна важная вещь, о которой вы должны знать, это то, что только COUNT можно использовать с «*». Для всех других функций требуется атрибут (или формула) в скобках. Мы увидим это позже.

Агрегатные функции и соединения

А теперь попробуем еще две вещи. Сначала мы проверим, как COUNT работает, когда мы объединяем таблицы.Сделать
то мы будем использовать следующие запросы:

Хотя первый запрос не нужен, я использовал его, чтобы показать, что он вернет.Я сделал это, потому что это то, что учитывает второй запрос. Когда две таблицы объединяются, вы можете представить этот результат как некую промежуточную таблицу, которую можно использовать как любые другие таблицы (например, для вычислений с использованием агрегатных функций в подзапросах).

• Совет: Каждый раз, когда вы пишете сложный запрос, вы можете проверить, что возвращают части, и
  таким образом вы будете уверены, что ваш запрос работает и будет работать, как и ожидалось.

Также стоит отметить еще одну вещь.Мы использовали INNER JOIN при объединении таблиц.
страна и город . Это исключит страны без городов из результата.
(Вы можете проверить почему здесь). Теперь запустим 3
больше запросов, в которых таблицы объединяются с использованием LEFT JOIN :

Мы можем заметить несколько вещей:

• 1 запрос ^st вернул 8 строк. Это те же 6 строк, что и в запросе с использованием INNER JOIN
  и еще 2 строки для стран, у которых нет связанных городов (Россия и Испания)
• 2 запрос ^nd подсчитывает количество строк, возвращаемых запросом 1 ^st , поэтому это число равно 8
• 3 ^rd запрос содержит два важных замечания.Во-первых, мы использовали агрегатную функцию
  ( COUNT ) дважды в части запроса SELECT . Обычно это происходит потому, что вас интересуют более подробные сведения о группе, которую вы хотите проанализировать (количество записей, средние значения и т. Д.). Вторая важная вещь заключается в том, что эти 2 счетчика использовали имена столбцов вместо «*» и возвращали разные значения. Это происходит потому, что таким образом было создано COUNT . Если вы поместите имена столбцов в скобки, COUNT будет подсчитывать количество имеющихся значений (не включая значения NULL).Все наши записи имели значение для country_name, поэтому 1 ^st COUNT вернул 8. С другой стороны, city_name
  не был определен 2 раза (= NULL), поэтому 2 ^и COUNT вернули 6 (8-2 = 6)

• Примечание: Это также означает другие агрегатные функции. Если они имеют значение NULL,
  они просто проигнорируют их и посчитают, поскольку их не существует.

Агрегатные функции SQL

Пришло время упомянуть все агрегатные функции T-SQL.Чаще всего используются:

• COUNT — подсчитывает количество элементов в определенной группе
• SUM — вычисляет сумму данного атрибута / выражения в определенной группе
• AVG — вычисляет среднее значение данного атрибута / выражения в определенной группе
• MIN — находит минимум в определенной группе
• MAX — находит максимум в определенной группе

Эти 5 наиболее часто используются и стандартизированы, поэтому они понадобятся вам не только в SQL Server, но и в других СУБД.Остальные агрегатные функции:

• APPROX_COUNT_DISTINCT
• CHECKSUM_AGG
• COUNT_BIG
• ГРУППИРОВКА
• GROUPING_ID
• СТАНДОТКЛОН
• STDEVP
• STRING_AGG
• VAR
• ВАРПБ

Хотя все агрегатные функции можно использовать без предложения GROUP BY , все дело в том, чтобы использовать
пункт GROUP BY .Этот пункт служит местом, где вы определяете условие о том, как
создать группу. Когда группа будет создана, вы рассчитаете агрегированные значения.

• Пример: Представьте, что у вас есть список профессиональных спортсменов, и вы знаете, какой вид спорта
  каждый из них играет. Вы можете спросить себя что-то вроде — Из моего списка верните минимальное, максимальное и
  средний рост игроков, сгруппированный по виду спорта, которым они занимаются.Результатом, конечно же, будет MIN, MAX и AVG.
  высота для групп — «футболисты», «баскетболисты» и др.

Агрегатные функции — примеры

Теперь давайте посмотрим, как эти функции работают с одной таблицей. Их так редко используют, но это хорошо
чтобы увидеть это хотя бы в образовательных целях:

Запрос вернул агрегированное значение для всех городов. Хотя эти значения не имеют практического применения, они демонстрируют мощь агрегатных функций.

Теперь мы сделаем что-нибудь умнее. Мы будем использовать эти функции гораздо ближе, чем вы могли ожидать в
реальные жизненные ситуации:

Это гораздо более «умный» запрос, чем предыдущий. Он вернул список всех стран с количеством городов в них, а также SUM, AVG, MIN и MAX из их значений lat .

Обратите внимание, что мы использовали пункт GROUP BY .Разместив country.id и
страна. country_name , мы определили группу. Все города, принадлежащие одной стране, будут в
та же группа. После создания группы рассчитываются агрегированные значения.

• Примечание: Предложение GROUP BY должно содержать все атрибуты, не относящиеся к агрегатным функциям (в нашем случае это было country.country_name). Вы также можете включить другие атрибуты. Мы включили страну.id, потому что мы уверены, что он однозначно определяет каждую страну.

Заключение

Агрегатные функции — очень мощный инструмент в базах данных. Они служат той же цели, что и их эквиваленты в MS.
Excel, но волшебство в том, что вы можете запрашивать данные и применять функции в одном операторе. Сегодня мы рассмотрели основные примеры. Позже в этой серии мы будем использовать их для решения более сложных задач (с более сложными запросами),
так что следите за обновлениями.

Содержание

Эмиль — профессионал в области баз данных с более чем 10-летним опытом работы во всем, что касается баз данных.В течение многих лет он работал в сфере информационных технологий и финансов, а сейчас работает фрилансером.

Его прошлые и настоящие занятия варьируются от дизайна и программирования баз данных до обучения, консультирования и написания статей о базах данных. Также не забывайте, BI, создание алгоритмов, шахматы, филателия, 2 собаки, 2 кошки, 1 жена, 1 ребенок …

Вы можете найти его в LinkedIn

Просмотреть все сообщения Эмиля Drkusic

Последние сообщения Эмиля Drkusic (увидеть все)

.

Агрегатные функции SQL Server

Резюме : в этом руководстве вы узнаете об агрегатных функциях SQL Server и о том, как их использовать для вычисления агрегатов.

Агрегатная функция выполняет вычисление одного или нескольких значений и возвращает одно значение. Агрегатная функция часто используется с предложением GROUP BY и предложением HAVING оператора SELECT .

В следующей таблице показаны агрегатные функции SQL Server:

Синтаксис агрегатной функции SQL Server

Синтаксис агрегатной функции показан ниже:

 
  aggregate_function_name (DISTINCT | ALL выражение)
  
 

В этом синтаксисе;

• Сначала укажите имя агрегатной функции, которую вы хотите использовать, например AVG , SUM и MAX .
• Во-вторых, используйте DISTINCT , если вы хотите, чтобы при вычислении учитывались только отдельные значения, или ALL , если в вычислении учитываются все значения. По умолчанию ALL используется, если вы не указали модификатор.
• В-третьих, выражение может быть столбцом таблицы или выражением, состоящим из нескольких столбцов с арифметическими операторами.

Примеры агрегатных функций SQL Server

Мы будем использовать таблицу products из образца базы данных для демонстрации.

Пример AVG

В следующем операторе используется функция AVG () для возврата средней прейскурантной цены всех продуктов в таблице продуктов:

 
  SELECT
    AVG (list_price) avg_product_price
ОТ
    production.products;
  
 

Ниже показан результат:

Поскольку прейскурантная цена в долларах США, она должна содержать не более двух десятичных знаков. Следовательно, вам нужно округлить результат до числа с двумя десятичными знаками. Для этого вы используете функции ROUND и CAST , как показано в следующем запросе:

 
  SELECT
    CAST (ROUND (AVG (list_price); 2) AS DEC (10,2))
    avg_product_price
ОТ
    производство.продукты;
  
 

Сначала функция ОКРУГЛ возвращает округленное среднее значение прейскуранта. Затем функция CAST преобразует результат в десятичное число с двумя десятичными знаками.

Пример COUNT

Следующий оператор использует функцию COUNT () для возврата количества продуктов, цена которых превышает 500:

 
  SELECT
    COUNT (*) product_count
ОТ
    production.products
ГДЕ
    list_price> 500;
  
 

Ниже показан результат:

В этом примере:

• Во-первых, в предложение WHERE попадают продукты, прейскурантная цена которых превышает 500.
• Во-вторых, функция COUNT возвращает количество продуктов с прейскурантной ценой, превышающей 500.

Пример MAX

Следующий оператор использует функцию MAX () для возврата наивысшей прейскурантной цены всех продуктов:

 
  ВЫБРАТЬ
    MAX (list_price) max_list_price
ОТ
    production.products;
  
 

Выходные данные показаны на следующем рисунке:

Пример MIN

Аналогично, следующий оператор использует функцию MIN () для возврата наименьшей цены по прейскуранту для всех продуктов:

 
  SELECT
    MIN (list_price) min_list_price
ОТ
    производство.продукты;
  
 

Результат:

Пример СУММ

Чтобы продемонстрировать функцию СУММ () , мы будем использовать таблицу акций из образца базы данных.

Следующий оператор использует функцию СУММ () для вычисления общего запаса по идентификатору продукта на всех складах:

 
  SELECT
    идантификационный номер продукта,
    SUM (количество) stock_count
ОТ
    production.stocks
ГРУППА ПО
    идантификационный номер продукта
СОРТИРОВАТЬ ПО
    stock_count DESC;
  
 

Вот результат:

Вот как работает оператор:

• Во-первых, предложение GROUP BY суммировало строки по идентификаторам продукта в группы.
• Во-вторых, функция СУММ () вычисляет сумму количества для каждой группы.

Пример СТАНДОТКЛОНА

Следующий оператор использует функцию СТАНДОТКЛОН () для вычисления статистического стандартного отклонения всех прейскурантных цен:

 
  SELECT
    CAST (ROUND (STDEV (list_price); 2) как DEC (10,2)) stdev_list_price
ОТ
    production.products;
  
 

В этом руководстве вы узнали об агрегатных функциях SQL Server и о том, как их использовать для вычисления агрегатов.

.