Converting to VARCHAR

One way to remove the time from a DATETIME value is to convert it to a VARCHAR data type. This is handy when you need the date returned as a VARCHAR value and when you need the option to return the date in any number of different formats, with or without the century (i.e. 2009 vs 09). The full list of the different formats that are available using CONVERT is located in Books Online. Here is an example of a few the different formats.

DECLARE @dt DATETIME
SET @dt = GETDATE()

SELECT CONVERT(VARCHAR,@dt,1) AS Date1
     , CONVERT(VARCHAR,@dt,101) AS Date101
     , CONVERT(VARCHAR,@dt,12) AS Date12
     , CONVERT(VARCHAR,@dt,112) AS Date112

Date1      Date101    Date12     Date112
---------- ---------- ---------- ----------
03/19/09   03/19/2009 090319     20090319

One thing to consider when comparing a DATETIME value to another DATETIME value that has been converted to VARCHAR, you should always convert it back to DATETIME. This is called an explicit conversion when you use CAST or CONVERT to change a value to a different data type. The comparison will still work properly without the explicit conversion, but this will cause SQL Server to convert it at runtime, called an implicit conversion, putting unneccesary overhead on the server.

Using DATEADD and DATEDIFF

Another way to remove the time from a DATETIME value is to use a combination of the DATEADD and DATEDIFF functions. This is a good way to not only strip the time off of a particular DATETIME value, but you can also use that value to get other dates without the time. Here is an example of a few different dates that can be returned using the current date as a reference point.

DECLARE @dt DATETIME
SET @dt = GETDATE()

SELECT DATEADD(DAY,DATEDIFF(DAY,0,@dt),0) AS Today
     , DATEADD(DAY,DATEDIFF(DAY,0,@dt),-1) AS Yesterday
     , DATEADD(MONTH,DATEDIFF(MONTH,0,@dt),0) AS FirstOfThisMonth
     , DATEADD(MONTH,DATEDIFF(MONTH,-1,@dt),-1) AS LastOfThisMonth
     , DATEADD(MONTH,DATEDIFF(MONTH,0,@dt),-1) AS LastOfPrevMonth
     , DATEADD(YEAR,DATEDIFF(YEAR,0,@dt),0) AS FirstOfYear

Today               Yesterday           FirstOfThisMonth    LastOfThisMonth     LastOfPrevMonth     FirstOfYear
------------------- ------------------- ------------------- ------------------- ------------------- -------------------
2009-03-19 00:00:00 2009-03-18 00:00:00 2009-02-28 00:00:00 2009-03-31 00:00:00 2009-02-28 00:00:00 2009-01-01 00:00:00

ODBC Date/Time Escape Clauses

Another interesting method I found recently involves ODBC date and time escape clauses. I don’t really know much about these, but I thought they were intriguing. There are 3 extensions, one for date (d), time (t), and timestamp (ts). The only one I thought might be useful was the time extension. Here’s an example of using this to retrieve today’s date with no time value.

SELECT {t '00:00:00'} AS Today

Today
-------------------
2009-03-19 00:00:00

I could see this being handy if you only ever wanted to get the current date at midnight, but I haven’t found a way to pass in a variable or column to this, so it is limited to the current date only. Just for kicks, here’s how you would use the date and timestamp escape clauses.

SELECT {ts '2009-03-19 00:00:00'}
     , {d '2009-03-19'}

Both of these will return today’s date at midnight as well. I’d be interested to see if anyone knows any other uses for these.

Aaron

One of the difficult things about something that seems like it should be so simple is that some of the ways to check the version number only exist on certain versions. Other ways give you way more info than you really need.

Recently, I was digging through a system stored procedure, which is always the best place to find cool code, and I came across the undocumented system function @@MICROSOFTVERSION which is used internally by Microsoft.

It returns a seemingly random number, but you can use a bitwise AND operator to find the major version number.

SELECT @@MICROSOFTVERSION / 0x01000000

