We have a table with a CreateDateTime PK. The program that does the inserts is multithreaded. Obviously, this is not thread safe. There is a 3 column composite key that can be made from existing data in the table. This is a logging table and the traffic is expected to be high. Performance is the main concern.
One of our developers believes that because the way SQL internally stores datetime’s (Epoch?), DateTime is an optimal PK for performance reasons.
I suggested we create a composite key out of 3 columns. Will this key change negatively impact performance?
It has also been suggested that we use GUID PK’s. Once again, performance is in question.
Is it best to switch over to a composite key? If yes, how can we address/explain these performance concerns?
GUIDs may seem to be a natural choice for your primary key – and if you really must, you could probably argue to use it for the PRIMARY KEY of the table. What I’d strongly recommend not to do is use the GUID column as the clustering key, which SQL Server does by default, unless you specifically tell it not to.
You really need to keep two issues apart:
1) the primary key is a logical construct – one of the candidate keys that uniquely and reliably identifies every row in your table. This can be anything, really – an INT, a GUID, a string – pick what makes most sense for your scenario.
2) the clustering key (the column or columns that define the “clustered index” on the table) – this is a physical storage-related thing, and here, a small, stable, ever-increasing data type is your best pick – INT or BIGINT as your default option.
By default, the primary key on a SQL Server table is also used as the clustering key – but that doesn’t need to be that way! I’ve personally seen massive performance gains when breaking up the previous GUID-based Primary / Clustered Key into two separate key – the primary (logical) key on the GUID, and the clustering (ordering) key on a separate INT IDENTITY(1,1) column.
As Kimberly Tripp – the Queen of Indexing – and others have stated a great many times – a GUID as the clustering key isn’t optimal, since due to its randomness, it will lead to massive page and index fragmentation and to generally bad performance.
Yes, I know – there’s
newsequentialid()in SQL Server 2005 and up – but even that is not truly and fully sequential and thus also suffers from the same problems as the GUID – just a bit less prominently so.Then there’s another issue to consider: the clustering key on a table will be added to each and every entry on each and every non-clustered index on your table as well – thus you really want to make sure it’s as small as possible. Typically, an INT with 2+ billion rows should be sufficient for the vast majority of tables – and compared to a GUID as the clustering key, you can save yourself hundreds of megabytes of storage on disk and in server memory.
Quick calculation – using INT vs. GUID as Primary and Clustering Key:
TOTAL: 25 MB vs. 106 MB – and that’s just on a single table!
Some more food for thought – excellent stuff by Kimberly Tripp – read it, read it again, digest it! It’s the SQL Server indexing gospel, really.
As for composite keys : the main drawback in my opinion is the fact that all tables that want to reference this composite PK now have to have a composite FK with all the columns defined in the composite PK. This gets really unwieldy when you have a lot of queries that need to join child tables to a table with this composite keys.
DATEITMEalone doesn’t seem like a good idea for a primary key – in SQL Server, theDATETIMEhas an accuracy of 3.33ms, so there’s a good chance in a busy system that you’ll have non-unique values – not a good idea for a PK !If performance is your utmost priority, then I would definitely recommend a single
INT IDENTITYcolumn (even if it’s a surrogate column) to be used for your unique, clustered primary key index.