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 (\\).

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

Used MySQL memory:

key_buffer + max_connections * (join_buffer

+ record_buffer + sort_buffer + thread_stack

+ tmp_table_size)

If innodb is enabled.

max memory utilization:

key_buffer_size + innoDB_buffer_pool_size +

max_connections * ( read_buffer_size +

sort_buffer_size + binlog_cache_size)

+ max_connections * 2M