T Funzione stimata tabella SQL per dividere una colonna su virgole

Ho scritto una funzione con valori di tabella in Microsoft SQL Server 2008 per prendere una colonna delimitata da virgole in un database per sputare righe separate per ciascun valore.

Esempio: "uno, due, tre, quattro" restituirà una nuova tabella con una sola colonna contenente i seguenti valori:

one
two
three
four

Ragazzi, questo codice sembra soggetto a errori? Quando lo collaudo con

SELECT * FROM utvf_Split('one,two,three,four',',') 

funziona solo per sempre e non restituisce mai nulla. Questo sta diventando davvero scoraggiante soprattutto perché non ci sono funzioni split integrate sul server MSSQL (PERCHÉ PERCHÉ PERCHÉ ?!) e tutte le funzioni simili che ho trovato sul web sono spazzatura assoluta o semplicemente irrilevante per quello che sto cercando di fare .

Ecco la funzione:

USE *myDBname*
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
ALTER FUNCTION [dbo].[utvf_SPlit] (@String VARCHAR(MAX), @delimiter CHAR)

RETURNS @SplitValues TABLE
(
    Asset_ID VARCHAR(MAX) NOT NULL
)

AS
BEGIN
            DECLARE @FoundIndex INT
            DECLARE @ReturnValue VARCHAR(MAX)

            SET @FoundIndex = CHARINDEX(@delimiter, @String)

            WHILE (@FoundIndex <> 0)
            BEGIN
                  DECLARE @NextFoundIndex INT
                  SET @NextFoundIndex = CHARINDEX(@delimiter, @String, @FoundIndex+1)
                  SET @ReturnValue = SUBSTRING(@String, @FoundIndex,@NextFoundIndex-@FoundIndex)
                  SET @FoundIndex = CHARINDEX(@delimiter, @String)
                  INSERT @SplitValues (Asset_ID) VALUES (@ReturnValue)
            END

            RETURN
END

Rielaborato leggermente ...

DECLARE @FoundIndex INT
DECLARE @ReturnValue VARCHAR(MAX)

SET @FoundIndex = CHARINDEX(@delimiter, @String)

WHILE (@FoundIndex <> 0)
BEGIN
      SET @ReturnValue = SUBSTRING(@String, 0, @FoundIndex)
      INSERT @SplitValues (Asset_ID) VALUES (@ReturnValue)
      SET @String = SUBSTRING(@String, @FoundIndex + 1, len(@String) - @FoundIndex)
      SET @FoundIndex = CHARINDEX(@delimiter, @String)
END

INSERT @SplitValues (Asset_ID) VALUES (@String)

RETURN

Non lo farei con un ciclo; ci sono alternative molto migliori. Di gran lunga il migliore, quando si ha a dividere, è CLR, e l'approccio di Adam Machanic è il più veloce che ho provato .

Il prossimo approccio migliore IMHO, se non è possibile implementare CLR, è una tabella numerica:

SET NOCOUNT ON;

DECLARE @UpperLimit INT = 1000000;

WITH n AS
(
    SELECT
        x = ROW_NUMBER() OVER (ORDER BY s1.[object_id])
    FROM       sys.all_objects AS s1
    CROSS JOIN sys.all_objects AS s2
    CROSS JOIN sys.all_objects AS s3
)
SELECT Number = x
  INTO dbo.Numbers
  FROM n
  WHERE x BETWEEN 1 AND @UpperLimit
  OPTION (MAXDOP 1); -- protecting from Paul White's observation

GO
CREATE UNIQUE CLUSTERED INDEX n ON dbo.Numbers(Number) 
    --WITH (DATA_COMPRESSION = PAGE);
GO

... che consente questa funzione:

CREATE FUNCTION dbo.SplitStrings_Numbers
(
   @List       NVARCHAR(MAX),
   @Delimiter  NVARCHAR(255)
)
RETURNS TABLE
WITH SCHEMABINDING
AS
   RETURN
   (
       SELECT Item = SUBSTRING(@List, Number, 
         CHARINDEX(@Delimiter, @List + @Delimiter, Number) - Number)
       FROM dbo.Numbers
       WHERE Number <= CONVERT(INT, LEN(@List))
         AND SUBSTRING(@Delimiter + @List, Number, 1) = @Delimiter
   );
GO

Credo che tutti questi funzioneranno meglio della funzione che hai, quando riuscirai a farlo funzionare, soprattutto perché sono in linea anziché multi-istruzione. Non ho studiato perché il tuo non funziona, perché non credo che valga la pena far funzionare quella funzione.

Ma tutto ciò ha detto ...

Dato che stai usando SQL Server 2008, c'è un motivo per cui devi dividere in primo luogo? Preferirei usare un TVP per questo:

CREATE TYPE dbo.strings AS TABLE
(
  string NVARCHAR(4000)
);

Ora puoi accettarlo come parametro per le tue procedure memorizzate e utilizzare i contenuti proprio come faresti con un TVF:

CREATE PROCEDURE dbo.foo
  @strings dbo.strings READONLY
AS
BEGIN
  SET NOCOUNT ON;

  SELECT Asset_ID = string FROM @strings;
  -- SELECT Asset_ID FROM dbo.utvf_split(@other_param, ',');
END

