How to Use CAST Function in SQL?

By Cristian G. Guasch • Updated: 02/09/24 • 9 min read

Navigating the world of SQL can sometimes feel like you’re trying to solve a complex puzzle. But don’t worry, I’ve got your back. Today, I’m diving into one of SQL’s most versatile functions: the CAST function. It’s like having a magic wand that lets you transform data types with ease, ensuring your data fits perfectly where you need it.

What is the CAST function in SQL?

The CAST function in SQL is essentially a tool that comes in handy when I need to change the data type of a column in a database. Imagine working on a project where you’ve got columns of data in one format, but your application needs them in a different format. That’s where CAST saves the day, allowing me to effortlessly transform data types to fit my needs.

For example, I often use CAST to convert a varchar data type to an integer. This could be useful in scenarios where numerical operations on a column initially stored as text are required. Here’s a simple snippet to illustrate:

SELECT CAST(column_name AS INT) FROM table_name;

However, it’s important to note that while CAST is powerful, it’s not magical. There are some nuances and common mistakes I’ve learned to avoid. One such pitfall is trying to cast incompatible types, like attempting to change a text string that doesn’t represent a number into an integer. SQL Server would throw an error because ‘hello’ cannot be converted to a number.

Understanding Variations

SQL provides another function similar to CAST, named CONVERT. While both can be used for type conversion, CONVERT offers a bit more flexibility with formatting, especially with date and time types. An example where CONVERT might be preferable is when I need a specific date format:

SELECT CONVERT(VARCHAR, GETDATE(), 103);  -- Converts current date to dd/MM/yyyy format

Common Mistakes

One common error I’ve encountered is neglecting the precision in decimal conversions. For instance, if I’m casting a float to a decimal and don’t specify precision, I might not get the accuracy I need. Precision and scale are critical here:

SELECT CAST(column_name AS DECIMAL(10,2)) FROM table_name;

In my years of working with SQL, using the CAST function has been like having a Swiss Army knife for data manipulation. Whether it’s preparing data for analytics, ensuring compatibility between systems, or simply cleaning up data formats, CAST has been an indispensable part of my SQL toolkit.

Syntax of the CAST function

When it comes to effectively using the CAST function in SQL, understanding its syntax is crucial. The basic form looks something like this: CAST (expression AS data_type). Here, expression refers to the column or value you want to convert, and data_type specifies the target data type you wish to achieve. Getting this syntax right is my first step in ensuring proper data type conversion.

Let’s dive into some examples to illustrate how it works in real-world scenarios. Suppose you have a column labeled price with varchar data type but you want it as an integer to perform numerical operations. You’d use the CAST function like so:

SELECT CAST(price AS INT) FROM products;

This conversion allows me to perform calculations or even aggregate functions on price that wouldn’t be possible with varchar data types. Another common scenario involves date formatting. Imagine you have a varchar column date_string and you wish to convert it into a DATE type:

SELECT CAST(date_string AS DATE) FROM events;

However, mistakes can easily slip in. A frequent error occurs when trying to cast incompatible data types, like attempting to cast a non-numeric string to an INT. SQL would throw an error because it cannot perform this transformation. Always ensure the data you’re casting is compatible with the target data type.

Using CAST with precision data types requires specifying the precision along with the data type. For example, converting a number to a decimal with two places:

SELECT CAST(price AS DECIMAL(10,2)) FROM products;

This converts price to a decimal type with 10 digits, of which 2 are after the decimal point. It’s crucial to not only master the syntax but also understand these variations and common mistakes to avoid pitfalls in data conversions.

How to use the CAST function to convert data types

When diving deeper into manipulating and transforming data in SQL, understanding the nuances of the CAST function is crucial. I’ve encountered numerous scenarios where data type conversions were essential for generating meaningful insights. Let me share how I typically leverage this powerful tool.

The syntax for the CAST function is straightforward: CAST (expression AS target_type [length]). Here, expression is the data you wish to convert, and target_type is the new data type you aim for. The optional length parameter is used for specifying the size for the target data type.

Let’s look at some examples. Suppose you have a varchar column, employee_age, in a database, but you need to perform arithmetic operations. You can easily convert it to an integer like so:

SELECT CAST(employee_age AS INT) FROM Employees;

Converting date formats is another common use case. If the date is stored as a varchar in the form ‘YYYYMMDD’ and you want to convert it into a DATE type to use date functions, here’s how you’d do it:

SELECT CAST(date_string AS DATE) FROM Table1;

