How to Get the Previous Month in T-SQL: A Straightforward Guide for Developers

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

Navigating through dates in T-SQL can often feel like a labyrinth, especially when it comes to retrieving specific date periods such as the previous month. But don’t worry, I’m here with some simple steps that will help you get there.

T-SQL, or Transact-SQL, is Microsoft’s and Sybase’s proprietary extension to SQL. It offers an assortment of functions that are incredibly handy for manipulating and analyzing data effectively. One such function is getting the previous month from a given date, which might seem tricky at first glance but becomes quite straightforward once we delve into it.

Understanding how to perform this task isn’t just about mastering a single function, though. It’s also about grasping how T-SQL handles dates overall — an understanding that can open up a world of possibilities for your data analysis efforts. So buckle up: we’re about to embark on an exciting journey through time…in T-SQL!

Understanding T-SQL Language Basics

I’d like to take a moment to get back to basics. Let’s chat about Transact-SQL or as it’s more commonly known, T-SQL. This is Microsoft’s proprietary extension of the SQL (Structured Query Language). It adds several features to standard SQL, including transaction control, error and exception handling, and row processing.

Let me give you an example:

UPDATE Accounts
SET balance = balance - 1000
WHERE account_id = 1;

In this code snippet, I’m initiating a transaction that deducts 1000 from the balance column of the table ‘Accounts’ where ‘account_id’ equals 1. The COMMIT command at the end ensures that if all commands within the transaction operate successfully, changes are saved in the database.

What differentiates T-SQL from other SQL languages? Primarily its integrations with Windows OS and .NET Framework make it stand out. Moreover, T-SQL has been optimized for use with Microsoft’s SQL Server management systems.

Now here’s something important! A common mistake I’ve seen is not using semicolons at the end of each statement. Although older versions of SQL Server allowed this lapse, newer ones require it. For instance:

SELECT * FROM Employees --This will fail in newer versions!

Instead, you should write:

SELECT * FROM Employees; --This will succeed.

Tough stuff? Maybe initially but once you get your hands dirty with some practical work on T-SQL language basics, you’ll find it’s quite intuitive!

Importance of Date and Time Functions in T-SQL

Dealing with dates and time is a common task in any programming language. When you’re working with databases, it’s especially crucial to handle these data types effectively. That’s where Transact-SQL (T-SQL) steps in.

T-SQL, the proprietary procedural language used by Microsoft SQL Server, offers a plethora of date and time functions that make your life easier. From getting the current system date or time to performing complex calculations like determining the difference between two dates, T-SQL has got you covered. If you’ve ever wondered how many days are left until Christmas or what day of the week your birthday will fall on next year, T-SQL can give you those answers!

Let’s take an example function GETDATE(). It returns the current system date and time as DATETIME value:

SELECT GETDATE() AS CurrentDateTime;

This simple query yields up-to-date results every time it runs. Handy, isn’t it?

But hang on! There’s more! You can even manipulate these values using other date and time functions provided by T-SQL. For instance, suppose we need to find out what was the first day of last month? We can use DATEADD along with EOMONTH to get this information:

SELECT DATEADD(DAY, 1 , EOMONTH (@Today,-2)) AS 'First Day Of Last Month';

In this code snippet, EOMONTH (@Today,-2) gets us end-of-day for two months prior (i.e., last month’s previous month), then DATEADD(DAY, 1 ,...) adds one day to reach last month’s first day.

However, I should warn ya – while dealing with dates and times can be straightforward most of the time, it can also get tricky. Remember that date and time data types in T-SQL are susceptible to common pitfalls such as ignoring time zones or daylight saving times. It’s essential to take these factors into account when performing calculations involving dates and times.

In a nutshell, mastering date and time functions in T-SQL is not only beneficial but also indispensable for any SQL Server developer or database administrator. Understanding how they work helps you write more efficient code, reduces the chances of errors, and ultimately makes your applications run smoother.

Methods to Retrieve the Previous Month in T-SQL

Diving right into the world of T-SQL, you’ll find that getting the previous month isn’t exactly rocket science. It’s fairly straightforward if you know what functions to use. One of my favorite methods involves making good use of SQL Server’s DATEADD() function.

Consider this: If today is April 20th and we want to go back one month, how would we do it? Easy! Here’s a simple line of code that’ll get us there:

