MySQL源码中的查询逻辑详解

目录

• mysql innodb的核心查询逻辑
• 方法位置：
• 参数：
• 开启事务
• 升序降序
• 事务read_view
• S锁
• 索引查询
• 非索引查询
• 各种查询条件对应的查询逻辑
• 范围查询
• 小于查询
• 大于查询
• 全表扫描
• 升序查询
• 降序查询
• 范围+降序查询
• in查询
• 辅助索引

mysql的架构采用引擎分离的模式，innodb引擎负责最终的数据查询。

mysql解析sql后，调用innodb进行搜索数据，这个过程并http://www.devze.com不是mysql一次性调用，然后等待innodb返回所有的结果。

innodb提供了一个查询方法，每次只查询一行记录，然后返回记录，直到查询不出结果。

mysql innodb的核心查询逻辑

方法位置：

storage/innobase/row/row0sel.cc

row_search_mvcc

单条查询，每次只查询一条，即使是全表扫描，也是用这个方法一条一条的读出来

参数：

buf 最终结果将存储到这个buf

mode 查询模式，B+树搜索/叶子节点正向遍历/叶子节点逆向遍历 PAGE_CUR_GE PAGE_CUR_L PAGE_CUR_G

prebuilt 表信息和查询条件，其中的search_tuple就是要条件索引条件字段和值

prebuilt->search_tuple 就是要条件索引条件字段和值

prebuilt->pcur 指向上一条查询出的记录，

match_mode 精确匹配， prefix匹配（mysql的最左匹配原则）

direction 升序或逆序查询

如果是精确匹配，并且如果是联合索引，索引字段不为空。 那么结果只可能是0或1个

