DISTINCT über mehrere Spalten zählen

Gibt es eine bessere Möglichkeit, eine Abfrage wie diese durchzuführen:

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

Ich muss die Anzahl der verschiedenen Elemente aus dieser Tabelle zählen, aber das Unterschied ist über zwei Spalten.

Meine Abfrage funktioniert einwandfrei, aber ich habe mich gefragt, ob ich mit nur einer Abfrage (ohne Verwendung einer Unterabfrage) das Endergebnis erzielen kann.

Wenn Sie versuchen, die Leistung zu verbessern, können Sie versuchen, eine persistierte berechnete Spalte entweder mit einem Hash oder einem verketteten Wert der beiden Spalten zu erstellen.

Sobald es beibehalten wird, kann die Spalte indiziert und / oder Statistiken erstellt werden, sofern die Spalte deterministisch ist und Sie "gesunde" Datenbankeinstellungen verwenden.

Ich glaube, eine eindeutige Anzahl der berechneten Spalten würde Ihrer Abfrage entsprechen.

Bearbeiten: Geändert von der weniger zuverlässigen Nur-Prüfsummen-Abfrage habe ich einen Weg gefunden, dies zu tun (in SQL Server 2005), der für mich ziemlich gut funktioniert, und ich kann so viele Spalten verwenden, wie ich brauche (indem ich sie hinzufüge) die CHECKSUM () Funktion). Die REVERSE () -Funktion wandelt die Ints in Varchars um, um die Unterscheidung zuverlässiger zu machen

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

Was gefällt Ihnen an Ihrer vorhandenen Abfrage nicht? Wenn Sie befürchten, dass DISTINCTüber zwei Spalten nicht nur die eindeutigen Permutationen zurückgegeben werden, probieren Sie es aus.

Es funktioniert auf jeden Fall so, wie Sie es von Oracle erwarten.

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>

bearbeiten

Ich ging mit Analytik eine Sackgasse entlang, aber die Antwort war bedrückend offensichtlich ...

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

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

SQL>

bearbeiten 2

Angesichts der folgenden Daten wird die oben bereitgestellte Verkettungslösung falsch gezählt:

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

Also müssen wir ein Trennzeichen einfügen ...

select col1 + '*' + col2 from t23
/

Offensichtlich muss das gewählte Trennzeichen ein Zeichen oder eine Reihe von Zeichen sein, die in keiner der Spalten erscheinen dürfen.

Um als einzelne Abfrage ausgeführt zu werden, verketten Sie die Spalten und ermitteln Sie dann die eindeutige Anzahl der Instanzen der verketteten Zeichenfolge.

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

In MySQL können Sie dasselbe ohne den Verkettungsschritt wie folgt tun:

SELECT count(DISTINCT DocumentId, DocumentSessionId) FROM DocumentOutputItems;

Diese Funktion wird in der MySQL-Dokumentation erwähnt:

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

Wie wäre es mit so etwas wie:

Anzahl auswählen (*)
von
  (Wählen Sie count (*) cnt
   von DocumentOutputItems
   gruppieren nach DocumentId, DocumentSessionId) t1

Wahrscheinlich macht es genau das Gleiche wie Sie es bereits sind, aber es vermeidet das UNTERSCHEIDEN.

Hier ist eine kürzere Version ohne die Unterauswahl:

SELECT COUNT(DISTINCT DocumentId, DocumentSessionId) FROM DocumentOutputItems

Es funktioniert gut in MySQL, und ich denke, dass es dem Optimierer leichter fällt, dieses zu verstehen.

Edit: Anscheinend habe ich MSSQL und MySQL falsch verstanden - sorry, aber vielleicht hilft es trotzdem.

Viele (die meisten?) SQL-Datenbanken können mit Tupeln wie Werten arbeiten, sodass Sie einfach SELECT COUNT(DISTINCT (DocumentId, DocumentSessionId)) FROM DocumentOutputItems; Folgendes tun können: Wenn Ihre Datenbank dies nicht unterstützt, kann dies gemäß dem Vorschlag von @ oncel-umut-turer von CHECKSUM oder einer anderen Skalarfunktion simuliert werden, die eine gute Eindeutigkeit bietet zB COUNT(DISTINCT CONCAT(DocumentId, ':', DocumentSessionId)).

Eine verwandte Verwendung von Tupeln ist das Ausführen von INAbfragen wie: SELECT * FROM DocumentOutputItems WHERE (DocumentId, DocumentSessionId) in (('a', '1'), ('b', '2'));

An Ihrer Abfrage ist nichts auszusetzen, aber Sie können dies auch folgendermaßen tun:

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

