在 T-SQL 中拆分字符串并折叠

Question

Is it possible to split a delimited string and then 'fold' the delimited parts such that the result is a string containing all possible 'paths'? I'm looking to purely use built-in functions if possible without resorting to recursive CTEs, etc.

This is a common functional pattern known as scan/fold. Wondering if T-SQL has a similar pattern.

Example

FOLD('A|B|C|D') = '[A],[A|B],[A|B|C],[A|B|C|D]'

EDIT: The order of the substrings must remain the same in the result. The target SQL version is Azure SQL.

Answer 1

if you have sql-server-2017 you can use STRING_AGG and STRING_SPLIT

declare @text VARCHAR(MAX) ='A|B|C|D'

declare @result VARCHAR(MAX) = ''

SELECT @result  = @result  + ',[' + STRING_AGG(X.value, '|') + ']' FROM 
    STRING_SPLIT(@text ,'|') X
    INNER JOIN STRING_SPLIT(@text ,'|') Y
    ON X.value <= Y.Value
GROUP BY Y.Value

SET @result = STUFF(@result,1,1,'')

print @result 

Result:

[A],[A|B],[A|B|C],[A|B|C|D]

Answer 2

As I note in the comments, STRING_SPLIT has a big caveat in the documentation :

The order is not guaranteed to match the order of the substrings in the input string.

As a result, you're safer off using a function that gives you the ordinal position. In this case I use DelimitedSplit8K_LEAD and then assume you are using SQL Server 2017+:

DECLARE @YourString varchar(20) = 'A|B|C|D';
WITH Splits AS(
    SELECT DS.ItemNumber,
           DS.Item
    FROM dbo.DelimitedSplit8K_LEAD(@YourString,'|') DS),
Groups AS(
    SELECT S1.ItemNumber,
           CONCAT('[',STRING_AGG(S2.Item,'|') WITHIN GROUP (ORDER BY S2.ItemNumber),']') AS Agg
    FROM Splits S1
         JOIN Splits S2 ON S1.ItemNumber >= S2.ItemNumber
    GROUP BY S1.ItemNumber)
SELECT STRING_AGG(Agg,',') WITHIN GROUP (ORDER BY ItemNumber)
FROM Groups;

If you aren't on SQL Server 2017+, you'll need to use the "old" FOR XML PATH (and STUFF ) method.

DB<>Fiddle

Answer 3

Just in case you don't want (or can't use) that SUPER DelimitedSplit8K_LEAD , here is an XML approach that will maintain the sequence

Example

Declare @S varchar(max) = 'A|B|C|D'

;with cte as (
    Select RetSeq = row_number() over (order by 1/0)
          ,RetVal = ltrim(rtrim(B.i.value('(./text())[1]', 'varchar(max)')))
    From  (Select x = Cast('<x>' + replace((Select replace(@S,'|','§§Split§§') as [*] For XML Path('')),'§§Split§§','</x><x>')+'</x>' as xml).query('.')) as A 
    Cross Apply x.nodes('x') AS B(i)
), cte1 as (
   Select *
         ,Comb ='['+stuff((select '|' +RetVal From cte Where RetSeq<=A.RetSeq Order By RetSeq For XML Path ('')),1,1,'') +']'
    From  cte A
    Group By RetSeq,RetVal
)
Select NewValue = stuff((select ',' +Comb From cte1 Order By RetSeq For XML Path ('')),1,1,'')

Returns

NewValue
[A],[A|B],[A|B|C],[A|B|C|D]

Answer 4

Starting with v2016 there is JSON, which allows for a position-safe splitter using a JSON array. The path can be built with a recursive CTE:

DECLARE @yourString VARCHAR(MAX) ='A|B|C|D';

WITH cte AS
(
    SELECT A.[key] AS ItmIndex
          ,A.[value] AS ItmVal 
    FROM OPENJSON(CONCAT('["',REPLACE(@yourString,'|','","'),'"]')) A
)
,rcte AS
(
    SELECT ItmIndex, ItmVal
          ,CAST(ItmVal AS VARCHAR(MAX)) AS Result 
    FROM cte 
    WHERE ItmIndex=0

    UNION ALL
    SELECT cte.ItmIndex, cte.ItmVal 
          ,CAST(CONCAT(rcte.Result,'|',cte.ItmVal) AS VARCHAR(MAX))
    FROM cte
    INNER JOIN rcte ON cte.ItmIndex=rcte.ItmIndex+1
)
SELECT * FROM rcte;

The idea in short:

• The first cte will transform your string into a set with a guaranteed sort order (other than STRING_SPLIT() ).
• The second cte will start with the array's index 0 and then travers the list adding each item to the growing string.