Funzione di partizione COUNT () OVER possibile utilizzando DISTINCT

Sto cercando di scrivere quanto segue per ottenere un totale parziale di NumUsers distinti, in questo modo:

NumUsers = COUNT(DISTINCT [UserAccountKey]) OVER (PARTITION BY [Mth])

Lo studio di gestione non sembra molto contento di questo. L'errore scompare quando rimuovo la DISTINCTparola chiave, ma non sarà un conteggio distinto.

DISTINCTnon sembra essere possibile all'interno delle funzioni di partizione. Come posso trovare il conteggio distinto? Uso un metodo più tradizionale come una sottoquery correlata?

Esaminando questo un po 'più in là, forse questi OVER funzioni funzionano in modo diverso da Oracle in quanto non possono essere utilizzate SQL-Serverper calcolare i totali correnti.

Ho aggiunto un esempio dal vivo qui su SQLfiddle in cui cerco di utilizzare una funzione di partizione per calcolare un totale parziale .

C'è una soluzione molto semplice usando dense_rank()

dense_rank() over (partition by [Mth] order by [UserAccountKey]) 
+ dense_rank() over (partition by [Mth] order by [UserAccountKey] desc) 
- 1

Questo ti darà esattamente quello che stavi chiedendo: il numero di distinte UserAccountKeys in ogni mese.

Negromante:

È relativamente semplice emulare un COUNT DISTINCT su PARTITION BY con MAX tramite DENSE_RANK:

;WITH baseTable AS
(
    SELECT 'RM1' AS RM, 'ADR1' AS ADR
    UNION ALL SELECT 'RM1' AS RM, 'ADR1' AS ADR
    UNION ALL SELECT 'RM2' AS RM, 'ADR1' AS ADR
    UNION ALL SELECT 'RM2' AS RM, 'ADR2' AS ADR
    UNION ALL SELECT 'RM2' AS RM, 'ADR2' AS ADR
    UNION ALL SELECT 'RM2' AS RM, 'ADR3' AS ADR
    UNION ALL SELECT 'RM3' AS RM, 'ADR1' AS ADR
    UNION ALL SELECT 'RM2' AS RM, 'ADR1' AS ADR
    UNION ALL SELECT 'RM3' AS RM, 'ADR1' AS ADR
    UNION ALL SELECT 'RM3' AS RM, 'ADR2' AS ADR
)
,CTE AS
(
    SELECT RM, ADR, DENSE_RANK() OVER(PARTITION BY RM ORDER BY ADR) AS dr 
    FROM baseTable
)
SELECT
     RM
    ,ADR

    ,COUNT(CTE.ADR) OVER (PARTITION BY CTE.RM ORDER BY ADR) AS cnt1 
    ,COUNT(CTE.ADR) OVER (PARTITION BY CTE.RM) AS cnt2 
    -- Not supported
    --,COUNT(DISTINCT CTE.ADR) OVER (PARTITION BY CTE.RM ORDER BY CTE.ADR) AS cntDist
    ,MAX(CTE.dr) OVER (PARTITION BY CTE.RM ORDER BY CTE.RM) AS cntDistEmu 
FROM CTE

Nota:
questo presuppone che i campi in questione siano campi NON annullabili.
Se sono presenti una o più voci NULL nei campi, è necessario sottrarre 1.

Uso una soluzione simile a quella di David sopra, ma con una svolta aggiuntiva se alcune righe devono essere escluse dal conteggio. Ciò presuppone che [UserAccountKey] non sia mai nullo.

-- subtract an extra 1 if null was ranked within the partition,
-- which only happens if there were rows where [Include] <> 'Y'
dense_rank() over (
  partition by [Mth] 
  order by case when [Include] = 'Y' then [UserAccountKey] else null end asc
) 
+ dense_rank() over (
  partition by [Mth] 
  order by case when [Include] = 'Y' then [UserAccountKey] else null end desc
)
- max(case when [Include] = 'Y' then 0 else 1 end) over (partition by [Mth])
- 1

Un SQL Fiddle con un esempio esteso può essere trovato qui.

Penso che l'unico modo per farlo in SQL-Server 2008R2 sia utilizzare una sottoquery correlata o un'applicazione esterna:

SELECT  datekey,
        COALESCE(RunningTotal, 0) AS RunningTotal,
        COALESCE(RunningCount, 0) AS RunningCount,
        COALESCE(RunningDistinctCount, 0) AS RunningDistinctCount
FROM    document
        OUTER APPLY
        (   SELECT  SUM(Amount) AS RunningTotal,
                    COUNT(1) AS RunningCount,
                    COUNT(DISTINCT d2.dateKey) AS RunningDistinctCount
            FROM    Document d2
            WHERE   d2.DateKey <= document.DateKey
        ) rt;

Questo può essere fatto in SQL-Server 2012 utilizzando la sintassi che hai suggerito:

SELECT  datekey,
        SUM(Amount) OVER(ORDER BY DateKey) AS RunningTotal
FROM    document

Tuttavia, l'uso di non DISTINCTè ancora consentito, quindi se DISTINCT è richiesto e / o se l'aggiornamento non è un'opzione, penso che OUTER APPLYsia la tua migliore opzione