Hoffe das funktioniert ich schreibe auf prima vista

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

Ich habe diesen Ansatz verwendet und es hat bei mir funktioniert.

SELECT COUNT(DISTINCT DocumentID || DocumentSessionId) 
FROM  DocumentOutputItems

Für meinen Fall liefert es das richtige Ergebnis.

Wenn Sie nur ein Feld für "DISTINCT" hätten, könnten Sie Folgendes verwenden:

SELECT COUNT(DISTINCT DocumentId) 
FROM DocumentOutputItems

und das gibt den gleichen Abfrageplan wie das Original zurück, wie mit SET SHOWPLAN_ALL ON getestet. Sie verwenden jedoch zwei Felder, um etwas Verrücktes auszuprobieren:

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

Sie haben jedoch Probleme, wenn NULL-Werte beteiligt sind. Ich würde mich einfach an die ursprüngliche Abfrage halten.

Ich habe dies gefunden, als ich nach meinem eigenen Problem gegoogelt habe und festgestellt habe, dass beim Zählen von DISTINCT-Objekten die richtige Nummer zurückgegeben wird (ich verwende MySQL).

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

Ich wünschte, MS SQL könnte auch so etwas wie COUNT (DISTINCT A, B) tun. Aber es kann nicht.

Zuerst schien mir JayTees Antwort eine Lösung zu sein, aber nach einigen Tests konnte CHECKSUM () keine eindeutigen Werte erstellen. Ein kurzes Beispiel ist, dass sowohl CHECKSUM (31.467.519) als auch CHECKSUM (69.1120.823) dieselbe Antwort geben, nämlich 55.

Dann habe ich einige Nachforschungen angestellt und festgestellt, dass Microsoft die Verwendung von CHECKSUM NICHT zur Änderungserkennung empfiehlt. In einigen Foren schlugen einige die Verwendung vor

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

das ist aber auch nicht tröstlich.

Sie können die Funktion HASHBYTES () verwenden, wie im TSQL CHECKSUM-Rätsel vorgeschlagen . Dies hat jedoch auch eine geringe Wahrscheinlichkeit, dass keine eindeutigen Ergebnisse zurückgegeben werden.

Ich würde vorschlagen, zu verwenden

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

Wie wäre es damit,

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

Dadurch erhalten wir die Anzahl aller möglichen Kombinationen von DocumentId und DocumentSessionId

Für mich geht das. Im Orakel:

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

In jpql:

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

Ich hatte eine ähnliche Frage, aber die Abfrage, die ich hatte, war eine Unterabfrage mit den Vergleichsdaten in der Hauptabfrage. etwas wie:

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

Als ich die Komplexität ignorierte, stellte ich fest, dass ich den Wert von a.code mit der in der ursprünglichen Frage beschriebenen doppelten Unterabfrage nicht in die Unterabfrage aufnehmen konnte

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

Also fand ich schließlich heraus, dass ich schummeln und die Spalten kombinieren konnte:

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

Das hat letztendlich funktioniert

Wenn Sie mit Datentypen fester Länge arbeiten, können binarySie dies sehr einfach und sehr schnell tun. Angenommen DocumentIdund DocumentSessionIdsind beide ints und sind daher 4 Bytes lang ...

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

Mein spezifisches Problem erforderte, dass ich a SUMdurch die COUNTunterschiedliche Kombination verschiedener Fremdschlüssel und eines Datumsfelds dividierte, nach einem anderen Fremdschlüssel gruppierte und gelegentlich nach bestimmten Werten oder Schlüsseln filterte. Die Tabelle ist sehr groß, und die Verwendung einer Unterabfrage hat die Abfragezeit erheblich verlängert. Und aufgrund der Komplexität waren Statistiken einfach keine praktikable Option. DasCHECKSUM Konvertierung der Lösung war auch viel zu langsam, insbesondere aufgrund der verschiedenen Datentypen, und ich konnte ihre Unzuverlässigkeit nicht riskieren.

Die Verwendung der oben genannten Lösung hatte jedoch praktisch keine Verlängerung der Abfragezeit (im Vergleich zur Verwendung der einfachen Lösung SUM) und sollte absolut zuverlässig sein! Es sollte in der Lage sein, anderen in einer ähnlichen Situation zu helfen, also poste ich es hier.

Sie können die Zählfunktion einfach zweimal verwenden.

In diesem Fall wäre es:

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

Dieser Code verwendet unterschiedliche Parameter für 2 und gibt die Anzahl der Zeilen an, die für diese unterschiedlichen Werte spezifisch sind. Es hat für mich in MySQL wie ein Zauber funktioniert.

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