E puoi passare un TVP direttamente da C # ecc. Come DataTable. Questo quasi sicuramente supererà qualsiasi delle soluzioni sopra, specialmente se stai costruendo una stringa separata da virgola nella tua app in modo specifico in modo che la tua procedura memorizzata possa chiamare un TVP per dividerla di nuovo. Per molte più informazioni sui TVP, vedi il grande articolo di Erland Sommarskog .

Più recentemente, ho scritto una serie sulla divisione delle stringhe:

• http://sqlperformance.com/2012/07/t-sql-queries/split-strings
• http://sqlperformance.com/2012/08/t-sql-queries/splitting-strings-follow-up
• http://sqlperformance.com/2012/08/t-sql-queries/splitting-strings-now-with-less-t-sql

E se stai usando SQL Server 2016 o più recente (o Database SQL di Azure), c'è una nuova STRING_SPLITfunzione , di cui ho scritto un blog qui:

• Sorprese e ipotesi sul rendimento: STRING_SPLIT ()
• STRING_SPLIT () in SQL Server 2016: follow-up n. 1
• STRING_SPLIT () in SQL Server 2016: follow-up n. 2

SQL Server 2016 ha introdotto la funzione STRING_SPLIT () . Ha due parametri: la stringa da tagliare e il separatore. L'output è di una riga per valore restituito.

Per l'esempio dato

SELECT * FROM string_split('one,two,three,four', ',');

sarà di ritorno

value
------------------
one
two
three
four

Sto usando e amando lo splitter di stringa di Jeff Moden da quando è uscito.

Tally OH! Una funzione "CSV Splitter" SQL 8K migliorata

CREATE FUNCTION [dbo].[DelimitedSplit8K]
--===== Define I/O parameters
        (@pString VARCHAR(8000), @pDelimiter CHAR(1))
--WARNING!!! DO NOT USE MAX DATA-TYPES HERE!  IT WILL KILL PERFORMANCE!
RETURNS TABLE WITH SCHEMABINDING AS
 RETURN
--===== "Inline" CTE Driven "Tally Table" produces values from 1 up to 10,000...
     -- enough to cover VARCHAR(8000)
  WITH E1(N) AS (
                 SELECT 1 UNION ALL SELECT 1 UNION ALL SELECT 1 UNION ALL
                 SELECT 1 UNION ALL SELECT 1 UNION ALL SELECT 1 UNION ALL
                 SELECT 1 UNION ALL SELECT 1 UNION ALL SELECT 1 UNION ALL SELECT 1
                ),                          --10E+1 or 10 rows
       E2(N) AS (SELECT 1 FROM E1 a, E1 b), --10E+2 or 100 rows
       E4(N) AS (SELECT 1 FROM E2 a, E2 b), --10E+4 or 10,000 rows max
 cteTally(N) AS (--==== This provides the "base" CTE and limits the number of rows right up front
                     -- for both a performance gain and prevention of accidental "overruns"
                 SELECT TOP (ISNULL(DATALENGTH(@pString),0)) ROW_NUMBER() OVER (ORDER BY (SELECT NULL)) FROM E4
                ),
cteStart(N1) AS (--==== This returns N+1 (starting position of each "element" just once for each delimiter)
                 SELECT 1 UNION ALL
                 SELECT t.N+1 FROM cteTally t WHERE SUBSTRING(@pString,t.N,1) = @pDelimiter
                ),
cteLen(N1,L1) AS(--==== Return start and length (for use in substring)
                 SELECT s.N1,
                        ISNULL(NULLIF(CHARINDEX(@pDelimiter,@pString,s.N1),0)-s.N1,8000)
                   FROM cteStart s
                )
--===== Do the actual split. The ISNULL/NULLIF combo handles the length for the final element when no delimiter is found.
 SELECT ItemNumber = ROW_NUMBER() OVER(ORDER BY l.N1),
        Item       = SUBSTRING(@pString, l.N1, l.L1)
   FROM cteLen l
;

CREATE FUNCTION [dbo].[fnSplit]
(

    @sInputList VARCHAR(8000),         -- List of delimited items

    @sDelimiter VARCHAR(8000) = ','    -- delimiter that separates items

)
RETURNS @List TABLE (colData VARCHAR(8000))

BEGIN

DECLARE @sItem VARCHAR(8000)

    WHILE CHARINDEX(@sDelimiter,@sInputList,0) <> 0

    BEGIN

        SELECT @sItem=RTRIM(LTRIM(SUBSTRING(@sInputList,1,CHARINDEX
(@sDelimiter,@sInputList,0)-1))),

        @sInputList=RTRIM(LTRIM(SUBSTRING(@sInputList,CHARINDEX(@sDelimiter,@sInputList,0)
+LEN(@sDelimiter),LEN(@sInputList))))

        IF LEN(@sItem) > 0
            INSERT INTO @List SELECT @sItem
        END

        IF LEN(@sInputList) > 0
            INSERT INTO @List SELECT @sInputList -- Put the last item in
        RETURN
    END

--TEST

--Example 1: select * from fnSplit('1,22,333,444,,5555,666', ',')

--Example 2: select * from fnSplit('1##22#333##444','##')  --note second colData has embedded #

--Example 3: select * from fnSplit('1 22 333 444  5555 666', ' ')