පේළි තුනක් සහිත නම් සහිත දත්ත සමුදා වගුවක් සලකා බලන්න:

Peter
Paul
Mary

මෙය තනි නූලක් බවට පත් කිරීමට පහසු ක්‍රමයක් Peter, Paul, Maryතිබේද?

ඔබ SQL Server 2017 හෝ Azure හි සිටී නම්, Mathieu Renda පිළිතුර බලන්න .

මම එක හා බොහෝ සම්බන්ධතා ඇති වගු දෙකකට සම්බන්ධ වීමට උත්සාහ කරන විට මට සමාන ප්‍රශ්නයක් ඇති විය. SQL 2005 දී මට එය හමු වියXML PATH ක්‍රමයට පේළි වල සංක්ෂිප්තය ඉතා පහසුවෙන් හැසිරවිය හැකි බවයි.

නම් මේසයක් තිබේ නම් STUDENTS

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

මම බලාපොරොත්තු වූ ප්‍රති ult ලය වූයේ:

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

මම පහත සඳහන් දෑ භාවිතා කළෙමි 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]

ආරම්භයේදීම කොමාව සංයුක්ත substringකර පළමු එක මඟ හැරීමට ඔබට හැකි නම් ඔබට උප-විමසුමක් කිරීමට අවශ්‍ය නොවන්නේ නම් ඔබට එකම දේ වඩාත් සංයුක්ත ආකාරයකින් කළ හැකිය :

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

මෙම පිළිතුර අනපේක්ෂිත ප්‍රති results ල ලබා දිය හැකිය ස්ථාවර ප්‍රති results ල සඳහා, වෙනත් පිළිතුරු වල විස්තර කර ඇති FOR XML PATH ක්‍රමවලින් එකක් භාවිතා කරන්න.

භාවිතා කරන්න COALESCE:

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

යම් පැහැදිලි කිරීමක් පමණි (මෙම පිළිතුර සාපේක්ෂව නිත්‍ය අදහස් ලබා ගන්නා බව පෙනේ):

• Coalesce යනු කාරණා දෙකක් ඉටු කරන ප්‍රයෝජනවත් වංචාවකි:

1) @Namesහිස් නූල් අගයකින් ආරම්භ කිරීම අවශ්‍ය නොවේ .

2) අවසානයේ අතිරේක බෙදුම්කරුවෙකු ඉවත් කිරීමට අවශ්‍ය නැත.

• පේලියට සතුව නම් ඉහත විසඳුම වැරදි ප්රතිඵල ලබා දෙනු ඇත NULL (නම වටිනාකම තිබේ නම් NULL එම NULL කරන්නෙමි @Names NULL ලෑම බව පසු, ඊළඟ පේළිය නැවත හිස් අගයක් ලෙස නැවත ආරම්භ වනු ඇත. පහසුවෙන් පාලනය කරන්න දෙකෙන් එකක්, ස්ථාවර විසඳුම්:

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

හෝ:

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

ඔබට අවශ්‍ය හැසිරීම මත පදනම්ව (පළමු විකල්පය NULL පිටතට පෙරීම , දෙවන විකල්පය ඒවා සලකුණු පණිවිඩයක් සමඟ ලැයිස්තුවේ තබා ගනී ['N / A' වෙනුවට ඔබට සුදුසු ඕනෑම දෙයක් ආදේශ කරන්න]).

SQL සේවාදායකය 2017+ සහ SQL Azure: STRING_AGG

SQL සේවාදායකයේ මීළඟ අනුවාදයෙන් පටන් ගෙන, අපට කිසිදු විචල්‍යයක් හෝ එක්ස්එම්එල් මායාකාරියකට යොමු නොවී පේළි හරහා සමපාත විය හැකිය.

STRING_AGG (ගනුදෙනු- SQL)

කණ්ඩායම් කිරීමකින් තොරව

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

කණ්ඩායම් කිරීම සමඟ:

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

කණ්ඩායම්කරණය සහ උප වර්ග කිරීම සමඟ

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

XML data()MS SQL සේවාදායකයේ විධානය හරහා තවමත් පෙන්වා නැති එක් ක්‍රමයක් නම්:

FName නම් එක් තීරුවක් සමඟ NameList නම් වගුව උපකල්පනය කරන්න,

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

ප්‍රතිලාභ:

"Peter, Paul, Mary, "

අතිරේක කොමාව සමඟ පමණක් කටයුතු කළ යුතුය.

සංස්කරණය කරන්න: @ එන්. රයිලිංගේ අදහස් දැක්වීමෙන්, ඔබට පහත සඳහන් ක්‍රමය භාවිතා කර පසුපස කොමාව ඉවත් කළ හැකිය. එකම වගුව සහ තීරු නම් උපකල්පනය කිරීම:

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

දී 2005 SQL Server

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

SQL සේවාදායකය 2016 දී

ඔබට FOR JSON සින්ටැක්ස් භාවිතා කළ හැකිය

එනම්

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

ප්රති result ලය බවට පත්වනු ඇත

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

ඔබගේ දත්ත වල පවා වලංගු නොවන XML අක්ෂර අඩංගු වේ

මෙම '"},{"_":"'නිසා ඔබ විසින් දත්ත අඩංගු නම් ආරක්ෂිත '"},{"_":"',එය පලා කරනු ඇත"},{\"_\":\"

ඔබට ', 'ඕනෑම නූල් බෙදුම්කරුවෙකු සමඟ ප්රතිස්ථාපනය කළ හැකිය

සහ SQL Server 2017 හි Azure SQL දත්ත සමුදාය

ඔබට නව STRING_AGG ශ්‍රිතය භාවිතා කළ හැකිය

MySQL හි GROUP_CONCAT () ශ්‍රිතයක් ඇත, එමඟින් ඔබට පේළි කිහිපයකින් අගයන් සංයුක්ත කිරීමට ඉඩ ලබා දේ. උදාහරණයක්:

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

COALESCE භාවිතා කරන්න - මෙතැන් සිට වැඩිදුර ඉගෙන ගන්න

උදාහරණයක් ලෙස:

102

103 යි

104 යි

ඉන්පසු 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

ප්‍රතිදානය වනුයේ:

102,103,104

Postgres අරා නියමයි. උදාහරණයක්:

පරීක්ෂණ දත්ත කිහිපයක් සාදන්න:

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)