This will return the following based on your version of SQL Server:

7 (SQL 7 )
8 (SQL 2000)
9 (SQL 2005)
10 (SQL 2008)

This will work on any version of SQL Server as of now, but since it is undocumented, it’s always possible that it could be removed in the future.

Aaron

Here is an example of a simple CTE using the AdventureWorks database that will return a list of orders.

USE AdventureWorks

;WITH CTE_Orders (OrderID, OrderDate) AS
(
  SELECT PurchaseOrderID, OrderDate
    FROM Purchasing.PurchaseOrderHeader h
)

SELECT * FROM CTE_Orders

OrderID     OrderDate
----------- ----------
1           2001-05-17
2           2001-05-17
3           2001-05-17
4           2001-05-17
5           2001-05-31
...

What isn’t very clear is the use of multiple CTE definitions in one statement. Here is an example of multiple CTEs used in one statement. Each CTE in the statement has its own definition, and the final SELECT statement is able to query both CTEs. This will return a list of dates that orders were made along with the number of products ordered and the total amount of those products for each date.

;WITH CTE_OrdersDetail (OrderID, OrderDetailQty, OrderDetailAmt) AS
(
  SELECT PurchaseOrderID, OrderQty, LineTotal
    FROM Purchasing.PurchaseOrderDetail
),

CTE_Orders (OrderID, OrderDate) AS
(
  SELECT PurchaseOrderID, OrderDate
    FROM Purchasing.PurchaseOrderHeader h
)

SELECT o.OrderDate, SUM(od.OrderDetailQty) AS TotalOrderQty, SUM(od.OrderDetailAmt) AS TotalOrderAmt
  FROM CTE_Orders o
    INNER JOIN CTE_OrdersDetail od ON o.OrderID = od.OrderID
  GROUP BY o.OrderDate
  ORDER BY o.OrderDate

OrderDate  TotalOrderQty TotalOrderAmt
---------- ------------- -------------
2001-05-17 563           9491.518
2001-05-31 2765          94404.303
2002-01-14 718           39874.7685
2002-01-15 11931         259365.2145
2002-02-08 2768          50781.36
...

If you take this concept of having multiple CTE definitions in one statement, you can then apply it to a statement with nested CTEs. I’m using the following statement to return the same result set as in the previous example, but this time I want to know the number of orders for each date that had more than 100 products ordered.

;WITH CTE_OrdersDetail (OrderID, OrderDetailQty, OrderDetailAmt) AS
(
  SELECT PurchaseOrderID, OrderQty, LineTotal
    FROM Purchasing.PurchaseOrderDetail
),

CTE_Orders (OrderID, OrderDate, IsLargeOrder) AS
(
  SELECT PurchaseOrderID, OrderDate
       , (
         SELECT CASE
                  WHEN SUM(OrderDetailQty) >= 100 THEN 1
                  ELSE 0
                END
           FROM CTE_OrdersDetail d
           WHERE h.PurchaseOrderID = d.OrderID
         )
    FROM Purchasing.PurchaseOrderHeader h
)

SELECT o.OrderDate, SUM(od.OrderDetailQty) AS TotalOrderQty, SUM(od.OrderDetailAmt) AS TotalOrderAmt, SUM(o.IsLargeOrder) AS NumLargeOrders
  FROM CTE_Orders o
    INNER JOIN CTE_OrdersDetail od ON o.OrderID = od.OrderID
  GROUP BY o.OrderDate
  ORDER BY o.OrderDate

OrderDate  TotalOrderQty TotalOrderAmt         NumLargeOrders
---------- ------------- --------------------- --------------
2001-05-17 563           9491.518              1
2001-05-31 2765          94404.303             5
2002-01-14 718           39874.7685            1
2002-01-15 11931         259365.2145           26
2002-02-08 2768          50781.36              5
...

