How to Change Date and Time Formats in T-SQL: A Comprehensive Guide for SQL Users

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

Working with databases often involves dealing with dates and times. If you’re a SQL Server user, chances are you’ve wrestled with formatting date and time values in T-SQL, the language used for interacting with this database system. Don’t worry – I’m here to help! In this blog post, I’ll walk you through how to change date and time formats in T-SQL.

T-SQL offers a plethora of functions that can be harnessed to manipulate date and time data types. However, it’s the CONVERT function that tends to take center stage when it comes to changing these formats. This function allows us to format our date and time values into more readable or suitable forms for our specific needs.

But there’s more than just one way to skin this cat. Each method has its own unique application depending on your use case scenario or personal preference. Stick around as I dive into the nitty-gritty of T-SQL date and time formatting techniques.

Understanding T-SQL Date and Time Formats

Diving headfirst into the world of SQL can be a bit intimidating. There’s so much to learn, especially when it comes to handling date and time formats in T-SQL. But don’t worry, I’m here to guide you through.

First off, let’s tackle what exactly T-SQL is. Transact-SQL (T-SQL) is Microsoft’s proprietary extension of the SQL (Structured Query Language). It adds several features to standard SQL, including transaction control, exception and error handling, row processing and declared variables.

In T-SQL, dates and times are stored in various formats. The two most commonly used data types for managing dates and times are DATETIME and DATE. Here’s an example:

SET @MyDateTime = GETDATE();
SELECT @MyDateTime AS 'Current DateTime';

This snippet simply declares a DATETIME variable named ‘@MyDateTime’, assigns it the current date and time using the built-in function GETDATE(), then displays it.

Now, suppose we want to change how this date-time information is presented? This is where formatting kicks in. Formatting doesn’t alter the underlying data; it just changes how we perceive it on-screen.

For instance, if you’d prefer your dates formatted as “MM-DD-YYYY”, or maybe even “Month Day, Year”, you can use the built-in function CONVERT() like so:


The first argument of CONVERT() is the target data type; here we’re using VARCHAR. The second argument is our source value – in this case our current date via GETDATE(). The third argument is the style code; ‘101’ gives us a “MM/DD/YYYY” format, while ‘107’ provides a “Mon DD, YYYY” format.

A common mistake to avoid when working with date and time formats in T-SQL is neglecting to consider your SQL Server’s default language settings. Different languages have different default date formats. For example, the U.S. English default date format is “month/day/year”, whereas British English defaults to “day/month/year”. Always keep this in mind when crafting your queries.

Hopefully, that’s helped demystify the concept of handling dates and times in T-SQL for you. Remember: practice makes perfect! Keep experimenting with different styles until you find what works best for you.

Steps to Change Date Format in T-SQL

Let’s dive right into the task at hand. To change the date format in T-SQL, you’ll need to make use of CONVERT function. This function is a real lifesaver when it comes to formatting dates. It’s versatile and allows you to convert an expression from one data type to another.

Here’s a basic example of how this works:


In this code snippet, we’re converting the current date (GETDATE()) into a string (VARCHAR), specifying that we want the length of the string to be 10, and using style 101 which corresponds with MM/DD/YYYY format.

You can experiment with different styles for various date formats. Here are some commonly used styles:

  • 1: MM/DD/YY
  • 3: DD/MM/YY
  • 4: DD.MM.YY
  • 101: MM/DD/YYYY
  • 103: DD/MM/YYYY
  • 104: DD.MM.YYYY

A common mistake beginners often make is forgetting that these style codes are dependent on language settings. For instance, if your SQL Server Language setting is British English, then style code ‘1’ would give you a date format as ‘DD/MM/YY’, not ‘MM/DD/YY’. So always double-check your server language settings!

Another pitfall people fall into is trying to convert NULL values. Remember that any attempt at conversion will return NULL if you feed it NULL values.

So there you have it! The process isn’t too complicated once you get the hang of it. Practice makes perfect, so don’t shy away from experimenting until you’ve got it down pat!

Modifying Time Format in T-SQL: A Guide

Let’s dive right in! Time formatting in T-SQL can be a bit of a pickle, especially if you’re new to it. But don’t sweat it; I’m here to walk you through the process.

First off, the default time format in T-SQL is HH:MM:SS. You might be wondering, “What if I want my time displayed differently?” Well, that’s exactly where the CONVERT function comes into play! This handy little tool allows us to transform our data into different formats. For instance:


