Modo ottimale per concatenare / aggregare stringhe

Sto trovando un modo per aggregare stringhe di righe diverse in una singola riga. Sto cercando di farlo in molti posti diversi, quindi sarebbe bello avere una funzione per facilitare questo. Ho provato soluzioni usando COALESCEe FOR XML, ma semplicemente non mi hanno tagliato.

L'aggregazione di stringhe farebbe qualcosa del genere:

id | Name                    Result: id | Names
-- - ----                            -- - -----
1  | Matt                            1  | Matt, Rocks
1  | Rocks                           2  | Stylus
2  | Stylus

Ho dato un'occhiata alle funzioni aggregate definite da CLR in sostituzione di COALESCEe FOR XML, ma apparentemente SQL Azure non supporta le cose definite da CLR, il che è un problema per me perché so che essere in grado di usarlo risolverebbe un sacco di problemi per me.

Esiste una possibile soluzione alternativa o un metodo altrettanto ottimale (che potrebbe non essere ottimale come CLR, ma ehi , prenderò quello che posso ottenere) che posso usare per aggregare le mie cose?

SOLUZIONE

La definizione di ottimale può variare, ma ecco come concatenare stringhe da righe diverse usando Transact SQL normale, che dovrebbe funzionare correttamente in Azure.

;WITH Partitioned AS
(
    SELECT 
        ID,
        Name,
        ROW_NUMBER() OVER (PARTITION BY ID ORDER BY Name) AS NameNumber,
        COUNT(*) OVER (PARTITION BY ID) AS NameCount
    FROM dbo.SourceTable
),
Concatenated AS
(
    SELECT 
        ID, 
        CAST(Name AS nvarchar) AS FullName, 
        Name, 
        NameNumber, 
        NameCount 
    FROM Partitioned 
    WHERE NameNumber = 1

    UNION ALL

    SELECT 
        P.ID, 
        CAST(C.FullName + ', ' + P.Name AS nvarchar), 
        P.Name, 
        P.NameNumber, 
        P.NameCount
    FROM Partitioned AS P
        INNER JOIN Concatenated AS C 
                ON P.ID = C.ID 
                AND P.NameNumber = C.NameNumber + 1
)
SELECT 
    ID,
    FullName
FROM Concatenated
WHERE NameNumber = NameCount

SPIEGAZIONE

L'approccio si riduce a tre passaggi:

1. Numerare le righe utilizzando OVERe PARTITIONraggruppandole e ordinandole secondo necessità per la concatenazione. Il risultato è PartitionedCTE. Manteniamo il conteggio delle righe in ogni partizione per filtrare i risultati in seguito.

2. Utilizzando CTE ricorsivo ( Concatenated) iterare attraverso i numeri di riga ( NameNumbercolonna) aggiungendo Namevalori alla FullNamecolonna.

3. Filtra tutti i risultati tranne quelli con il più alto NameNumber.

Tieni presente che per rendere prevedibile questa query è necessario definire sia il raggruppamento (ad esempio, nel tuo scenario le righe con le stesse IDsono concatenate) che l'ordinamento (presumo che tu semplicemente ordini la stringa alfabeticamente prima della concatenazione).

Ho testato rapidamente la soluzione su SQL Server 2012 con i seguenti dati:

INSERT dbo.SourceTable (ID, Name)
VALUES 
(1, 'Matt'),
(1, 'Rocks'),
(2, 'Stylus'),
(3, 'Foo'),
(3, 'Bar'),
(3, 'Baz')

Il risultato della query:

ID          FullName
----------- ------------------------------
2           Stylus
3           Bar, Baz, Foo
1           Matt, Rocks

I metodi che utilizzano FOR XML PATH come di seguito sono davvero così lenti? Itzik Ben-Gan scrive che questo metodo ha buone prestazioni nel suo libro T-SQL Querying (Mr. Ben-Gan è una fonte affidabile, a mio avviso).

create table #t (id int, name varchar(20))

insert into #t
values (1, 'Matt'), (1, 'Rocks'), (2, 'Stylus')

select  id
        ,Names = stuff((select ', ' + name as [text()]
        from #t xt
        where xt.id = t.id
        for xml path('')), 1, 2, '')
from #t t
group by id

Per quelli di noi che l'hanno trovato e non usano il database SQL di Azure:

STRING_AGG()in PostgreSQL, SQL Server 2017 e Azure SQL
https://www.postgresql.org/docs/current/static/functions-aggregate.html
https://docs.microsoft.com/en-us/sql/t-sql/ funzioni / string-agg-transact-sql

GROUP_CONCAT()in MySQL
http://dev.mysql.com/doc/refman/5.7/en/group-by-functions.html#function_group-concat

