### What is Soundex?

[**Soundex**][1] is:

> a phonetic algorithm for indexing names by sound, *as pronounced **in English***; first developed by Robert C. Russell and Margaret King Odell in 1918

### How does it Work?

There are several implementations of Soundex, but most implement the following steps:

1. Retain the first letter of the name and drop all other occurrences of vowels and `h,w`:  
  `|a, e, i, o, u, y, h, w  | → ""  |`  
2. Replace consonants with numbers as follows (after the first letter):  
  `| b, f, p, v             | →  1  |`  
  `| c, g, j, k, q, s, x, z | →  2  |`  
  `| d, t                   | →  3  |`  
  `| l                      | →  4  |`  
  `| m, n                   | →  5  |`  
  `| r                      | →  6  |` 
3. Replace identical adjacent numbers with a single value (*if they were next to each other prior to step 1*):  
  `| M33                    | → M3   |`   
4. *Cut* or *Pad* with zeros or cut to produce a 4 digit result:  
  `| M3                     | → M300 |`   
  `| M34123                 | → M341 |`   

Here's an interactive demo in [**jsFiddle**][2]:

[![jsFiddle Demo][3]][2show]

And here's a demo in SQL using [**SQL Fiddle**][7]

In SQL Server, [`SOUNDEX`][4] is often used in conjunction with [`DIFFERENCE`][5], which is used to score how many of the resulting digits are identical (just like the game mastermind<sup>†</sup>), with higher numbers matching most closely.

[![Mastermind][6]][6]


### What are the Alternatives?

It's important to understand the limitations and criticisms of soundex and where people have tried to improve it, notably only being rooted in English pronunciation and also [discards a lot of data, resulting in more false positives][11].

-----

Both [**Metaphone**][8] & [**Double Metaphone**][9] still focus on English pronunciations, but add much more granularity to the [nuances of speech in Enlgish][10] (ie. `PH` → `F`)

Phil Factor wrote a [Metaphone Function in SQL][13] with the [source on github][12]

----

Soundex is most commonly used on identifying similar names, and it'll have a really hard time finding any **similar nicknames** (i.e. `Robert` → `Rob` or `Bob`).  Per this question on a [Database of common name aliases / nicknames of people][14], you could incorporate a lookup against similar nicknames as well in your matching process.  

Here are a couple free lists of common nicknames:

* [**SOEMPI** - `name_to_nick.csv` | Github][15]
* [**carltonnorthern** - `names.csv` | Github][16]


### Further Reading:

* [Fuzzy matching using T-SQL][17]
* [SQL Server – Do You Know Soundex Functions?][18]


  [2show]: http://jsfiddle.net/KyleMit/zyjLph3n/show
  [1]: https://en.wikipedia.org/wiki/Soundex
  [2]: http://jsfiddle.net/KyleMit/zyjLph3n/
  [3]: https://i.stack.imgur.com/g04t6.png
  [4]: https://learn.microsoft.com/en-us/sql/t-sql/functions/soundex-transact-sql
  [5]: https://learn.microsoft.com/en-us/sql/t-sql/functions/difference-transact-sql
  [6]: https://i.stack.imgur.com/KPCBj.png
  [7]: http://sqlfiddle.com/#!18/9eecb/30588
[8]: https://en.wikipedia.org/wiki/Metaphone
[9]: https://en.wikipedia.org/wiki/Metaphone#Double_Metaphone
[10]: https://en.wikipedia.org/wiki/Ghoti
[11]: https://stackoverflow.com/a/6576522/1366033
[12]: https://github.com/Phil-Factor/SQLMetaPhone/blob/master/SQLMetaphone.sql
[13]: https://www.red-gate.com/simple-talk/blogs/string-comparisons-sql-metaphone-algorithm/
[14]: https://stackoverflow.com/q/2381522/1366033
[15]: https://github.com/MrCsabaToth/SOEMPI/blob/master/openempi/conf/name_to_nick.csv
[16]: https://github.com/carltonnorthern/nickname-and-diminutive-names-lookup/blob/master/names.csv
[17]: https://stackoverflow.com/q/921978/1366033
[18]: http://www.sqlservergeeks.com/sql-server-do-you-know-soundex-functions/

Here's an example of Soundex code in SQL:



    SELECT SOUNDEX('Smith'), SOUNDEX('Smythe');
    ----- ----- 
    S530  S530  

How does `'Smith'` become `S530`?

In this example, the first digit is `S` because that's the first character in the input expression, but how are the remaining three digits are calculated?