It's easy to become complacent about saving disk space when hard disk sizes keep growing and disk prices keep on dropping, but saving a few bytes here and there can help improve SQL Server performance considerably.
If you have ever looked at an Execution Plan for a SQL Server query (and if you haven't, you should!) you will see that SQL Server produces an estimated "cost" for executing queries. This cost is not in money terms, obviously, but in terms of computer resources required to run the query. The primary component of this costing is disk I/O, so it stands to reason that if we can reduce disk I/O then we reduce the cost of executing a query, and therefore increase performance. In this article we will look at a few ways of doing this.
Here is an fairly extreme example--I created two tables in SQL Server 7 and loaded each with 10,000 4-byte strings.
create table t1 (v char(255) NOT NULL) create table t2 (v varchar(255) NULL)
One table was created using the varchar(255) column type, and the other using the char(255) type. Now, the char(255) type uses a fixed length to store data, so if the string you store is less than 255 characters long, the remaining space is wasted. This is not true with the varchar data type.
Running DBCC SHOWCONTIG against the tables showed that the table with fixed length columns took up 334 pages (a page is 8 Kilobytes in SQL 7 or SQL 2000) of storage space to store 10,000 rows. The version using varchar took up only 23 pages to store the same data. The reduced disk space means that any retrieval operation, and particularly simple table-scanning operations such as SELECT COUNT(1) FROM... run much quicker against the smaller table.
Although this is an extreme example, even small savings can make a big difference. In the next example I re-created the two tables as follows and loaded 10,000 rows into each. (To keep the examples simple I am using one column in each table, but the same applies to tables with any number of columns, it's the total row length that matters)
create table t1 (v char(4000)) create table t2 (v char(4040))
Table t1, when loaded with 10,000 rows, took up 5000 pages of disk space. The row length for table t2 is precisely one percent longer that t1, so you might expect table t2 to take up only one percent more space, but it actually takes up double the number of pages that t1 does. The reason for this is that SQL Server 7 can store up to 8060 bytes of data on one page, so there is plenty of room for two rows from table t1 on each page. However, when we extend the row length to 4040, then only one row will fit on a page, hence we end up using twice as many pages. SQL Server insists on fitting a whole row on a single page, and will never try to save space by splitting a row across two pages.
Again, that was an extreme example, but as a general rule:
- The shorter the row length, the more rows you will fit on a page, and the smaller your table will be.
The effect is even more noticeable in SQL Server 6.5, where the maximum row length is slightly over 2000 bytes.
Some space saving hints:
- Use varchar instead of char unless your data is almost always of a fixed length, or is very short anyway.
- Using Unicode double-byte datatypes such as nchar and nvarchar take up double (Duh!) the space, so avoid them unless you really need them.
- Use smallint and tinyint to save one or three bytes a time if you do not need the big numbers, and use integers instead of Float or Numeric wherever suitable.
- Using smalldatetime instead of datetime saves two bytes, if accuracy to the nearest minute is good enough.
- Avoid using GUID columns unless you really need them
These are just a few examples, and you should familiarise yourself with the whole range of datatypes in SQL Server, and choose from them very carefully. You might choose to use the smallmoney data type instead of the money type to save 4 bytes a time, but the values this data type can handle are comparatively small, especially if you are dealing with currencies like Japanese Yen or Italian Lira. If you choose a data type that you will eventually outgrow, then this will cause more problems than it's worth.
Remember that indexes also take up space, so if you keep your indexes small (create only indexes that you are going to use, use short columns in indexes, and refrain from using long compound indexes if possible) you can improve performance in this way too.
Read up on the fillfactor and pad_index options for indexes. In general, SQL Server leaves blank space in it's indexes to allow for later additions, but if you are indexing a table that never, or very rarely, changes, then you can adjust the fill factor to save space and increase performance.
For tables that change more often, it's important to do regular table and index maintenance to keep your data compact and efficiently accessible.
Keeping your data as compact as possible does not only reduce the size of your data on disk, it provides other benefits too:
- You can fit more data into your cache RAM, increasing your cache hit ratio and reducing disk I/O even further.
- Smaller and faster backups.
- Less traffic when moving data over the network.
- Faster joins (short columns are easier to compare than long ones)
All the following subjects are well documented on Books Online, and a Quick Guide to most of the topics can be found at my own home page.
- SQL Server Datatypes
- Estimating space usage
- Choosing efficient indexes
- Reading query execution plans
- Table and Index maintenance