Adventures in Machine Learning

Mastering datetime conversion in SQL Server with TRY_CONVERT()

Converting a String to Datetime in SQL Server

In today’s world, data is everything. Metrics, insights, and analysis all stem from data.

However, getting real value from data often requires converting it to a format that is easier to analyze. SQL Server is one of the most popular database management systems today, used to store and manage vital organizational data.

One way to convert data in SQL Server is by converting a string to CONVERT() and TRY_CONVERT() functions

The CONVERT() function is a powerful SQL Server feature that converts a value of one data type to another data type. This function is useful when we need to convert a string to datetime.

On the other hand, TRY_CONVERT() is similar to the CONVERT() function, but it returns NULL when it’s impossible to convert a value to the desired data type rather than generating an error. TRY_CONVERT() provides us with more flexibility compared to CONVERT().

Using the CONVERT() function to convert a string to datetime

When converting a string to datetime, we must specify the format of the datetime value that we wish to generate. The ANSI date format (yyyy-mm-dd) is the most common format used for datetime values in SQL Server.

To convert a string to datetime using the CONVERT() function, we can use the following code:

SELECT CONVERT(datetime, ‘2022-11-30’)

This code will convert the string ‘2022-11-30’ to a datetime value. However, if the input string is in an incorrect date format, the CONVERT() function raises an error message.

Using the TRY_CONVERT() function to convert a string to datetime

Unlike the CONVERT() function, if the input string in TRY_CONVERT() is an incorrect date format, it will return a NULL value instead of raising an error. This can be useful in cases where we need to handle exceptions and can’t afford to have the conversion process fail.

The below code demonstrates how the TRY_CONVERT() function handles an incorrect date format:

SELECT TRY_CONVERT(datetime, ’11-30-2022′)

The output of this code will be NULL since the string is not in an acceptable date format, and TRY_CONVERT() will not raise an error. Converting a string in ANSI/ISO and US date format to datetime

In addition to the ANSI/ISO date format, SQL Server also supports the US datetime format (mm/dd/yyyy hh:mm:ss AM/PM), which is commonly used in the United States.

To convert a string that uses the ISO format, we can do:

SELECT CONVERT(datetime, ‘2022-11-30T08:30:00.123’)

On the other hand, to convert a string that uses the US datetime format, we can do:

SELECT CONVERT(datetime, ’11/30/2022 08:30:00 AM’)

Differences between CONVERT() and TRY_CONVERT()

One of the main differences between the CONVERT() and TRY_CONVERT() functions is how they handle conversion failures. If the input value is an incorrect data type or format, CONVERT() raises an error message, while TRY_CONVERT() returns NULL.

This means that TRY_CONVERT() is more adaptable and can provide us with more control over our code.


Converting a string to datetime can be a very useful technique in SQL Server when working with data. The CONVERT() and TRY_CONVERT() functions provide us with the necessary tools to perform this task.

By using the right format and function, we can generate a datetime value that represents data in a clear and precise format.

Advantages of Using TRY_CONVERT() over CONVERT()

In the world of programming, we know that things don’t always go as planned, and we must be able to handle exceptions gracefully. One such scenario arises when we need to convert data from one data type to another.

When it comes to converting a string to datetime in SQL Server, we have two options – the CONVERT() function and the TRY_CONVERT() function. While both work similarly, there are some distinct benefits to using TRY_CONVERT() when handling conversion failures.

The Benefits of TRY_CONVERT() for Handling Conversion Failures

One of the primary advantages of TRY_CONVERT() is that it protects against errors resulting from incorrect data types or formats. In contrast, CONVERT() raises an error when it attempts to convert a value that does not have the correct format or data type.

This fulfills one of the primary objectives of error handling – maintaining control and preventing the program from halting abruptly. This feature is particularly useful when handling large datasets with inconsistent data types or formats.

For example, suppose the source data contains both valid and invalid date formats. In that case, using CONVERT() can stop the conversion process when it attempts to convert an invalid value, and the program crashes.

TRY_CONVERT() provides a way to handle these exceptions gracefully by returning a NULL value, allowing us to continue processing the remaining data. TRY_CONVERT() also simplifies code readability and management.

By using this function, we don’t need to handle exceptions explicitly with complicated nested conditionals or try-catch statements. Instead, the NULL return values can be dealt with separately, helping to isolate potential issues quickly.

Another advantage of TRY_CONVERT() is that it is more versatile in comparison to CONVERT(). TRY_CONVERT() can convert to any data type, while CONVERT() has some limitations.

For example, when using CONVERT() to convert a string representation of a Boolean value to a bit value, we need to specify the style number explicitly. In comparison, TRY_CONVERT() handles the conversion process seamlessly without requiring any additional parameters.

Using TRY_CONVERT() can also help to simplify data analysis tasks. In a real-world scenario, SQL Server’s data may contain values that require modification before analysis.

When we use CONVERT(), we get an error message for invalid values. In contrast, when we use TRY_CONVERT(), the invalid values become NULL, allowing us to manage the data more efficiently.

We can focus on cleaning up the dataset and removing anomalies without having to worry about any error messages, ensuring that we get the insights we need from the data. Finally, TRY_CONVERT() helps to simplify testing procedures.

When a program is under development, it is common for the input variables to undergo changes frequently. In such cases, TRY_CONVERT() allows us to test the program’s output in the presence of various data types and formats easily.

By maintaining control over the program’s execution even in the face of unexpected input data, we can streamline the testing process without compromising the overall functionality.


In conclusion, TRY_CONVERT() offers several benefits when handling conversion failures, making it a versatile and reliable tool for efficient data management in SQL Server. With TRY_CONVERT(), we can streamline the conversion process for large datasets, avoid program crashes due to incorrect data types or formats, and simplify our codebase, enhancing code readability and maintenance.

These benefits make TRY_CONVERT() an essential component of any SQL Server programmer’s toolkit. In conclusion, when dealing with data in SQL Server, the need to convert data from one data type to another is inevitable, and failure handling is critical.

Two functions – CONVERT() and TRY_CONVERT() – provide alternatives for converting strings to datetime values. While both work similarly, TRY_CONVERT() has several advantages over CONVERT() in failure handling.

TRY_CONVERT() returns NULL instead of generating an error when it encounters incorrect data types or formats. TRY_CONVERT() also simplifies coding, analysis, testing procedures and is more adaptable, making it an essential SQL Server programming tool.

The use of TRY_CONVERT() ensures that your programs continue executing and provide reliable, accurate outputs even in the face of unexpected input data errors.