Combine a coluna de várias linhas em uma única linha

Isso é relativamente trivial para fazer com uma subconsulta correlacionada. Você não pode usar o método COALESCE destacado na postagem do blog que você mencionou, a menos que você extraia isso para uma função definida pelo usuário (ou a menos que você queira retornar apenas uma linha por vez). Aqui está como eu normalmente faço isso:

DECLARE @x TABLE 
(
  id INT, 
  row_num INT, 
  customer_code VARCHAR(32), 
  comments VARCHAR(32)
);

INSERT @x SELECT 1,1,'Dilbert','Hard'
UNION ALL SELECT 1,2,'Dilbert','Worker'
UNION ALL SELECT 2,1,'Wally','Lazy';

SELECT id, customer_code, comments = STUFF((SELECT ' ' + comments 
    FROM @x AS x2 WHERE id = x.id
     ORDER BY row_num
     FOR XML PATH('')), 1, 1, '')
FROM @x AS x
GROUP BY id, customer_code
ORDER BY id;

Se você tiver um caso em que os dados nos comentários possam conter caracteres não seguros para XML ( >, <, &), altere isso:

     FOR XML PATH('')), 1, 1, '')

Para esta abordagem mais elaborada:

     FOR XML PATH(''), TYPE).value(N'(./text())[1]', N'varchar(max)'), 1, 1, '')

(Certifique-se de usar o tipo de dados de destino correto, varcharou nvarchar, e o comprimento correto, e prefixe todos os literais de string Nse estiver usando nvarchar.)

Se você tiver permissão para usar o CLR em seu ambiente, esse é um caso sob medida para um agregado definido pelo usuário.

Em particular, este é provavelmente o caminho a seguir se os dados de origem não forem muito grandes e/ou você precisar fazer muito esse tipo de coisa em seu aplicativo. Suspeito fortemente que o plano de consulta para a solução de Aaron não será dimensionado bem à medida que o tamanho da entrada aumentar. (Tentei adicionar um índice à tabela temporária, mas isso não ajudou.)

Esta solução, como muitas outras coisas, é uma troca:

• Política/política para até mesmo usar a Integração CLR em seu ambiente ou no ambiente de seu cliente.
• A função CLR é provavelmente mais rápida e dimensionará melhor com um conjunto real de dados.
• A função CLR será reutilizável em outras consultas e você não precisará duplicar (e depurar) uma subconsulta complexa toda vez que precisar fazer esse tipo de coisa.
• Straight T-SQL é mais simples do que escrever e gerenciar um pedaço de código externo.
• Talvez você não saiba programar em C# ou VB.
• etc.

