Skip to content

# Month: June 2012

## DELETE, don’t INSERT

MySQL common_schema openark kit Performance QueryScript June 27, 2012June 27, 2012

Have just read INSERT, Don’t DELETE by Aaron Brown, and have some lengthy response, which is why I write this post instead of commenting on said post.

I wish to offer my counter thought and suggest that DELETEs are probably the better choice.

Aaron suggests that, when one wishes to purge rows from some table, a trick can be used: instead of DELETEing unwanted rows, one can INSERT “good” rows into a new table, then switch over with RENAME (but please read referenced post for complete details).

I respectfully disagree on several points discussed.

#### Lockdown

The fact one needs to block writes during the time of creation of new table is problematic: you need to essentially turn off parts of your application. The posts suggests one could use a slave – but this solution is far from being trivial as well. To switch over, you yet again need to turn off access to DB, even if for a short while. Continue reading » “DELETE, don’t INSERT”

## A new MySQL backups temperature scale, with showers

MySQL Backup June 26, 2012June 27, 2012

We’re used to Cold, Warm and Hot backups. This scale of three temperatures does not quite reflect the impact of backups on your MySQL database.

In this post I offer a new backup temperature scale, and (somewhat seriously) compare it with showers. Call it the backup shower scale.

> A database backup is like a shower: the colder it is, the less time you want to spend doing it.

#### Cold

A cold backup requires taking your database down (i.e. stop the service).

Example: file system copy

This can work well for replicating slaves, which may not be required for normal operation. You take the slave down, turn off the service, make your backup, turn everything on again, and let the backup catch up. Just make sure its master has all the necessary binary logs.

A friend was staying at my place and was lecturing me on the benefits of cold showers; how it was good for your health. A couple hours later, preparing for bed, I hear him exclaiming from the bathroom: “Whaaaaa! There’s no hot water!” Continue reading » “A new MySQL backups temperature scale, with showers”

## Who is hogging my MySQL connections?

MySQL common_schema June 21, 2012June 21, 2012

Got “too many connections” this morning. New attempts continuously abort. Every once in a while some slipped through, but overall behavior was unacceptable.

max_connections is set to 500, well above normal requirements.

Immediate move: raise max_connections to 600, some urgent connections must take place. But, this is no solution: if 500 got hogged, so will the extra 100 I’ve just made available.

So, who’s to blame? SHOW PROCESSLIST is so unfriendly at that. Wait. Didn’t I create that view in common_schema, called processlist_per_userhost? I wonder what it says…

>     SELECT * FROM common_schema.processlist_per_userhost;
>     +-------------+------------------+-----------------+------------------+---------------------+
>     | user        | host             | count_processes | active_processes | average_active_time |
>     +-------------+------------------+-----------------+------------------+---------------------+
>     | maatkit     | sqlhost02.myweb  |               1 |                0 |                NULL |
>     | rango       | webhost04.myweb  |               2 |                0 |                NULL |
>     | rango       | webhost07.myweb  |               8 |                0 |                NULL |
>     | rango       | sqlhost02.myweb  |              38 |                0 |                NULL |
>     | rango       | management.myweb |              35 |                0 |                NULL |
>     | rango       | webhost03.myweb  |              10 |                0 |                NULL |
>     | rango       | local01.myweb    |               8 |                0 |                NULL |
>     | rango       | analytic02.myweb |              11 |                0 |                NULL |
>     | mytop       | localhost        |               2 |                0 |                NULL |
>     | buttercup   | sqlhost02.myweb  |             451 |                5 |              0.0000 |
>     | replc_user  | sqlhost00.myweb  |               1 |                1 |         392713.0000 |
>     | replc_user  | sqlhost02.myweb  |               1 |                1 |          38028.0000 |
>     | root        | localhost        |               2 |                0 |                NULL |
>     | system user |                  |               2 |                2 |         196311.5000 |
>     +-------------+------------------+-----------------+------------------+---------------------+

Ah! It’s buttercup connecting from sqlhost02.myweb who is making a fuss. I knew that view was created for a reason.

Continue reading » “Who is hogging my MySQL connections?”

## On stored routines and dynamic statements

MySQL common_schema Prepared Statements QueryScript Stored routines June 18, 2012

I very much enjoyed reading Overloading Procedures by Michael McLaughlin: good stuff!

I’m dealing with similar issues in common_schema/QueryScript, where I implement a whole new scripting language within MySQL, interpreted by stored routines. I am now finalizing the next version of common_schema/QueryScript, with a major addition to the scripting language to put yet even more power at the hands of the programmer/DBA using simple, clean syntax.

Still hush hush, the development of that feature touched at the very same issues described in Michael’s post. Present in current release, these issues are intensified by the use and complexity of the new development. Here are a few insights of mine:

#### Internal array implementation

Like Michael, I started by implementing arrays through tables. That is, create a (temporary, in my case) table, wrap it up with a lot of stored routine code, and simulate an array. This array is not yet provided to the user, but is used internally for QueryScript’s own code.

Well, disappointment here: during load tests on intense structures, such as a foreach loop, where each iteration of the loop requires the creation of an array, I found that the current solution does not hold well on busy servers.

Seemingly, there’s nothing wrong with the creation of a new table every once in a while — and in particular a temporary table. However, I quickly found out that a busy server thrashes the table cache with such intense rate of creation/dropping of tables. The competition over the table cache mutex becomes intolerable and hogs not only the script’s execution but the entire server’s.

There’s also the issue of the type of array values — no going around using textual columns, of course, but — how long? A VARCHAR(32767) should be enough for any reasonable implementation, but — how much memory would that consume? Both MEMORY and standard temporary tables (Percona Server has that partially resolved) use a fixed row format, which means a 32K text is actually allocated in memory even when your value is ‘x’. Continue reading » “On stored routines and dynamic statements”

## CHAR and spaces

MySQL Data Types June 12, 2012

I know about it, I knew about it all along, but… it’s so easy to fall for it; there’s just so much absurdity!

A CHAR type has a known number of characters. For example, the column:

>     CountryCode CHAR(3) CHARSET ascii NOT NULL

– is known to have exactly three characters. These could be ‘USA’, ‘FRA’, etc.

What happens with spaces? A SQL CHAR type ignores any trailing spaces; thus, the code ‘GB ‘ (the characters ‘G’, ‘B’, and the space ‘ ‘) is interpreted as ‘GB’. Trailing spaces are not regarded as part of the text. Want to see some absurdity?

>     CREATE TABLE `c_test` (
>       `c` char(1) DEFAULT NULL
>     );
>     INSERT INTO c_test VALUES ('a');
>     INSERT INTO c_test VALUES ('b');
>     INSERT INTO c_test VALUES (' ');

>     SELECT c, LENGTH(c), c = 'a', c = 'b', c = ' ', LENGTH(' ') FROM c_test;
>     +------+-----------+---------+---------+---------+-------------+
>     | c    | LENGTH(c) | c = 'a' | c = 'b' | c = ' ' | LENGTH(' ') |
>     +------+-----------+---------+---------+---------+-------------+
>     | a    |         1 |       1 |       0 |       0 |           1 |
>     | b    |         1 |       0 |       1 |       0 |           1 |
>     |      |         0 |       0 |       0 |       1 |           1 |
>     +------+-----------+---------+---------+---------+-------------+

Continue reading » “CHAR and spaces”