Simple question. Wondering if your lengthy IN clause is really a code smell? I do not really understand how to justify it. I can not put my finger on why it smells apart from that It does.

from us_states
  code in
    ('NJ', 'NY', 'PA', 'CA', 'AL', 'AK', 'AZ',
    'IL', 'IN', 'KY', 'KS', 'DC', 'MD', 'MA')

So how exactly does a database typically implement this type of research? Is really a temporary table made and became a member of to? Or perhaps is it simply broadened into a number of logical ORs?

It feels as though it will happen to be a join...

I am not to imply all IN clauses can be harmful. Sometimes you cannot help it to. But you will find certain cases (specially the longer they get) in which the group of elements you are matching against really originates from somewhere. And should not that be became a member of on rather?

Could it be worth creating (through the application level) a brief table which has all of the elements you need to search against after which carrying out a real join against that?

select u.*
from us_states u

join #chosen_states t
on u.code = t.code

It is really a code smell. To begin with, databases have limits regarding the quantity of elements permitted within an IN clause, and when your SQL is produced dynamically, you might eventually bump facing individuals limits.

Once the list begins being lengthy-ant, I'd become utilizing a saved procedure having a temporary table, to prevent any possibility of errors.

I doubt performance is really a major concern though, IN clauses are extremely fast, as they possibly can short-circuit, unlike NOT IN clauses.

I too contemplate it a 'smell'. An IN clause may, to some casual observer, look like a set, list, bag, table, etc but is not.

Based on the SQL Standards, your IN clause is basically syntactic sugar for

 code = 'NJ' OR code = 'NY' OR code = 'PA' OR code = 'CA' 
    OR code = 'AL' OR code = 'AK' OR code = 'AZ' 
    OR code = 'IL' OR code = 'IN' OR code = 'KY' 
    OR code = 'KS' OR code = 'DC' OR code = 'MD' 
    OR code = 'MA'

I'd expect an average parser to grow out an IN clause in exactly by doing this I understand SQL Server does since the nice, neat IN clauses I personally use to produce certain CHECK constraints become an ugly group of OR clauses after i examine the constraint's definition within the INFORMATION_SCHEMA. YMMV: if you're worried about performance, test.

There's a design guideline that states, when the group of values is small , stable then make use of an IN clause, otherwise make use of a table. Whether 14 from 52 is 'small' is subjective. Whether a little table is better indexed may rely on how it's became a member of with other tables: this SO question might be a helpful reference.

Could it be worth creating (through the application level) a brief table.

The issue with IN is it does not make use of an index and also the comparison (worst situation: x14 here) will get repeated for each row inside your source table.

Developing a temp table may be beneficial, should you put a catalog around the join fields.
This way the query can research the worthiness directly, utilizing a BTree index which should just take three or four evaluations worst situation log2(14) = 3.something
That is considerably faster.

If you are wise you may also make use of a hash-index by which situation the DB only must do 1 comparison, speeding your query up 3 fold in comparison towards the btree index.

Strategies for utilizing a temp table
Make certain to utilize a memory table
Make use of a hash index as the primary key.
Try to perform the card inserts in a single statement.

The semi-constant time you'll spend creating the temp-table is going to be dwarfed through the speedup due to the O(1) research time while using hash index.

I'm not sure it's a code smell, exactly. Sometimes you've just got a lengthy listing of things in which your problem could exist.

For creating a temp table (or perhaps a research table) using the elements and joining against (as well as carrying out a where [column] in (select [lookup] from [lookuptable]) is just one of my preferred techniques IFF* a) You will find a lot of values that b) can change rarely when.

*: "If and Only When"