Tagged as

Why SQL Updates Fail – Five Reasons

"The SQL command ran, there's no error message but nothing changed! What's going on? Do you think it's a virus? Maybe there's a bug in .NET!"

"The SQL command ran, there's no error message but nothing changed! What's going on? Do you think it's a virus? Maybe there's a bug in .NET!"

The junior programmer was almost in tears when he came to me for help. Proud and confident in his abilities and faced with failure on what should have been an easy task, the poor little fellow's puffed up ego collapsed like a house of cards. I patted him gently on the shoulder and said soothingly, "It's because you're an idiot."

OK, I didn't really say that.

Actually, having an SQL update statement not change any records and not produce an error is expected and desirable behavior:

If you run an update to add a late fee to all outstanding accounts over 2 weeks late and there are no late accounts….the update will succeed, no records will be modified and there will be no error message. This is as it should be.

When an update does not produce an error and no records are modified, it's because the WHERE clause did not locate any records to update. Sometimes this is OK, other times it is a mistake.

Here are three ways this can happen by mistake.

Case Sensitivity Misses

If the collating sequence of the database or column is case sensitive, the text in the column may not match the text in the WHERE clause: Z123 does NOT equal z123. In SQL Server, the default is case insensitive.

Space Padded Data

The field type in the database may space pad the data. In SQL Server, if a column type is char(6) or nchar(6) and 'ABC' is saved, what is actually put in the table is 'ABC ' (note the 3 spaces after ABC). A search for 'ABC' will fail because 'ABC' does not equal 'ABC '.

Dates with Extraneous Time Stamps

DateTime columns have two components (Date and Time…duh). If you are searching a DateTime column either the data or the search criteria may include a timestamp that causes the search to fail:

12-31-2000 12:23:45 AM does not equal 12-31-2000 12:00:00 AM

When storing dates, it is a best practice to truncate the time of DateTime fields so the times are zero (or 12:00:00 AM).

Here is a SQL statement to scrub existing data:

UPDATE MyTable SET MyDate = dateadd(dd, datediff(dd, 0, MyDate), 0)

When searching for records, you can set the search criteria to include only the date by using the Date property of the DateTime structure:

DateTime SearchDate = DateTime.Now.Date;

Note: SQL Server 2008 has new data types of just DATE and TIME.

Bonus: Floating Point Numbers

This is extremely rare but if you have floating point numbers in the data and expect to use an exact WHERE clause to retrieve and update data, good luck. As everyone knows who's taken Numerical Analysis 1001:

1.50000000000 does not equal 1.49999999999

Final

If you are unsure of what is going to be updated in a statement, it is easy to replace the UPDATE with a SELECT and check what is actually being retrieved.

I hope this helps someone.

[Edit]

One more thing that can cause a WHERE clause to fail….

A field containing NULL will not be found if the WHERE clause is looking for an empty string (and vice versa).

This is a good tip Steve.
Personally, I think it is best practice to always start with a SELECT statement to make sure you are only going to be altering exactly the number of records you want to, and then just substituting the SELECT for UPDATE.

I learned this after making a few REALLY stupid mistakes which, fortunately, were fairly limited in the amount of damage they caused!

Very handy tips, I've run into all of them myself with the exception of the floating-point equality test (which has been taboo in my mind from an early age ). In PostgreSQL for example, there are some weird inconsistencies w.r.t. spaces at the end of CHAR(n) datatypes -- e.g. regexp_replace() ignores trailing spaces, while the ~ regex-matching operator honours them. (For this reason among others, it's actually best to always use VARCHAR types instead of fixed-width types -- that incurs no performance/space penalty on PostgreSQL, although it may do on other DBs.) Tricky!

But: Use transactions!

Live production changes are too important not to be shielded by a transaction in case you mess something up!

For anything that I expect to modify only a handful of rows, I'll SELECT the relevant lines before and after and eyeball them to make sure they're right. For anything that I expect to modify many rows, I'll run SELECT COUNT(*) WHERE my_conditions first, and check that the number of rows reported matches the number of rows changed by the UPDATE/DELETE I run next.