As you can see from this example, the CTE_OrdersDetail expression is being referenced within the definition of the CTE_Orders expression, giving you the functionality of nested CTEs. In order for a statement like this to work properly, you must declare each CTE definition before it is used in another CTE. This means that since CTE_OrdersDetail is being reference within CTE_Orders, I must declare CTE_OrdersDetail first. Otherwise, if the two definitions were switched, SQL would not be able to find the CTE_OrdersDetail object when it goes to verify the CTE_Orders expression.

SELECT * FROM People
GO

LastName FirstName
-------- ---------
Smith    John
Smith    John
Smith    John
Jackson  Tom
Jones    Sarah
Jones    Sarah
Williams Jessica

As you can see, there is nothing in this table that makes each row unique, and therefore you cannot delete one of the records for John Smith without deleting both records.

The easiest way to delete these duplicates is to add a new IDENTITY column to the table.

ALTER TABLE People ADD ID INT IDENTITY(1,1)
GO

SELECT * FROM People
GO

ID          LastName FirstName
----------- -------- ---------
1           Smith    John
2           Smith    John
3           Smith    John
4           Jackson  Tom
5           Jones    Sarah
6           Jones    Sarah
7           Williams Jessica

This will provide us with a unique value across all records, which we can use to find and delete the duplicate rows.

DELETE FROM People WHERE ID NOT IN
  (
  --Return only the ID for records we want to keep
  SELECT ID
    FROM
         (
         --Return one ID for each person
         SELECT MIN(ID) AS ID, LastName, FirstName
           FROM People
           GROUP BY LastName, FirstName
         ) a
  )
GO

SELECT * FROM People
GO

ID          LastName FirstName
----------- -------- ---------
1           Smith    John
4           Jackson  Tom
5           Jones    Sarah
7           Williams Jessica

We are now left with only one record for each person.  You can now drop the ID column from the table.

ALTER TABLE People DROP COLUMN ID
GO

-A

Apparently, you cannot connect to SSIS 2005 from within SSMS 2008.  I found a feedback ticket with Microsoft that confirms the issue, though I wasn’t completely clear if they are planning on fixing it or not.

So, for those of you who installed SSMS 2008, make sure you keep SSMS 2005 installed as well if you still have SSIS 2005 packages out there…even if it is a pain to have to switch back and forth.

-A

It wasn’t long before this started to get irritate me.  I did some digging and found 2 system stored procedures (sp_dts_listfolders and sp_dts_listpackages) in the msdb database that SQL Server uses to display the packages and folders in menus.

The first procedure, msdb.dbo.sp_dts_listfolders, returns the list of folders.  You can modify the procedure and add an ORDER BY clause to the end of the query, as shown below.

USE [msdb]
GO

ALTER PROCEDURE [dbo].[sp_dts_listfolders]
  @parentfolderid uniqueidentifier = NULL
AS
  SELECT
   folderid,
   parentfolderid,
   foldername
  FROM
      sysdtspackagefolders90
  WHERE
      [parentfolderid] = @parentfolderid OR
      (@parentfolderid IS NULL AND [parentfolderid] IS NULL)
  ORDER BY foldername

The second procedure, msdb.dbo.sp_dts_listpackages, returns the list of packages.  You can modify this procedure in the same way by adding the ORDER BY clause, as shown below.

USE [msdb]
GO

ALTER PROCEDURE [dbo].[sp_dts_listpackages]
  @folderid uniqueidentifier
AS
  SELECT
      name,
      id,
      description,
      createdate,
      folderid,
      datalength(packagedata),
      vermajor,
      verminor,
      verbuild,
      vercomments,
      verid
  FROM
      sysdtspackages90
  WHERE
      [folderid] = @folderid
  ORDER BY name

Now if you refresh your menu, you’ll see that everything is now ordered.

In SQL 2008, these procedures are now called msdb.dbo.sp_ssis_listfolders and msdb.dbo.sp_ssis_listpackages, and Microsoft has already added the ORDER BY clauses to both queries.