EDIT: Bem, eu fui tentar ver se isso realmente era melhor, e acontece que o requisito de que os comentários estejam em uma ordem específica atualmente não é possível satisfazer usando uma função agregada. :(

Consulte SqlUserDefinedAggregateAttribute.IsInvariantToOrder . Basicamente, o que você precisa fazer é, OVER(PARTITION BY customer_code ORDER BY row_num)mas ORDER BYnão é suportado na OVERcláusula ao agregar. Estou assumindo que adicionar essa funcionalidade ao SQL Server abre uma lata de worms, porque o que precisaria ser alterado no plano de execução é trivial. O link mencionado acima diz que isso está reservado para uso futuro, então isso pode ser implementado no futuro (em 2005 você provavelmente está sem sorte).

Isso ainda pode ser feito empacotando e analisando o row_numvalor na string agregada e, em seguida, fazendo a classificação dentro do objeto CLR ... o que parece bastante hackish.

De qualquer forma, abaixo está o código que usei no caso de alguém achar isso útil mesmo com a limitação. Vou deixar a parte de hacking como exercício para o leitor. Observe que usei o AdventureWorks (2005) para dados de teste.

Montagem agregada:

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

namespace MyCompany.SqlServer
{
    [Serializable]
    [SqlUserDefinedAggregate
    (
        Format.UserDefined,
        IsNullIfEmpty = false,
        IsInvariantToDuplicates = false,
        IsInvariantToNulls = true,
        IsInvariantToOrder = false,
        MaxByteSize = -1
    )]
    public class StringConcatAggregate : IBinarySerialize
    {
        private string _accum;
        private bool _isEmpty;

        public void Init()
        {
            _accum = string.Empty;
            _isEmpty = true;
        }

        public void Accumulate(SqlString value)
        {
            if (!value.IsNull)
            {
                if (!_isEmpty)
                    _accum += ' ';
                else
                    _isEmpty = false;

                _accum += value.Value;
            }
        }

        public void Merge(StringConcatAggregate value)
        {
            Accumulate(value.Terminate());
        }

        public SqlString Terminate()
        {
            return new SqlString(_accum);
        }

        public void Read(BinaryReader r)
        {
            this.Init();

            _accum = r.ReadString();
            _isEmpty = _accum.Length == 0;
        }

        public void Write(BinaryWriter w)
        {
            w.Write(_accum);
        }
    }
}

T-SQL para teste ( CREATE ASSEMBLY, e sp_configurepara habilitar o CLR omitido):

CREATE TABLE [dbo].[Comments]
(
    CustomerCode int NOT NULL,
    RowNum int NOT NULL,
    Comments nvarchar(25) NOT NULL
)

INSERT INTO [dbo].[Comments](CustomerCode, RowNum, Comments)
    SELECT
        DENSE_RANK() OVER(ORDER BY FirstName),
        ROW_NUMBER() OVER(PARTITION BY FirstName ORDER BY ContactID),
        Phone
        FROM [AdventureWorks].[Person].[Contact]
GO

CREATE AGGREGATE [dbo].[StringConcatAggregate]
(
    @input nvarchar(MAX)
)
RETURNS nvarchar(MAX)
EXTERNAL NAME StringConcatAggregate.[MyCompany.SqlServer.StringConcatAggregate]
GO


SELECT
    CustomerCode,
    [dbo].[StringConcatAggregate](Comments) AS AllComments
    FROM [dbo].[Comments]
    GROUP BY CustomerCode

Aqui está uma solução baseada em cursor que garante a ordem dos comentários por row_num. (Veja minha outra resposta para saber como a [dbo].[Comments]tabela foi preenchida.)

SET NOCOUNT ON

DECLARE cur CURSOR LOCAL FAST_FORWARD FOR
    SELECT
        CustomerCode,
        Comments
        FROM [dbo].[Comments]
        ORDER BY
            CustomerCode,
            RowNum

DECLARE @curCustomerCode int
DECLARE @lastCustomerCode int
DECLARE @curComment nvarchar(25)
DECLARE @comments nvarchar(MAX)

DECLARE @results table
(
    CustomerCode int NOT NULL,
    AllComments nvarchar(MAX) NOT NULL
)


OPEN cur

FETCH NEXT FROM cur INTO
    @curCustomerCode, @curComment

SET @lastCustomerCode = @curCustomerCode


WHILE @@FETCH_STATUS = 0
BEGIN

    IF (@lastCustomerCode != @curCustomerCode)
    BEGIN
        INSERT INTO @results(CustomerCode, AllComments)
            VALUES(@lastCustomerCode, @comments)

        SET @lastCustomerCode = @curCustomerCode
        SET @comments = NULL
    END

    IF (@comments IS NULL)
        SET @comments = @curComment
    ELSE
        SET @comments = @comments + N' ' + @curComment

    FETCH NEXT FROM cur INTO
        @curCustomerCode, @curComment

END

IF (@comments IS NOT NULL)
BEGIN
    INSERT INTO @results(CustomerCode, AllComments)
        VALUES(@curCustomerCode, @comments)
END

CLOSE cur
DEALLOCATE cur


SELECT * FROM @results

-- solution avoiding the cursor ...

DECLARE @idMax INT
DECLARE @idCtr INT
DECLARE @comment VARCHAR(150)

SELECT @idMax = MAX(id)
FROM [dbo].[CustomerCodeWithSeparateComments]

IF @idMax = 0
    return
DECLARE @OriginalTable AS Table
(
    [id] [int] NOT NULL,
    [row_num] [int] NULL,
    [customer_code] [varchar](50) NULL,
    [comment] [varchar](120) NULL
)

DECLARE @FinalTable AS Table
(
    [id] [int] IDENTITY(1,1) NOT NULL,
    [customer_code] [varchar](50) NULL,
    [comment] [varchar](120) NULL
)

INSERT INTO @FinalTable 
([customer_code])
SELECT [customer_code]
FROM [dbo].[CustomerCodeWithSeparateComments]
GROUP BY [customer_code]

INSERT INTO @OriginalTable
           ([id]
           ,[row_num]
           ,[customer_code]
           ,[comment])
SELECT [id]
      ,[row_num]
      ,[customer_code]
      ,[comment]
FROM [dbo].[CustomerCodeWithSeparateComments]
ORDER BY id, row_num

SET @idCtr = 1
SET @comment = ''

WHILE @idCtr < @idMax
BEGIN

    SELECT @comment = @comment + ' ' + comment
    FROM @OriginalTable 
    WHERE id = @idCtr
    UPDATE @FinalTable
       SET [comment] = @comment
    WHERE [id] = @idCtr 
    SET @idCtr = @idCtr + 1
    SET @comment = ''

END 

SELECT @comment = @comment + ' ' + comment
        FROM @OriginalTable 
        WHERE id = @idCtr

UPDATE @FinalTable
   SET [comment] = @comment
WHERE [id] = @idCtr

SELECT *
FROM @FinalTable