The attached pdf has a  table that anticipates that you want to know two things about privileges:

• What action is permitted: Read either the “What action is permitted” column, or the “Privilege Column Name” column
• At what level of granularity can it be set: For the privilege you’re interested in, note the “X”‘s, and read up the table to see which privilege tables provide that privilege, and then inspect their Key columns to understand the level of granularity.

General MySQL Settings
The Most important ones are:
Key Buffer
The key buffer holds the indexes of tables in memory and a bigger key buffer results in faster row lookups. Adjust according to your own needs. Bigger is better, but prevent swapping at all costs. A good rule of thumb seems to be to use 1/4 of system memory.

Query Cache
This is where the magic happens. Well, not magic really, just plain old caching. Keeping the result of queries in memory until they are invalidated by additional writes enhances performance by magnitudes. The query_cache_size, as the name suggests, is the total size of memory available to query caching. The value query_cache_limit is the maximum number of kilobytes one query may be in order to be cached. Setting this value too high might prevent a lot of smaller queries to be cached. Setting it too low will result in bigger queries to never be cached, and the smaller queries not being able to completely fill the cache size, which would be a waste of resources. Adjust according to your own needs and memory available:

Table Cache
An important variable if your application accesses many tables. It is the number of tables a thread can keep open at the same time. A value of 512 should do no harm.

Sort Buffers
sort_buffer_size (the variable previously known as sort_buffer), used for grouping and sorting and is a per-thread buffer. If the buffer can not hold the data to be sorted, a sort is performed on disk. Watch out for making this too large as the buffer is allocated for every thread that needs sorting and with many sorts it can easily consume all your memory.

Binary Logging
MySQL has a few powerful features. Replicating data changes to a second server is one of them. MySQL keeps a log file of data changes which is used for this purpose. If you do not use replication or use the file as incremental backup, you can disable it. This will save you expensive disk write actions for every change to your data. For applications that have a lot of frequently updated data, this can be quite a performance boost. According to the official docs, this will generally result in just a 1% boost but it’s an easy gain if you do not need the log. Read more about the binary log here. Comment the following line:
log-bin = /var/log/mysql/mysql-bin.log

Temporary Tables
Temporary tables are used for sorting and grouping. The buffer is created on demand so watch out for setting this too high here as well. If the buffer cannot accomodate the data, a temp file is used on disk instead.

Delayed Writing
This setting can greatly improve writing or updating data to a table. Instead of directly committing data to the disk, MySQL queues writes and returns write queries immediately. Be very very careful with this, because this also means that in case of a power failure or crash, you lose data. You can use this for logging if you don’t mind losing a couple of rows in case of a crash.

Connection Timeout
This is a little tweak that determines the closing of sleeping connections. The default is one hour and is often too long for practical purposes. I often set this at one minute instead (60).
wait_timeout = 60
The above settings are just to make mysql a little faster in general. You can get much better speed improvements by optimizing the database itself. Setting the correct indexes on tables can be a life-saver.

MySQL Innodb Settings
The most important ones are:

innodb_buffer_pool_size
70-80% of memory is a safe bet. I set it to 12G on 16GB box.

innodb_log_file_size
This depends on your recovery speed needs but 256M seems to be a good balance between reasonable recovery time and good performance

innodb_log_buffer_size=4M
4M is good for most cases unless you’re piping large blobs to Innodb in this case increase it a bit.

innodb_flush_log_at_trx_commit=2
If you’re not concern about ACID and can loose transactions for last second or two in case of full OS crash than set this value. It can dramatic effect especially on a lot of short write transactions.

innodb_thread_concurrency=8
Even with current Innodb Scalability Fixes having limited concurrency helps. The actual number may be higher or lower depending on your application and default which is 8 is decent start

innodb_flush_method=O_DIRECT
Avoid double buffering and reduce swap pressure, in most cases this setting improves performance. Though be careful if you do not have battery backed up RAID cache as when write IO may suffer.

innodb_file_per_table
If you do not have too many tables use this option, so you will not have uncontrolled innodb main tablespace growth which you can’t reclaim. This option was added in MySQL 4.1 and now stable enough to use.

