SQL Server - Como concatenar linhas agrupando os dados por uma coluna (Grouped concatenation)

Como concatenar colunas em strings agrupadas utilizando COALESCE

DECLARE @Nomes VARCHAR(MAX)

SELECT 
    @Nomes = COALESCE(@Nomes + ', ', '') + Descricao
FROM 
    dbo.Teste_XML

SELECT @Nomes

Como podemos observar acima, utilizando a função COALESCE, precisamos armazenar os resultados sempre em uma variável, e por este motivo, não conseguimos obter os resultados de forma agrupada por categoria, conforme precisamos. Se você quer apenas converter colunas em uma string, sem agrupar, essa solução irá te atender, mas não ao que precisamos para esse post.

Como concatenar colunas em strings agrupadas utilizando STUFF + FOR XML PATH

Uma forma prática e performática de se resolver esse problema, é utilizar o FOR XML PATH e o STUFF para realizarmos a concatenação agrupada, de forma que o resultado é exatamente aquilo que esperávamos:

SELECT  
    Categoria,
    STUFF((
        SELECT ', ' + B.Descricao 
        FROM dbo.Teste_Group_Concat B 
        WHERE ISNULL(B.Categoria, '') = ISNULL(A.Categoria, '')
        ORDER BY B.Descricao 
        FOR XML PATH('')), 1, 2, ''
    ) AS Descricao
FROM
    dbo.Teste_Group_Concat A
GROUP BY 
    Categoria
ORDER BY 
    Categoria

Como concatenar colunas em strings agrupadas utilizando UPDATE

DECLARE 
    @Categoria VARCHAR(MAX),
    @Descricoes VARCHAR(MAX)
 
DECLARE @Tabela TABLE (
    Categoria VARCHAR(200),
    Descricao VARCHAR(200),
    Descricoes VARCHAR(200)
)
 
INSERT @Tabela ( 
    Categoria,
    Descricao
)
SELECT  
    Categoria,
    Descricao
FROM
    dbo.Teste_Group_Concat
ORDER BY 
    Categoria,
    Descricao
 

UPDATE 
    @Tabela
SET
    @Descricoes = Descricoes = COALESCE(CASE COALESCE(@Categoria, '')
                                WHEN Categoria THEN @Descricoes + ', ' + Descricao
                                ELSE Descricao
                            END, ''),
    @Categoria = ISNULL(Categoria, '')


SELECT  
    Categoria,
    Descricoes = MAX(Descricoes)
FROM
    @Tabela
GROUP BY 
    Categoria
ORDER BY 
    Categoria

Mais uma solução que nos permitiu gerar os dados conforme nossa necessidade demanda.

Como concatenar colunas em strings agrupadas utilizando LOOPING com CURSOR

DECLARE @Tabela TABLE (
    Categoria VARCHAR(MAX),
    Descricoes VARCHAR(MAX)
)
 
INSERT @Tabela ( 
    Categoria,
    Descricoes
)
SELECT  
    Categoria,
    ''
FROM
    dbo.Teste_Group_Concat
GROUP BY 
    Categoria
 

DECLARE 
    @Categoria VARCHAR(MAX),
    @Descricao VARCHAR(MAX),
    @Descricoes VARCHAR(MAX)
 
DECLARE c CURSOR LOCAL FAST_FORWARD
FOR

    SELECT  
        Categoria,
        Descricao
    FROM
        dbo.Teste_Group_Concat
    ORDER BY 
        Categoria,
        Descricao
 

OPEN c
 
FETCH c INTO @Categoria, @Descricao
 
WHILE @@FETCH_STATUS = 0
BEGIN

    UPDATE  @Tabela
    SET     Descricoes += ', ' + @Descricao
    WHERE   ISNULL(Categoria, '') = ISNULL(@Categoria, '')
 
    FETCH c INTO @Categoria, @Descricao
END
 
CLOSE c
DEALLOCATE c

SELECT  
    Categoria,
    Descricoes = STUFF(Descricoes, 1, 1, '')
FROM
    @Tabela
ORDER BY 
    Categoria

Essa solução também atendeu ao que precisamos, mas assim como todo looping, não é performático. Eu particularmente abomino a criação de cursores (a menos que você AINDA esteja no SQL Server 2000), em último caso, eu prefiro utilizar WHILE, mas temos soluções melhores aqui nesse post.

Como concatenar colunas em strings agrupadas utilizando LOOPING com WHILE

DECLARE @Tabela_Original TABLE (
    Id INT IDENTITY(1, 1),
    Categoria VARCHAR(MAX),
    Descricao VARCHAR(MAX)
)
INSERT @Tabela_Original ( 
    Categoria,
    Descricao
)
SELECT  
    Categoria,
    Descricao
FROM
    dbo.Teste_Group_Concat
ORDER BY
    Categoria


DECLARE @Tabela TABLE (
    Id INT IDENTITY(1, 1),
    Categoria VARCHAR(MAX),
    Descricoes VARCHAR(MAX)
)

INSERT @Tabela ( 
    Categoria,
    Descricoes
)
SELECT  
    Categoria,
    ''
FROM
    dbo.Teste_Group_Concat
GROUP BY 
    Categoria
 