(Grazie a @Brianjorden e @milanio per l'aggiornamento di Azure)

Codice di esempio:

select Id
, STRING_AGG(Name, ', ') Names 
from Demo
group by Id

SQL Fiddle: http://sqlfiddle.com/#!18/89251/1

Sebbene la risposta di @serge sia corretta, ho confrontato il consumo di tempo con xmlpath e ho scoperto che xmlpath è molto più veloce. Scriverò il codice di confronto e potrai controllarlo da solo. Questo è il modo @serge:

DECLARE @startTime datetime2;
DECLARE @endTime datetime2;
DECLARE @counter INT;
SET @counter = 1;

set nocount on;

declare @YourTable table (ID int, Name nvarchar(50))

WHILE @counter < 1000
BEGIN
    insert into @YourTable VALUES (ROUND(@counter/10,0), CONVERT(NVARCHAR(50), @counter) + 'CC')
    SET @counter = @counter + 1;
END

SET @startTime = GETDATE()

;WITH Partitioned AS
(
    SELECT 
        ID,
        Name,
        ROW_NUMBER() OVER (PARTITION BY ID ORDER BY Name) AS NameNumber,
        COUNT(*) OVER (PARTITION BY ID) AS NameCount
    FROM @YourTable
),
Concatenated AS
(
    SELECT ID, CAST(Name AS nvarchar) AS FullName, Name, NameNumber, NameCount FROM Partitioned WHERE NameNumber = 1

    UNION ALL

    SELECT 
        P.ID, CAST(C.FullName + ', ' + P.Name AS nvarchar), P.Name, P.NameNumber, P.NameCount
    FROM Partitioned AS P
        INNER JOIN Concatenated AS C ON P.ID = C.ID AND P.NameNumber = C.NameNumber + 1
)
SELECT 
    ID,
    FullName
FROM Concatenated
WHERE NameNumber = NameCount

SET @endTime = GETDATE();

SELECT DATEDIFF(millisecond,@startTime, @endTime)
--Take about 54 milliseconds

E questo è il modo xmlpath:

DECLARE @startTime datetime2;
DECLARE @endTime datetime2;
DECLARE @counter INT;
SET @counter = 1;

set nocount on;

declare @YourTable table (RowID int, HeaderValue int, ChildValue varchar(5))

WHILE @counter < 1000
BEGIN
    insert into @YourTable VALUES (@counter, ROUND(@counter/10,0), CONVERT(NVARCHAR(50), @counter) + 'CC')
    SET @counter = @counter + 1;
END

SET @startTime = GETDATE();

set nocount off
SELECT
    t1.HeaderValue
        ,STUFF(
                   (SELECT
                        ', ' + t2.ChildValue
                        FROM @YourTable t2
                        WHERE t1.HeaderValue=t2.HeaderValue
                        ORDER BY t2.ChildValue
                        FOR XML PATH(''), TYPE
                   ).value('.','varchar(max)')
                   ,1,2, ''
              ) AS ChildValues
    FROM @YourTable t1
    GROUP BY t1.HeaderValue

SET @endTime = GETDATE();

SELECT DATEDIFF(millisecond,@startTime, @endTime)
--Take about 4 milliseconds

Aggiornamento: Ms SQL Server 2017+, database SQL di Azure

È possibile utilizzare: STRING_AGG.

L'utilizzo è piuttosto semplice per la richiesta di OP:

SELECT id, STRING_AGG(name, ', ') AS names
FROM some_table
GROUP BY id

Leggi di più

Bene, la mia vecchia non risposta è stata giustamente cancellata (lasciata intatta sotto), ma se qualcuno dovesse atterrare qui in futuro, ci sono buone notizie. Hanno implementato STRING_AGG () anche nel database SQL di Azure. Ciò dovrebbe fornire la funzionalità esatta originariamente richiesta in questo post con supporto nativo e integrato. @hrobky lo ha menzionato in precedenza come funzionalità di SQL Server 2016 all'epoca.

--- Vecchio messaggio: reputazione insufficiente qui per rispondere direttamente a @hrobky, ma STRING_AGG ha un bell'aspetto, tuttavia al momento è disponibile solo in SQL Server 2016 vNext. Si spera che presto seguirà anche Azure SQL Datababse.

Puoi usare + = per concatenare le stringhe, ad esempio:

declare @test nvarchar(max)
set @test = ''
select @test += name from names

se selezioni @test, ti verranno forniti tutti i nomi concatenati

Ho trovato la risposta di Serge molto promettente, ma ho anche riscontrato problemi di prestazioni con essa come scritta. Tuttavia, quando l'ho ristrutturato per utilizzare tabelle temporanee e non includere tabelle CTE doppie, le prestazioni sono passate da 1 minuto e 40 secondi a un secondo per 1000 record combinati. Qui è per chiunque abbia bisogno di farlo senza FOR XML su versioni precedenti di SQL Server:

DECLARE @STRUCTURED_VALUES TABLE (
     ID                 INT
    ,VALUE              VARCHAR(MAX) NULL
    ,VALUENUMBER        BIGINT
    ,VALUECOUNT         INT
);

INSERT INTO @STRUCTURED_VALUES
SELECT   ID
        ,VALUE
        ,ROW_NUMBER() OVER (PARTITION BY ID ORDER BY VALUE) AS VALUENUMBER
        ,COUNT(*) OVER (PARTITION BY ID)    AS VALUECOUNT
FROM    RAW_VALUES_TABLE;

WITH CTE AS (
    SELECT   SV.ID
            ,SV.VALUE
            ,SV.VALUENUMBER
            ,SV.VALUECOUNT
    FROM    @STRUCTURED_VALUES SV
    WHERE   VALUENUMBER = 1

    UNION ALL

    SELECT   SV.ID
            ,CTE.VALUE + ' ' + SV.VALUE AS VALUE
            ,SV.VALUENUMBER
            ,SV.VALUECOUNT
    FROM    @STRUCTURED_VALUES SV
    JOIN    CTE 
        ON  SV.ID = CTE.ID
        AND SV.VALUENUMBER = CTE.VALUENUMBER + 1

)
SELECT   ID
        ,VALUE
FROM    CTE
WHERE   VALUENUMBER = VALUECOUNT
ORDER BY ID
;