Подсчет DISTINCT по нескольким столбцам

Есть ли лучший способ сделать запрос, подобный этому:

SELECT COUNT(*) 
FROM (SELECT DISTINCT DocumentId, DocumentSessionId
      FROM DocumentOutputItems) AS internalQuery

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

Мой запрос работает нормально, но мне было интересно, смогу ли я получить окончательный результат, используя только один запрос (без использования подзапроса)

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

Как только он сохраняется, при условии, что столбец является детерминированным, и вы используете «нормальные» настройки базы данных, он может быть проиндексирован и / или может быть создана статистика для него.

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

Изменить: Изменено из менее надежного запроса только контрольной суммы, я обнаружил способ сделать это (в SQL Server 2005), который работает довольно хорошо для меня, и я могу использовать столько столбцов, сколько мне нужно (добавляя их в функция CHECKSUM ()). Функция REVERSE () превращает целые числа в varchars, чтобы сделать их более надежными

SELECT COUNT(DISTINCT (CHECKSUM(DocumentId,DocumentSessionId)) + CHECKSUM(REVERSE(DocumentId),REVERSE(DocumentSessionId)) )
FROM DocumentOutPutItems

Что вам больше не нравится в существующем запросе? Если вы обеспокоены тем, что DISTINCTпо двум столбцам не возвращается только уникальная перестановка, почему бы не попробовать?

Это, безусловно, работает, как и следовало ожидать в Oracle.

SQL> select distinct deptno, job from emp
  2  order by deptno, job
  3  /

    DEPTNO JOB
---------- ---------
        10 CLERK
        10 MANAGER
        10 PRESIDENT
        20 ANALYST
        20 CLERK
        20 MANAGER
        30 CLERK
        30 MANAGER
        30 SALESMAN

9 rows selected.


SQL> select count(*) from (
  2  select distinct deptno, job from emp
  3  )
  4  /

  COUNT(*)
----------
         9

SQL>

редактировать

Я пошел в тупик с аналитикой, но ответ был удручающе очевиден ...

SQL> select count(distinct concat(deptno,job)) from emp
  2  /

COUNT(DISTINCTCONCAT(DEPTNO,JOB))
---------------------------------
                                9

SQL>

редактировать 2

С учетом следующих данных приведенное выше объединенное решение будет неверно учтено:

col1  col2
----  ----
A     AA
AA    A

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

select col1 + '*' + col2 from t23
/

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

Чтобы выполнить один запрос, объедините столбцы, а затем получите различное количество экземпляров объединенной строки.

SELECT count(DISTINCT concat(DocumentId, DocumentSessionId)) FROM DocumentOutputItems;

В MySQL вы можете сделать то же самое без этапа объединения следующим образом:

SELECT count(DISTINCT DocumentId, DocumentSessionId) FROM DocumentOutputItems;

Эта функция упоминается в документации MySQL:

http://dev.mysql.com/doc/refman/5.7/en/group-by-functions.html#function_count-distinct

Как насчет чего-то вроде:

выберите количество (*)
из
  (выберите количество (*) cnt
   из DocumentOutputItems
   группировка по DocumentId, DocumentSessionId) t1

Вероятно, просто делает то же самое, что вы уже сделали, но это избегает ОТЛИЧИЯ.

Вот более короткая версия без подвыбора:

SELECT COUNT(DISTINCT DocumentId, DocumentSessionId) FROM DocumentOutputItems

Он прекрасно работает в MySQL, и я думаю, что оптимизатору легче понять это.

Изменить: Очевидно, я неправильно прочитал MSSQL и MySQL - извините за это, но, возможно, это все равно помогает.

Многие (большинство?) Базы данных SQL могут работать с кортежами, такими как значения, так что вы можете просто сделать: SELECT COUNT(DISTINCT (DocumentId, DocumentSessionId)) FROM DocumentOutputItems; если ваша база данных не поддерживает это, она может быть смоделирована в соответствии с предложением @ Oncel-umut-turer CHECKSUM или другой скалярной функции, обеспечивающей хорошую уникальность например COUNT(DISTINCT CONCAT(DocumentId, ':', DocumentSessionId)).

Связанное использование кортежей выполняет INтакие запросы: SELECT * FROM DocumentOutputItems WHERE (DocumentId, DocumentSessionId) in (('a', '1'), ('b', '2'));

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

WITH internalQuery (Amount)
AS
(
    SELECT (0)
      FROM DocumentOutputItems
  GROUP BY DocumentId, DocumentSessionId
)
SELECT COUNT(*) AS NumberOfDistinctRows
  FROM internalQuery

Надеюсь, что это работает, я пишу на Prima Vista

SELECT COUNT(*) 
FROM DocumentOutputItems 
GROUP BY DocumentId, DocumentSessionId

