This is day three of the SQL Advent 2012 series of blog posts. Today we are going to look at sargable queries. You might ask yourself, what is this weird term sargable. Sargable comes from searchable argument, sometimes also referred as Search ARGument ABLE. What that means is that the query will be able to use an index, a seek will be performed instead of a scan. In general any time you have a function wrapped around a column, an index won't be used

Some examples that are not sargable

Those three should be rewritten like this in order to become sargable

Let's create a table, insert some data so that we can look at the execution plan
Create this simple table

Let's insert some data that will start with a letter followed by some digits

That insert should have generated 32768 rows

Now create this index on that table

Let's take a look at the execution plan, hit CTRL + M, this will add the execution plan once the query is done running

Here is what the plans looks like

As you can see it is 9% versus 91% between the two queries, that is a big difference
Hit CTRL + M again to disable the inclusion of the plan

Run this codeblock, it will give you the plans in a text format

Here are the two plans

|--Clustered Index Seek(OBJECT:([master].[dbo].[Test].[cx_test]),
SEEK:([master].[dbo].[Test].[SomeID] >= 'Rþ' AND [master].[dbo].[Test].[SomeID] < 'T'),
WHERE:([master].[dbo].[Test].[SomeID] like 's%') ORDERED FORWARD)

|--Clustered Index Scan(OBJECT:([master].[dbo].[Test].[cx_test]),
WHERE:(substring([master].[dbo].[Test].[SomeID],(1),(1))='s'))

As you can see the top one while looking more complicated is actually giving you a seek

Making a case sensitive search sargable

Now let's take a look at how we can make a case sensitive search sargable as well
In order to do a search and make it case sensitive, you have to have a case sensitive collation, if your table is not created with a case sensitive collation then you can supply it as part of the query

Here is an example to demonstrate what I mean

This is a simple table created without a collation

Running this select statement will return both rows

Val
-----
A
a

Now create the same kind of table but with a case sensitive collation

Run the same query

Val
-----
A

As you can see you only get the one row now that matches the case

Val
-----
A
a

Now let's take a look at how we can make the case sensitive search sargable

First create this table and insert some data

Now we will insert some lowercase characters

Now we will create our real table which will have 65536 rows

We will do a couple of cross joins to generate the data for our queries

Create an index on the table

Just like before, if we run this we will get back the exact value we passed in and also all the upper case and lower case variations

Here are the results of that query
Val
-----
AbCd
ABcd
Abcd
ABCd
aBCd
abCd
aBcd
abcd
abCD
aBcD
abcD
aBCD
ABCD
AbCD
ABcD
AbcD

If you add the collation to the query, you will get only what matches your value

Here is the result, it maches what was passed in
Val
---
ABCD


The problem with the query above is that it will cause a scan. So what can we do, how can we make it perform better? It is simple combine the two queries
First grab all case sensitive and case insensitive values and then after that filter out the case insensitive values

Here is what that query will look like

AND Val LIKE 'ABCD' will result in a seek, now when it also does the Val = 'ABCD' COLLATE SQL_Latin1_General_CP1_CS_AS part, it only returns the row that matches your value

If you run both queries, you can look at the plan difference (hit CTRL + M so that the plan is included)

Here is the plan

As you can see, there is a big difference between the two

Here is the plan in text as well

|--Table Scan(OBJECT:([tempdb].[dbo].[CaseSensitiveSearch]),
WHERE:(CONVERT_IMPLICIT(varchar(50),[tempdb].[dbo].[CaseSensitiveSearch].[Val],0)=CONVERT(varchar(8000),[@1],0)))

|--Index Seek(OBJECT:([tempdb].[dbo].[CaseSensitiveSearch].[IX_SearchVal]), SEEK:([tempdb].[dbo].[CaseSensitiveSearch].[Val] >= 'ABCD'
AND [tempdb].[dbo].[CaseSensitiveSearch].[Val] <= 'ABCD'),
WHERE:(CONVERT_IMPLICIT(varchar(50),[tempdb].[dbo].[CaseSensitiveSearch].[Val],0)='ABCD' AND [tempdb].[dbo].[CaseSensitiveSearch].[Val] like 'ABCD') ORDERED FORWARD)

Also take a look at Only In A Database Can You Get 1000% + Improvement By Changing A Few Lines Of Code to see how this works with dates

That is all for day three of the SQL Advent 2012 series, come back tomorrow for the next one, you can also check out all the posts from last year here: SQL Advent 2011 Recap