Also check if your application can run in READ-COMMITED isolation mode – if it does – set it to be default as transaction-isolation=READ-COMMITTED. This option has some performance benefits, especially in locking in 5.0 and even more to come with MySQL 5.1 and row level replication.

Every 60 days I add a user on the database that has the only needed privileges for the application to run. I show the current privileges and change user and password and add the new user. I record the old one in case I need to fail back. I also have changed the default user “root” to  another username, and I have deleted the testdb that is installed when you setup mysql initially.

I use the CLI to do all my mysql work but you can easily do this yourself using phpmyadmin, make sure the user you make the changes with has GRANT OPTION.

1) SHOW GRANTS FOR ‘<username> ‘@’<host>’;

GRANT USAGE ON *.* TO ‘olduser’@'%’ IDENTIFIED BY PASSWORD ‘*BCF0C51505BF07C0AC46B9AEBB7F9726EB4677B8′;
GRANT SELECT, INSERT, UPDATE, DELETE, CREATE, DROP, INDEX, ALTER, CREATE TEMPORARY TABLES, LOCK TABLES, EXECUTE, CREATE VIEW, SHOW VIEW, CREATE ROUTINE, ALTER ROUTINE ON `databasename`.* TO ‘olduser’@'localhost’;

2) Now you need to change the use and password from GRANT. You have 4 otptions for setting password by calling the password function or by using plain text. Using plain text will put the plain text in the binary log!!!

Option A: Generate the password hash using mysql

SELECT PASSWORD(‘somepassword’);

this will out put
——————————————-+
| password(‘somepassword’)                  |
+——————————————-+
| *DAABDB4081CCE333168409A6DB119E18D8EAA073 |
+——————————————-+
1 row in set (0.00 sec)
Now that we have the has of the password “somepassword” we can use that to update the password when applying grants.

GRANT USAGE ON *.* TO ‘newuser’@'%’ IDENTIFIED BY PASSWORD ‘*DAABDB4081CCE333168409A6DB119E18D8EAA073′;
GRANT SELECT, INSERT, UPDATE, DELETE, CREATE, DROP, INDEX, ALTER, CREATE TEMPORARY TABLES, LOCK TABLES, EXECUTE, CREATE VIEW, SHOW VIEW, CREATE ROUTINE, ALTER ROUTINE ON `databasename`.* TO ‘newuser’@'localhost’;

Option B: You can use the password function to update the password during grant option.

GRANT USAGE ON *.* TO ‘newuser’@'%’ IDENTIFIED BY PASSWORD(‘somepassword’);
GRANT SELECT, INSERT, UPDATE, DELETE, CREATE, DROP, INDEX, ALTER, CREATE TEMPORARY TABLES, LOCK TABLES, EXECUTE, CREATE VIEW, SHOW VIEW, CREATE ROUTINE, ALTER ROUTINE ON `databasename`.* TO ‘newuser’@'localhost’;

Option C: You can set the password by removing the password from the old grant.

GRANT USAGE ON *.* TO ‘newuser’@'%’ IDENTIFIED BY ‘somepassword’;
GRANT SELECT, INSERT, UPDATE, DELETE, CREATE, DROP, INDEX, ALTER, CREATE TEMPORARY TABLES, LOCK TABLES, EXECUTE, CREATE VIEW, SHOW VIEW, CREATE ROUTINE, ALTER ROUTINE ON `databasename`.* TO ‘newuser’@'localhost’;

Option D: I do not reccomend this as it is not a proper way to update grants for a user, but you can update the mysql.user table to change the user and passwords.

UPDATE mysql.user set user = ‘newuser’, password = PASSWORD(‘newpassword’) where user = ‘olduser’;

This is not a proper way of updateing user but you can use it as long as you have rights to the mysql database.

The next step for any of these changes is to FLUSH PRIVILEGES: This flushes the new user to disk and refreshes the memory.

The final step will be to update the wp-config.php file in your www directory. In your www directory open your wp-config.php file with a text editor I use VIM for mine and look for these lines:
/** MySQL database username */
define(‘DB_USER’, ‘olduser’);
/** MySQL database password */
define(‘DB_PASSWORD’, ‘oldpassword’);
Update the user and password with your new information.

