# Tame Those Strings! Part 2 – CHARINDEX

## Introduction

It’s time to talk about string manipulation. What is it? Why do it? When should we do it?
string manipulation techniques that I used to solve another problem. If you are new, I write about
specific problems, not general ones, in general :), so I hope you enjoy this and learn something.

## My Problem

I hope that few of you have run into this, but given the experiences I have had, it’s quite likely more than a
this problem. In one table, the developers had decided that they needed to store answers to questions asked on the
website. Some of the questions that were asked contained multiple possible answers. An example of this type of questions
is shown below:

```1. What types of computers do you have in your company?
A. Servers
B. Workstations
C. Laptops
D. Mainframes
```

From this you can see that the user may choose to select 1, 2, 3, or all 4 of the answers. Not a problem, but the
developers decided that the easiest way to store this information was in a table like this:

```UserID      Answer
------      -----------
1          A,B,C
2          B,C
3          A,C,D
4          D
```

So why is this a problem? Well, how would you find all the people that answered “A”? This one is easy, you would select
all users like this:

No problem. Well, what about all people that answered “B” and “C”? This one is tougher; you could try

It does not work. I want to get this result set:

```UserID    Answer
------    -------
1      A,B,C
2      B,C
3      A,C,D
```

What you end up with is a result that looks like this:

```UserID    Answer
------    -------
1      A,B,C
```

In order to get the result set I want, what I would have to do is union multiple queries.
This really does not scale and as the number of answers grows

## The Solution

The solution in this case was to “bend” that data so that it is in a more normal form. What I mean by this is to take the table
above and change it to look like this:

```UserID    Answer
------    ------
1       A
1       B
1       C
2       B
2       C
3       A
3       C
3       D
4       D
```

With the data in this form, we can more easily build a scalable and self-maintaining solution that will grow and handle
new questions and answers with minimal work from the development staff and (more importantly) the DBA.

## The Code

The objects involved are given below. Since this was corporate code, I have
altered names and schemas slightly to protect my company. Other than name changes and some missing fields for other data, this is
the same code in our database.

• Answer – Table that holds the original data
• NewAnswer – Table that holds the new data
• dbspBendAnswers – stored procedure that “bends”
the data in the Answer table.

In order to extract each answer out and place it in a separate row, I decided to row process
this data one row at a time rather than develop a set oriented solution. I normally frown upon
this type of code, but this needed to be done quickly and was a one-time maintenance
operation with a piece of code that I would have thrown away (if I was not writing this article).

To process this data, I built a cursor of the primary key from this table which was
the userID field and the questionID field. I then looped through this cursor and processed each row’s
answer data. The processing of each row was where the string manipulation came in.

Each row can be formatted as a pattern that looks like this:

```"x,y,z,...,n"
```

where x is a single answer and the number of answers in this field is unknown. However, each field
can also be written in the following manner.

```"x" + ",y" + ",z" + ",..." + ",n"
```

In this format, an algorithm starts to become apparent. If I can delimit each answer by looking at
the commas, then what I need to do is parse this string by finding the location of the
commas. Once I do this, then the SUBSTRING function can easily be used to extract the answers
that are between the commas. If there is no comma in the string, then the assumption is that
this is a single answer, so we insert the entire string as a new answer and loop to the next row
of data.

In my haste to build this, I decided that I would use the charindex function to find commas and
then process the string based on the commas. charindex allows you to find the numeric location
in a string of another string. In other words, it returns the position in any string of
some character that you are looking for (in my case, commas). So if I had the following string:

```'A,B,C'
```

I could run the following code:

```select charindex( ',', 'A,B,C')
```

and get these results:

```------
2
```

Where 2 is the position (2nd character) in the string of the comma. One thing to be
aware of is that only the first occurance of the string is found. So now I have the
location of the first comma. If I include this in a SUBSTRING statement that starts
at the beginning of the string, I can extract the first answer.

```answer
------
A,B,C

select @a = substring( answer, 1, @comma - 1)

select @a

-------
A

```

Now I have a single answer, how does this help me get the rest of the answers? In
my algorithm I have stord the location of the first comma off. What I now do is remove both
the first answer and the first comma from the string. This would result in this code and result:

```select @str = substring( @str, @comma + 1, len( @str))
select @str

------
B,C
```

Now I repeat the process and find the next comma. Again, if I get a zero (0) back
for the location of the comma, I know I have a single answer left, insert it and end
the loop. I check with an IF statement if there is a comma since passing a -1 to the
SUBSTRING function returns an error.

## Conclusion

This is probably not the most elegant or efficient solution, but it does work. And it was very quick
to develop. In fact, it took three or four times as long to write this article as it did to develop the
algorithm, test it, and execute it on my data. I do think, however, that this technique will be useful in
some situations and is a worthwhile addition to the DBA toolbox. I find many times when I need string manipulation, especially in adhoc queries I write. Like any other tool in
SQL Server, it has a time and a place where it is helpful and effective in its application. Spend some time experimenting
and learning about the CHARINDEX() function. It will probably come in handy at some point.

Here is the online reference for
CHARINDEX
for those of you interested.

Steve Jones
)2000 dkranch