Méthode optimale pour concaténer / agréger des chaînes

Je trouve un moyen d'agréger des chaînes de différentes lignes en une seule ligne. Je cherche à faire cela dans de nombreux endroits différents, donc avoir une fonction pour faciliter ce serait bien. J'ai essayé des solutions utilisant COALESCEet FOR XML, mais elles ne me conviennent pas.

L'agrégation de chaînes ferait quelque chose comme ceci:

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

J'ai examiné les fonctions d'agrégation définies par CLR en remplacement de COALESCEet FOR XML, mais apparemment, SQL Azure ne prend pas en charge les éléments définis par CLR, ce qui est pénible pour moi car je sais que pouvoir l'utiliser résoudrait beaucoup de problèmes. problèmes pour moi.

Existe-t-il une solution de contournement possible, ou une méthode similaire optimale (qui n'est peut-être pas aussi optimale que CLR, mais bon je vais prendre ce que je peux obtenir) que je peux utiliser pour agréger mes données?

SOLUTION

La définition de l' optimal peut varier, mais voici comment concaténer des chaînes de différentes lignes à l'aide de Transact SQL standard, ce qui devrait fonctionner correctement dans 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

EXPLICATION

L'approche se résume à trois étapes:

1. Numéroter les lignes à l' aide OVERet de PARTITIONregroupement et leur ordonnant au besoin pour la concaténation. Le résultat est PartitionedCTE. Nous conservons le nombre de lignes dans chaque partition pour filtrer les résultats ultérieurement.

2. L'utilisation récursive de CTE ( Concatenated) permet de parcourir les numéros de ligne ( NameNumbercolonne) en ajoutant des Namevaleurs à la FullNamecolonne.

3. Filtrez tous les résultats, sauf ceux avec les plus élevés NameNumber.

Veuillez garder à l'esprit que pour rendre cette requête prévisible, il faut définir à la fois le regroupement (par exemple, dans votre scénario, les lignes avec les mêmes IDsont concaténées) et le tri (j'ai supposé que vous triiez simplement la chaîne par ordre alphabétique avant la concaténation).

J'ai rapidement testé la solution sur SQL Server 2012 avec les données suivantes:

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

Le résultat de la requête:

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

Les méthodes utilisant FOR XML PATH comme ci-dessous sont-elles vraiment aussi lentes? Itzik Ben-Gan écrit que cette méthode a de bonnes performances dans son livre T-SQL Querying (M. Ben-Gan est une source digne de confiance, à mon avis).

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

Pour ceux d'entre nous qui ont trouvé ça et n'utilisez pas Azure SQL Database:

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

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

(Merci à @Brianjorden et @milanio pour la mise à jour Azure)

Exemple de code:

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

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

Bien que la réponse @serge soit correcte, j'ai comparé la consommation de temps de son chemin à xmlpath et j'ai trouvé que xmlpath était tellement plus rapide. J'écrirai le code de comparaison et vous pourrez le vérifier vous-même. C'est la manière @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

Et c'est la manière 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

Mise à jour: Ms SQL Server 2017+, Azure SQL Database

Vous pouvez utiliser: STRING_AGG .

L'utilisation est assez simple pour la demande d'OP:

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

Lire la suite

Eh bien, mon ancienne non-réponse a été supprimée à juste titre (laissée intacte ci-dessous), mais si quelqu'un arrive à atterrir ici à l'avenir, il y a de bonnes nouvelles. Ils ont également implémenté STRING_AGG () dans Azure SQL Database. Cela devrait fournir la fonctionnalité exacte initialement demandée dans cet article avec un support natif et intégré. @hrobky l'a mentionné précédemment en tant que fonctionnalité SQL Server 2016 à l'époque.

--- Old Post: Pas assez de réputation ici pour répondre directement à @hrobky, mais STRING_AGG a l'air génial, mais il n'est actuellement disponible que dans SQL Server 2016 vNext. Espérons que cela suivra bientôt Azure SQL Databse.

Vous pouvez utiliser + = pour concaténer des chaînes, par exemple:

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

si vous sélectionnez @test, il vous donnera tous les noms concaténés

J'ai trouvé la réponse de Serge très prometteuse, mais j'ai également rencontré des problèmes de performance avec celle-ci telle qu'elle était écrite. Cependant, lorsque je l'ai restructuré pour utiliser des tables temporaires et ne pas inclure de tables doubles CTE, les performances sont passées de 1 minute 40 secondes à sous-seconde pour 1000 enregistrements combinés. Voici pour tous ceux qui ont besoin de le faire sans FOR XML sur les anciennes versions de 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
;