{"id":89,"date":"2014-05-15T20:35:00","date_gmt":"2014-05-15T19:35:00","guid":{"rendered":"https:\/\/debuggersspace.com\/index.php\/2014\/05\/15\/surrogate-key-in-sql-server\/"},"modified":"2014-05-15T20:35:00","modified_gmt":"2014-05-15T19:35:00","slug":"surrogate-key-in-sql-server","status":"publish","type":"post","link":"https:\/\/debuggersspace.com\/index.php\/2014\/05\/15\/surrogate-key-in-sql-server\/","title":{"rendered":"Surrogate Key in SQL Server?"},"content":{"rendered":"
\n
\n \t<\/i> Read Time:<\/span>6 Minute, 3 Second <\/div>\n\n <\/div>
\n
\nIntroduction<\/b>
A Surrogate Key in SQL Server is a unique identifier for each row in the table. It is just a key. Using this key we can identify a unique row. There is no business meaning for Surrogate Keys. This type of key is either database generated or generated via another application (not supplied by user). 

A Surrogate Key is just unique identifier for each row and it may use as a Primary Key. There is only requirement for a surrogate Primary Key, which is that each row must have a unique value for that column. A Surrogate Key is also known as an artificial key or identity key. It can be used in data warehouses.

A Surrogate Key should have the following characteristics:<\/span><\/div>\n
    \n
  • Unique Value<\/span><\/li>\n
  • The key is generated by the system, in other words automatically generated<\/span><\/li>\n
  • The key is not visible to the user (not a part of the application)<\/span><\/li>\n
  • It is not composed of multiple keys<\/span><\/li>\n
  • There is no semantic meaning of the key<\/span><\/li>\n<\/ul>\n
    \nGenerally, a Surrogate Key is a sequential unique number generated by SQL Server or the database itself. The purpsoe of a Surrogate Key is to act as the Primary Key. There is a slight difference between a Surrogate Key and a Primary Key. Ideally, every row has both a Primary Key and a Surrogate Key. The Primary Key identifies the unique row in the database while the Surrogate Key identifies a unique entity in the model.

    Note that Surrogate Keys are never used with any business logic other than simple Create, Read, Update and Delete (CRUD) operations.

    Example of Surrogate Key<\/b><\/span><\/div>\n
      \n
    • Identity Column in SQL Server<\/span><\/li>\n
    • GUID (Globally Unique Identifier)<\/span><\/li>\n
    • UUID (Universally Unique Identifier)<\/span><\/li>\n<\/ul>\n
      \nHow can we implement Surrogate Key?<\/b>
      There are several ways to implement Surrogate Keys <\/span>as in the following:<\/span><\/div>\n
        \n
      • Auto Incremental key in Database<\/b><\/span>\n
        \nA Surrogate Key can be implementing by an auto incremented key. SQL Server supports an IDENTITY column to perform the auto increment feature. It allows a unique number to be generated when a new record is inserted into the database table.<\/span><\/div>\n
        \n–Syntax for Introducing Auto identity column with Create Table.<\/span><\/span><\/div>\n
        \nCREATE<\/span>TABLE<\/span> [dbo].<\/span>[EmployeeMaster](<\/span><\/span><\/span><\/div>\n
        \n[EmployeeId] [int]IDENTITY<\/span>(<\/span>1,<\/span>1)<\/span>NOT<\/span> NULL,<\/span><\/span><\/span><\/div>\n
        \n[EmployeeCode] [varchar](<\/span>25)<\/span>NULL,<\/span><\/span><\/span><\/div>\n
        \n[EmployeeName] [varchar](<\/span>50)<\/span>NULL,<\/span><\/span><\/span><\/div>\n
        \n[EmailAddress] [varchar](<\/span>50)<\/span>NULL,<\/span><\/span><\/span><\/div>\n
        \n)<\/span><\/span><\/div>\n
        \n–Syntax for Introducing Auto identity column with Create Table.<\/span><\/span><\/div>\n
        \nALTER<\/span>TABLE<\/span> EmployeeMasterADD<\/span> ID INT<\/span>IDENTITY<\/span>(<\/span>1,<\/span>1)<\/span><\/span><\/span><\/div>\n<\/li>\n<\/ul>\n
          \n
        • Manual Incremental key in Database<\/b><\/span>\n
          \nA Surrogate Key can be implemented by manual incremental key. Using the max() function we can find a maximum value of a column and this value is incremented by one. This approach suffers from a performance problem when a table has a large amount of data.<\/span><\/div>\n
          \n–Example<\/span><\/span><\/div>\n
          \nDECLARE<\/span> @newId INT<\/span><\/span><\/span><\/div>\n
          \nSELECT<\/span> @newId =<\/span> ISNULL<\/span>(<\/span>MAX<\/span>(<\/span>EmployeeId),<\/span>0)<\/span>+<\/span> 1 FROM<\/span> EmployeeMaster<\/span><\/span><\/div>\n
          \nPRINT<\/span> @newId<\/span><\/span><\/div>\n
          \n–The varible @newId can be used as indentifier of newly inserted data.<\/span><\/span><\/div>\n<\/li>\n<\/ul>\n
            \n
          • Globally Unique Identifiers (GUID)<\/b><\/span>\n
            \nGUID is a Microsoft standard that extends Universally Unique Identifier (UUID). Using a NEWID() function we can generate a new GUID in SQL Server. It is a 16 byte GUID.<\/span><\/div>\n
            \n–Example<\/span><\/span><\/div>\n
            \nDECLARE<\/span> @newID UNIQUEIDENTIFIER<\/span><\/span><\/span><\/div>\n
            \nSET<\/span> @newID =<\/span> NEWID<\/span>()<\/span><\/span><\/span><\/div>\n
            \n–The varible @newId can be used as indentifier of newly inserted data.<\/span><\/span><\/div>\n
            \n<\/span><\/b>
            NEWSEQUENTIALID() can be used with DEFAULT constraints on the table column of type uniqueidentifier. We cannot use the NEWSEQUENTIALID() function as a reference in queries.<\/span><\/span><\/div>\n<\/li>\n<\/ul>\n
              \n
            • Universally unique identifier (UUID)<\/b>

              UUID is 128 bit values that are created from hash of the ID of Ethernet card and current data time of SQL Server.<\/span><\/li>\n<\/ul>\n
              \nAdvantages of Surrogate Key<\/b><\/span><\/div>\n
                \n
              • A Surrogate Key does not change so the application cannot lose their reference row in the database.<\/span><\/li>\n
              • If the Primary Key is changed then the related foreign key does not change across the database because the Surrogate Key is used as a reference key. In other words, the Surrogate Key value is never changed, so the foreign key values become stable.<\/span><\/li>\n
              • A Surrogate Key is most often a compact data type such as an integer. A Surrogate Key is less expensive in a “Join” than the compound key.<\/span><\/li>\n
              • Business logic does not something in this key.<\/span><\/li>\n
              • A table always has a uniform Surrogate Key, so some tasks can be easily automated by writing the code table independently.<\/span><\/li>\n
              • There is no locking contention because it is a unique identifier.<\/span><\/li>\n
              • A Surrogate Key does not require an extra field; that helps to save space in the database.<\/span><\/li>\n
              • The relationship between any two tables is simple and consistent in SQL code expressions.<\/span><\/li>\n
              • Object Relational Mapping (ORM) frameworks such as Entity Framework, N-Hibernate, and so on are designed to work optimally with Surrogate Keys. It is very simple to implement them over the composite keys.<\/span><\/li>\n
              • It allows for a higher degree of normalization, so data is not duplicated within the database.<\/span><\/li>\n<\/ul>\n
                \nDisadvantages of Surrogate Key<\/b><\/span><\/div>\n
                  \n
                • Additional index is required.<\/span><\/li>\n
                • It cannot be used as a search key because it is not related to any business logic or it is independent of any business logic.<\/span><\/li>\n
                • There is always a requirement to join to the main table when data is selected from a child table.<\/span><\/li>\n
                • It increases the sequential number by a random amount.<\/span><\/li>\n
                • There is some administrative overhand to maintain a Surrogate Key.<\/span><\/li>\n
                • Extra disk space required to store a Surrogate Key.<\/span><\/li>\n<\/ul>\n
                  \nHow Surrogate Key is differing from the Natural Key?<\/b>
                  The alternative to a Surrogate Key is Natural Keys. A Natural Key is a true unique identifier in the database. It is a single value or composite value that has business meaning. The Natural Key can be one or more columns with any data type. If there is no Surrogate Key on table then there is no need to create a unique index or sequence on a database table, so it helps us to reduce administrative overhead.

                  Disadvantages of Natural Key<\/b><\/span><\/div>\n
                    \n
                  • A query join may become complex because the Natural Key can have one or more columns.<\/span><\/li>\n
                  • It is a reduced normalization form.<\/span><\/li>\n
                  • It is very difficult to use and time consuming with ORM because ORM is designed to work best with Surrogate Keys.<\/span><\/li>\n
                  • The key type is not consistent.<\/span><\/li>\n
                  • More work is required to change a Natural Key when the foreign key relationship has been built by a Natural Key.<\/span><\/li>\n
                  • A Natural Key is larger than a Surrogate Key.<\/span><\/li>\n
                  • A Natural Key can be any data type, so it might require a long execution time in a “join” query. For example, if there is a VARCHAR data type as a Natural Key type then the join between two tables may take more time to produce output.<\/span><\/li>\n
                  • A Natural Key is assigned by the application, so there is no way to know whether a record is new or an existing record.<\/span><\/li>\n<\/ul>\n
                    \nConclusion
                    <\/b>A Surrogate Key is unique in the database table; it is just like an artificial or alternative key to a Primary Key because a Primary Key may be alphanumeric or a composite key. A Surrogate Key is always unique per table.

                    Surrogate Keys offer many benefits. Simplicity, consistency and stability, makes the use of an ORM extremely feasible. We can use a Natural Key instead of A Surrogate Key when A Natural Key is small and this key is never updated.<\/span><\/div>\n<\/div>\n","protected":false},"excerpt":{"rendered":"

                    IntroductionA Surrogate Key in SQL Server is a unique identifier for each row in the table. It is just a key. Using this key we can identify a unique row. There is no business meaning for Surrogate Keys. This type of key is either database generated or generated via another application (not supplied by user). A […]<\/p>\n","protected":false},"author":43,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_uag_custom_page_level_css":"","footnotes":""},"categories":[34,27],"tags":[],"class_list":["post-89","post","type-post","status-publish","format-standard","hentry","category-ibm","category-sql"],"uagb_featured_image_src":{"full":false,"thumbnail":false,"medium":false,"medium_large":false,"large":false,"1536x1536":false,"2048x2048":false},"uagb_author_info":{"display_name":"Himanshu Namdeo","author_link":"https:\/\/debuggersspace.com\/author\/admin\/"},"uagb_comment_info":0,"uagb_excerpt":"IntroductionA Surrogate Key in SQL Server is a unique identifier for each row in the table. It is just a key. Using this key we can identify a unique row. There is no business meaning for Surrogate Keys. This type of key is either database generated or generated via another application (not supplied by user). A…","_links":{"self":[{"href":"https:\/\/debuggersspace.com\/index.php\/wp-json\/wp\/v2\/posts\/89"}],"collection":[{"href":"https:\/\/debuggersspace.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/debuggersspace.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/debuggersspace.com\/index.php\/wp-json\/wp\/v2\/users\/43"}],"replies":[{"embeddable":true,"href":"https:\/\/debuggersspace.com\/index.php\/wp-json\/wp\/v2\/comments?post=89"}],"version-history":[{"count":0,"href":"https:\/\/debuggersspace.com\/index.php\/wp-json\/wp\/v2\/posts\/89\/revisions"}],"wp:attachment":[{"href":"https:\/\/debuggersspace.com\/index.php\/wp-json\/wp\/v2\/media?parent=89"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/debuggersspace.com\/index.php\/wp-json\/wp\/v2\/categories?post=89"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/debuggersspace.com\/index.php\/wp-json\/wp\/v2\/tags?post=89"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}