Posted By: Anonymous
I have an application that uses GUID as the Primary Key in almost all tables and I have read that there are issues about performance when using GUID as Primary Key. Honestly, I haven’t seen any problem, but I’m about to start a new application and I still want to use the GUIDs as the Primary Keys, but I was thinking of using a Composite Primary Key (The GUID and maybe another field.)
I’m using a GUID because they are nice and easy to manage when you have different environments such as “production”, “test” and “dev” databases, and also for migration data between databases.
I will use Entity Framework 4.3 and I want to assign the Guid in the application code, before inserting it in the database. (i.e. I don’t want to let SQL generate the Guid).
What is the best practice for creating GUID-based Primary Keys, in order to avoid the supposed performance hits associated with this approach?
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:
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
GUID, a string – pick what makes most sense for your scenario.
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 –
BIGINTas 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
GUID as Primary and Clustering Key:
- Base Table with 1’000’000 rows (3.8 MB vs. 15.26 MB)
- 6 nonclustered indexes (22.89 MB vs. 91.55 MB)
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.
- GUIDs as PRIMARY KEY and/or clustered key
- The clustered index debate continues
- Ever-increasing clustering key – the Clustered Index Debate……….again!
- Disk space is cheap – that’s not the point!
PS: of course, if you’re dealing with just a few hundred or a few thousand rows – most of these arguments won’t really have much of an impact on you. However: if you get into the tens or hundreds of thousands of rows, or you start counting in millions – then those points become very crucial and very important to understand.
Update: if you want to have your
PKGUID column as your primary key (but not your clustering key), and another column
INT IDENTITY) as your clustering key – use this:
CREATE TABLE dbo.MyTable (PKGUID UNIQUEIDENTIFIER NOT NULL, MyINT INT IDENTITY(1,1) NOT NULL, .... add more columns as needed ...... ) ALTER TABLE dbo.MyTable ADD CONSTRAINT PK_MyTable PRIMARY KEY NONCLUSTERED (PKGUID) CREATE UNIQUE CLUSTERED INDEX CIX_MyTable ON dbo.MyTable(MyINT)
Basically: you just have to explicitly tell the
PRIMARY KEY constraint that it’s
NONCLUSTERED (otherwise it’s created as your clustered index, by default) – and then you create a second index that’s defined as
This will work – and it’s a valid option if you have an existing system that needs to be “re-engineered” for performance. For a new system, if you start from scratch, and you’re not in a replication scenario, then I’d always pick
ID INT IDENTITY(1,1) as my clustered primary key – much more efficient than anything else!