Zliczanie DISTINCT w wielu kolumnach

Czy istnieje lepszy sposób wykonania takiego zapytania:

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

Muszę policzyć liczbę odrębnych pozycji z tej tabeli, ale odrębność dotyczy dwóch kolumn.

Moje zapytanie działa dobrze, ale zastanawiałem się, czy mogę uzyskać końcowy wynik za pomocą tylko jednego zapytania (bez użycia pod-zapytania)

Jeśli próbujesz poprawić wydajność, możesz spróbować utworzyć utrwaloną kolumnę obliczeniową na podstawie wartości skrótu lub konkatenacji dwóch kolumn.

Po utrwaleniu, pod warunkiem, że kolumna jest deterministyczna i używasz „zdrowych” ustawień bazy danych, można ją indeksować i / lub tworzyć na niej statystyki.

Uważam, że odrębna liczba obliczonych kolumn byłaby równoważna z zapytaniem.

Edycja: Zmieniony z mniej niż wiarygodnego zapytania zawierającego tylko sumę kontrolną Odkryłem sposób na to (w SQL Server 2005), który działa całkiem dobrze dla mnie i mogę użyć tyle kolumn, ile potrzebuję (dodając je do funkcja CHECKSUM ()). Funkcja REVERSE () przekształca ints w varchary, aby uczynić wyróżnienie bardziej niezawodnym

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

Co takiego jest w twoim istniejącym zapytaniu, czego nie lubisz? Jeśli się tym martwiszDISTINCT dwie kolumny nie zwracają tylko unikatowych permutacji, spróbuj tego?

Z pewnością działa tak, jak można oczekiwać w 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>

edytować

Poszedłem ślepą uliczką z analizami, ale odpowiedź była przygnębiająco oczywista ...

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

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

SQL>

edycja 2

Biorąc pod uwagę następujące dane, powyższe rozwiązanie konkatenacyjne zostanie przelane:

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

Więc dołączymy separator ...

select col1 + '*' + col2 from t23
/

Oczywiście wybrany separator musi być znakiem lub zestawem znaków, które nigdy nie mogą pojawić się w żadnej kolumnie.

Aby uruchomić jako pojedyncze zapytanie, połącz kolumny, a następnie uzyskaj odrębną liczbę wystąpień połączonego łańcucha.

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

W MySQL możesz zrobić to samo bez kroku konkatenacji w następujący sposób:

SELECT count(DISTINCT DocumentId, DocumentSessionId) FROM DocumentOutputItems;

Ta funkcja jest wspomniana w dokumentacji MySQL:

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

Co powiesz na coś takiego:

wybierz liczbę (*)
z
  (wybierz liczbę (*) cnt
   z DocumentOutputItems
   grupuj według DocumentId, DocumentSessionId) t1

Prawdopodobnie robi to samo, co już jesteś, ale unika to DISTINCT.

Oto krótsza wersja bez podselekcji:

SELECT COUNT(DISTINCT DocumentId, DocumentSessionId) FROM DocumentOutputItems

Działa dobrze w MySQL i myślę, że optymalizator ma łatwiejszy czas na zrozumienie tego.

Edycja: Najwyraźniej źle odczytałem MSSQL i MySQL - przepraszam za to, ale może i tak to pomaga.

Wiele (większość?) Baz danych SQL może współpracować z krotkami takimi jak wartości, więc możesz po prostu to zrobić: SELECT COUNT(DISTINCT (DocumentId, DocumentSessionId)) FROM DocumentOutputItems; jeśli twoja baza danych tego nie obsługuje, można ją zasymulować zgodnie z sugestią @ oncel-umut-turer dotyczącą CHECKSUM lub innej funkcji skalarnej zapewniającej dobrą wyjątkowość np COUNT(DISTINCT CONCAT(DocumentId, ':', DocumentSessionId)).

Powiązanym zastosowaniem krotek jest wykonywanie INzapytań, takich jak: SELECT * FROM DocumentOutputItems WHERE (DocumentId, DocumentSessionId) in (('a', '1'), ('b', '2'));

W zapytaniu nie ma nic złego, ale możesz to zrobić w ten sposób:

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

