Si está en SQL Server 2017 o Azure, consulte Respuesta de Mathieu Renda.

Tuve un problema similar cuando intentaba unir dos tablas con relaciones de uno a varios. En SQL 2005 encontré que XML PATH El método puede manejar la concatenación de filas muy fácilmente.

Si hay una mesa llamada STUDENTS

SubjectID       StudentName
----------      -------------
1               Mary
1               John
1               Sam
2               Alaina
2               Edward

El resultado que esperaba fue:

SubjectID       StudentName
----------      -------------
1               Mary, John, Sam
2               Alaina, Edward

Utilicé lo siguiente T-SQL:

SELECT Main.SubjectID,
       LEFT(Main.Students,Len(Main.Students)-1) As "Students"
FROM
    (
        SELECT DISTINCT ST2.SubjectID, 
            (
                SELECT ST1.StudentName + ',' AS [text()]
                FROM dbo.Students ST1
                WHERE ST1.SubjectID = ST2.SubjectID
                ORDER BY ST1.SubjectID
                FOR XML PATH ('')
            ) [Students]
        FROM dbo.Students ST2
    ) [Main]

Puede hacer lo mismo de una manera más compacta si puede colocar las comas al principio y usar substring para omitir el primero para que no necesite hacer una subconsulta:

SELECT DISTINCT ST2.SubjectID, 
    SUBSTRING(
        (
            SELECT ','+ST1.StudentName  AS [text()]
            FROM dbo.Students ST1
            WHERE ST1.SubjectID = ST2.SubjectID
            ORDER BY ST1.SubjectID
            FOR XML PATH ('')
        ), 2, 1000) [Students]
FROM dbo.Students ST2

Esta respuesta puede volver resultados inesperados Para obtener resultados consistentes, use uno de los métodos FOR XML PATH detallados en otras respuestas.

Utilice la herramienta COALESCE:

DECLARE @Names VARCHAR(8000) 
SELECT @Names = COALESCE(@Names + ', ', '') + Name 
FROM People

Solo una explicación (ya que esta respuesta parece obtener vistas relativamente regulares):

• Coalesce es realmente un truco útil que logra dos cosas:

1) No es necesario inicializar @Names con un valor de cadena vacío.

2) No es necesario quitar un separador adicional al final.

