the WHERE clause before using it in the UPDATE statement. We’ll see examples of that soon in this chapter. For now, let’s look at a simple method of conditionally updating a single row.
The humans table contains a row for a young woman named Rusty Osborne. She was married recently and wants to change her last name to her husband’s name, Johnson. We can do this with the UPDATE statement. First, let’s retrieve the record for her. We’ll select data based on her first and last name. There may be only one Rusty Osborne in the
database, but there may be a few members with the family name of Osborne. So we would enter this in the mysql client:
SELECT human_id, name_first, name_last FROM humans
WHERE name_first = 'Rusty' AND name_last = 'Osborne';
+---+---+---+
| human_id | name_first | name_last | +---+---+---+
| 3 | Rusty | Osborne | +---+---+---+
Looking at the results, we can see that there is indeed only Rusty Osborne, and that the value of her human_id is 3. We’ll use that value in the UPDATE statement to be sure that we update only this one row. Let’s enter the following:
UPDATE humans
SET name_last = 'Johnson' WHERE human_id = 3;
SELECT human_id, name_first, name_last FROM humans
WHERE human_id = 3;
+---+---+---+
| human_id | name_first | name_last | +---+---+---+
| 3 | Rusty | Johnson | +---+---+---+
That worked just fine. It’s easy to use the UPDATE statement, especially when you know the identification number of the key column for the one row you want to change. Let’s
suppose that two of our members who are married women have asked us to change their title from Mrs. to Ms. (this information is contained in an enumerated column called
formal_title). After running a SELECT statement to find their records, we see that their
human_id numbers are 24 and 32. We could then execute the following UPDATE statement in MySQL:
UPDATE humans
SET formal_title = 'Ms.' WHERE human_id IN(24, 32);
Things get slightly more complicated when you want to change more than one row, but it’s still easy if you know the key values. In this example, we used the IN operator to list the human_id numbers to match specific rows in the table.
Suppose that after updating the title for the two women just shown, we decide that we want to make this change for all married women in the database, to get with the modern times. We would use the UPDATE statement again, but we’ll have to modify the WHERE clause. There may be too many women with the formal_title of Mrs. in the table to manually enter the human_id for all of them. Plus, there’s an easier way to do it. First, let’s
see how the formal_title column looks now:
SHOW FULL COLUMNS FROM humans
LIKE 'formal_title' \G
*************************** 1. row ***************************
Field: formal_title
Type: enum('Mr.','Miss','Mrs.','Ms.') Collation: latin1_bin
Null: YES Key:
Default: NULL Extra:
Privileges: select,insert,update,references Comment:
Looking at the enumerated values of this column, we decide that the choices seem
somewhat sexist to us. We have one choice for boys and men, regardless of their age and marital status, and three choices for women. We also don’t have other genderless choices like Dr., but we decide to ignore those possibilities for now. In fact, we could eliminate the column so as not to be gender biased, but we decide to wait before making that decision.
At this point, we want to change our schema so it limits the list of choices in the column to Mr. or Ms. however, we should not make that change to the schema until we fix all the existing values in the column. To do that, we’ll enter this UPDATE statement:
UPDATE humans
SET formal_title = 'Ms.'
WHERE formal_title IN('Miss','Mrs.');
Now that all of the members have either a value of Mr. or Ms. in the formal_title
column, we can change the settings of that column to eliminate the other choices. We’ll use the ALTER TABLE statement covered in Chapter 4. Enter the following to change the table on your server:
ALTER TABLE humans
CHANGE COLUMN formal_title formal_title ENUM('Mr.','Ms.');
Query OK, 62 rows affected (0.13 sec) Records: 62 Duplicates: 0 Warnings: 0
As you can see from the message in the results, the column change went well. However, if we had forgotten to change the data for one of the rows (e.g., didn’t change Miss to Ms.
for one person), the Warnings would show a value of 1. In that case, you would then have to execute the SHOW WARNINGS statement to see this warning:
SHOW WARNINGS \G
*************************** 1. row ***************************
Level: Warning Code: 1265
Message: Data truncated for column 'formal_title' at row 44
This tells us that MySQL eliminated the value for the formal_title column of the 44th row. We’d then have to use the UPDATE statement to try to set the formal_title for the person whose title was clobbered and hope we set the title correctly. That’s why it’s usually better to update the data before altering the table.
Sometimes, when changing bulk data, you have to alter the table before you can do the update. For example, suppose that we decide that we prefer to have the enumerated values of the formal_title set to Mr or Ms, without any periods. To do this, we would need to add that pair of choices to the ENUM column before we eliminate the old values. Then we
can easily change the data to the new values. In this situation, we can tweak the criteria of the WHERE clause of the UPDATE statement. The values have a pattern: the new values are the same as the first two characters of the old value. So we can use a function to extract that part of the string. We would do something like this:
ALTER TABLE humans
CHANGE COLUMN formal_title formal_title ENUM('Mr.','Ms.','Mr','Ms');
UPDATE humans
SET formal_title = SUBSTRING(formal_title, 1, 2);
ALTER TABLE humans
CHANGE COLUMN formal_title formal_title ENUM('Mr','Ms');
The first ALTER TABLE statement adds the two new choices of titles without a period to the column, without yet eliminating the previous two choices because existing table contents use them. The final ALTER TABLE statement removes the two old choices of titles with a period from the column. Those two SQL statements are fine and not very interesting. The second one is more interesting, the UPDATE.
In the SET clause, we set the value of the formal_title column to a substring of its current value. We’re using the SUBSTRING() function to extract the text. Within the
parentheses, we give the column from which to get a string (formal_title). Then we give the start of the substring we want to extract: 1, meaning the first character of the original string. We specify the number of characters we want to extract: 2. So wherever
SUBSTRING() encounters “Mr.” it will extract “Mr”, and wherever it encounters “Ms.” it will extract “Ms”.
It’s critical to note that fuctions don’t change the data in the table. SUBSTRING() simply gives you back the substring. In order to actually change the column, you need the SET
formal_title = clause. That changes formal_title to the value you got back from
SUBSTRING(). Note that, if you wanted, you could just as easily have run SUBSTRING() on one column and used it to set the value of a different one.
In this chapter, we’ll work with a few string functions that are useful with the UPDATE
statement. We’ll cover many more string functions in Chapter 10.