Conteggio DISTINCT su più colonne

Esiste un modo migliore di eseguire una query come questa:

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

Devo contare il numero di elementi distinti da questa tabella, ma il distinto si trova su due colonne.

La mia query funziona bene, ma mi chiedevo se posso ottenere il risultato finale usando solo una query (senza usare una query secondaria)

Se si sta tentando di migliorare le prestazioni, è possibile provare a creare una colonna calcolata persistente su un hash o su un valore concatenato delle due colonne.

Una volta persistente, purché la colonna sia deterministica e si utilizzino impostazioni di database "normali", può essere indicizzata e / o è possibile creare statistiche su di essa.

Credo che un conteggio distinto della colonna calcolata sarebbe equivalente alla tua query.

Modifica: modificato dalla query di checksum non affidabile che ho scoperto un modo per farlo (in SQL Server 2005) che funziona abbastanza bene per me e posso usare tutte le colonne di cui ho bisogno (aggiungendole a la funzione CHECKSUM ()). La funzione REVERSE () trasforma gli in in varchar per rendere il distinto più affidabile

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

Cosa non ti piace della tua query esistente? Se sei preoccupato che DISTINCTattraverso due colonne non restituisca solo le permutazioni uniche, perché non provarlo?

Funziona certamente come ci si potrebbe aspettare da 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>

modificare

Sono andato in un vicolo cieco con analisi ma la risposta era deprimentemente ovvia ...

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

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

SQL>

modifica 2

Dati i seguenti dati, la soluzione concatenante fornita sopra non conterà:

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

Quindi includiamo un separatore ...

select col1 + '*' + col2 from t23
/

Ovviamente il separatore scelto deve essere un carattere, o un insieme di caratteri, che non può mai apparire in nessuna delle colonne.

Per eseguire come una singola query, concatenare le colonne, quindi ottenere il conteggio distinto di istanze della stringa concatenata.

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

In MySQL puoi fare la stessa cosa senza il passo di concatenazione come segue:

SELECT count(DISTINCT DocumentId, DocumentSessionId) FROM DocumentOutputItems;

Questa funzionalità è menzionata nella documentazione di MySQL:

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

Che ne dici di qualcosa come:

seleziona conteggio (*)
a partire dal
  (seleziona count (*) cnt
   da DocumentOutputItems
   raggruppa per DocumentId, DocumentSessionId) t1

Probabilmente fa lo stesso che sei già, ma evita il DISTINCT.

Ecco una versione più breve senza la sottoselezione:

SELECT COUNT(DISTINCT DocumentId, DocumentSessionId) FROM DocumentOutputItems

Funziona bene in MySQL e penso che l'ottimizzatore abbia più tempo a comprenderlo.

Modifica: Apparentemente ho letto male MSSQL e MySQL - mi dispiace, ma forse aiuta comunque.

Molti (la maggior parte?) Database SQL possono funzionare con tuple come i valori, quindi puoi semplicemente farlo: SELECT COUNT(DISTINCT (DocumentId, DocumentSessionId)) FROM DocumentOutputItems; se il tuo database non lo supporta, può essere simulato secondo il suggerimento di @ oncel-umut-turer di CHECKSUM o altre funzioni scalari che forniscono una buona unicità es COUNT(DISTINCT CONCAT(DocumentId, ':', DocumentSessionId)).

Un uso correlato delle tuple sta eseguendo INquery come: SELECT * FROM DocumentOutputItems WHERE (DocumentId, DocumentSessionId) in (('a', '1'), ('b', '2'));

Non c'è niente di sbagliato nella tua query, ma puoi anche farlo in questo modo:

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

Spero che funzioni, sto scrivendo su prima vista

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

Ho usato questo approccio e ha funzionato per me.

SELECT COUNT(DISTINCT DocumentID || DocumentSessionId) 
FROM  DocumentOutputItems

Nel mio caso, fornisce risultati corretti.

se avessi un solo campo su "DISTINCT", potresti usare:

SELECT COUNT(DISTINCT DocumentId) 
FROM DocumentOutputItems

e che restituisce lo stesso piano di query dell'originale, come testato con SET SHOWPLAN_ALL ON. Tuttavia stai utilizzando due campi in modo da poter provare qualcosa di folle come:

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

ma avrai problemi se sono coinvolti NULL. Mi limiterei a seguire la query originale.

Ho trovato questo quando ho cercato su Google il mio problema, ho scoperto che se si contano gli oggetti DISTINCT, si ottiene il numero corretto restituito (sto usando MySQL)

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

Vorrei che MS SQL potesse anche fare qualcosa come COUNT (DISTINCT A, B). Ma non può.

Inizialmente la risposta di JayTee mi è sembrata una soluzione dopo alcuni test CHECKSUM () non è riuscito a creare valori univoci. Un rapido esempio è che sia CHECKSUM (31.467.519) sia CHECKSUM (69,1120,823) danno la stessa risposta che è 55.

Quindi ho fatto alcune ricerche e ho scoperto che Microsoft NON consiglia di utilizzare CHECKSUM per scopi di rilevamento delle modifiche. In alcuni forum alcuni hanno suggerito di utilizzare

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

ma anche questo non è confortante.

È possibile utilizzare la funzione HASHBYTES () come suggerito nell'enigma di TSQL CHECKSUM . Tuttavia, ciò ha anche una piccola possibilità di non restituire risultati unici.

Suggerirei di usare

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

Cosa ne pensi di questo,

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

Questo ci consentirà di contare tutte le possibili combinazioni di DocumentId e DocumentSessionId

Per me funziona. In oracolo:

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;

Avevo una domanda simile ma la query che avevo era una sottoquery con i dati di confronto nella query principale. qualcosa di simile a:

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

ignorando la complessità di questo, mi sono reso conto che non potevo ottenere il valore di a.code nella sottoquery con la doppia sub query descritta nella domanda originale

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

Quindi alla fine ho capito che avrei potuto imbrogliare e combinare le colonne:

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

Questo è ciò che ha finito per funzionare

Se stai lavorando con tipi di dati di lunghezza fissa, puoi eseguire il cast binaryper farlo molto facilmente e molto rapidamente. Supponendo DocumentIdche DocumentSessionIdsiano entrambi ints, e pertanto siano lunghi 4 byte ...

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

Il mio problema specifico mi ha richiesto di dividere a SUMper la COUNTcombinazione distinta di varie chiavi esterne e un campo data, raggruppando per un'altra chiave esterna e occasionalmente filtrando per determinati valori o chiavi. La tabella è molto grande e l'utilizzo di una query secondaria ha aumentato notevolmente il tempo di query. E a causa della complessità, le statistiche non erano semplicemente un'opzione praticabile. La CHECKSUMsoluzione era anche troppo lenta nella sua conversione, in particolare a causa dei vari tipi di dati, e non potevo rischiare la sua inaffidabilità.

Tuttavia, l'utilizzo della soluzione di cui sopra non ha praticamente avuto alcun aumento del tempo di query (rispetto all'utilizzo del solo SUM) e dovrebbe essere completamente affidabile! Dovrebbe essere in grado di aiutare gli altri in una situazione simile, quindi sto pubblicando qui.

Puoi semplicemente usare la funzione Count due volte.

In questo caso, sarebbe:

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

Questo codice utilizza parametri distinti su 2 e fornisce il conteggio del numero di righe specifiche per il conteggio delle righe di quei valori distinti. Ha funzionato per me in MySQL come un fascino.

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