Implementation of different values for mysql batch update and batch update of multiple records

Batch update

The mysql update statement is simple. to update a field of a piece of data, write as follows:

Copy codeThe Code is as follows:
UPDATE mytable SET myfield = 'value' WHERE other_field = 'other _ value ';

If the same field is updated to the same value, mysql is also very simple. modify where:

Copy codeThe Code is as follows:
UPDATE mytable SET myfield = 'value' WHERE other_field in ('other _ values ');
 

Note that 'other _ values' is a comma (,)-separated string, for example, 1, 2, 3.

If multiple data entries are updated with different values, many may write as follows:

Copy codeThe Code is as follows:
Foreach ($ display_order as $ id => $ ordinal ){
$ SQL = "UPDATE categories SET display_order = $ ordinal WHERE id = $ id ";
Mysql_query ($ SQL );
}

It is an update record that repeats one by one. Update a record once, which has poor performance and can easily cause blocking.

Can I update an SQL statement in batches? Mysql does not provide a direct method for batch update, but it can be implemented with tips.

Copy codeThe Code is as follows:
UPDATE mytable
SET myfield = CASE id
WHEN 1 THEN 'value'
WHEN 2 THEN 'value'
WHEN 3 THEN 'value'
END
WHERE id IN (1, 2, 3)

Here we use the case when tip to implement batch update.
For example:

Copy codeThe Code is as follows:
UPDATE categories
SET display_order = CASE id
WHEN 1 THEN 3
WHEN 2 THEN 4
WHEN 3 THEN 5
END
WHERE id IN (1, 2, 3)

This SQL statement indicates that the display_order field is updated. If id = 1, the value of display_order is 3. If id = 2, the value of display_order is 4, if id = 3, the value of display_order is 5.
The condition statements are written together.
The where part does not affect code execution, but it increases the SQL Execution efficiency. Make sure that the SQL statement only executes the number of rows to be modified. Here, only three rows of data are updated, and the where clause ensures that only three rows of data are executed.

If you want to update multiple values, you only need to slightly modify them:

Copy codeThe Code is as follows:
UPDATE categories
SET display_order = CASE id
WHEN 1 THEN 3
WHEN 2 THEN 4
WHEN 3 THEN 5
END,
Title = CASE id
WHEN 1 THEN 'new Title 1'
WHEN 2 THEN 'new Title 2'
WHEN 3 THEN 'new Title 3'
END
WHERE id IN (1, 2, 3)

At this point, a mysql statement has been completed to update multiple records.
But to use it in the business, you need to combine the server language. Here we take php as an example to construct this mysql statement:

Copy codeThe Code is as follows:
$ Display_order = array (
1 => 4,
2 => 1,
3 => 2,
4 => 3,
5 => 9,
6 => 5,
7 => 8,
8 => 9
);
$ Ids = implode (',', array_keys ($ display_order ));
$ SQL = "UPDATE categories SET display_order = CASE id ";
Foreach ($ display_order as $ id => $ ordinal ){
$ SQL. = sprintf ("WHEN % d THEN % d", $ id, $ ordinal );
}
$ SQL. = "END WHERE id IN ($ ids )";
Echo $ SQL;

In this example, eight records are updated. The code is easy to understand. Have you learned it?

Performance Analysis

When I use tens of thousands of records to use mysql for batch update, I find that the performance is poor when using the most primitive batch update. I can summarize the following three methods on the Internet:

1. Batch update: one record is updated once, with poor performance

Copy codeThe Code is as follows:
Update test_tbl set dr = '2' where id = 1;

2. replace into or insert into... on duplicate key update

Copy codeThe Code is as follows:
Replace into test_tbl (id, dr) values (1, '2'), (2, '3'),... (x, 'y ');

Or use

Copy codeThe Code is as follows:
Insert into test_tbl (id, dr) values (1, '2'), (2, '3 '),... (x, 'y') on duplicate key update dr = values (dr );

3. Create a temporary table, update the temporary table first, and then update from the temporary table

The Code is as follows:
Create temporary table tmp (id int (4) primary key, dr varchar (50 ));
Insert into tmp values (0, 'gone'), (1, 'xx'),... (m, 'yy ');
Update test_tbl, tmp set test_tbl.dr = tmp. dr where test_tbl.id = tmp. id;

Note: This method requires you to have the create permission for the temporary table.

The following is the performance test result of the above method to update 100000 pieces of data:

Update one by one

Real 0m15. 557 s
User 0m1. 684 s
Sys 0m1. 372 s

Replace
Real 0m1. 394 s
User 0m0. 060 s
Sys 0m0. 012 s

Insert into on duplicate key update
Real 0m1. 474 s
User 0m0. 052 s
Sys 0m0. 008 s

Create temporary table and update:
Real 0m0. 643 s
User 0m0. 064 s
Sys 0m0. 004 s

The test results show that the performance of replace into is better.

The difference between replace into and insert into on duplicate key update is:
The replace into operation is essentially to delete duplicate records and then insert them. If the updated field is not plenary, set the missing field to the default value.
Insert into indicates that only the record is updated and other fields are not changed.