ඒවා පෙළට එකතු කරන්න:

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

අරාව කොමා වලින් වෙන් කරන ලද නූලකට පරිවර්තනය කරන්න:

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

කළා

PostgreSQL 9.0 සිට එය ඊටත් වඩා පහසුය .

Oracle 11g Release 2 LISTAGG ශ්‍රිතයට සහය දක්වයි. මෙහි ලේඛනගත කිරීම .

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.

අවවාදයයි

එහි ප්‍රති string ලයක් ලෙස අක්ෂර 4000 ඉක්මවා යාමට ඉඩ තිබේ නම් මෙම ක්‍රියාව ක්‍රියාත්මක කිරීමට ප්‍රවේශම් වන්න. එය ව්යතිරේකයක් විසි කරනු ඇත. එය එසේ නම්, ඔබට ව්‍යතිරේකය හැසිරවිය යුතුය, නැතහොත් ඔබේම ශ්‍රිතය රෝල් කළ යුතුය, එමඟින් එක්වූ නූල අක්ෂර 4000 ඉක්මවා යාම වළක්වයි.

SQL Server 2005 සහ ඊට පසු, පේළි සංයුක්ත කිරීම සඳහා පහත විමසුම භාවිතා කරන්න.

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

මට නිවසේදී SQL සේවාදායකයකට ප්‍රවේශය නොමැත, එබැවින් මම මෙහි වාක්‍ය ඛණ්ඩය අනුමාන කරමි, නමුත් එය වැඩි හෝ අඩු:

DECLARE @names VARCHAR(500)

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

පුනරාවර්තන CTE විසඳුමක් යෝජනා කළ නමුත් කේතයක් ලබා දී නැත. පහත කේතය පුනරාවර්තන CTE සඳහා උදාහරණයකි. ප්රතිඵල ප්රශ්නය ගැලපෙන වුවත්, දත්ත නොවන බව සටහන ඉතා ලබා දී විස්තර, මම ඔයාට ඇත්තටම මේසය නැති, පේළි කණ්ඩායම් සියලු පේළි මත මේ දේ කිරීමට අවශ්ය බව උපකල්පනය ලෙස නොගැලපේ. වගුවේ ඇති සියලුම පේළි වලට ගැලපෙන පරිදි එය වෙනස් කිරීම පා er කයාට අභ්‍යාසයක් ලෙස ඉතිරි වේ.

;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

PostgreSQL 9.0 සමඟ ආරම්භ කිරීම මෙය බෙහෙවින් සරල ය:

select string_agg(name, ',') 
from names;