To try to secure my website I have changed my wp-config.php adn took the above lines out and put them in a seperate file and moved it to a directory outside of the www directory. I have my own server so I can put it anywhere as long as I know the absolute path. I have also encrypted the file using gpg which I will talk about in the near future. Once I make all the password and user updates I remove the old user from mysql and flush privileges once again.

Hopefully this article will help those who want to try to secure their site more effeciently. Please let me know if you have any questions or suggestions to secure a site.

SELECT word_id
FROM forum.wordmatch
GROUP BY word_id
HAVING COUNT( word_id ) =53805;

This seems pretty straightforward; the query is trying to display how many entries have a word_id (indexed) greater than 53805.  But an explain shows that this is a table scan:

| table | type | possible_keys | key | key_len | ref | rows | Extra |
| wordmatch | index | NULL | word_id | 3 | NULL | 6374529 | Using index |

The problem is there is no WHERE clause, and HAVING just controls output.  So rewriting the query like so improves the performance by a factor of 10:

SELECT count( word_id )
FROM forum.wordmatch
WHERE word_id =53805;

| table | type | possible_keys | key | key_len | ref | rows | Extra |
| wordmatch | range | word_id | word_id | 3 | NULL | 641340 | Using where; Using index |

To quote mysql.com:

“Do not use HAVING for items that should be in the WHERE clause”. For example, do not write the following:

SELECT col_name FROM tbl_name HAVING col_name = 0;

Write this instead:

SELECT col_name FROM tbl_name WHERE col_name = 0;

The HAVING clause can refer to aggregate functions, which the WHERE clause cannot:

SELECT user, MAX(salary) FROM users
GROUP BY user HAVING MAX(salary) ;

SELECT DISTINCT ac2.category, ac0.name
FROM snaggy.a2_category ac1, snaggy.a2_category ac2, snaggy.a2_catalog ac0
WHERE ac1.category = 'GAME'
AND ac2.vendor_code = ac1.vendor_code
AND ac2.item_id = ac1.item_id
AND ac0.category = ac2.category
ORDER BY ac0.name

| table | type | possible_keys | key | key_len | ref | rows | Extra |
| ac0 | ALL | NULL | NULL | NULL | NULL | 145 |
| ac1 | ALL | category | NULL | NULL | NULL | 2886 | Using where; Using temporary; Using filesort
| ac2 | ALL | category | NULL | NULL | NULL |2886 | Using where |

CREATE TABLE `a2_category` (
`vendor_code` varchar(4) default NULL,
`item_id` int(5) default NULL,
`category` varchar(8) default NULL,
FULLTEXT KEY `category` (`category`)
) TYPE=MyISAM

Just adding an index helps makes the same query complete in a realistic timeframe:

ALTER TABLE a2_category ADD INDEX (item_id);

| table | type | possible_keys | key | key_len | ref | rows | Extra |
| ac0 | ALL | NULL | NULL | NULL | NULL | 145 | Using where |
| ac1 | ALL | item_id,category | NULL | NULL | NULL | 2886 | Using where; Using temporary; Using filesort |
| ac2 | ref | item_id,category | item_id | 5 | ac1.item_id | 3 | Using where |

The format for reg expression for a SELECT is:

SELECT something FROM table WHERE column REGEXP 'regexp'

For example, to select all columns from the table events where the values in the column id end with 5309, use:

SELECT * FROM events WHERE id REGEXP '5309$'

A more elaborate example selects all columns of the table reviews where the values in the column description contain the word “mysql”:

SELECT * FROM reviews WHERE description REGEXP '[[:<:]]mysql[[:>:]]'

MySQL allows the following regular expression metacharacters:. match any character

• ? match zero or one
• * match zero or more
• + match one or more
• {n} match n times
• {m,n} match m through n times
• {n,} match n or more times
• ^ beginning of line
• $ end of line
• [[:<:]] match beginning of words [[:>:]] match ending of words
• [:class:] match a character class
• i.e., [:alpha:] for letters
• [:space:] for whitespace
• [:punct:] for punctuation
• [:upper:] for upper case letters
• [abc] match one of enclosed chars
• [^xyz] match any char not enclosed
• | separates alternatives

