Question: I need to do some in-memory merging in C# of two sorted streams of strings coming from one or more SQL Server 2000 databases into a single sorted stream. These streams of data can be huge, so I don't want to pull both streams into memory. Instead, I need to keep one item at a time from each stream in memory and at each step, compare the current item from each stream, push the minimum onto the final stream, and pull the next item from the appropriate source stream. To do this correctly, though, the in-memory comparison has to match the collation of the database (consider the streams `[A,B,C]` and `[A,B,C]`: the correct merged sequence is `[A,A,B,B,C,C]`, but if your in-memory comparison thinks `C < B`, your in-memory merge will yield `A,A,B`, at which point it will be looking at a `B` and a `C`, and will yield the `C`, resulting in an incorrectly sorted stream.)

So, my question is: is there any way to mimic any of the collations in SQL Server 2000 with a `System.StringComparison` enum in C# or vise-versa? The closest I've come is to use `System.StringCompaison.Ordinal` with the results of the database strings converted to `VARBINARY` with the standard `VARBINARY` ordering, which works, but I'd rather just add an `"order by name collate X"` clause to my SQL queries, where X is some collation that works exactly like the `VARBINARY` ordering, rather than converting all strings to `VARBINARY` as they leave the database and then back to strings as they come in memory.

Answer: 
Wow, the answers are all over the map. So the [Documentation](http://doc.ddart.net/mssql/sql2000/html/createdb/cm_8_des_04_8ypg.htm) says:

A FOREIGN KEY constraint is a candidate for an index because:

* Changes to PRIMARY KEY constraints are checked with FOREIGN KEY constraints in related tables.
* Foreign key columns are often used in join criteria when the data from related tables is combined in queries by matching the column(s) in the FOREIGN KEY constraint of one table with the primary or unique key column(s) in the other table. An index allows Microsoft® SQL Server™ 2000 to find related data in the foreign key table quickly. However, creating this index is not a requirement. Data from two related tables can be combined even if no PRIMARY KEY or FOREIGN KEY constraints are defined between the tables, but a foreign key relationship between two tables indicates that the two tables have been optimized to be combined in a query that uses the keys as its criteria.

So it seems pretty clear (although the documentation is a bit muddled) that it does not in fact create an index.
Strictly speaking, foreign keys have absolutely nothing to do with indexes, yes. But, as the speakers above me pointed out, it makes sense to create one to speed up the FK-lookups. In fact, in MySQL, if you don't specify an index in your FK declaration, the engine (InnoDB) creates it for you automatically.