Example 3 – Create a sequential range of numbers

In this example, I’ll show you how to use a CTE to create a range of sequential numbers given a minimum (lower limit) and maximum (upper limit) number.  First, I’m going to declare the variables that I’ll be using.  The @LowerLimit and @UpperLimit variables will be used as starting and ending points of the range of numbers.  The @IncludeLowerLimit and @IncludeUpperLimit variables will tell the query if it needs to return the @LowerLimit and @UpperLimit values in the result set.  In this case, I want to use the range from 15 to 20, and I do want the limits to be a part of the result set.

DECLARE
      @LowerLimit           INT    -- Lower limit
    , @UpperLimit           INT    -- Upper limit
    , @IncludeLowerLimit    BIT    -- Includes lower limit in results
    , @IncludeUpperLimit    BIT    -- Includes upper limit in results

SELECT
      @LowerLimit           = 15
    , @UpperLimit           = 20
    , @IncludeLowerLimit    = 1
    , @IncludeUpperLimit    = 1

;WITH CTE_Range (Number) AS
(
  SELECT @LowerLimit + 1
  UNION ALL
  SELECT Number + 1
    FROM CTE_Range
    WHERE Number < @UpperLimit + 1
)
SELECT Number - @IncludeLowerLimit AS Number
  FROM CTE_Range
  WHERE Number < (@UpperLimit + @IncludeLowerLimit + @IncludeUpperLimit)
  ORDER BY Number

This query will return a sequential range of numbers from 15 through 20.

Number
-----------
15
16
17
18
19
20

(6 row(s) affected)

You can also change the @IncludeLowerLimit and @IncludeUpperLimit variables to shift the ranges a little.  I’ll now change the values for both of these variables to 0 and rerun the query.

SELECT
      @IncludeLowerLimit    = 0
    , @IncludeUpperLimit    = 0

This query will now only return a sequential range of numbers from 16 through 19.

Number
-----------
16
17
18
19

(4 row(s) affected)

Example 4 – Create a sequential range of dates

This example takes the same concept from example 3 and applies it to datetime values instead of numbers.  First, I’m going to declare the variables that I’ll be using.  The @LowerLimit and @UpperLimit variables will be used as starting and ending points of the range of datetime values.  The @IncludeLowerLimit and @IncludeUpperLimit variables will tell the query if it needs to return the @LowerLimit and @UpperLimit values in the result set.

The one variable that I added to this example is the @RangeInterval variable.  This allows you to specify the number of years, months, days, hours, minutes, seconds, etc. between the two datetime limits that should be returned in the result set.  If you want to change the datepart value (i.e. MONTH, DAY, HOUR, etc.), you will have to change that manually since the datepart value cannot be assigned from a variable.  However, you could add some more custom code to get this to work from a variable.

In this case, I’m going to use the range from 1/15/2009 12:00 AM to 1/20/2009 12:00 AM, use 1 day as the interval, and I do want the limits to be a part of the result set.

DECLARE
      @LowerLimit           DATETIME   -- Lower limit
    , @UpperLimit           DATETIME   -- Upper limit
    , @RangeInterval        INT        -- Interval between dates/times
    , @IncludeLowerLimit    BIT        -- Includes lower limit in results
    , @IncludeUpperLimit    BIT        -- Includes upper limit in results 

SELECT
      @LowerLimit           = '1/15/2009 12:00 AM'
    , @UpperLimit           = '1/20/2009 12:00 AM'
    , @RangeInterval        = 1
    , @IncludeLowerLimit    = 1
    , @IncludeUpperLimit    = 1

;WITH CTE_Range (Date) AS
(
  SELECT DATEADD(DAY,@RangeInterval,@LowerLimit)
  UNION ALL
  SELECT DATEADD(DAY,@RangeInterval,Date)
    FROM CTE_Range
    WHERE Date < DATEADD(DAY,@RangeInterval,@UpperLimit)
)
SELECT DATEADD(DAY,-@RangeInterval*@IncludeLowerLimit,Date) AS Date
  FROM CTE_Range
  WHERE Date < DATEADD(DAY,@RangeInterval*@IncludeLowerLimit,
               DATEADD(DAY,@RangeInterval*@IncludeUpperLimit,@UpperLimit))
  ORDER BY Date

