Conteggio SQL distinto su partizione

Ho una tabella con due colonne, voglio contare i valori distinti su Col_B su (condizionato da) Col_A.

MyTable

Col_A | Col_B 
A     | 1
A     | 1
A     | 2
A     | 2
A     | 2
A     | 3
b     | 4
b     | 4
b     | 5

Risultato atteso

Col_A   | Col_B | Result
A       | 1     | 3
A       | 1     | 3
A       | 2     | 3
A       | 2     | 3
A       | 2     | 3
A       | 3     | 3
b       | 4     | 2
b       | 4     | 2
b       | 5     | 2

Ho provato il seguente codice

select *, 
count (distinct col_B) over (partition by col_A) as 'Result'
from MyTable

count (distinto col_B) non funziona. Come posso riscrivere la funzione di conteggio per contare valori distinti?

Ecco come lo farei:

SELECT      *
FROM        #MyTable AS mt
CROSS APPLY (   SELECT COUNT(DISTINCT mt2.Col_B) AS dc
                FROM   #MyTable AS mt2
                WHERE  mt2.Col_A = mt.Col_A
                -- GROUP BY mt2.Col_A 
            ) AS ca;

La GROUP BYclausola è ridondante, dati i dati forniti nella domanda, ma può fornire un piano di esecuzione migliore. Guarda il seguito Q & A CROSS APPLY produce un join esterno .

Valutare la possibilità di votare per la richiesta di miglioramento della clausola OVER: clausola DISTINCT per le funzioni aggregate sul sito di feedback se si desidera aggiungere quella funzionalità a SQL Server.

È possibile emularlo utilizzando dense_rank, quindi selezionare il grado massimo per ciascuna partizione:

select col_a, col_b, max(rnk) over (partition by col_a)
from (
    select col_a, col_b
        , dense_rank() over (partition by col_A order by col_b) as rnk 
    from #mytable
) as t    

Dovresti escludere qualsiasi null da col_bper ottenere gli stessi risultati di COUNT(DISTINCT).

Questa è, in un certo senso, un'estensione della soluzione di Lennart , ma è così brutta che non oso suggerirla come una modifica. L'obiettivo qui è ottenere i risultati senza una tabella derivata. Potrebbe non esserci mai la necessità, e combinato con la bruttezza della domanda l'intero sforzo può sembrare uno sforzo sprecato. Volevo comunque fare questo come esercizio, e ora vorrei condividere il mio risultato:

SELECT
  Col_A,
  Col_B,
  DistinctCount = DENSE_RANK() OVER (PARTITION BY Col_A ORDER BY Col_B ASC )
                + DENSE_RANK() OVER (PARTITION BY Col_A ORDER BY Col_B DESC)
                - 1
                - CASE COUNT(Col_B) OVER (PARTITION BY Col_A)
                  WHEN COUNT(  *  ) OVER (PARTITION BY Col_A)
                  THEN 0
                  ELSE 1
                  END
FROM
  dbo.MyTable
;

La parte fondamentale del calcolo è questa (e vorrei prima di tutto notare che l'idea non è mia, ho imparato questo trucco altrove):

  DENSE_RANK() OVER (PARTITION BY Col_A ORDER BY Col_B ASC )
+ DENSE_RANK() OVER (PARTITION BY Col_A ORDER BY Col_B DESC)
- 1

Questa espressione può essere utilizzata senza alcuna modifica se i valori in Col_Bsono garantiti per non avere mai valori null. Se la colonna può contenere valori null, tuttavia, è necessario tenerne conto, ed è esattamente a questo che serve l' CASEespressione. Confronta il numero di righe per partizione con il numero di Col_Bvalori per partizione. Se i numeri differiscono, significa che alcune righe hanno un valore null inCol_B e, pertanto, il calcolo iniziale ( DENSE_RANK() ... + DENSE_RANK() - 1) deve essere ridotto di 1.

Si noti che poiché - 1fa parte della formula principale, ho scelto di lasciarlo così. Tuttavia, può effettivamente essere incorporato CASEnell'espressione, nel inutile tentativo di rendere meno brutta l'intera soluzione:

SELECT
  Col_A,
  Col_B,
  DistinctCount = DENSE_RANK() OVER (PARTITION BY Col_A ORDER BY Col_B ASC )
                + DENSE_RANK() OVER (PARTITION BY Col_A ORDER BY Col_B DESC)
                - CASE COUNT(Col_B) OVER (PARTITION BY Col_A)
                  WHEN COUNT(  *  ) OVER (PARTITION BY Col_A)
                  THEN 1
                  ELSE 2
                  END
FROM
  dbo.MyTable
;

Questa demo dal vivo su db <> fiddle.uk può essere utilizzata per testare entrambe le varianti della soluzione.

create table #MyTable (
Col_A varchar(5),
Col_B int
)

insert into #MyTable values ('A',1)
insert into #MyTable values ('A',1)
insert into #MyTable values ('A',2)
insert into #MyTable values ('A',2)
insert into #MyTable values ('A',2)
insert into #MyTable values ('A',3)

insert into #MyTable values ('B',4)
insert into #MyTable values ('B',4)
insert into #MyTable values ('B',5)


;with t1 as (

select t.Col_A,
       count(*) cnt
 from (
    select Col_A,
           Col_B,
           count(*) as ct
      from #MyTable
     group by Col_A,
              Col_B
  ) t
  group by t.Col_A
 )

select a.*,
       t1.cnt
  from #myTable a
  join t1
    on a.Col_A = t1.Col_a

Alternativa se sei leggermente allergico alle sottoquery correlate (la risposta di Erik Darling) e alle CTE (la risposta di kevinnwhat) come me.

Tieni presente che quando vengono inseriti valori null nel mix, nessuno di questi potrebbe funzionare come vorresti. (ma è abbastanza semplice modificarli a piacere)

Caso semplice:

--ignore the existence of nulls
SELECT [mt].*, [Distinct_B].[Distinct_B]
FROM #MyTable AS [mt]

INNER JOIN(
    SELECT [Col_A], COUNT(DISTINCT [Col_B]) AS [Distinct_B]
    FROM #MyTable
    GROUP BY [Col_A]
) AS [Distinct_B] ON
    [mt].[Col_A] = [Distinct_B].[Col_A]
;

Come sopra, ma con commenti su cosa modificare per la gestione nulla:

--customizable null handling
SELECT [mt].*, [Distinct_B].[Distinct_B]
FROM #MyTable AS [mt]

INNER JOIN(
    SELECT 

    [Col_A],

    (
        COUNT(DISTINCT [Col_B])
        /*
        --uncomment if you also want to count Col_B NULL
        --as a distinct value
        +
        MAX(
            CASE
                WHEN [Col_B] IS NULL
                THEN 1
                ELSE 0
            END
        )
        */
    )
    AS [Distinct_B]

    FROM #MyTable
    GROUP BY [Col_A]
) AS [Distinct_B] ON
    [mt].[Col_A] = [Distinct_B].[Col_A]
/*
--uncomment if you also want to include Col_A when it's NULL
OR
([mt].[Col_A] IS NULL AND [Distinct_B].[Col_A] IS NULL)
*/