• La solución anterior dará resultados incorrectos si una fila tiene una NULL Valor de nombre (si hay un NULL, la NULL hará @Names NULL después de esa fila, y la siguiente fila comenzará de nuevo como una cadena vacía. Se arregla fácilmente con una de dos soluciones:

DECLARE @Names VARCHAR(8000) 
SELECT @Names = COALESCE(@Names + ', ', '') + Name
FROM People
WHERE Name IS NOT NULL

o bien:

DECLARE @Names VARCHAR(8000) 
SELECT @Names = COALESCE(@Names + ', ', '') + 
    ISNULL(Name, 'N/A')
FROM People

Dependiendo del comportamiento que desee (la primera opción solo filtra NULLs fuera, la segunda opción los mantiene en la lista con un mensaje de marcador [reemplace 'N / A' con lo que sea apropiado para usted]).

SQL Server 2017+ y SQL Azure: STRING_AGG

Comenzando con la próxima versión de SQL Server, finalmente podemos concatenar entre filas sin tener que recurrir a ninguna variable o brujería XML.

STRING_AGG (Transact-SQL)

Sin agrupar

SELECT STRING_AGG(Name, ', ') AS Departments
FROM HumanResources.Department;

Con agrupación:

SELECT GroupName, STRING_AGG(Name, ', ') AS Departments
FROM HumanResources.Department
GROUP BY GroupName;

Con agrupación y subclasificación

SELECT GroupName, STRING_AGG(Name, ', ') WITHIN GROUP (ORDER BY Name ASC) AS Departments
FROM HumanResources.Department 
GROUP BY GroupName;

Un método aún no se muestra a través del XML data() comando en MS SQL Server es:

Suponga una tabla llamada NameList con una columna llamada FName,

SELECT FName + ', ' AS 'data()' 
FROM NameList 
FOR XML PATH('')

devoluciones:

"Peter, Paul, Mary, "

Solo se debe tratar la coma adicional.

Edit: Como se adoptó del comentario de @ NReilingh, puede usar el siguiente método para eliminar la coma al final. Suponiendo los mismos nombres de tabla y columna:

STUFF(REPLACE((SELECT '#!' + LTRIM(RTRIM(FName)) AS 'data()' FROM NameList
FOR XML PATH('')),' #!',', '), 1, 2, '') as Brands

In SQL Server 2005

SELECT Stuff(
  (SELECT N', ' + Name FROM Names FOR XML PATH(''),TYPE)
  .value('text()[1]','nvarchar(max)'),1,2,N'')

En SQL Server 2016

se puede utilizar el PARA la sintaxis JSON

es decir,

SELECT per.ID,
Emails = JSON_VALUE(
   REPLACE(
     (SELECT _ = em.Email FROM Email em WHERE em.Person = per.ID FOR JSON PATH)
    ,'"},{"_":"',', '),'$[0]._'
) 
FROM Person per

Y el resultado se convertirá

Id  Emails
1   abc@gmail.com
2   NULL
3   def@gmail.com, xyz@gmail.com

Esto funcionará incluso si sus datos contienen caracteres XML no válidos.

'"},{"_":"' es seguro porque si tus datos contienen '"},{"_":"', se escapará a "},{\"_\":\"

Puedes reemplazar ', ' con cualquier separador de cadenas

Y en SQL Server 2017, Azure SQL Database

Puedes usar el nuevo Función STRING_AGG

En MySQL, hay una función, GROUP_CONCAT (), que le permite concatenar los valores de varias filas. Ejemplo:

SELECT 1 AS a, GROUP_CONCAT(name ORDER BY name ASC SEPARATOR ', ') AS people 
FROM users 
WHERE id IN (1,2,3) 
GROUP BY a

Utilice la herramienta JUNTARSE - Obtenga más información aquí.

Para un ejemplo:

102

103

104

Luego escriba el código a continuación en el servidor SQL,

Declare @Numbers AS Nvarchar(MAX) -- It must not be MAX if you have few numbers 
SELECT  @Numbers = COALESCE(@Numbers + ',', '') + Number
FROM   TableName where Number IS NOT NULL

SELECT @Numbers

La salida sería:

102,103,104

Las matrices de Postgres son increíbles. Ejemplo:

Cree algunos datos de prueba:

postgres=# \c test
You are now connected to database "test" as user "hgimenez".
test=# create table names (name text);
CREATE TABLE                                      
test=# insert into names (name) values ('Peter'), ('Paul'), ('Mary');                                                          
INSERT 0 3
test=# select * from names;
 name  
-------
 Peter
 Paul
 Mary
(3 rows)

Agréguelos en una matriz:

test=# select array_agg(name) from names;
 array_agg     
------------------- 
 {Peter,Paul,Mary}
(1 row)

Convierta la matriz en una cadena delimitada por comas:

test=# select array_to_string(array_agg(name), ', ') from names;
 array_to_string
-------------------
 Peter, Paul, Mary
(1 row)

LISTO

Desde PostgreSQL 9.0 es aún más fácil.

Oracle 11g Release 2 admite la función LISTAGG. Documentación aquí.

COLUMN employees FORMAT A50

SELECT deptno, LISTAGG(ename, ',') WITHIN GROUP (ORDER BY ename) AS employees
FROM   emp
GROUP BY deptno;

    DEPTNO EMPLOYEES
---------- --------------------------------------------------
        10 CLARK,KING,MILLER
        20 ADAMS,FORD,JONES,SCOTT,SMITH
        30 ALLEN,BLAKE,JAMES,MARTIN,TURNER,WARD

3 rows selected.

advertencia

Tenga cuidado al implementar esta función si existe la posibilidad de que la cadena resultante supere los 4000 caracteres. Lanzará una excepción. Si ese es el caso, entonces debe manejar la excepción o ejecutar su propia función que evita que la cadena unida supere los 4000 caracteres.

En SQL Server 2005 y versiones posteriores, utilice la consulta siguiente para concatenar las filas.

DECLARE @t table
(
    Id int,
    Name varchar(10)
)
INSERT INTO @t
SELECT 1,'a' UNION ALL
SELECT 1,'b' UNION ALL
SELECT 2,'c' UNION ALL
SELECT 2,'d' 

SELECT ID,
stuff(
(
    SELECT ','+ [Name] FROM @t WHERE Id = t.Id FOR XML PATH('')
),1,1,'') 
FROM (SELECT DISTINCT ID FROM @t ) t

No tengo acceso a un servidor SQL en casa, así que supongo que la sintaxis aquí, pero es más o menos:

DECLARE @names VARCHAR(500)

SELECT @names = @names + ' ' + Name
FROM Names

Se sugirió una solución CTE recursiva, pero no se proporcionó ningún código. El siguiente código es un ejemplo de CTE recursivo. Tenga en cuenta que aunque los resultados coinciden con la pregunta, los datos no exactamente coincida con la descripción dada, ya que supongo que realmente desea hacer esto en grupos de filas, no en todas las filas de la tabla. Cambiarlo para que coincida con todas las filas de la tabla se deja como ejercicio para el lector.

;WITH basetable AS (
    SELECT
        id,
        CAST(name AS VARCHAR(MAX)) name, 
        ROW_NUMBER() OVER (Partition BY id ORDER BY seq) rw, 
        COUNT(*) OVER (Partition BY id) recs 
    FROM (VALUES
        (1, 'Johnny', 1),
        (1, 'M', 2), 
        (2, 'Bill', 1),
        (2, 'S.', 4),
        (2, 'Preston', 5),
        (2, 'Esq.', 6),
        (3, 'Ted', 1),
        (3, 'Theodore', 2),
        (3, 'Logan', 3),
        (4, 'Peter', 1),
        (4, 'Paul', 2),
        (4, 'Mary', 3)
    ) g (id, name, seq)
),
rCTE AS (
    SELECT recs, id, name, rw
    FROM basetable
    WHERE rw = 1

    UNION ALL

    SELECT b.recs, r.ID, r.name +', '+ b.name name, r.rw + 1
    FROM basetable b
    INNER JOIN rCTE r ON b.id = r.id AND b.rw = r.rw + 1
)
SELECT name
FROM rCTE
WHERE recs = rw AND ID=4

Necesita crear una variable que contenga su resultado final y seleccione en él, así.

Solución más sencilla

DECLARE @char VARCHAR(MAX);

SELECT @char = COALESCE(@char + ', ' + [column], [column]) 
FROM [table];

PRINT @char;

En SQL Server vNext, esto se integrará con la función STRING_AGG, lea más sobre esto aquí: https://msdn.microsoft.com/en-us/library/mt790580.aspx

El uso de XML me ayudó a separar las filas con comas. Para la coma adicional, podemos usar la función de reemplazo de SQL Server. En lugar de agregar una coma, el uso de AS 'data ()' concatenará las filas con espacios, que luego se pueden reemplazar con comas como la sintaxis escrita a continuación.

REPLACE(
        (select FName AS 'data()'  from NameList  for xml path(''))
         , ' ', ', ') 

Una solución lista para usar, sin comas adicionales:

select substring(
        (select ', '+Name AS 'data()' from Names for xml path(''))
       ,3, 255) as "MyList"

Una lista vacía dará como resultado un valor NULO. Por lo general, insertará la lista en una columna de tabla o variable de programa: ajuste la longitud máxima de 255 a sus necesidades.

(Diwakar y Jens Frandsen proporcionaron buenas respuestas, pero necesitan mejorar).

SELECT STUFF((SELECT ', ' + name FROM [table] FOR XML PATH('')), 1, 2, '')

Aquí hay una muestra:

DECLARE @t TABLE (name VARCHAR(10))
INSERT INTO @t VALUES ('Peter'), ('Paul'), ('Mary')
SELECT STUFF((SELECT ', ' + name FROM @t FOR XML PATH('')), 1, 2, '')
--Peter, Paul, Mary

Con las otras respuestas, la persona que lee la respuesta debe conocer una tabla de dominio específico, como vehículo o estudiante. La tabla debe crearse y completarse con datos para probar una solución.

A continuación se muestra un ejemplo que utiliza la tabla "Information_Schema.Columns" de SQL Server. Al usar esta solución, no es necesario crear tablas ni agregar datos. Este ejemplo crea una lista de nombres de columna separados por comas para todas las tablas de la base de datos.

SELECT
    Table_Name
    ,STUFF((
        SELECT ',' + Column_Name
        FROM INFORMATION_SCHEMA.Columns Columns
        WHERE Tables.Table_Name = Columns.Table_Name
        ORDER BY Column_Name
        FOR XML PATH ('')), 1, 1, ''
    )Columns
FROM INFORMATION_SCHEMA.Columns Tables
GROUP BY TABLE_NAME 

DECLARE @Names VARCHAR(8000)
SELECT @name = ''
SELECT @Names = @Names + ',' + Names FROM People
SELECT SUBSTRING(2, @Names, 7998)

Esto pone la coma perdida al principio.

Sin embargo, si necesita otras columnas o CSV en una tabla secundaria, debe envolverla en un campo escalar definido por el usuario (UDF).

También puede usar la ruta XML como una subconsulta correlacionada en la cláusula SELECT (pero tendría que esperar hasta volver al trabajo porque Google no hace las cosas del trabajo en casa :-)

Esto funcionó para míServidor Sql 2016):