This query will return a sequential range of datetime values every 1 day from 1/15/2009 12:00 AM to 1/20/2009 12:00 AM.

Date
-----------------------
2009-01-15 00:00:00.000
2009-01-16 00:00:00.000
2009-01-17 00:00:00.000
2009-01-18 00:00:00.000
2009-01-19 00:00:00.000
2009-01-20 00:00:00.000

(6 row(s) affected)

Now I’ll change the @RangeInterval, @LowerLimit and @UpperLimit variables to show you some different output.  I’ll also need to change the datepart in every DATEADD function from DAY to HOUR so that it will return a datetime value for every 6 hours between 1/15/2009 4:00 AM and 1/16/2009 4:00 AM.

SELECT
      @LowerLimit           = '1/15/2009 4:00 AM'
    , @UpperLimit           = '1/16/2009 4:00 AM'
    , @RangeInterval        = 4
    , @IncludeLowerLimit    = 1
    , @IncludeUpperLimit    = 1

;WITH CTE_Range (Date) AS
(
  SELECT DATEADD(HOUR,@RangeInterval,@LowerLimit)
  UNION ALL
  SELECT DATEADD(HOUR,@RangeInterval,Date)
    FROM CTE_Range
    WHERE Date < DATEADD(HOUR,@RangeInterval,@UpperLimit)
)
SELECT DATEADD(HOUR,-@RangeInterval*@IncludeLowerLimit,Date) AS Date
  FROM CTE_Range
  WHERE Date < DATEADD(HOUR,@RangeInterval*@IncludeLowerLimit,
               DATEADD(HOUR,@RangeInterval*@IncludeUpperLimit,@UpperLimit))
  ORDER BY Date

This query will now only return a sequential range of datetime values every 6 hours from 1/15/2009 4:00 AM to 1/20/2009 4:00 AM.

Date

-----------------------
2009-01-15 04:00:00.000
2009-01-15 10:00:00.000
2009-01-15 16:00:00.000
2009-01-15 22:00:00.000
2009-01-16 04:00:00.000

(5 row(s) affected)

Conclusion

You might wonder why you would ever need these queries, and I would have thought the same thing…until recently.  I hope this helps someone out there.

I recently had a project that required me to find the number of employees who were scheduled for every 15 minute increment, for every business day for a week, and for many stores.  Yikes!  Sure, I could use tons of loops and temp tables to do this, but I’m all about set based queries whenever possible…and I knew this was possible and I love a challenge!

It finally occurred to me that I could use the self-referencing (recursive) capabilities of Common Table Expressions (introduced in SQL 2005) to the mimic loops I needed to accomplish my goal.

I took some of the recursive CTE queries that I came up with for my project and turned them into 4 examples.  It was quite a bit of info, so I’ll be spreading them across 2 posts.

What is a Common Table Expression (CTE)?

Books Online defines a CTE as a temporary result set that is defined within the execution scope of a single SELECT, INSERT, UPDATE, DELETE, or CREATE VIEW statement. A CTE is similar to a derived table in that it is not stored as an object and lasts only for the duration of the query. Unlike a derived table, a CTE can be self-referencing and can be referenced multiple times in the same query.

Here’s a very basic example of a CTE.

USE AdventureWorks
GO

;WITH Employees (EmployeeID, JobTitle) AS
(
    SELECT EmployeeID, Title
      FROM HumanResources.Employee
)
SELECT *
  FROM Employees

As you can see in the example, I preceded the CTE with an semicolon.  The reason for this is because if a CTE is not the first statement in a batch, the previous statement must always be terminated with a semicolon, and you will receive one of two errors.