MySQL interprets a backslash (\) character as an escape character. To use a backslash in a regular expression, you must escape it with another backslash (\\).

A link is a reference on a web page that references some other place on the same page or somewhere else on the Internet. If text is “clickable” that means it is a hyperlink. You can identify a hyperlink in a number of ways but the easiest way is to move your mouse pointer over the top of a picture or word and if your mouse cursor change to look like a small hand then the item you are looking at, is a link and you can click it.

Yes links are great, but if you are a regular user you most likely have it bookmarked or in your cache. I understand the re-organization of MySQL.com and this is something we all have to accept, with ORACLE being the new owners. We went through similar changes with SUN, like the certified candidates list. We complained, they did nothing and we accepted it. ORACLE is going to make changes whether the community likes it or not. We still know where to go to get to dev.mysql.com or MySQL.org

I’m actually providing a link in my blog-roll for those who need a link. I do suggest that we all make comments to ORACLE asking them to provide the tools we need to be successful DBA’s or Developers. We also need to make sure we watch out for bigger changes like, no more support for community releases or stop development on MySQL.

As a community we still can provide each other support with sites like:

• MySQL Performance Blog
• XAPRB
• High Availability MySQL
• Planet MySQL

Sorry for the ones I forgot as this list can go ON and ON If you want me to add to my blog roll let me and I will. I also apologize for defending ORACLE but give them a chance, they “might do good things”. We know some of the changes will be bad but, maybe not all? Who knows.

USAGE:
Set up cron job to call the script once a week passing 3 variables
  1. Weeks to keep older tables
  2. Database Name
  3. Table Name
0 0 * * 0 /bin/lt_rotate_tables 3 testdb testing

// This code written by Lee Thompson with debugging by Dave Allmon//
// This program will rotate definded table and keep backup tables for n ammount of weeks //
// The inital table must exist first!! //
// to compile **** gcc lt_rotate_tables.c -o lt_rotate_tables  `mysql_config --cflags --libs` ***//
// Cron ***  *** //

#include <time.h>
#include <my_global.h>
#include <mysql.h>

#define ONE_WEEK (86400 * 7)

// This code will create a new backup and delete the backup that is n weeks old.
// Ex: This is week 21. Running this code with weeks=4 will create a table_21 table and delete a writes_17 table.

char tableNameNew[64];
char tableNameDrop[64];
char tmpTable[64];
char tmpDBname[64];

// Creates two suffixes based on the week of the year:
//  1. This week for new backup.
//  2. (weeks) ago to be deleted.

void CreateTargetDateStrs( int weeks )
{
  time_t thisTime;
  struct tm * lt;

  memset( tableNameNew, 0, sizeof ( tableNameNew ));
  memset( tableNameDrop, 0, sizeof ( tableNameDrop ));

  thisTime = time( NULL );
  lt = localtime( &thisTime );
  strftime(( char * ) & tableNameNew, sizeof ( tableNameNew ), "%B_%d", lt );

  thisTime -= ( ONE_WEEK * weeks );
  lt = localtime( &thisTime );
  strftime(( char * ) & tableNameDrop, sizeof ( tableNameDrop ), "%B_%d", lt );
}

int main(int argc, char **argv)
{
  char tmpStr[256];
  MYSQL *conn;

  if ( argc == 4 )
  {
    CreateTargetDateStrs( atoi( argv[1] ));
    sprintf(tmpTable,(argv[3]));
    sprintf(tmpDBname,(argv[2]));
  }
  else
  {
    printf( "\nUsage: ./lt_rotate_tables <weeks> <database name> <table name>\n" );
    exit( 1 );
  }
  conn = mysql_init(NULL);
  /////////////// Make only change here ////////////////////////
  //Set connection here change <user_name>  <password>
  mysql_real_connect(conn, "localhost", "<user_name>", "<password>", tmpDBname, 0, NULL, 0);

  // Drop oldest saved table.
  sprintf( tmpStr, "DROP TABLE %s_%s", tmpTable, tableNameDrop );
  mysql_query(conn, tmpStr );

  // Rename current table to new name.
  sprintf( tmpStr, "RENAME TABLE %s to %s_%s",tmpTable, tmpTable, tableNameNew );
  mysql_query(conn, tmpStr );

  // Create a new table like the last table.
  sprintf( tmpStr, "CREATE TABLE %s like %s_%s", tmpTable, tmpTable, tableNameNew );
  mysql_query(conn, tmpStr );

  mysql_close(conn);
}