9.0 ට පෙර සංස්කරණ array_agg()වලදී hgmnz පෙන්වා ඇති පරිදි භාවිතා කළ හැකිය

ඔබේ අවසාන ප්‍රති result ලය රඳවා තබා ගත හැකි විචල්‍යයක් ඔබ විසින් නිර්මාණය කළ යුතුය.

පහසුම විසඳුම

DECLARE @char VARCHAR(MAX);

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

PRINT @char;

SQL සේවාදායකයේ vNext හි මෙය STRING_AGG ශ්‍රිතය සමඟ ගොඩනගනු ඇත, ඒ ගැන වැඩි විස්තර මෙතැනින් කියවන්න: https://msdn.microsoft.com/en-us/library/mt790580.aspx

කොමා සමඟ පේළි වෙන් කිරීමට XML භාවිතා කිරීම මට උපකාරී විය. අමතර කොමාව සඳහා අපට SQL සේවාදායකයේ ප්‍රතිස්ථාපන කාර්යය භාවිතා කළ හැකිය. කොමාව එකතු කිරීම වෙනුවට, AS 'දත්ත ()' භාවිතා කිරීමෙන් පේළි අවකාශයන් සමඟ සංයුක්ත වන අතර පසුව එය කොමා මඟින් ප්‍රතිස්ථාපනය කළ හැකිය.

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

අමතර කොමාවකින් තොරව භාවිතා කිරීමට සූදානම් විසඳුමක්:

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

හිස් ලැයිස්තුවක් නිසා NULL අගය ලැබෙනු ඇත. සාමාන්‍යයෙන් ඔබ ලැයිස්තුව වගු තීරුවකට හෝ ක්‍රමලේඛ විචල්‍යයකට ඇතුළත් කරනු ඇත: ඔබේ අවශ්‍යතාවයට අනුව උපරිම දිග 255 ක් සකසන්න.

(දීවාකර් සහ ජෙන්ස් ෆ්‍රැන්ඩ්සන් හොඳ පිළිතුරු සැපයූ නමුත් වැඩිදියුණු කිරීම අවශ්‍යයි.)

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

මෙන්න නියැදියක්:

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

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

මෙය අයාලේ යන කොමාව ආරම්භයේදීම තබයි.

කෙසේ වෙතත්, ඔබට වෙනත් තීරු අවශ්‍ය නම්, හෝ ළමා වගුවකට CSV කිරීමට අවශ්‍ය නම්, මෙය පරිමාණ පරිශීලක අර්ථ දක්වා ඇති ක්ෂේත්‍රයක (යූඩීඑෆ්) ඔතා තැබිය යුතුය.

SELECT වගන්තියේ සහසම්බන්ධිත අනුකාරකයක් ලෙස ඔබට XML මාර්ගය භාවිතා කළ හැකිය (නමුත් ගූගල් නිවසේදී වැඩ කටයුතු නොකරන නිසා මම නැවත වැඩට යන තෙක් බලා සිටිය යුතුය :-)

අනෙක් පිළිතුරු සමඟ, පිළිතුර කියවන පුද්ගලයා වාහනය හෝ ශිෂ්‍යයා වැනි නිශ්චිත වසම් වගුවක් පිළිබඳව දැනුවත් විය යුතුය. විසඳුමක් පරීක්ෂා කිරීම සඳහා වගුව නිර්මාණය කර දත්ත වලින් පිරී තිබිය යුතුය.

පහත දැක්වෙන්නේ SQL සේවාදායකයේ "Information_Schema.Columns" වගුව භාවිතා කරන උදාහරණයකි. මෙම විසඳුම භාවිතා කිරීමෙන් වගු සෑදීම හෝ දත්ත එකතු කිරීම අවශ්‍ය නොවේ. මෙම උදාහරණය මඟින් දත්ත සමුදායේ ඇති සියලුම වගු සඳහා කොමා මඟින් වෙන් කරන ලද තීරු නම් ලැයිස්තුවක් නිර්මාණය කරයි.

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 

ඔරකල් ඩීබී සඳහා, මෙම ප්‍රශ්නය බලන්න: ගබඩා කළ ක්‍රියා පටිපාටියක් නිර්මාණය නොකර පේළි කිහිපයක් ඔරකල් එකකට එකකට සම්බන්ධ කරන්නේ කෙසේද?

හොඳම පිළිතුර ලෙස පෙනෙන්නේ එමානුවෙල්, බිල්ට් ලිස්ටැග් () ශ්‍රිතය භාවිතා කරමින්, ඔරකල් 11g නිකුතුව 2 සහ පසුව ලබා ගත හැකි බවයි.

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