Mam nadzieję, że to działa Piszę na prima vista

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

Zastosowałem to podejście i zadziałało dla mnie.

SELECT COUNT(DISTINCT DocumentID || DocumentSessionId) 
FROM  DocumentOutputItems

W moim przypadku zapewnia prawidłowy wynik.

jeśli masz tylko jedno pole do „DISTINCT”, możesz użyć:

SELECT COUNT(DISTINCT DocumentId) 
FROM DocumentOutputItems

i to zwraca ten sam plan zapytań co oryginał, co przetestowano przy użyciu SET SHOWPLAN_ALL ON. Jednak używasz dwóch pól, aby wypróbować coś szalonego:

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

ale będziesz mieć problemy, jeśli zaangażowane są wartości NULL. Pozostałbym przy pierwotnym zapytaniu.

Znalazłem to, gdy poszukałem Google'a w związku z moim problemem, stwierdziłem, że jeśli policzysz obiekty DISTINCT, otrzymasz poprawną liczbę (używam MySQL)

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

Chciałbym, aby MS SQL mógł zrobić coś w rodzaju COUNT (DISTINCT A, B). Ale nie może.

Na początku odpowiedź JayTee wydawała mi się rozwiązaniem po kilku testach CHECKSUM () nie udało się stworzyć unikalnych wartości. Szybki przykład jest taki, że zarówno CHECKSUM (31 467 519), jak i CHECKSUM (69 1120 823) daje tę samą odpowiedź, która wynosi 55.

Później przeprowadziłem badania i odkryłem, że Microsoft NIE zaleca korzystania z funkcji CHECKSUM do wykrywania zmian. Na niektórych forach niektórzy sugerowali użycie

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

ale to również nie jest wygodne.

Możesz użyć funkcji HASHBYTES () zgodnie z sugestią w zagadce TSQL CHECKSUM . Ma to jednak niewielką szansę na nie zwrócenie unikatowych wyników.

Sugerowałbym użycie

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

Co powiesz na to,

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

Otrzymamy w ten sposób liczbę wszystkich możliwych kombinacji DocumentId i DocumentSessionId

Mi to pasuje. W wyroczni:

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

W jpql:

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

Miałem podobne pytanie, ale zapytanie, które zadałem, było zapytaniem cząstkowym z danymi porównawczymi w zapytaniu głównym. coś jak:

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

ignorując złożoność tego, zdałem sobie sprawę, że nie mogę wprowadzić wartości a.code do podzapytania za pomocą podwójnego zapytania podrzędnego opisanego w pierwotnym pytaniu

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

W końcu doszedłem do wniosku, że mogę oszukiwać i łączyć kolumny:

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

To właśnie skończyło się na pracy

Jeśli pracujesz z typami danych o stałej długości, możesz rzutować, aby binaryto zrobić bardzo łatwo i bardzo szybko. Zakładając, DocumentIdi DocumentSessionIdto zarówno ints, a zatem są 4 bajty długo ...

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

Mój specyficzny problem wymagał ode mnie podzielenia SUMprzez COUNTodrębną kombinację różnych kluczy obcych i pola daty, grupowania według innego klucza obcego i czasami filtrowania według określonych wartości lub kluczy. Tabela jest bardzo duża, a użycie zapytania częściowego znacznie wydłużyło czas zapytania. Ze względu na złożoność statystyki po prostu nie były realną opcją. CHECKSUMRozwiązaniem było również zbyt powolne w jego konwersji, szczególnie w wyniku różnych typów danych, a ja nie mogłem ryzykować jego zawodność.

Jednak użycie powyższego rozwiązania praktycznie nie wydłużyło czasu zapytania (w porównaniu z użyciem po prostu SUM) i powinno być całkowicie niezawodne! Powinien być w stanie pomóc innym w podobnej sytuacji, więc zamieszczam to tutaj.

Możesz po prostu użyć funkcji Count Count dwa razy.

W takim przypadku byłoby to:

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

Ten kod używa odrębnego dla 2 parametrów i podaje liczbę wierszy charakterystyczną dla liczby różnych wierszy. W MySQL zadziałało to jak urok.

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