<?

#################################
######  Mysql Replication Mapper #########
######     Lee Thompson ##############
######      Version 1.0   ###############
#################################

$user = "<username>";
$pass = "<password>";

$masterserver = $_REQUEST['master_server'];

$masterport = $_REQUEST['master_port'];
if ($masterport == '')
$masterport = '3306';

echo "Please enter a master server";
echo "<form method='post' action='$php_self'>";
echo "Server: <input type ='text' name='master_server' value='" . $masterserver . "'><br />";
echo "Port: <input type ='text' name='master_port' value='3306'><br />";
echo "<input type ='submit'><hr />";

$serverlist = array();

// fill data
$serverlist = query_slave_server($masterserver.":".$masterport);

// print data
print "<b>Master Server: </b>".$serverlist." on Port: ".$masterport . '<br />';

$array = query_server($serverlist);
print_server($array, 0);

function query_slave_server($server)
{
  global $user, $pass, $masterport, $masterserver;

  $sql ="show processlist";
        $foundmaster = FALSE;
        while ( $foundmaster === FALSE )
        {
    $con = mysql_connect($server.":".$masterport,$user,$pass) or die($server. mysql_error());
                $result = mysql_query($sql,$con);
                while ($row = mysql_fetch_array($result))
                {
                        $slaveuser = $row['User'];
                        if ($slaveuser=='system user')
                        {
                                $sql2 = "show slave status";
                                $result = mysql_query($sql2,$con);
                                while ($row2 = mysql_fetch_array($result))
                                {
                                        $smasterserver = $row2['Master_Host'];
                                        $smasterport = $row2['Master_Port'];
                                        $server = $row2['Master_Host'];
                                        $masterport = $row2['Master_Port'];
                                }
                                break;
                        }
                }
                if ( $slaveuser != 'system user' )
                {
                        $foundmaster = TRUE;
                }
        }
        return $server;
}

function query_server($mserver)
{
  global $user, $pass, $masterport;

  $sql ="show processlist";

  $con = @mysql_connect($mserver.":".$masterport,$user,$pass) or die(mysql_error());
  $result = @mysql_query($sql,$con);
  while ($row = @mysql_fetch_array($result))
  {
    $slave = $row['Host'];
    $slavehost = ereg_replace(":.*", "", $slave);
    $slavecmd = $row['Command'];
    if ($slavecmd=='Binlog Dump')
    {
      $current[$slavehost] = query_server($slavehost.":".$masterport);
    }
  }
  return $current;
}

function print_server($current, $depth)
{
  global $user, $pass;

  foreach ($current as $slave => $ary)
  {
    $conn2 = mysql_connect($slave,$user,$pass);
    $sql2 = "show slave status";
    $result2 = mysql_query($sql2, $conn2);
    while ($row2 = mysql_fetch_array($result2))
    {
      $slavecmd = $row2['Slave_IO_Running'];
      $slavecmd1 = $row2['Slave_SQL_Running'];
    }

      if ($slavecmd=='Yes' && $slavecmd1=='Yes')
      {
        $slaverunning = "Yes";
      }
      else
      {
        $slaverunning = "<font color ='red'>No</font>";
      }
    $local = "localhost";
    $lconn = mysql_connect($local,$user,$pass);
    $lsql = "select server_name from myman.server where primary_ip = '".ereg_replace(":.*", "", $slave)."'";
    $lresult = mysql_query($lsql, $lconn);
    while($lrow = mysql_fetch_array($lresult))
    {
      if ($depth > 0) print str_repeat('&nbsp;',10 * ($depth - 1));
      echo "&#160---&gt;&#160; ";
      echo $lrow[0]. " (" . $slave . ") Slave Running:" . $slaverunning . "(depth: $depth)<br />\n";
      if ($ary) print_server($ary, $depth + 1);
    }
  }
}
?>

