I want to find all the tables in my db that contain the column name Foo, and update its value to 0, I was thinking something like this, but I don’t know how to place the UPDATE on that code, I plan on having this statement on the Events inside the MySQL database, I’m using WAMP, the idea is basically having an event run daily which sets all my ‘Foo’ Columns to 0 without me having to do it manually
SELECT TABLE_NAME, COLUMN_NAME FROM INFORMATION_SCHEMA.COLUMNS WHERE column_name LIKE 'Foo'
No, not in a single statement.
To get the names of all that tables that contain column named
SELECT table_schema, table_name FROM information_schema.columns WHERE column_name = 'Foo'
Then, you’d need an UPDATE statement for each table. (It’s possible to do update multiple tables in a single statement, but that would need to be an (unnecessary) cross join.) It’s better to do each table separately.
You could use dynamic SQL to execute the UPDATE statements in a MySQL stored program (e.g. PROCEDURE)
DECLARE sql VARCHAR(2000); SET sql = 'UPDATE db.tbl SET Foo = 0'; PREPARE stmt FROM sql; EXECUTE stmt; DEALLOCATE stmt;
If you declare a cursor for the select from information_schema.tables, you can use a cursor loop to process a dynamic
UPDATE statement for each table_name returned.
DECLARE done TINYINT(1) DEFAULT FALSE; DECLARE sql VARCHAR(2000); DECLARE csr FOR SELECT CONCAT('UPDATE `',c.table_schema,'`.`',c.table_name,'` SET `Foo` = 0') AS sql FROM information_schema.columns c WHERE c.column_name = 'Foo' AND c.table_schema NOT IN ('mysql','information_schema','performance_schema'); DECLARE CONTINUE HANDLER FOR NOT FOUND SET done = TRUE; OPEN csr; do_foo: LOOP FETCH csr INTO sql; IF done THEN LEAVE do_foo; END IF; PREPARE stmt FROM sql; EXECUTE stmt; DEALLOCATE PREPARE stmt; END LOOP do_foo; CLOSE csr;
(This is just an rough outline of an example, not syntax checked or tested.)
Some brief notes about some ideas that were probably glossed over in the answer above.
To get the names of the tables containing column
Foo, we can run a query from the
information_schema.columns table. (That’s one of the tables provided in the MySQL
Because we may have tables in multiple databases, the table_name is not sufficient to identify a table; we need to know what database the table is in. Rather than mucking with a “
use db” statement before we run an
UPDATE, we can just reference the table
UPDATE db.mytable SET Foo....
We can use our query of
information_schema.columns to go ahead and string together (concatenate) the parts we need to create for an UPDATE statement, and have the SELECT return the actual statements we’d need to run to update column
Foo, basically this:
UPDATE `mydatabase`.`mytable` SET `Foo` = 0
But we want to substitute in the values from
table_name in place of
mytable. If we run this SELECT
SELECT 'UPDATE `mydatabase`.`mytable` SET `Foo` = 0' AS sql
That returns us a single row, containing a single column (the column happens to be named
sql, but name of the column isn’t important to us). The value of the column will just be a string. But the string we get back happens to be (we hope) a SQL statement that we could run.
We’d get the same thing if we broke that string up into pieces, and used CONCAT to string them back together for us, e.g.
SELECT CONCAT('UPDATE `','mydatabase','`.`','mytable','` SET `Foo` = 0') AS sql
We can use that query as a model for the statement we want to run against
information_schema.columns. We’ll replace
'mytable' with references to columns from the
information_schema.columns table that give us the database and table_name.
SELECT CONCAT('UPDATE `',c.table_schema,'`.`',c.table_name,'` SET `Foo` = 0') AS sql FROM information_schema.columns WHERE c.column_name = 'Foo'
There are some databases we definitely do not want to update…
performance_schema. We either need whitelist the databases containing the table we want to update
AND c.table_schema IN ('mydatabase','anotherdatabase')
–or– we need to blacklist the databases we definitely do not want to update
AND c.table_schema NOT IN ('mysql','information_schema','performance_schema')
We can run that query (we could add an
ORDER BY if we want the rows returned in a particular order) and what we get back is list containing the statements we want to run. If we saved that set of strings as a plain text file (excluding header row and extra formatting), adding a semicolon at the end of each line, we’d have a file we could execute from the
mysql> command line client.
(If any of the above is confusing, let me know.)
The next part is a little more complicated. The rest of this deals with an alternative to saving the output from the SELECT as a plain text file, and executin the statements from the
mysql command line client.
MySQL provides a facility/feature that allows us to execute basically any string as a SQL statement, in the context of a MySQL stored program (for example, a stored procedure. The feature we’re going to use is called dynamic SQL.
To use dynamic SQL, we use the statements
DEALLOCATE PREPARE. (The deallocate isn’t strictly necessary, MySQL will cleanup for us if we don’t use it, but I think it’s good practice to do it anyway.)
Again, dynamic SQL is available ONLY in the context of a MySQL stored program. To do this, we need to have a string containing the SQL statement we want to execute. As a simple example, let’s say we had this:
DECLARE str VARCHAR(2000); SET str = 'UPDATE mytable SET mycol = 0 WHERE mycol < 0';
To get the contents of
str evaluated and executed as a SQL statement, the basic outline is:
PREPARE stmt FROM str; EXECUTE stmt; DEALLOCATE PREPARE stmt;
The next complicated part is putting that together with the query we are running to get string value we want to execute as SQL statements. To do that, we put together a cursor loop. The basic outline for that is to take our SELECT statement:
SELECT bah FROM humbug
And turn that into a cursor definition:
DECLARE mycursor FOR SELECT bah FROM humbug ;
What we want to is execute that and loop through the rows it returns. To execute the statement and prepare a resultset, we “open” the cursor
When we’re finished with it, we’re goin to issue a “close”, to release the resultset, so the MySQL server knows we don’t need it anymore, and can cleanup, and free up the resources allocated to that.
But, before we close the cursor, we want to “loop” through the resultset, fetching each row, and do something with the row. The statement we use to get the next row from the resultset into a procedure variable is:
FETCH mycursor INTO some_variable;
Before we can fetch rows into variables, we need to define the variables, e.g.
DECLARE some_variable VARCHAR(2000);
Since our cursor (SELECT statement) is returning only a single column, we only need one variable. If we had more columns, we’d need a variable for each column.
Eventually, we’ll have fetched the last row from the result set. When we attempt to fetch the next one, MySQL is going to throw an error.
Other programming languages would let us just do a
while loop, and let us fetch the rows and exit the loop when we’ve processed them all. MySQL is more arcane. To do a loop:
mylabel: LOOP -- do something END LOOP mylabel;
That by itself makes for a very fine infinite loop, because that loop doesn’t have an “exit”. Fortunately, MySQL gives us the
LEAVE statement as a way to exit a loop. We typically don’t want to exit the loop the first time we enter it, so there’s usually some conditional test we use to determine if we’re done, and should exit the loop, or we’re not done, and should go around the the loop again.
mylabel: LOOP -- do something useful IF some_condition THEN LEAVE mylabel; END IF; END LOOP mylabel;
In our case, we want to loop through all of the rows in the resultset, so we’re going to put a
FETCH a the first statement inside the loop (the something useful we want to do).
To get a linkage between the error that MySQL throws when we attempt to fetch past the last row in the result set, and the conditional test we have to determine if we should leave…
MySQL provides a way for us to define a
CONTINUE HANDLER (some statement we want performed) when the error is thrown…
DECLARE CONTINUE HANDLER FOR NOT FOUND
The action we want to perform is to set a variable to TRUE.
SET done = TRUE;
Before we can run the SET, we need to define the variable:
DECLARE done TINYINT(1) DEFAULT FALSE;
With that we, can change our LOOP to test whether the
done variable is set to TRUE, as the exit condition, so our loop looks something like this:
mylabel: LOOP FETCH mycursor INTO some_variable; IF done THEN LEAVE mylabel; END IF; -- do something with the row END LOOP mylabel;
The “do something with the row” is where we want to take the contents of
some_variable and do something useful with it. Our cursor is returning us a string that we want to execute as a SQL statement. And MySQL gives us the dynamic SQL feature we can use to do that.
NOTE: MySQL has rules about the order of the statements in the procedure. For example the
DECLARE statement have to come at the beginning. And I think the CONTINUE HANDLER has to be the last thing declared.
Again: The cursor and dynamic SQL features are available ONLY in the context of a MySQL stored program, such as a stored procedure. The example I gave above was only the example of the body of a procedure.
To get this created as a stored procedure, it would need to be incorporated as part of something like this:
DELIMITER $$ DROP PROCEDURE IF EXISTS myproc $$ CREATE PROCEDURE myproc NOT DETERMINISTIC MODIFIES SQL DATA BEGIN -- procedure body goes here END$$ DELIMITER ;
Hopefully, that explains the example I gave in a little more detail.