Adventures in Machine Learning

Streamline Your Data: Optimizing SQL Server with Computed Columns

Introduction to SQL Server Computed Columns

In the world of database management, SQL Server computed columns are a truly powerful asset. As the name suggests, computed columns are columns that are filled with values that are computed or derived from other columns in the same table.

In simpler terms, computed columns act as virtual columns that are not physically stored in the table. Instead, their values are calculated every time they are queried or accessed.

This results in a dynamic and flexible way of managing large amounts of data, making computed columns an essential tool in SQL Server. The purpose of this article is to provide a detailed explanation of SQL Server computed columns, how to add them to tables, and how they can be used to display relevant data efficiently.

We will also include examples of how computed columns can be used to display full names using the CONCAT() function and cover the benefits of using persisted computed columns.

Example Using CONCAT() Function to Display Full Names

Let’s start with an example of how we can use computed columns to display full names using the CONCAT() function. Say we have a table named “Employees” with columns “First Name” and “Last Name.” In this scenario, we would like to create a computed column named “Full Name” that displays the complete name of the employee by concatenating the first and last name columns.

To create the computed column for “Full Name,” we use the following SQL statement:



ADD [Full Name] AS CONCAT([First Name], ‘ ‘, [Last Name])


The above statement adds a new column called “Full Name” to the table “Employees.” This column computes its values by concatenating the “First Name” and “Last Name” columns separated by a space. Now, if we query the “Employees” table, we will get a result set that includes the “Full Name” column alongside other columns.

This provides us with a convenient way to display full names only by using a single computed Computed Columns as a More Convenient Solution

Computed columns play an essential role in SQL Server because they provide a more efficient and convenient way to display data in our tables. With computed columns, we do not need to store duplicate information in our tables.

Instead, we can derive computed values based on the other column properties. This feature enhances table efficiency while reducing the storage space required to store redundant information, making it an essential asset in data management.

By using computed columns, we can create tables that are more accurate, consistent, and reliable. Additionally, computed columns are calculated on the fly, making them ideal for any changing data where accuracy is necessary.

Adding Computed Columns to Tables

Now, let’s take a closer look at how we can add a computed column to a table using the ALTER TABLE ADD statement. When we want to add a computed column to a table, we need to embed it using the SQL statement below:


ALTER TABLE tablename

ADD columnname AS formula


The SQL statement above adds a new column named “columnname” to the “tablename” table. The “AS formula” part of the statement allows us to specify the way in which the column will be calculated.

Example of Using a Computed Column for Full Names

Returning to our previous example, we can add a computed column to our “Employees” table that combines the “First Name” and “Last Name” columns. This will allow us to display the employee’s full name every time we query the table, without adding any additional columns.



ADD [Full Name] AS CONCAT([First Name], ‘ ‘, [Last Name])


Persisted Computed Columns and Their Benefits

Computed columns can be either persisted or non-persisted. A persisted computed column is calculated once, stored in the data storage container, and used every time the table is queried.

Persisted computed columns provide some benefits, such as improved performance, indexability, and a reduction in the amount of code that is required to access the data. One of the benefits of persisted computed columns is their ability to improve query performance.

Computed columns provide us with an efficient method to derive derived data from the table columns, which is commonly used in business intelligence (BI) applications and reporting. Persisted computed columns can be indexed, which helps to improve query performance significantly.

The fact that the computed column values are stored directly with the table columns allows us to set up and maintain indexes while avoiding the overhead of an additional memory requirement.


SQL Server computed columns are a powerful asset in the world of data management. By adding computed columns to tables, we can derive values from other columns, making our data more organized, efficient, and reliable.

In this article, we have highlighted the importance of computed columns, how to add them to tables, and their benefits. By following these guidelines, you can optimize your SQL Server databases, resulting in efficient and streamlined data storage and management.

3) Deterministic Computed Columns