Example Output:

Master Server: 172.1.1.102 on Port: 3306
 ---> testdb02 (172.1.1.103) Slave Running:Yes(depth: 0)
 ---> testdb03 (172.1.1.104) Slave Running:Yes(depth: 0)
 ---> testdb04 (172.1.1.105) Slave Running:Yes(depth: 0)
     ---> testdb04-02 (172.1.1.106) Slave Running:Yes(depth: 1)
     ---> devdb01 (172.1.1.107) Slave Running:Yes(depth: 1)
       ---> dc2testdb (172.1.1.108) Slave Running:Yes(depth: 2)
	  ---> dctestdb-02 (172.2.2.101) Slave Running:Yes(depth: 3)
	  ---> dctestdb-03 (172.2.2.102) Slave Running:Yes(depth: 3)
       ---> dc3testdb (172.1.1.108) Slave Running:Yes(depth: 2)
	 ---> dctestdb-02 (172.2.2.103) Slave Running:Yes(depth: 3)
---> devdb02 (172.3.3.101) Slave Running:Yes(depth: 0)
---> devdb03 (172.3.4.101) Slave Running:Yes(depth: 0)

1. Data caches that hold often-referenced application data.
2. Code caches that retain often-executed SQL or procedural code.
3. Metadata caches that keep reference data such as object structure information, security information, and more.

#!/bin/bash
user=<username>
pass=<password>
SOCKET=$1

while [ 1 ] ; do
READ_REQ=$( mysql -u$user -p$pass -S ${SOCKET} -NBe "SHOW GLOBAL STATUS LIKE 'Key_read_requests'" | awk '{print $2}' )
READS=$( mysql -u$user -p$pass -S ${SOCKET} -NBe "SHOW GLOBAL STATUS LIKE 'Key_reads'" | awk '{print $2}' )
TOTAL=$( echo "${READ_REQ} + ${READS}" | bc )
HIT_RATIO=$( echo "scale=6; ( ${READS} / ${TOTAL}) * 100" | bc -l )
MISS_RATIO=$( echo "scale=6; ( ${READ_REQ} / ${TOTAL}) * 100" | bc -l )
echo "Total Requests: ${TOTAL} - Key Hits: ${HIT_RATIO} - Key Misses: ${MISS_RATIO}"
sleep 1;
done

Example Output:
Total Requests: 12257352 – Key Hits: 7.696400 – Key Misses: 92.303500
Total Requests: 12270080 – Key Hits: 7.691600 – Key Misses: 92.308300
Total Requests: 12283029 – Key Hits: 7.686000 – Key Misses: 92.313900
Total Requests: 12283031 – Key Hits: 7.686000 – Key Misses: 92.313900
Total Requests: 12297598 – Key Hits: 7.680100 – Key Misses: 92.319800
Total Requests: 12316584 – Key Hits: 7.671900 – Key Misses: 92.328000
Total Requests: 12344366 – Key Hits: 7.658700 – Key Misses: 92.341200
Total Requests: 12359157 – Key Hits: 7.652800 – Key Misses: 92.347100

DSR Load Balance

To set up Loop-back
Create a second lo file Make sure there is no ARP

cp /etc/sysconfig/network-scripts/ifcfg-lo /etc/sysconfig/network-scripts/ifcfg-lo:0
vi /etc/sysconfig/network-scripts/ifcfg-lo:0

DEVICE=lo:0
IPADDR=1
#### Make sure you use nor arp
ARP=no
NETMASK=255.255.255.255
# If you're having problems with gated making 127.0.0.0/8 a martian,
# you can change this to something else (255.255.255.255, for example)
ONBOOT=yes

Now bring up your loop-back

 /sbin/ifup lo:0