mysql InnoDb在SELECT查询上非常慢

Question

I have a mysql table with following structure:

mysql> show create table logs \G;

Create Table: CREATE TABLE `logs` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `request` text,
  `response` longtext,
  `msisdn` varchar(255) DEFAULT NULL,
  `username` varchar(255) DEFAULT NULL,
  `shortcode` varchar(255) DEFAULT NULL,
  `response_code` varchar(255) DEFAULT NULL,
  `response_description` text,
  `transaction_name` varchar(250) DEFAULT NULL,
  `system_owner` varchar(250) DEFAULT NULL,
  `request_date_time` datetime DEFAULT NULL,
  `response_date_time` datetime DEFAULT NULL,
  `comments` text,
  `user_type` varchar(255) DEFAULT NULL,
  `channel` varchar(20) DEFAULT 'WEB',

  /**

  other columns here....

  other 18 columns here, with Type varchar and Text

  **/

  PRIMARY KEY (`id`),
  KEY `transaction_name` (`transaction_name`) USING BTREE,
  KEY `msisdn` (`msisdn`) USING BTREE,
  KEY `username` (`username`) USING BTREE,
  KEY `request_date_time` (`request_date_time`) USING BTREE,
  KEY `system_owner` (`system_owner`) USING BTREE,
  KEY `shortcode` (`shortcode`) USING BTREE,
  KEY `response_code` (`response_code`) USING BTREE,
  KEY `channel` (`channel`) USING BTREE,
  KEY `request_date_time_2` (`request_date_time`),
  KEY `response_date_time` (`response_date_time`)
) ENGINE=InnoDB AUTO_INCREMENT=59582405 DEFAULT CHARSET=utf8

and it has more than 30000000 records in it.

mysql> select count(*) from logs;
+----------+
| count(*) |
+----------+
| 38962312 |
+----------+
1 row in set (1 min 17.77 sec)

Now the problem is that it is very slow, the result of select takes ages to fetch records from table.

My following sub query takes almost 30 minutes to fetch records of one day:

    SELECT 
    COUNT(sub.id) AS count,
    DATE(sub.REQUEST_DATE_TIME) AS transaction_date,
    sub.SYSTEM_OWNER,
    sub.transaction_name,
    sub.response,
    MIN(sub.response_time),
    MAX(sub.response_time),
    AVG(sub.response_time),
    sub.channel
FROM
    (SELECT 
        id,
            REQUEST_DATE_TIME,
            RESPONSE_DATE_TIME,
            TIMESTAMPDIFF(SECOND, REQUEST_DATE_TIME, RESPONSE_DATE_TIME) AS response_time,
            SYSTEM_OWNER,
            transaction_name,
            (CASE
                WHEN response_code IN ('0' , '00', 'EIL000') THEN 'Success'
                ELSE 'Failure'
            END) AS response,
            channel
    FROM
        logs
    WHERE
        response_code != ''
            AND DATE(REQUEST_DATE_TIME) BETWEEN '2016-10-26 00:00:00' AND '2016-10-27 00:00:00'
            AND SYSTEM_OWNER != '') sub
GROUP BY DATE(sub.REQUEST_DATE_TIME) , sub.channel , sub.SYSTEM_OWNER , sub.transaction_name , sub.response
ORDER BY DATE(sub.REQUEST_DATE_TIME) DESC , sub.SYSTEM_OWNER , sub.transaction_name , sub.response DESC;

I have also added indexes to my table, but still it is very slow.

Any help on how can I make it fast ?

EDIT: Ran the above query using EXPLAIN

+----+-------------+------------+------+----------------------------+------+---------+------+----------+---------------------------------+
| id | select_type | table      | type | possible_keys              | key  | key_len | ref  | rows     | Extra                           |
+----+-------------+------------+------+----------------------------+------+---------+------+----------+---------------------------------+
|  1 | PRIMARY     | <derived2> | ALL  | NULL                       | NULL | NULL    | NULL | 16053297 | Using temporary; Using filesort |
|  2 | DERIVED     | logs       | ALL  | system_owner,response_code | NULL | NULL    | NULL | 32106592 | Using where                     |
+----+-------------+------------+------+----------------------------+------+---------+------+----------+---------------------------------+

Answer 1

As it stands, the query must scan the entire table.

But first, let's air a possible bug:

AND DATE(REQUEST_DATE_TIME) BETWEEN '2016-10-26 00:00:00'
                                AND '2016-10-27 00:00:00'

Gives you the logs for two days -- all of the 26th and all of the 27th. Or is that what you really wanted? ( BETWEEN is inclusive .)

But the performance problem is that the index will not be used because request_date_time is hiding inside a function ( DATE ).

Jump forward to a better way to phrase it:

AND REQUEST_DATE_TIME >= '2016-10-26'
AND REQUEST_DATE_TIME  < '2016-10-26' + INTERVAL 1 DAY

• A DATETIME can be compared against a date.
• Midnight of the morning of the 26th is included, but midnight of the 27th is not.
• You can easily change 1 to however many days you wish -- without having to deal with leap days, etc.
• This formulation allows the use of the index on request_date_time , thereby cutting back severely on amount of data to be scanned.

As for other tempting areas:

• != does not optimize well, so no 'composite' index is likely to be beneficial.
• Since we can't really get past the WHERE , no index is useful for GROUP BY or ORDER BY .
• My comments about DATE() in WHERE do not apply to GROUP BY ; no change needed.

Why have the subquery? I think it can be done in a single layer. This will eliminate a rather large temp table. (Yeah, it means 3 uses of TIMESTAMPDIFF() , but that is probably a lot cheaper than the temp table.)

How much RAM? What is the value of innodb_buffer_pool_size ?

If my comments are not enough, and if you frequently run a query like this (over a day or over a date range), then we can talk about building and maintaining a Summary table , which might give you a 10x speedup.