Incorrect syntax near the keyword ‘with’. If this statement is a common table expression or an xmlnamespaces clause, the previous statement must be terminated with a semicolon.

or

Incorrect syntax near ‘Employees’.

In my example, the semicolon is not needed since GO starts a new batch and the CTE is the first statement in the batch, I always make a habit of starting them off with a semicolon in case I ever add a preceding statement.

Recursive Queries

One of the most powerful features of common table expressions is their ability to be self-referenced, allowing a recursive query.  The most common use of a recursive query in a CTE is to create a hierarchy.  For example, if you had an Employee table that had a column for the EmployeeID and another column for the ManagerEmployeeID, you could use a self-referencing CTE to build a hierarchical result set of an organizational chart.

Srinivas Sampath wrote a good article on building a hierarchy using a CTE on sqlservercentral.com, so I’m not going to go into much detail here.  Instead, I figured I would show you other ways that a recursive query can be used within a CTE.

Example 1 – Finding missing numbers in a sequence

In this example, I’ll show you how to use a CTE to find missing numbers (gaps) in a range of sequential numbers.  First, I’m going to create a temporary table and add some numbers to it.

CREATE TABLE #Numbers (Num INT)

INSERT INTO #Numbers VALUES (1)
INSERT INTO #Numbers VALUES (3)
INSERT INTO #Numbers VALUES (6)
INSERT INTO #Numbers VALUES (10)

Now, I can use a CTE to find the missing sequential numbers.