Variations in the use of CAST can accommodate almost any data conversion need. However, it’s essential to avoid common mistakes. A frequent error is attempting to cast incompatible types, such as trying to convert a letter-based varchar to an integer. This invariably leads to errors. Precision is another critical aspect; when working with decimal or numeric types, always specify precision to avoid unexpected truncations.

By keeping these insights in mind and utilizing the examples I’ve shared, you’ll find that the CAST function becomes an indispensable tool in your SQL toolkit. It’s about asking the data to fit the mold you need, and with CAST, the possibilities extend as far as your queries can take you.

Examples of using the CAST function

In my time working with SQL, I’ve found the CAST function to be incredibly useful for data manipulation and transformation. Here are some examples that highlight its versatility.

Converting varchar to Integer

Imagine you’ve got a database column in varchar format that actually stores numeric values. To perform mathematical operations, you’ll need to convert these values to integers. Here’s how I’d do it:

SELECT CAST(column_name AS INT) as converted_column
FROM table_name;

This simple line of code transforms the varchar data into integers, allowing for operations like sums or averages to be performed on what was once text data.

Changing varchar to Date Type

When working with dates stored as text, converting them into a DATE type is essential for any operations that require date logic. I’ve often run into this scenario and here’s a straightforward solution:

SELECT CAST(date_column AS DATE) as new_date_column
FROM table_name;

This conversion lets me use date functions on the date_column, which can be pivotal for reports or data analytics that hinge on date calculations.

Avoiding Common Mistakes

While the CAST function is powerful, I’ve learned that it’s also easy to stumble with it. A common mistake is attempting to convert incompatible data types, like trying to CAST a varchar containing letters to an INTEGER. SQL will throw an error since it can’t make sense of the conversion.

Another aspect to watch out for is precision. When converting to decimal or numeric types, it’s vital to specify the precision, or you might end up with rounded or truncated values, which can significantly affect your data’s integrity. For example:

SELECT CAST(column_name AS DECIMAL(10,2)) as converted_decimal
FROM table_name;

By specifying (10,2), I’m telling SQL to give me a number with up to 10 digits, two of which can be after the decimal point, ensuring the precision of the converted data matches my requirements.

Through these examples, it’s clear that the CAST function is a fundamental tool in my SQL toolkit, offering both flexibility and precision in data transformation tasks.

Limitations and considerations when using the CAST function

When diving into the nuances of the CAST function in SQL, it’s crucial to understand both its power and its constraints. My journey through SQL has taught me that while CAST is immensely useful for data manipulation, there are certain limitations and considerations one must keep in mind to avoid common pitfalls.

Firstly, one significant limitation of the CAST function is its strictness in data compatibility. Not all data types are seamlessly convertible. For instance, trying to cast a varchar containing alphabetic characters directly to an integer will throw an error. Here’s a practical example to illustrate:


This query attempts to convert a varchar of non-numeric characters to an integer, resulting in a conversion error. It’s a clear reminder that the data type you’re casting from and to must be compatible, or at least contain convertible data.

Another vital consideration is the precision and scale when converting decimals. Failing to specify precision and scale can lead to unexpected rounding or truncation. Let’s look at an example to understand this better:

-- Incorrect use without specifying precision and scale
-- Correct use with specified precision and scale
SELECT CAST(123.4567 AS DECIMAL(5,2));

The first query might not behave as anticipated because it lacks precision and scale, potentially leading to default settings that don’t match the user’s expectations. The second query makes these specifications clear, ensuring accurate conversion.

Lastly, utilizing CAST to change data types within WHERE clauses can lead to performance issues, particularly if casting causes an index to be ignored. For instance:

SELECT * FROM myTable WHERE CAST(dateColumn AS VARCHAR) = '2023-04-01';

While functional, this query can suffer from slow performance if dateColumn is indexed because the CAST operation prevents efficient use of the index.

Understanding these limitations and considerations is fundamental in harnessing the full potential of the CAST function without encountering unexpected hurdles.


Mastering the CAST function in SQL has empowered me to manipulate and transform data with precision. Through practical examples, I’ve shared how to seamlessly convert data types, from varchar to integer and date types, enhancing the versatility of database operations. It’s essential to be mindful of the common pitfalls, like data type incompatibility and the necessity of specifying precision for decimals. Also, considering the limitations and performance implications when using CAST, especially in WHERE clauses, ensures smooth and efficient data handling. With these insights, I’m confident in the CAST function’s role as a critical tool in my SQL toolkit, enabling me to tackle a wide range of data transformation challenges.

Related articles