SELECT CarNamesString = STUFF((
         SELECT ',' + [Name]
            FROM tbl_cars 
            FOR XML PATH('')
         ), 1, 1, '')

Aquí está la fuente: https://www.mytecbits.com/

Y una solucion para MySql (ya que esta página aparece en Google para MySql)

SELECT [Name],
       GROUP_CONCAT(DISTINCT [Name]  SEPARATOR ',')
       FROM tbl_cars

Desde Documentaciones MySql

Para bases de datos de Oracle, consulte esta pregunta: ¿Cómo se pueden concatenar varias filas en una en Oracle sin crear un procedimiento almacenado?

La mejor respuesta parece ser @Emmanuel, usando la función incorporada LISTAGG (), disponible en Oracle 11g Release 2 y posteriores.

SELECT question_id,
   LISTAGG(element_id, ',') WITHIN GROUP (ORDER BY element_id)
FROM YOUR_TABLE;
GROUP BY question_id

como señaló @ user762952, y de acuerdo con la documentación de Oracle http://www.oracle-base.com/articles/misc/string-aggregation-techniques.php, la función WM_CONCAT () también es una opción. Parece estable, pero Oracle recomienda explícitamente no usarlo para ninguna aplicación SQL, así que úselo bajo su propio riesgo.

Aparte de eso, tendrá que escribir su propia función; el documento de Oracle anterior tiene una guía sobre cómo hacerlo.

