[high concurrency foundation] MySQL index optimization

Preface

This paper is compiled from MySQL Official website , The connection to the official website is trivial . Avoid repeatedly opening more pages , Here are some key points .

How MySQL Uses Indexes

Most MySQL indexes (PRIMARY KEY, UNIQUE, INDEX, and FULLTEXT) are stored in B-trees. Exceptions: Indexes on spatial data types use R-trees; MEMORY tables also support hash indexes; InnoDB uses inverted lists for FULLTEXT indexes.

PRIMARY KEY, UNIQUE, INDEX　 Stored in Ｂ In the tree （ The official website says B Trees , The essence is to B+ The tree is implemented as a technology ）

• Indexes are divided into clustered indexes and secondary indexes Original address

The Physical Structure of an InnoDB Index

• Clustered index
  InnoDB The clustered index of is actually saved in the same structure B-Tree Indexes ( Technically B+Tree) And data lines .
  More detailed data structure diagram

MySQL uses indexes for these operations

• hit where The condition in the statement
• Filter out inappropriate rows （ The value on the column exceeds the storage length , Can't equal hit , Only unequal values can be filtered out ）

If a search term exceeds the index prefix length, the index is used to exclude non-matching rows, and the remaining rows are examined for possible matches. ( Original address )

For additional information about index prefixes,

• Left most matching principle

if you have a three-column index on (col1, col2, col3), you have indexed search capabilities on (col1), (col1, col2), and (col1, col2, col3).

Example of the official website of the leftmost matching principle ：

CREATE TABLE test (
    id         INT NOT NULL,
    last_name  CHAR(30) NOT NULL,
    first_name CHAR(30) NOT NULL,
    PRIMARY KEY (id),
    INDEX name (last_name,first_name)
);

（1） have access to name Indexes ：

SELECT * FROM test WHERE last_name='Jones';

SELECT * FROM test
  WHERE last_name='Jones' AND first_name='John';

SELECT * FROM test
  WHERE last_name='Jones'
  AND (first_name='John' OR first_name='Jon');

SELECT * FROM test
  WHERE last_name='Jones'
  AND first_name >='M' AND first_name < 'N';

（2） Can't use name Indexes

SELECT * FROM test WHERE first_name='John';

SELECT * FROM test
 WHERE last_name='Jones' OR first_name='John';

Implicit compatibility of Federated indexes ：(col1, col2, col3) It's kind of set up (col1), (col1, col2), and (col1, col2, col3) Indexes

if you have a three-column index on (col1, col2, col3), you have indexed search capabilities on (col1), (col1, col2), and (col1, col2, col3).

SELECT * FROM tbl_name WHERE col1=val1; --  You can use the index 
SELECT * FROM tbl_name WHERE col1=val1 AND col2=val2; --  You can use the index 

SELECT * FROM tbl_name WHERE col2=val2; --  You cannot use an index 
SELECT * FROM tbl_name WHERE col2=val2 AND col3=val3; --  You cannot use an index 

• Table connecting , Same type 、 length 、 The index of character set can be used as a connection condition to improve the efficiency

To retrieve rows from other tables when performing joins. MySQL can use indexes on columns more efficiently if they are declared as the same type and size.

• Use different parts of the index to improve efficiency

To find the MIN() or MAX() value for a specific indexed column key_col. This is optimized by a preprocessor that checks whether you are using WHERE key_part_N = constant on all key parts that occur before key_col in the index. In this case, MySQL does a single key lookup for each MIN() or MAX() expression and replaces it with a constant. If all expressions are replaced with constants, the query returns at once. For example:
SELECT MIN(key_part2),MAX(key_part2) FROM tbl_name WHERE key_part1=10;

Change the meaning of the above ：max(key_part2) where col = key_part1; If there is a federated index index(key_part1,key_part2) So this query is very fast . Query optimization is based on the index B+ The ordering of the tree is very fast ,max The declared column is in the second position of the union index , Then the first position also needs to use equivalent hit . And so on ,index(key_part1,key_part2,key_part3) max(key_part3) You need to make the first two index columns do where Equal hit . It is worth mentioning that index(key_part1,key_part2,key_part3) stay SELECT MIN(key_part2),MAX(key_part2) FROM tbl_name WHERE key_part1=10; Can still go through the index . because max(key_part2) Only required key_part1 Equivalent hit

• order by When using composite index , Note the leftmost match and reverse order .DESC The index is read in the reverse order of the expression .

To sort or group a table if the sorting or grouping is done on a leftmost prefix of a usable index (for example, ORDER BY key_part1, key_part2). If all key parts are followed by DESC, the key is read in reverse order.

1. order by Optimize
2. group by Optimize

• Index overlay

In some cases, a query can be optimized to retrieve values without consulting the data rows

Look up the index directly B Trees can get data , No need to go through the index

SELECT key_part3 FROM tbl_name
  WHERE key_part1=1

• Avoid full table scanning (EXPLAIN come out Type The value of the field is ALL )

The output from EXPLAIN shows ALL in the type column when MySQL uses a full table scan to resolve a query.
Full table scanning will occur ：

1. A table with very few rows
2. ON perhaps WHERE The selected column is not indexed
3. Query optimizer pair where Clause , Found that full table scans are faster than indexes .
4. Query keywords used on the index , There is not much differentiation in the index distribution

• For tables with large amounts of data , Avoid wrong index selection by the query optimizer

SELECT * FROM t1, t2 FORCE INDEX (index_for_column)
  WHERE t1.col_name=t2.col_name;