if (match_mode == ROW_SEL_EXACT
    && dict_index_is_unique(index)
    && dtuple_get_n_fields(search_tuple)
    == dict_index_get_n_unique(javascriptindex)
    && (dict_index_is_clust(index)
	|| !dtuple_contains_null(search_tuple))) {
搜索结果是唯一的
unique_search = TRUE;

开启事务

trx_start_if_not_started(trx, false);
// 如果隔离级别是读未提交或读已提交，不用加gap锁
if (trx->isolation_level <= TRX_ISO_READ_COMMITTED
    && prebuilt->select_lock_type != LOCK_NONE
    && trx->mysql_thd != NULL
    && thd_is_select(trx->mysql_thd)) {

	set_also_gap_locks = FALSE;
}

升序降序

direction==0 默认或1（ROW_SEL_NEXT就是ASC）
moves_up = TRUE 设为升级遍历
if (direction == 0) {
	if (mode == PAGE_CUR_GE
	    || mode == PAGE_CUR_G
	    || mode >= PAGE_CUR_CONTAIN) {
		moves_up = TRUE;
	}
} else if (direction == ROW_SEL_NEXT) {
	moves_up = TRUE;
}

取第一个索引，第一个索引必定是聚集索引

clust_index = dict_table_get_first_index(index->table);

事务read_view

若当前查询不需要加锁LOCK_phpNONE，

那就只需要保证一致性读，也就是最普通的select查询，

需要生成一个read_view，实现一致性读

if (prebuilt->select_lock_type == LOCK_NONE) {
	if (!srv_read_only_mode) {
		trx_assign_read_view(trx);
	}
	prebuilt->sql_stat_start = FALSE;
}

S锁

需要加锁的情况

这里先加了表锁， 没有直接加行锁

若是S锁，则加IS锁，否则加IX锁

else {
            // 加锁读，先加意向表锁
            // 加表锁，要么是LOCK_IS，要么是LOCK_IX
	err = lock_table(0, index->table,
			 prebuilt->select_lock_type == LOCK_S
			 ? LOCK_IS : LOCK_IX, thr);
	if (err != DB_SUCCESS) {
		table_lock_waited = TRUE;
		goto lock_table_wait;
	}
	prebuilt->sql_stat_start = FALSE;
}

判断查询条件，是否在索引范围内

这决定是否走索引查询

索引查询

if (dtuple_get_n_fields(search_tuple) > 0) { … }

利用索引遍历B+树

search_tuple就是查询目标值，根据参数查询到第0层（叶子节点）

btr_pcur_open_with_no_init(index, search_tuple, mode,
				   BTR_SEARCH_LEAF,
				   pcur, 0, &mtr);
	主要逻辑就是遍历树 
	btr_cur_search_to_nth_level 找到第n层
		先找到索引树的根页，加载到内存 
		page_cur_search_with_match(index,tuple,mode) 在当前页进行查找（从根页开始，深度优先遍历）
		node_ptr = page_cur_get_rec(page_cursor) 找到下一个node
		loop 循环遍历， 直到找到目标层或第0层，
		page_cur_search_with_match_bytes()  找到目标行

根据搜索到的指针pcur，读取找到的行记录

rec = btr_pcur_get_rec(pcur)

在索引遍历时，如果是降序遍历，并且还需要加锁

就会额外处理，找到当前行的下一行，增加GAP锁

若当前id=100，下一个110，则会在100和110的间隙加间隙锁。

if (!moves_up
    && !page_rec_is_supremum(rec)
    && set_also_gap_locks
    && !(srv_locks_unsafe_for_binlog
	 || trx->isolation_level <= TRX_ISO_READ_COMMITTED)
    && prebuilt->select_lock_type != LOCK_NONE
    && !dict_index_is_spatial(index)) {

	consjst rec_t*	next_rec = page_rec_get_next_const(rec);

	offsets = rec_get_offsets(next_rec, index, offsets,
				  ULINT_UNDEFINED, &heap);
	err = sel_set_rec_lock(pcur,
			       next_rec, index, offsets,
			       prebuilt->select_lock_type,
			       LOCK_GAP, thr, &mtr);

	switch (err) {
	case DB_SUCCESS_LOCKED_REC:
		err = DB_SUCCESS;
	case DB_SUCCESS:
		break;
	default:
		goto lock_wait_or_error;
	}
}

非索引查询

如果不走索引，那就进行全表扫描， 利用叶子节点的双向链表遍历。

PAGE_CUR_G 从B+树叶子节点最左侧开始扫描（最小节点升序遍历）

PAGE_CUR_L 从B+树叶子节点最右侧开始扫描（最大节点降序遍历）

else if (mode == PAGE_CUR_G || mode == PAGE_CUR_L) {
    btr_pcur_open_at_index_side(
		mode == PAGE_CUR_G, index, BTR_SEARCH_LEAF,
		pcur, false, 0, &mtr);
}

row_search_mvcc方法内容非常多，主要的查询逻辑就是这些。

还有锁的处理，事务的处理，mvcc，将在后面分析。

各种查询条件对应的查询逻辑

范围查询

小于查询

select * from t where id<10;

参数mode为 PAGE_CUR_G

search_tuple为空，取出根页的最小记录，查出最小页，最小记录。

然后根据叶子节点的链表，依次取出所有符合条件的记录。

if(mode==PAGE_CUR_G || mode==PAGE_CUR_L)
	btr_pcur_open_at_index_side() 
btr_pcur_open_at_index_side方法将从叶子节点的最左或最右取值
mode决定了它从哪边取值
PAGE_CUR_G从最左侧（最小）取值，PAGE_CUR_L从最右侧（最大）取值。

终结条件

compare_key(end_range)

找到大于end_range时，符合判断跳出循环。

找到符合条件的记录时，会判断当前版本是不是readView可见

如果不可见，将从版本链的上一级取出。

lock_clust_rec_cons_read_sees(rec,index,offsets,trx_get_read_view(trx))

判断找到的记录是不是被删了

rec_get_deleted_flag(rec, comp)

转格式，存储引擎是innodb，取出来的数据是innodb格式，需要转成mysql

row_sel_store_mysql_rec()

大于查询

select * from t where id>10;

和小于不同，search_tuple有值，也就是需要先查询出“id=10"的记录。

然后从"id=10"的记录往后遍历，剩余部分同小于查询

全表扫描

select * from t;

同小于查询 mode类型为 PAGE_CUR_G ，只是没有终结条件

升序查询

聚集索引默认就是按升序存储的，全表扫描就是升序查询

MOVES_UP = true 升序

降序查询

mode类型为 PAGE_CUR_L， 从叶子节点链表的最右侧取值

然后从左往右遍历

MOVES_UP = false 降序

叶子节点页存在双向链表指针，从而可以快速取出数据。

但记录与记录之间只有单向链表关系。

如果是升序取数据，可以利用记录的链表关系。

如果是降序，只能通过页之间的链表关系，页内的记录就无法通过链表依次取出，会比升序要复杂一些。

btr_pcur_move_to_pre()

btr_pcur_move_to_prev_on_page()

btr_pcur_move_to_pre(btr_pcur_get_page_cur(cursor))

页内降序查询的办法比较笨，从页内最小记录开始遍历，匹配到目标值，回退到上一个，就是反向遍历。

如存在1-10的一组数据， 当前值10，从1开始遍历，找到10，退回到9，返回

再从1开始遍历，找到9，退回到8，返回

范围+降序查询

原本的小于查询从最小页开始遍历，有降序条件后，将从范围值开始降序遍历

原本的大于查询从范围值开始遍历，有降序条件后，将从最大页开始降序遍历，直到终结条件。

in查询

原理页就是逐个按主键取。

但它返回的数据是升序的，这说明它在查询前就把in里面的条件排序过了再逐个查询。

辅助索引

通用也是走row_search_mvcc 不同的是传入的index索引是辅助索引，search_tuple为辅助索引值 匹配到辅助索引的记录后，再进行回表查询。 回表查询，因为辅助索引的叶子节点没有记录完整的数据，只存储了主键id和辅助索引值，如果select的值超出了辅助索引存的值，就需要从聚集索引里面取值，也就是再进行一次或多次主键索引查询，查出完整的数据。 如果辅助索引是唯一索引，只会发生一次回表。 如果辅助索引不是唯一索引，就android有可能多次回表。 ·

row_sel_get_clust_rec_for_mysql(prebuilt, index, rec,
					      thr, &clust_rec,
					      &offsets, &heap,
					      need_vrow ? &vrow : NULL,
					      &mtr);
这个方法最终调用前面用到的遍历B+树的方法从聚集索引查询出数据
拿到聚集索引
clust_index = dict_table_get_first_index(sec_index->table);
遍历聚集索引B+树
btr_pcur_open_with_no_init

mysql通过bitmap来记录当前表需要获取的字段

到此这篇关于MySQL源码中的查询逻辑的文章就介绍到这了,更多相关mysql查询逻辑内容请搜索编程客栈(www.devze.com)以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程客栈(www.devze.com)！