In discussing indexes and primary keys, it's helpful to distinguish the view of each in RDB theory and implementation.
In the theory, a "primary key" is a minimal set of fields such that the other fields in the row are functionally dependent on the key. The primary key for a table is a candidate key. There is only one primary key for a table, while there can be multiple candidate keys.
In practice, MySQL primary keys are unique, non-null, indexed fields.

Originally Posted by
fguy64
As I see it, loosely defined, an index field is a specially defined field in a table that aids in query and sort operations
A more useful view is to talk about indexed fields. An index is not a property of fields or a special field but (in practice) a separate data structure that refers to the table and that can increase performance. From the theoretical viewpoint, an index is entirely redundant. It's useful in the theory for query optimizations, but not for table design.

Originally Posted by
fguy64
if you wanted to link to another table, say orders, then the last name would not be appropriate. intuitively, you can imagine the trouble you would run into with a large number of customers and you queried something like (show me all the orders from Smith). Cause Smith is not unique.
Non-intuitively, last name is not a foreign key because it's not a candidate key (i.e. the other fields in both tables aren't functionally dependent on last name).

Originally Posted by
fguy64
Is it correct to say that a primary key field is just an index field whose values are unique. ?
That's almost true in terms of (some) implementations. In MySQL, a primary key is implemented with a unique, non-null index. In RDB theory, a primary key doesn't involve an index.

Originally Posted by
garrettroyce
Logically though, a unique field can be null, as long as that column only has one row with a null.
True for MSSQL, but not for MySQL and PostgreSQL. Since NULL isn't equal to NULL, you can have an arbitrary number of rows with a NULL in a UNIQUE field. This is conceptually sound because NULL means "missing value" or "field inapplicable". For example, a driver's license field might be UNIQUE (as no two drivers in one state will have the same ID) but allow multiple NULL values (as not everyone drives).
Try this:
Code:
CREATE TABLE nullable (
id INT UNIQUE DEFAULT NULL,
value VARCHAR(64) NOT NULL
);
INSERT INTO nullable (value) VALUES ('foo'), ('bar');
SELECT * FROM nullable;
Indexing a NULL-able column isn't "good" or "bad" from a design standpoint. Remember, indexes are about performance, and you will usually get a performance gain when you query against an indexed field. Whether a column should allow NULL values is entirely dependent on whether it makes sense to allow for missing values or inapplicable fields. For example, to handle people like Cher and Madonna who don't have last names, a "last name" column should allow NULLs. Note that you'll probably end up indexing the last name field. This isn't to say that "if you find yourself indexing a NULLable column, re-examine your table design" isn't a useful rubric for some people, just that if you follow other design principles, it isn't needed.
Much of table design comes from database normalization, which involves the notions of "keys" and "dependencies". Maurer and Scherbakov's "Relational Data Model" looks to be a decent text on the subject. For other information on RDB design, look to Codd's seminal "A Relational Model of Data for Large Shared Data Banks".