Para evitar valores nulos, puede usar CONCAT ()

DECLARE @names VARCHAR(500)
SELECT @names = CONCAT(@names, ' ', name) 
FROM Names
select @names

Ejemplo completo de MySQL:

Tenemos usuarios que pueden tener muchos datos y queremos tener una salida, donde podemos ver todos los datos de los usuarios en una lista:

Resultado:

___________________________
| id   |  rowList         |
|-------------------------|
| 0    | 6, 9             |
| 1    | 1,2,3,4,5,7,8,1  |
|_________________________|

Configuración de la mesa:

CREATE TABLE `Data` (
  `id` int(11) NOT NULL,
  `user_id` int(11) NOT NULL
) ENGINE=InnoDB AUTO_INCREMENT=11 DEFAULT CHARSET=latin1;


INSERT INTO `Data` (`id`, `user_id`) VALUES
(1, 1),
(2, 1),
(3, 1),
(4, 1),
(5, 1),
(6, 0),
(7, 1),
(8, 1),
(9, 0),
(10, 1);


CREATE TABLE `User` (
  `id` int(11) NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=latin1;


INSERT INTO `User` (`id`) VALUES
(0),
(1);

consulta:

SELECT User.id, GROUP_CONCAT(Data.id ORDER BY Data.id) AS rowList FROM User LEFT JOIN Data ON User.id = Data.user_id GROUP BY User.id

Realmente me gustó la elegancia de La respuesta de Dana. Solo quería completarlo.

DECLARE @names VARCHAR(MAX)
SET @names = ''

SELECT @names = @names + ', ' + Name FROM Names 

-- Deleting last two symbols (', ')
SET @sSql = LEFT(@sSql, LEN(@sSql) - 1)

Esta respuesta requerirá algunos privilegios en el servidor para funcionar.

asambleas son una buena opción para ti. Hay muchos sitios que explican cómo crearlo. El que creo que está muy bien explicado es este .

Si quieres, ya he creado el ensamblaje y es posible descargar la DLL aquí.

Una vez que lo haya descargado, deberá ejecutar el siguiente script en su servidor SQL:

EXEC sp_configure 'show advanced options', 1
RECONFIGURE;
EXEC sp_configure 'clr strict security', 1;
RECONFIGURE;

CREATE Assembly concat_assembly 
   AUTHORIZATION dbo 
   FROM '<PATH TO Concat.dll IN SERVER>' 
   WITH PERMISSION_SET = SAFE; 
GO 

CREATE AGGREGATE dbo.concat ( 

    @Value NVARCHAR(MAX) 
  , @Delimiter NVARCHAR(4000) 

) RETURNS NVARCHAR(MAX) 
EXTERNAL Name concat_assembly.[Concat.Concat]; 
GO  

sp_configure 'clr enabled', 1;
RECONFIGURE

Observe que el servidor puede acceder a la ruta al ensamblaje. Dado que ha realizado con éxito todos los pasos, puede utilizar la función como:

SELECT dbo.Concat(field1, ',')
FROM Table1

¡¡¡Espero eso ayude!!!

ACTUALIZACIÓN:

Desde MS-SQL 2017 es posible utilizar el STRING_AGG función

Por lo general, uso seleccionar como este para concatenar cadenas en SQL Server:

with lines as 
( 
  select 
    row_number() over(order by id) id, -- id is a line id
    line -- line of text.
  from
    source -- line source
), 
result_lines as 
( 
  select 
    id, 
    cast(line as nvarchar(max)) line 
  from 
    lines 
  where 
    id = 1 
  union all 
  select 
    l.id, 
    cast(r.line + N', ' + l.line as nvarchar(max))
  from 
    lines l 
    inner join 
    result_lines r 
    on 
      l.id = r.id + 1 
) 
select top 1 
  line
from
  result_lines
order by
  id desc

Si desea lidiar con nulos, puede hacerlo agregando una cláusula where o agregando otra COALESCE alrededor de la primera.

DECLARE @Names VARCHAR(8000) 
SELECT @Names = COALESCE(COALESCE(@Names + ', ', '') + Name, @Names) FROM People

además de la respuesta de Chris Shaffer

si sus datos pueden repetirse como

Tom
Ali
John
Ali
Tom
Mike

En vez de tener Tom,Ali,John,Ali,Tom,Mike

Puede utilizar DISTINCT para evitar duplicados y obtener Tom,Ali,John,Mike

DECLARE @Names VARCHAR(8000) 
SELECT DISTINCT @Names = COALESCE(@Names + ',', '') + Name
FROM People
WHERE Name IS NOT NULL
SELECT @Names

En Oracle, es wm_concat. Creo que esta función está disponible en Liberación de 10g y más alto.

Esto también puede ser útil

create table #test (id int,name varchar(10))
--use separate inserts on older versions of SQL Server
insert into #test values (1,'Peter'), (1,'Paul'), (1,'Mary'), (2,'Alex'), (3,'Jack')

DECLARE @t VARCHAR(255)
SELECT @t = ISNULL(@t + ',' + name, name) FROM #test WHERE id = 1
select @t
drop table #test

devoluciones

Peter,Paul,Mary