This piece of code will fetch the current system date and time, then convert it into an HH:MI:SS format.

Now let’s spice things up a bit with some variations. Say you want your time format as HH.MM.SS instead? No problem! Here’s how we do it:


In this example, we’ve used the REPLACE function alongside CONVERT to replace colons ‘:’ with periods ‘.’ .

But hey, nobody’s perfect and mistakes are bound to happen when working with conversions. One common error is forgetting that SQL server uses military (24-hour) time by default.

For instance:

SELECT CONVERT(VARCHAR(8), '13/07/2021 22:10', 108)

The above statement will throw an error because SQL Server doesn’t recognize ’22’ as a valid hour on a 12-hour clock.

Remember – practice makes perfect! So go ahead and try out these examples for yourself. Before long, you’ll be able to manipulate T-SQL date and times like a pro.

Common Issues While Changing Formats and Their Solutions

Sometimes, when you’re working with T-SQL, you might run into a few bumps in the road. One issue that’s known to crop up is incorrectly formatted date and time outputs. But don’t sweat it—I’ve got your back! Let’s dive right in and see how we can solve these common formatting issues.

The first snag you might hit involves an error message stating ‘Conversion failed when converting date and/or time from character string’. This typically happens when you’re trying to convert a string that doesn’t match any recognized date or time format into a datetime data type. To troubleshoot this problem, make sure the string you’re converting aligns with one of the recognized formats. For example:

DECLARE @Date AS VARCHAR(10) = '12/31/2020'; 
SELECT CONVERT(DATETIME, @Date, 101) AS 'New Date Format';

Another common issue revolves around dealing with NULL or empty fields during conversion. If your result returns ‘NULL’ after conversion, it’s likely because there were no values present in the field to be converted. Use ISNULL() function to handle such scenarios gracefully.

SELECT ISNULL(CONVERT(VARCHAR(10), @NullField, 101),'No Date') AS 'Handled Null';

In this case, if @NullField is NULL, SQL Server will return ‘No Date’ instead of NULL.

Let’s not forget about regional differences either—what works for one location may not work for another due to variations in date-time formats across different regions. It’s always best practice to use unambiguous formats like 'YYYYMMDD' which are universally understood regardless of region settings.

DECLARE @AmbiguousDate VARCHAR(10) = '05/06/2020'; 
SELECT CONVERT(DATETIME, @AmbiguousDate, 101) AS 'US Format', 
       CONVERT(DATETIME, @AmbiguousDate, 103) AS 'UK Format';

Here '05/06/2020' can be interpreted as May 6th in US or June 5th in UK. Specifying the correct format code (101 for US and 103 for UK) ensures accurate conversion.

Lastly, always remember to test your conversions meticulously before implementing them in a production environment. That’s because improperly formatted date-time data can lead to incorrect results or even system errors. It’s all about being proactive rather than reactive!

Conclusion: Mastering Date and Time Modifications in T-SQL

To say I’ve enjoyed our journey through the intricacies of date and time modifications in T-SQL would be an understatement. We’ve covered a great deal of ground, from the basics to more advanced techniques. And at this point, you should feel confident navigating these aspects within your own database environment.

Remember those initial steps we took? We looked at how to use the CONVERT function for changing date and time format. Let’s take another quick peek:

SELECT CONVERT(varchar, GETDATE(), 1) AS 'U.S. style MM/DD/YY';

This simple line of code transforms a regular date into a U.S.-style formatted date with month, day, and year.

Then we delved deeper. We discovered the power of custom formats using the FORMAT function as shown below:

SELECT FORMAT (GETDATE(), 'dd/MMM/yyyy', 'en-gb') AS 'Custom Format';

The beauty of this lies in its flexibility – able to adapt to any desired format based on your requirements.

But it wasn’t all smooth sailing! Remember those common pitfalls we discussed?

  • Not specifying a proper style code can lead to unexpected results.
  • Forgetting that SQL Server uses military time (24-hour clock), resulting in confusion between AM and PM times.
  • Neglecting regional settings which could affect certain output formats.

By understanding these potential hiccups, you’re already ahead of many developers out there!

So now armed with this newfound knowledge what will you do? Perhaps enhance your data reporting for clearer insights or streamline database management tasks? The possibilities are endless when you master T-SQL’s powerful tools for manipulating dates and times!

Related articles