DECLARE 
    @Categoria VARCHAR(MAX),
    @Descricao VARCHAR(MAX),
    @Descricoes VARCHAR(MAX),
    @Contador INT = 1,
    @Numero_Linhas INT = (SELECT COUNT(*) FROM @Tabela_Original)
 
 WHILE(@Contador <= @Numero_Linhas)
 BEGIN

    SELECT  
        @Categoria = ISNULL(Categoria, ''),
        @Descricao = Descricao
    FROM
        @Tabela_Original
    WHERE
        Id = @Contador
    ORDER BY 
        Categoria,
        Descricao
    

    UPDATE  @Tabela
    SET     Descricoes += ', ' + @Descricao
    WHERE   ISNULL(Categoria, '') = ISNULL(@Categoria, '')


    SET @Contador = @Contador + 1

END


SELECT  
    Categoria,
    Descricoes = STUFF(Descricoes, 1, 1, '')
FROM
    @Tabela
ORDER BY 
    Categoria

Solução atendida, mas como todo looping, não é performática.

Como concatenar colunas em strings agrupadas utilizando CTE Recursivo

;WITH Dados as 
(
    SELECT 
        Categoria, 
        CONVERT(NVARCHAR(MAX), Descricao) AS Descricao,
        ROW_NUMBER() OVER (PARTITION BY Categoria ORDER BY Descricao) AS Linha
    FROM 
        dbo.Teste_Group_Concat
),
Tabela1 AS 
(
    SELECT Categoria, Descricao, Linha FROM Dados WHERE Linha = 1
),
Resultado AS
(
    SELECT Categoria, Descricao, Linha FROM Tabela1 WHERE Linha = 1
    
    UNION ALL

    SELECT Dados.Categoria, Resultado.Descricao + N', ' + Dados.Descricao, Dados.Linha
    FROM Dados 
    JOIN Resultado ON Resultado.Categoria = Dados.Categoria AND Dados.Linha = Resultado.Linha + 1
)
SELECT 
    Categoria, 
    Descricoes = MAX(Descricao)
FROM 
    Resultado
GROUP BY 
    Categoria 
ORDER BY 
    Categoria
OPTION (MAXRECURSION 0);

Essa solução utiliza da técnica de recursividade para resolver nosso problema sem precisar de looping. Embora não seja muito fácil de entender a princípio, é uma solução prática e muito interessante.

Como concatenar colunas em strings agrupadas utilizando Função Scalar (UDF)

CREATE FUNCTION dbo.fncConcatCategoria ( 
    @Ds_Categoria VARCHAR(MAX) 
)
RETURNS VARCHAR(MAX)
WITH SCHEMABINDING
AS
BEGIN

    DECLARE @Retorno VARCHAR(MAX);
 
    SELECT  
        @Retorno = COALESCE(@Retorno + ', ', '') + Descricao
    FROM
        dbo.Teste_Group_Concat
    WHERE
        ISNULL(Categoria, '') = ISNULL(@Ds_Categoria, '')
    ORDER BY 
        Descricao
 
    RETURN @Retorno

END
GO

SELECT 
    Categoria,
    dbo.fncConcatCategoria(Categoria) AS Descricao
FROM 
    dbo.Teste_Group_Concat
GROUP BY
    Categoria

Função bem útil e após criada, se torna muito prática de utilizar. O problema dessa solução é que ela não é muito performática e exige que você crie uma função para cada tabela que você precise realizar essa solução, ou seja, acaba não sendo muito genérica e você precisaria criar várias funções que fazem praticamente a mesma coisa na sua base de dados.

Como concatenar colunas em strings agrupadas utilizando SCL CLR (C#)

using System;
using System.Data.SqlTypes;
using Microsoft.SqlServer.Server;
using System.Text;

[Serializable]
[SqlUserDefinedAggregate(
    Format.UserDefined,
    IsInvariantToNulls = false,
    IsInvariantToDuplicates = false,
    IsInvariantToOrder = true,
    MaxByteSize = -1)]
public struct concat : IBinarySerialize, INullable
{
    private StringBuilder _accumulator;
    private string _delimiter;

    public bool IsNull { get; private set; }

    public void Init()
    {
        _accumulator = new StringBuilder();
        _delimiter = string.Empty;
        this.IsNull = true;
    }

    public void Accumulate([SqlFacet(MaxSize = -1)]SqlString Value, [SqlFacet(MaxSize = -1)]SqlString Delimiter)
    {

        if (Value.IsNull) return;

        if (!Delimiter.IsNull & Delimiter.Value.Length > 0)
        {
            _delimiter = Delimiter.Value;
            if (_accumulator.Length > 0)
                _accumulator.Append(Delimiter.Value);

        }

        _accumulator.Append(Value.Value);
        IsNull = false;
    }
    
    public void Merge(concat Group)
    {
        if (_accumulator.Length > 0
            & Group._accumulator.Length > 0) _accumulator.Append(_delimiter);

        _accumulator.Append(Group._accumulator.ToString());

    }

    public SqlString Terminate()
    {
        return new SqlString(_accumulator.ToString());
    }

    void IBinarySerialize.Read(System.IO.BinaryReader r)
    {
        _delimiter = r.ReadString();
        _accumulator = new StringBuilder(r.ReadString());

        if (_accumulator.Length != 0) this.IsNull = false;
    }

    void IBinarySerialize.Write(System.IO.BinaryWriter w)
    {
        w.Write(_delimiter);
        w.Write(_accumulator.ToString());
    }
}

Minha solução favorita. Prática, extremamente rápida, genérica e resolve nosso problema. Não sabe o que é CLR ou sabe, mas não sabe como implementar na sua base de dados? Saiba mais acessando meu post Introdução ao SQL CLR (Common Language Runtime) no SQL Server.