;WITH CTE_MissingNumbers (MissingNum) AS
(
     SELECT n1.Num + 1
       FROM #Numbers n1
       WHERE NOT EXISTS (SELECT NULL FROM #Numbers n2 WHERE n2.Num = n1.Num + 1)
         AND n1.Num < (SELECT MAX(Num) FROM #Numbers)
     UNION ALL
     SELECT cte.MissingNum + 1
       FROM CTE_MissingNumbers cte
       WHERE NOT EXISTS (SELECT NULL FROM #Numbers n WHERE n.Num = cte.MissingNum + 1)
)
SELECT MissingNum
  FROM CTE_MissingNumbers
  ORDER BY MissingNum

The first SELECT statement in the CTE will only return the first missing number in each gap, so in this case, it will return the numbers 2, 4, and 7.

The second SELECT statement in the CTE will return the remaining missing numbers, if any, in each gap, so in this case, it will return the numbers 5, 8, and 9.  It does this by continually referencing itself and reevaluating the gaps.  As the more numbers are returned, the gaps get smaller and smaller until all numbers are returned.  Think of the CTE as a WHILE loop that runs the first statement in the CTE and missing numbers back into the table.  The loop then would continue over and over until the SELECT statement no longer returned any results.

Example 2 – Finding missing dates in a sequence

This example takes the same concept from example 1 and applies it to dates instead of numbers.  First, I’m going to create a temporary table and add some dates to it.

CREATE TABLE #Dates (Date SMALLDATETIME) 

INSERT INTO #Dates VALUES ('1/1/2009')
INSERT INTO #Dates VALUES ('1/3/2009')
INSERT INTO #Dates VALUES ('1/6/2009')
INSERT INTO #Dates VALUES ('1/10/2009')

Now, I can use a CTE to find the missing sequential dates.

;WITH CTE_MissingDates (MissingDate) AS
(
    SELECT DATEADD(DAY,1,d1.Date)
      FROM #Dates d1
      WHERE NOT EXISTS (SELECT NULL FROM #Dates d2 WHERE d2.Date = DATEADD(DAY,1,d1.Date))
        AND d1.Date < (SELECT MAX(Date) FROM #Dates)
    UNION ALL
    SELECT DATEADD(DAY,1,cte.MissingDate)
      FROM CTE_MissingDates cte
      WHERE NOT EXISTS (SELECT NULL FROM #Dates d WHERE d.Date = DATEADD(DAY,1,cte.MissingDate))
)
SELECT MissingDate
  FROM CTE_MissingDates
  ORDER BY MissingDate

The only thing I really had to change to return missing dates instead of numbers was adding the DATEADD function.  This will find all of the missing days, but for this to work, all of the time values in the Date column must all be the same.  If your date values are not the same, you can strip off the time values as shown in red below:

TRUNCATE TABLE #Dates

INSERT INTO #Dates VALUES ('1/1/2009 5:00 PM')
INSERT INTO #Dates VALUES ('1/3/2009 3:00 PM')
INSERT INTO #Dates VALUES ('1/6/2009 1:00 PM')
INSERT INTO #Dates VALUES ('1/10/2009 2:00 PM')

;WITH CTE_MissingDates (MissingDate) AS
(
     SELECT DATEADD(DAY,1,DATEDIFF(DAY,0,d1.Date))
       FROM #Dates d1
       WHERE NOT EXISTS
             (
             SELECT NULL
               FROM #Dates d2
               WHERE DATEADD(DAY,0,DATEDIFF(DAY,0,d2.Date)) = DATEADD(DAY,1,DATEDIFF(DAY,0,d1.Date))
             )
         AND d1.Date < (SELECT MAX(Date) FROM #Dates)
     UNION ALL     SELECT DATEADD(DAY,1,cte.MissingDate)
       FROM CTE_MissingDates cte
       WHERE NOT EXISTS
             (
             SELECT NULL
               FROM #Dates d
               WHERE DATEADD(DAY,0,DATEDIFF(DAY,0,d.Date)) = DATEADD(DAY,1,cte.MissingDate)
             )
)
SELECT MissingDate
  FROM CTE_MissingDates
  ORDER BY MissingDate

Conclusion

Here are two examples of using common table expressions to find missing numbers and dates in a sequence.  In my next post, I’ll show you a few more examples of recursive queries with common table expressions based off of the examples in this post.

Error: Failed to lock variable XXXX for read access with error 0xC0010001 "The variable cannot be found. This occurs when an attempt is made to retrieve a variable from the Variables collection on a container during execution of the package, and the variable is not there. The variable name may have changed or the variable is not being created."

It was so frustrating that I figured I would post it here in case anyone else comes across the same problem.

If you’ve ever seen this error before, you’ll most likely find that it is caused by a script task/component that is referencing a variable that no longer exists.  In my case, I had no scripts but I did change some of my package variables.

After a while of trying to figure out what would cause this issue, I finally realized that my package had checkpoints enabled.  When checkpoints are enable, details about the variables are written to the checkpoint file when the package is executed.

In the process of fixing the original problem with my package, I deleted some of the existing variables.  I made sure to update all of my tasks that referenced the deleted variables, but I forgot to delete the checkpoint file before restarting the package.

When the checkpoint file was read upon execution, it tried to assign a value to the variables that were deleted, but since they did not exist anymore, I got this error.

I guess the point is, if you make changes to the structure of a package when checkpoints are enabled and a checkpoint file exists, it might be worth your time to delete the file before restarting the package with the new changes in effect.

-A

Visual Studios 8.0 (SQL 2005):
HKEY_CURRENT_USER\Software\Microsoft\VisualStudio\8.0\ProjectMRUList

Visual Studios 9.0 (SQL 2008):
HKEY_CURRENT_USER\Software\Microsoft\VisualStudio\9.0\ProjectMRUList

Here you’ll find a list of keys that represent the projects/solutions that appear in your Recent Projects.  You can either delete all of these entries, or just specific ones.  Be careful if you only delete specific ones though.  If you have 4 items (File1, File2, File3, File4) and you delete File2, only File1 will appear in your Recent Projects list.  To fix this, you’ll just need to rename the rest of the keys so that there are no gaps in the sequential numbering.  In this case, you would need to rename File3 to File2 and File4 to File3.

When you re-open Visual Studios, you should find a much cleaner list.

-A