When creating computed columns, it is important to understand the concept of deterministic and non-deterministic functions. Deterministic functions always return the same output given the same input, while non-deterministic functions can return varying results for the same input.

Deterministic computed columns are columns that always return the same result when computed given the same input. When creating a computed column, it can be marked as deterministic using the “WITH SCHEMABINDING” clause in the SQL statement.

This indicates that a computed column’s value is deterministic and will always produce the same value for the same input. An example of a non-deterministic function in SQL Server is the GETDATE() function.

The GETDATE() function returns the current date and time, which may change every time it is called. This makes it a non-deterministic function that should not be used in computed columns.

When a persisted computed column that is marked as deterministic is added to a table, SQL Server stores this computed column’s results in the database permanently. This persists the computed column’s values and ensures that it is always available to the queries that need it.

However, if a non-deterministic function is used in a persisted computed column, an error message will be generated when trying to persist the column. This is because the column’s value cannot be permanently stored since it may change every time it is called.

4) Syntax for Adding Computed Columns

Adding computed columns to existing tables is accomplished using the ALTER TABLE statement. To add a computed column, use the following syntax:


ALTER TABLE table_name

ADD column_name AS column_definition [PERSISTED] [WITH (property_list)];


In the above statement, “table_name” is the name of the table to which the computed column is added. “column_name” is the name for the computed column being added.

“column_definition” is the formula that computes the new column.

The optional “PERSISTED” keyword specifies that the values of the computed column are stored in the database permanently.

When using the persisted computed column, SQL Server calculates the result value only once and then stores it in the database. This value is then returned whenever the computed column is included in a query.

Additionally, the “WITH (property_list)” clause in the statement can be used to specify additional properties for the computed column. This includes the “SCHEMABINDING” keyword, which ensures that the computed column is deterministic.

The “SCHEMABINDING” keyword binds dependencies between the computed column and any other objects that depend on it. Persisted computed columns are stored in the data storage container, allowing indexation for improved query performance.

Indexing computed columns can speed up query performance when searching based on the computed column value. By using computed columns, we can improve the speed of any query with calculated columns, resulting in streamlined SQL Server queries.


Computed columns are an essential feature in SQL Server, providing a way to compute column values based on other column variables. Deterministic computed columns can play an important role in optimizing the data storage efficiency and performance of a table.

By using persisted computed columns, we can permanently store the computed column values, improving query performance and reducing the need to store redundant data. The syntax for adding computed columns is straightforward, and the PERSISTED property combined with indexing can significantly improve computing and retrieval speed.

5) Summary

SQL Server computed columns play an essential role in database management. They allow us to derive and display values based on other column variables, making data storage more efficient and streamlined.

Computed columns can be either deterministic or non-deterministic, and it is important to use the appropriate one. Non-deterministic functions should not be used in computed columns where possible, and deterministic computed columns should be marked with the SCHEMABINDING keyword.

The ALTER TABLE statement is used to add computed columns to existing tables. When using persisted computed columns, the PERSISTED property can be added to store the values in the data storage container, reducing the need to store redundant data.

Indexing computed columns is one efficient way to speed up queries with calculations, providing faster retrieval to users. The syntax for adding computed columns is simple and straightforward, making them an accessible tool for any database manager.

In summary, computed columns provide an effective and convenient solution to derive derived values based on other columns. Combining persisted computed columns with indexing leads to efficient and accurate SQL Server queries.

By using deterministic computed columns, we can improve the efficiency of our data storage operations, resulting in better performance and streamlined data retrieval. In conclusion, SQL Server computed columns are an essential feature for any database manager.

They provide a convenient and efficient way to derive values from other columns and streamline data storage. Deterministic computed columns provide the most benefit when used in persisted columns, reducing redundant data and efficiently storing computation results.

Proper syntax for adding computed columns is simple and straightforward, with the option to index to promote faster queries. Understanding the importance of and implementing computed columns can drastically improve database efficiency and query retrieval speed, resulting in more accurate and effective data management.

Popular Posts