Я использовал этот подход, и он сработал для меня.

SELECT COUNT(DISTINCT DocumentID || DocumentSessionId) 
FROM  DocumentOutputItems

Для моего случая это дает правильный результат.

если у вас есть только одно поле для «DISTINCT», вы можете использовать:

SELECT COUNT(DISTINCT DocumentId) 
FROM DocumentOutputItems

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

    SELECT COUNT(DISTINCT convert(varchar(15),DocumentId)+'|~|'+convert(varchar(15), DocumentSessionId)) 
    FROM DocumentOutputItems

но у вас будут проблемы, если участвуют NULL. Я бы просто придерживался оригинального запроса.

Я обнаружил это, когда гуглил по своей собственной проблеме, обнаружил, что если вы посчитаете объекты DISTINCT, вы получите верное правильное число (я использую MySQL)

SELECT COUNT(DISTINCT DocumentID) AS Count1, 
  COUNT(DISTINCT DocumentSessionId) AS Count2
  FROM DocumentOutputItems

Я хотел бы, чтобы MS SQL мог также делать что-то вроде COUNT (DISTINCT A, B). Но это не может.

Сначала ответ JayTee показался мне решением, но после некоторых тестов CHECKSUM () не смог создать уникальные значения. Быстрый пример: и CHECKSUM (31 467 519), и CHECKSUM (69,11 8 823) дают один и тот же ответ - 55.

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

SELECT COUNT(DISTINCT CHECKSUM(value1, value2, ..., valueN) + CHECKSUM(valueN, value(N-1), ..., value1))

но это тоже не обнадеживает.

Вы можете использовать функцию HASHBYTES (), как предложено в головоломке TSQL CHECKSUM . Однако это также имеет небольшой шанс не вернуть уникальные результаты.

Я бы предложил использовать

SELECT COUNT(DISTINCT CAST(DocumentId AS VARCHAR)+'-'+CAST(DocumentSessionId AS VARCHAR)) FROM DocumentOutputItems

Как насчет этого,

Select DocumentId, DocumentSessionId, count(*) as c 
from DocumentOutputItems 
group by DocumentId, DocumentSessionId;

Это даст нам счет всех возможных комбинаций DocumentId и DocumentSessionId.

Меня устраивает. В оракуле

SELECT SUM(DECODE(COUNT(*),1,1,1))
FROM DocumentOutputItems GROUP BY DocumentId, DocumentSessionId;

В jpql:

SELECT SUM(CASE WHEN COUNT(i)=1 THEN 1 ELSE 1 END)
FROM DocumentOutputItems i GROUP BY i.DocumentId, i.DocumentSessionId;

У меня был похожий вопрос, но у меня был подзапрос с данными сравнения в основном запросе. что-то вроде:

Select code, id, title, name 
(select count(distinct col1) from mytable where code = a.code and length(title) >0)
from mytable a
group by code, id, title, name
--needs distinct over col2 as well as col1

игнорируя сложности этого, я понял, что не могу получить значение a.code в подзапрос с двойным подзапросом, описанным в исходном вопросе

Select count(1) from (select distinct col1, col2 from mytable where code = a.code...)
--this doesn't work because the sub-query doesn't know what "a" is

В итоге я понял, что могу обмануть и объединить столбцы:

Select count(distinct(col1 || col2)) from mytable where code = a.code...

Это то, что в конечном итоге работает

Если вы работаете с типами данных фиксированной длины, вы можете использовать это, binaryчтобы сделать это очень легко и очень быстро. Предполагая , DocumentIdи DocumentSessionIdоба ints, и поэтому 4 байтам ...

SELECT COUNT(DISTINCT CAST(DocumentId as binary(4)) + CAST(DocumentSessionId as binary(4)))
FROM DocumentOutputItems

Моя конкретная проблема требует , чтобы я разделить SUMна COUNTиз отдельной комбинации различных внешних ключей и поля даты, группируя другой внешним ключом , а иногда фильтрации определенных значений или ключами. Таблица очень большая, и использование подзапроса значительно увеличило время запроса. И из-за сложности, статистика просто не была жизнеспособным вариантом. CHECKSUMРешение было также слишком медленно его преобразования, в частности , в результате различных типов данных, и я не мог рисковать своей ненадежности.

Однако использование вышеуказанного решения практически не увеличивает время запроса (по сравнению с использованием просто SUM) и должно быть абсолютно надежным! Это должно быть в состоянии помочь другим в подобной ситуации, поэтому я публикую это здесь.

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

В этом случае это будет:

SELECT COUNT (DISTINCT DocumentId), COUNT (DISTINCT DocumentSessionId) 
FROM DocumentOutputItems

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

select DISTINCT DocumentId as i,  DocumentSessionId as s , count(*) 
from DocumentOutputItems   
group by i ,s;