SELECT DATEADD(month, -1, GETDATE()) AS 'Previous Month'

In this snippet, month indicates the datepart argument which specifies the part of the date to add or subtract. The -1 is our number argument defining how much to add (a positive value) or subtract (a negative value). Finally, GETDATE() is a built-in function that gets us the current system timestamp.

But wait! What if you only need the month instead of an entire date? Well, there’s a solution for that too. In such cases I’d recommend combining our trusty DATEADD() with MONTH(). So here’s how we’d modify our earlier example:

SELECT MONTH(DATEADD(month, -1, GETDATE())) AS 'Previous Month'

Here’s another thing worth noting: When using these methods it’s easy to forget about handling year transitions. For instance when January rolls around and you run your query again expecting December as your result. To handle this scenario correctly always remember to include both MONTH() and YEAR() functions in your queries like so:

  YEAR(DATEADD(month,-1,GETDATE())) AS 'Year',
  MONTH(DATEADD(month,-1,GETDATE())) AS 'Month'

Just one more point before wrapping up this section – be aware of using these methods for critical calculations. Keep in mind that T-SQL’s GETDATE() function includes both date and time, which can sometimes lead to unexpected results. For example, when trying to subtract a month from ‘2022-03-31 15:30:00’, the result will not be ‘2022-02-28 15:30:00’ as one might expect, but rather ‘2022-03-03 15:30:00’. To avoid such pitfalls, consider setting the time part to zero or use CAST() for accurate results.

Alright! With this knowledge tucked safely under your belt, you’re now more prepared to handle date manipulations in T-SQL. So go on and give it a shot! Remember – practice makes perfect.

Common Mistakes When Using T-SQL for Date Retrieval

Let’s dive right into some of the common pitfalls that even seasoned developers might stumble upon while trying to retrieve the previous month in T-SQL.

One of the most frequent mistakes I’ve seen is misunderstanding how DATEADD and DATEDIFF functions work. Here’s a classic example:


This snippet might seem like it’s doing the job correctly because it subtracts one month from today’s date. But here’s where things can get tricky. If today is March 31st, this will return March 1st due to how SQL Server handles months with different numbers of days.

Another widespread issue arises when you’re not accounting for time components. Consider this piece of code:

SELECT DATEADD(month, DATEDIFF(month, 0, GETDATE()), -1)

At first glance, it looks like it should return the first day of last month. However, if you run this at any time other than exactly midnight on the first day of a month, you’ll end up getting partway through the day before! To avoid this pitfall and ensure accuracy down to the millisecond level use:


I’ve also noticed people often forget about NULL values when working with dates in T-SQL. This oversight can lead to unexpected results or errors during runtime if your code doesn’t handle potential NULL values properly.

Lastly, keep an eye out for incorrect date formats when retrieving data in T-SQL. US-based systems typically use MM/DD/YYYY format while many others around the world utilize DD/MM/YYYY format instead.

Avoiding these common mistakes can save you time and headaches when working with date retrieval in T-SQL. By understanding these pitfalls, you’ll be well on your way to mastering the art of manipulating dates in SQL Server.

Conclusion: Mastering Previous Month Retrieval in T-SQL

I’ve spent the last few sections detailing how to retrieve the previous month in T-SQL. Now that we’ve covered all steps, let’s wrap up with some final thoughts and tips.

Firstly, remember that when dealing with dates in SQL, it’s crucial to understand your data model thoroughly. The way your dates are stored can significantly impact the method you use for retrieving previous months.

Here’s a quick reminder of our basic code snippet:


The key part of this script is DATEADD and DATEDIFF. They work together to essentially “move” or subtract a month from the current date (GETDATE()).

But don’t forget about potential pitfalls! One common mistake is neglecting time components. If your date columns include time details (like ‘2022-03-15 14:25:00’), you’ll need to account for these when making your calculations.

Another point worth noting is timezone differences. If you’re working with data across different time zones, ensure you’re adjusting properly so as not to skew results.

When it comes to performance optimization, try using indexes on your date fields for speeding up queries involving date ranges like this one.


  • Understand your data model
  • Be aware of time components
  • Consider timezone differences
  • Use indexing for better performance

With these pointers in mind and some practice under your belt, I’m confident that mastering previous month retrieval in T-SQL will be an achievable feat!

Related articles