@ user762952 පෙන්වා ඇති පරිදි, සහ ඔරකල්ගේ ලියකියවිලි අනුව http://www.oracle-base.com/articles/misc/string-aggregation-techniques.php , WM_CONCAT () ශ්‍රිතය ද විකල්පයකි. එය ස්ථායී බවක් පෙනේ, නමුත් ඕනෑම යෙදුමක SQL සඳහා එය භාවිතා කිරීමට එරෙහිව ඔරකල් පැහැදිලිවම නිර්දේශ කරයි, එබැවින් ඔබේම අවදානමක භාවිතා කරන්න.

ඒ හැර, ඔබට ඔබේම කාර්යයක් ලිවීමට සිදුවේ; ඉහත ඔරකල් ලේඛනයේ එය කරන්නේ කෙසේද යන්න පිළිබඳ මාර්ගෝපදේශයක් ඇත.

ශුන්‍ය අගයන් වළක්වා ගැනීමට ඔබට CONCAT () භාවිතා කළ හැකිය

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

මම ඇත්තටම කැමතියි ඩනාගේ පිළිතුරේ අලංකාරයට . එය සම්පූර්ණ කිරීමට අවශ්‍ය විය.

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

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

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

මෙම පිළිතුරට සේවාදායකයේ වැඩ කිරීමට යම් වරප්‍රසාදයක් අවශ්‍ය වේ.

එකලස් කිරීම ඔබට හොඳ විකල්පයකි. එය නිර්මාණය කරන්නේ කෙසේද යන්න පැහැදිලි කරන අඩවි ගොඩක් තිබේ. මම ඉතා හොඳින් විස්තර කර ඇත හිතන්නේ එක මේ එක

ඔබට අවශ්‍ය නම්, මම දැනටමත් එකලස් කිරීම නිර්මාණය කර ඇති අතර, ඩීඑල්එල් මෙතැනින් බාගත හැකිය .

ඔබ එය බාගත කළ පසු, ඔබේ SQL සේවාදායකයේ පහත ස්ක්‍රිප්ට් ධාවනය කිරීමට ඔබට අවශ්‍ය වනු ඇත:

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

එකලස් කිරීමේ මාර්ගය සේවාදායකයට ප්‍රවේශ විය හැකි බව නිරීක්ෂණය කරන්න. ඔබ සියලු පියවර සාර්ථකව සිදු කර ඇති බැවින්, ඔබට පහත පරිදි ශ්‍රිතය භාවිතා කළ හැකිය:

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

එය උපකාරී වේ යැයි සිතමු !!!

MySQL සම්පූර්ණ උදාහරණය:

අපට බොහෝ දත්ත තිබිය හැකි පරිශීලකයින් සිටින අතර අපට ප්‍රතිදානයක් ලබා ගැනීමට අවශ්‍යය, එහිදී අපට සියලු පරිශීලකයින්ගේ දත්ත ලැයිස්තුවක් තුළ දැකිය හැකිය:

ප්‍රති ult ලය:

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

වගු සැකසුම:

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);

විමසුම:

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

මම සාමාන්‍යයෙන් SQL සේවාදායකයේ නූල් සංයුක්ත කිරීම සඳහා මෙවැනි තේරීමක් භාවිතා කරමි:

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

ඔබට ශුන්‍යයන් සමඟ ගනුදෙනු කිරීමට අවශ්‍ය නම්, ඔබට වගන්තියක් එක් කිරීමෙන් හෝ පළමු එක වටා තවත් COALESCE එකතු කිරීමෙන් එය කළ හැකිය.

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

මෙය මා වෙනුවෙන් වැඩ කළේය ( SqlServer 2016 ):

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

මූලාශ්‍රය මෙන්න: https://www.mytecbits.com/

සහ MySQL සඳහා විසඳුමක් (මෙම පිටුව ගූගල් හි MySQL සඳහා පෙන්වන බැවින්)

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

සිට MySQL ලියකියවිලි

ඔරකල්හි එය එසේ ය wm_concat. මෙම ක්‍රියාව 10g නිකුතුවෙන් සහ ඊට වඩා වැඩි ගණනකින් ලබා ගත හැකි යැයි මම විශ්වාස කරමි .

මෙයද ප්‍රයෝජනවත් විය හැකිය

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

ප්‍රතිලාභ

Peter,Paul,Mary