Print the position of commas in a given string in T-SQL - sql-server

Question

I want to print the position of commas in a given comma separated string, but i'm just getting only zeros.
Here is the code I wrote:
declare #begin int=0
declare #temp int=1
declare #count int=0
declare #Name nvarchar(MAX)='siva,lahsh,dsjhdsd,hjdhjds,ddjhds,yrehrf'
declare #max nvarchar(20)
set #max=len(#Name)-len(replace(#Name,',',''))
create table #table(delimiter int)
while #count>=#max
begin
set #temp=CHARINDEX(',',#Name,#begin)
set #begin=#temp+1
insert into #table(delimiter) values(#temp)
set #count+=1
end
select delimiter from #table
Any help?

Answer 1

Well, your logic is all wrong in several places... here's a fixed version that works:
declare #begin int=0
declare #temp int=1
declare #count int=0
declare #Name nvarchar(MAX)='siva,lahsh,dsjhdsd,hjdhjds,ddjhds,yrehrf'
declare #max nvarchar(20)
set #max=len(#Name)
IF OBJECT_ID('tempdb..#table') IS NOT NULL DROP TABLE #table
create table #table(delimiter int)
while CHARINDEX(',',#Name,#begin) > 0
begin
set #temp=CHARINDEX(',',#Name,#begin)
set #begin=#temp+1
insert into #table(delimiter) values(#temp)
set #count+=1
end
select delimiter from #table
Basically, your loop control was completely off, as was your initialization of #max. And you don't even really need "max", but I just made the tweaks to your code so you can see what changed. I'll leave it as an exercise to optimize it further.
Of course, I'm not sure why you want to do this... nothing about this seems like a reasonable solution to any reasonable problem I can think of. Maybe you could provide more detail about what it is you're actually trying to do...

Answer 2

using a CSV Splitter table valued function by Jeff Moden and sum() over() to sum the length of the parsed value +1 to report the delimiter position:
declare #Name nvarchar(MAX)='siva,lahsh,dsjhdsd,hjdhjds,ddjhds,yrehrf';
select s.*
, Delimiter = sum(len(Item)+1) over (order by ItemNumber)
from dbo.delimitedsplitN4K(#Name,',') s
rextester demo: http://rextester.com/BXD20065
returns:
+------------+---------+-----------+
| ItemNumber | Item | Delimiter |
+------------+---------+-----------+
| 1 | siva | 5 |
| 2 | lahsh | 11 |
| 3 | dsjhdsd | 19 |
| 4 | hjdhjds | 27 |
| 5 | ddjhds | 34 |
| 6 | yrehrf | 41 | <-- 41 is not a comma, but it is the end of the string+1
+------------+---------+-----------+
splitting strings reference:
Tally OH! An Improved SQL 8K “CSV Splitter” Function - Jeff Moden
Splitting Strings : A Follow-Up - Aaron Bertrand
Split strings the right way – or the next best way - Aaron Bertrand
string_split() in SQL Server 2016 : Follow-Up #1 - Aaron Bertrand
create function dbo.DelimitedSplitN4K (
#pString nvarchar(4000)
, #pDelimiter nchar(1)
)
returns table with schemabinding as
return
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
)
, e2(n) as (select 1 from e1 a, e1 b)
, e4(n) as (select 1 from e2 a, e2 b)
, cteTally(n) as (select top (isnull(datalength(#pString)/2,0))
row_number() over (order by (select null)) from e4)
, cteStart(n1) as (select 1 union all
select t.n+1 from cteTally t where substring(#pString,t.n,1) = #pDelimiter)
, cteLen(n1,l1) as(select s.n1
, isnull(nullif(charindex(#pDelimiter,#pString,s.n1),0)-s.n1,4000)
from cteStart s
)
select ItemNumber = row_number() over(order by l.n1)
, Item = substring(#pString, l.n1, l.l1)
from cteLen l;
go

Answer 3

A few things to consider...
First - if you don't need #name to be nvarchar(max) you should change it to nvarchar(4000). nvarchar(max) will kill performance (Jeff actually includes this in the comment portion of his function). If you DO have strings longer than 4000 - then the solution SqlZim posted will be wrong.
Though I love Jeff Moden's splitter, it is not the right tool for this job. SqlZim's solution will be very inefficient and, as he pointed out, returns one bad row (a problem with no inexpensive way to resolve.) Solving this problem using a loop & temp table is even worse.
I have a function that is designed for EXACTLY this type of thing. I just created an nvarchar(4000) version tonight for this problem. You can read more about it here. Nasty Fast N-Grams (Part 1): Character-Level Unigrams
Here's the nvarchar(4000) version I just finished developing:
CREATE FUNCTION dbo.NGramsN4K
(
#string nvarchar(4000), -- Input string
#N int -- requested token size
)
/****************************************************************************************
Purpose:
A character-level N-Grams function that outputs a contiguous stream of #N-sized tokens
based on an input string (#string). Accepts strings up to 4000 nvarchar characters long.
For more information about N-Grams see: http://en.wikipedia.org/wiki/N-gram.
Compatibility:
SQL Server 2008+, Azure SQL Database
Syntax:
--===== Autonomous
SELECT position, token FROM dbo.NGramsN4K(#string,#N);
--===== Against a table using APPLY
SELECT s.SomeID, ng.position, ng.token
FROM dbo.SomeTable s
CROSS APPLY dbo.NGramsN4K(s.SomeValue,#N) ng;
Parameters:
#string = The input string to split into tokens.
#N = The size of each token returned.
Returns:
Position = bigint; the position of the token in the input string
token = nvarchar(4000); a #N-sized character-level N-Gram token
Developer Notes:
1. NGramsN4K is not case sensitive
2. Many functions that use NGramsN4K will see a huge performance gain when the optimizer
creates a parallel execution plan. One way to get a parallel query plan (if the
optimizer does not chose one) is to use make_parallel by Adam Machanic which can be
found here:
sqlblog.com/blogs/adam_machanic/archive/2013/07/11/next-level-parallel-plan-porcing.aspx
3. When #N is less than 1 or greater than the datalength of the input string then no
tokens (rows) are returned. If either #string or #N are NULL no rows are returned.
This is a debatable topic but the thinking behind this decision is that: because you
can't split 'xxx' into 4-grams, you can't split a NULL value into unigrams and you
can't turn anything into NULL-grams, no rows should be returned.
For people who would prefer that a NULL input forces the function to return a single
NULL output you could add this code to the end of the function:
UNION ALL
SELECT 1, NULL
WHERE NOT(#N > 0 AND #N <= DATALENGTH(#string)) OR (#N IS NULL OR #string IS NULL);
4. NGramsN4K is deterministic. For more about deterministic functions see:
https://msdn.microsoft.com/en-us/library/ms178091.aspx
Usage Examples:
--===== Turn the string, 'abcd' into unigrams, bigrams and trigrams
SELECT position, token FROM dbo.NGramsN4K('abcd',1); -- unigrams (#N=1)
SELECT position, token FROM dbo.NGramsN4K('abcd',2); -- bigrams (#N=2)
SELECT position, token FROM dbo.NGramsN4K('abcd',3); -- trigrams (#N=3)
--===== How many times the substring "AB" appears in each record
DECLARE #table TABLE(stringID int identity primary key, string nvarchar(100));
INSERT #table(string) VALUES ('AB123AB'),('123ABABAB'),('!AB!AB!'),('AB-AB-AB-AB-AB');
SELECT string, occurances = COUNT(*)
FROM #table t
CROSS APPLY dbo.NGramsN4K(t.string,2) ng
WHERE ng.token = 'AB'
GROUP BY string;
----------------------------------------------------------------------------------------
Revision History:
Rev 00 - 20170324 - Initial Development - Alan Burstein
****************************************************************************************/
RETURNS TABLE WITH SCHEMABINDING AS RETURN
WITH
L1(N) AS
(
SELECT 1 FROM (VALUES -- 64 dummy values to CROSS join for 4096 rows
($),($),($),($),($),($),($),($),($),($),($),($),($),($),($),($),
($),($),($),($),($),($),($),($),($),($),($),($),($),($),($),($),
($),($),($),($),($),($),($),($),($),($),($),($),($),($),($),($),
($),($),($),($),($),($),($),($),($),($),($),($),($),($),($),($)) t(N)
),
iTally(N) AS
(
SELECT
TOP (ABS(CONVERT(BIGINT,((DATALENGTH(ISNULL(#string,''))/2)-(ISNULL(#N,1)-1)),0)))
ROW_NUMBER() OVER (ORDER BY (SELECT NULL)) -- Order by a constant to avoid a sort
FROM L1 a CROSS JOIN L1 b -- cartesian product for 4096 rows (16^2)
)
SELECT
position = N, -- position of the token in the string(s)
token = SUBSTRING(#string,CAST(N AS int),#N) -- the #N-Sized token
FROM iTally
WHERE #N > 0 AND #N <= (DATALENGTH(#string)/2); -- Protection against bad parameter values
GO
... and now for a quick, 1-row test (with actual execution plan turned on):
SET NOCOUNT ON;
declare #Name nvarchar(MAX)='siva,lahsh,dsjhdsd,hjdhjds,ddjhds,yrehrf';
-- comparing IO:
SET STATISTICS IO ON;
--NGramsN4K
PRINT 'NGramsN4K:'+char(13)+char(10)+replicate('-',50)+char(13)+char(10)+char(13)+char(10);
SELECT position
FROM dbo.NGramsN4K(#name,1)
WHERE token = ',';
--delimitedsplitN4K
PRINT 'delimitedsplitN4K-based solution'+char(13)+char(10)+replicate('-',50);
select Delimiter = sum(len(Item)+1) over (order by ItemNumber)
from dbo.delimitedsplitN4K(#Name,',') s;
SET STATISTICS IO OFF;
The results:
position
--------------------
5
11
19
27
34
Delimiter
-----------
5
11
19
27
34
41
The plans:
... and the IO stats:
NGramsN4K:
--------------------------------------------------
delimitedsplitN4K-based solution
--------------------------------------------------
Table 'Worktable'. Scan count 7, logical reads 37, physical reads 0, read-ahead reads 0, lob logical reads 0, lob physical reads 0, lob read-ahead reads 0.
37 reads for one row is very bad.