Optimale Möglichkeit, Zeichenfolgen zu verketten / zu aggregieren

Ich finde eine Möglichkeit, Zeichenfolgen aus verschiedenen Zeilen in einer einzigen Zeile zusammenzufassen. Ich möchte dies an vielen verschiedenen Orten tun, daher wäre es schön, eine Funktion zu haben, die dies erleichtert. Ich habe Lösungen mit COALESCEund ausprobiert FOR XML, aber sie schneiden es einfach nicht für mich.

Die String-Aggregation würde ungefähr so ​​aussehen:

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

Ich habe mir CLR-definierte Aggregatfunktionen als Ersatz für COALESCEund angesehen FOR XML, aber anscheinend unterstützt SQL Azure keine CLR-definierten Funktionen, was für mich ein Schmerz ist, da ich weiß, dass die Verwendung eine ganze Menge davon lösen würde Probleme für mich.

Gibt es eine mögliche Abhilfe, oder in ähnlicher Weise eine optimale Verfahren (die als optimal nicht als CLR sein könnte, aber hey ich nehme , was ich kriegen kann) , dass ich verwenden kann , meine Sachen zu aggregieren?

LÖSUNG

Die Definition von optimal kann variieren. Hier erfahren Sie jedoch, wie Sie Zeichenfolgen aus verschiedenen Zeilen mithilfe von regulärem Transact SQL verketten, was in Azure problemlos funktionieren sollte.

;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

ERLÄUTERUNG

Der Ansatz besteht aus drei Schritten:

1. Nummerieren Sie die Zeilen mit OVERund PARTITIONgruppieren und ordnen Sie sie nach Bedarf für die Verkettung. Das Ergebnis ist PartitionedCTE. Wir behalten die Anzahl der Zeilen in jeder Partition bei, um die Ergebnisse später zu filtern.

2. Verwenden Sie rekursives CTE ( Concatenated), um die Zeilennummern ( NameNumberSpalte) zu durchlaufen und der Spalte NameWerte hinzuzufügen FullName.

3. Filtern Sie alle Ergebnisse außer denen mit den höchsten heraus NameNumber.

Bitte beachten Sie, dass Sie, um diese Abfrage vorhersehbar zu machen, sowohl die Gruppierung (z. B. in Ihrem Szenario werden Zeilen mit derselben IDverkettet) als auch die Sortierung definieren müssen (ich habe angenommen, dass Sie die Zeichenfolge vor der Verkettung einfach alphabetisch sortieren).

Ich habe die Lösung unter SQL Server 2012 schnell mit den folgenden Daten getestet:

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

Das Abfrageergebnis:

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

Sind Methoden, die FOR XML PATH wie unten verwenden, wirklich so langsam? Itzik Ben-Gan schreibt, dass diese Methode in seinem T-SQL-Abfragebuch eine gute Leistung aufweist (Herr Ben-Gan ist meiner Ansicht nach eine vertrauenswürdige Quelle).

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

Für diejenigen von uns, die dies gefunden haben und verwenden keine Azure SQL-Datenbank::

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

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

(Danke an @Brianjorden und @milanio für das Azure-Update)

Beispielcode:

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

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

Obwohl die Antwort von @serge korrekt ist, habe ich den Zeitverbrauch seines Weges mit xmlpath verglichen und festgestellt, dass der xmlpath so schneller ist. Ich werde den Vergleichscode schreiben und Sie können ihn selbst überprüfen. Dies ist @serge Weg:

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

Und das ist xmlpath Weg:

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

Update: Frau SQL Server 2017+, Azure SQL-Datenbank

Sie können verwenden : STRING_AGG.

Die Verwendung ist für die Anfrage von OP ziemlich einfach:

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

Weiterlesen

Nun, meine alte Nichtantwort wurde zu Recht gelöscht (unten in Kontakt gelassen), aber wenn jemand in Zukunft hier landet, gibt es gute Nachrichten. Sie haben STRING_AGG () auch in die Azure SQL-Datenbank implementiert. Dies sollte die genaue Funktionalität bieten, die ursprünglich in diesem Beitrag angefordert wurde, und native und integrierte Unterstützung bieten. @hrobky erwähnte dies zu diesem Zeitpunkt bereits als SQL Server 2016-Funktion.

--- Alter Beitrag: Nicht genug Ruf hier, um direkt auf @hrobky zu antworten, aber STRING_AGG sieht gut aus, ist jedoch derzeit nur in SQL Server 2016 vNext verfügbar. Hoffentlich folgt bald auch Azure SQL Datababse.

Sie können + = verwenden, um Zeichenfolgen zu verketten, zum Beispiel:

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

Wenn Sie @test auswählen, werden alle Namen verkettet

Ich fand die Antwort von Serge sehr vielversprechend, stieß aber auch auf Leistungsprobleme, wie geschrieben. Als ich es jedoch umstrukturierte, um temporäre Tabellen zu verwenden und keine doppelten CTE-Tabellen einzuschließen, stieg die Leistung für 1000 kombinierte Datensätze von 1 Minute 40 Sekunden auf unter Sekunden. Hier ist es für alle, die dies ohne FOR XML in älteren Versionen von SQL Server tun müssen:

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
;