MySQL code解析

我不是女神ヾ 2022-06-10 14:40 224阅读 0赞

\# Query入口  
MySQL的代码比较messy，为了清楚理解MySQL的已有功能，本篇文章从MySQL的query层面进行分析，目的是理清MySQL的query处理流程和代码架构。本文基于MySQL5.7版本。  
  
  
MySQL的入口代码的skeloton可以参见官方文档：https://dev.mysql.com/doc/internals/en/guided-tour-skeleton.html  
本文着重讲解query parse和optimize的部分。个人认为官方文档对入口代码的说明言简意赅，本文也将采用类似的形式进行代码拆解和分析。  
  
  
我们首先延续官方文档中给出的入口函数(位于sql\_parse.cc下):     
\`\`\`  
  void mysql\_execute\_command(THD \*thd)  
       switch (lex->sql\_command) \{  
        case SQLCOM\_SELECT: ...  
        case SQLCOM\_SHOW\_ERRORS: ...  
        case SQLCOM\_CREATE\_TABLE: ...  
        case SQLCOM\_UPDATE: ...  
        case SQLCOM\_INSERT: ...                   // !  
        case SQLCOM\_DELETE: ...  
        case SQLCOM\_DROP\_TABLE: ...  
  case SQLCOM\_PREPARE:  
    \{  
    mysql\_sql\_stmt\_prepare(thd);  
    break;  
    \}  
    case SQLCOM\_EXECUTE:  
    \{  
    mysql\_sql\_stmt\_execute(thd);  
    break;  
    \}  
       \}  
\`\`\`  
注意，在MySQL5.7中mysql\_execute\_command是由mysql\_parse调用的。官方文档中调用函数为另一个（mysql\_stmt\_execute），但他们同为dispatch\_command下调用的，所以官方文档仍然可以借鉴。  
  
  
\# Prepare Statement  
上述入口代码上我们可以看到两处和Prepare Statement相关的地方mysql\_sql\_stmt\_prepare和mysql\_sql\_stmt\_execute。  
  
  
\#\# mysql\_sql\_stmt\_prepare  
  
  
我们先来看看mysql\_sql\_stmt\_prepare做了什么事。如下所示，mysql\_sql\_stmt\_prepare主要做了?件事。  
  
  
\`\`\`  
stmt->set\_name(name);  
thd->stmt\_map.insert(thd, stmt);  
stmt->m\_prepared\_stmt= MYSQL\_CREATE\_PS(stmt, stmt->id,  
                                       thd->m\_statement\_psi,  
                                       stmt->name().str, stmt->name().length,  
                                       query, query\_len);  
stmt->prepare(query, query\_len);  
\`\`\`  
这里的MYSQL\_CREATE\_PS对应了函数inline\_mysql\_create\_prepared\_stmt(IDENTITY, ID, LOCKER, NAME, NAME\_LENGTH, SQLTEXT, SQLTEXT\_LENGTH)，其位于include/mysql/psi/mysql\_ps.h：  
  
  
\`\`\`  
inline\_mysql\_create\_prepared\_stmt(void \*identity, uint stmt\_id,  
                                  PSI\_statement\_locker \*locker,  
                                  const char \*stmt\_name, size\_t stmt\_name\_length,  
                                  const char \*sqltext, size\_t sqltext\_length)  
\{  
  if (locker == NULL)  
    return NULL;  
  return PSI\_PS\_CALL(create\_prepared\_stmt)(identity, stmt\_id,   
                                           locker,  
                                           stmt\_name, stmt\_name\_length,  
                                           sqltext, sqltext\_length);  
\}  
\`\`\`  
我们可以看到，PSI\_PS\_CALL对应的执行的函数是create\_prepared\_stmt，该函数仅仅分配了prepare statement所需的各个数据结构。该函数其位于storage/perfschema/pfs\_prepared\_stmt.cc。  
  
  
真正\*\*对query进行parse的是stmt->prepare(query, query\_len)\*\*。这个stmt是其声明时定义的Prepared\_statement。Prepared\_statement这个类中有一个LEX成员变量lex，其保存了parse tree。注意：凡是看到LEX结构，就要想到其对应了parse tree。在源码中也指明了它是parse tree descriptor。prepare statement最重要的调用是parse\_sql(thd, &parser\_state, NULL)来解析sql语句生成parse tree。parse\_sql调用的是sql\_yacc.cc中的MYSQLparse来做的sql解析。  
  
  
\*\*注意，最后的结果都是在THD中。任何的数据结构想要访问query解析的结果，其都应该包含THD，通过THD来访问。\*\*  
  
  
\#\# mysql\_sql\_stmt\_execute  
  
  
\`\`\`  
void mysqld\_stmt\_execute(THD \*thd, ulong stmt\_id, ulong flags, uchar \*params,  
                         ulong params\_length)  
\{  
Prepared\_statement \*stmt;  
  stmt->execute\_loop(&expanded\_query, open\_cursor, params,  
                    params + params\_length);  
\}  
\`\`\`  
这里列出了最重要的内容，即执行函数execute\_loop。代码中对exectue\_loop的解释如下：  
  
  
\`\`\`  
/\*\*  
  Execute a prepared statement. Re-prepare it a limited number  
  of times if necessary.  
  
  
  Try to execute a prepared statement. If there is a metadata  
  validation error, prepare a new copy of the prepared statement,  
  swap the old and the new statements, and try again.  
  If there is a validation error again, repeat the above, but  
  perform no more than MAX\_REPREPARE\_ATTEMPTS.  
  
  
  @note We have to try several times in a loop since we  
  release metadata locks on tables after prepared statement  
  prepare. Therefore, a DDL statement may sneak in between prepare  
  and execute of a new statement. If this happens repeatedly  
  more than MAX\_REPREPARE\_ATTEMPTS times, we give up.  
  
  
  @return TRUE if an error, FALSE if success  
  @retval  TRUE    either MAX\_REPREPARE\_ATTEMPTS has been reached,  
                   or some general error  
  @retval  FALSE   successfully executed the statement, perhaps  
                   after having reprepared it a few times.  
\*/  
Prepared\_statement::execute\_loop(String \*expanded\_query,  
                                 bool open\_cursor,  
                                 uchar \*packet,  
                                 uchar \*packet\_end)  
\{  
...  
reexecute:  
error= execute(expanded\_query, open\_cursor) || thd->is\_error();  
    if (error) \{  
error= reprepare();  
\}  
  
  
if (! error)                                /\* Success \*/  
      goto reexecute;  
\}   
\`\`\`  
上述代码中真正执行的函数是execute(expanded\_query, open\_cursor)。  
  
  
\# Query Parsing  
接下来让我们看看query是如何被parse的。上面我们分析了execute command，在执行execute command之前，一个SQL query首先会被放入mysql\_parse()进行语法解析：  
  
  
The mysql\_parse() Function  
  
  
  
  
\`\`\`  
/\*  
Parse a query.  
@param thd Current thread  
@param rawbuf Begining of the query text  
@param length Length of the query text  
@param\[out\] found\_semicolon For multi queries, position of the character of  
the next query in the query text.  
\*/  
void mysql\_parse(THD \*thd, char \*rawbuf, uint length,  
Parser\_state \*parser\_state)  
\{  
int error \_\_attribute\_\_((unused));  
...  
if (\*\*query\_cache\_send\_result\_to\_client\*\*(thd, rawbuf, length) <= 0)  
\{  
LEX \*lex= thd->lex;  
...  
\*\*bool err= parse\_sql(thd, parser\_state, NULL);  
...  
error= mysql\_execute\_command(thd);\*\*  
...  
\}  
...  
\}  
else  
\{  
/\*  
Query cache hit. We need to write the general log here.  
Right now, we only cache SELECT results; if the cache ever  
becomes more generic, we should also cache the rewritten  
query string together with the original query string (which  
we'd still use for the matching) when we first execute the  
query, and then use the obfuscated query string for logging  
here when the query is given again.  
\*/  
thd->m\_statement\_psi= MYSQL\_REFINE\_STATEMENT(thd->m\_statement\_psi,  
sql\_statement\_info\[SQLCOM\_SELECT\].m\_key);  
if (!opt\_log\_raw)  
general\_log\_write(thd, COM\_QUERY, thd->query(), thd->query\_length());  
parser\_state->m\_lip.found\_semicolon= NULL;  
\}  
...  
\}  
\`\`\`  
  
  
上面代码中的黑色部分，我们看到了已经分析过的mysql\_execute\_command。在这之前就是parse\_sql。主要，在parse\_sql之前，有一个函数query\_cache\_send\_result\_to\_client，这个函数用来检查query cache。也就是说，如果之前有一个一模一样的query（包括参数哦），那么其结果有可能已经缓存了，如果是这样，就直接返回结果。  
  
  
让我们再回到parser。MySQL对query的parse是用BISON（sql\_yacc.yy）来做的，实际上就是根据MySQL的语法规则，把SQL进行解析存在LEX结构体中。接下来的章节我们会介绍LEX结构体。注意，不要修改sql\_yacc.cc, sql\_yacc.h和lex\_hash.h，这几个文件是自动生成的。  
  
  
\# Preparing for Optimization  
从MySQL的代码和官方文档中是不能严格区分parser和optimizer的边界的。但可以肯定的是sql命令的routing是属于optimier的。通过上面进行parse之后，query就要进入mysql\_execute\_command()。看到这个函数，是不是很熟悉啊。没错，上面我们提到的perpare statement就是这个函数进行routing的。对应的slq\_command存在lex->sql\_command里。上面我们已经分析过了prepare statement，现在我们看看正常的SELECT语句是怎么做的。  
  
  
\`\`\`  
int  
mysql\_execute\_command(THD \*thd)  
\{  
switch (lex->sql\_command) \{  
...  
case SQLCOM\_SHOW\_STATUS\_PROC:  
case SQLCOM\_SHOW\_STATUS\_FUNC:  
case SQLCOM\_SHOW\_DATABASES:  
case SQLCOM\_SHOW\_TABLES:  
...  
\*\*case SQLCOM\_SELECT:  
\{  
thd->status\_var.last\_query\_cost= 0.0;  
thd->status\_var.last\_query\_partial\_plans= 0;  
if ((res= select\_precheck(thd, lex, all\_tables, first\_table)))  
break;  
res= execute\_sqlcom\_select(thd, all\_tables);  
break;  
\}\*\*  
...  
\}  
\`\`\`  
  
  
这里又出现了precheck，不过和上面的check不同，这里的precheck是检查用户权限的。检查完权限就要执行SELECT了。让我们看看具体是怎么做的：  
  
  
The execute\_sqlcom\_command() Function  
  
  
\`\`\`  
static bool execute\_sqlcom\_select(THD \*thd, TABLE\_LIST \*all\_tables)  
\{  
LEX \*lex= thd->lex;  
select\_result \*result= lex->result;  
bool res;  
/\* assign global limit variable if limit is not given \*/  
\{  
SELECT\_LEX \*param= lex->unit.global\_parameters;  
if (!param->explicit\_limit)  
param->\*\*select\_limit\*\*=  
new Item\_int((ulonglong) thd->variables.select\_limit);  
\}  
if (!(res= open\_and\_lock\_tables(thd, all\_tables, 0)))  
\{  
if (lex->describe)  
\{  
/\*  
We always use select\_send for \*\*EXPLAIN\*\*, even if it's an EXPLAIN  
for SELECT ... INTO OUTFILE: a user application should be able  
to prepend EXPLAIN to any query and receive output for it,  
even if the query itself redirects the output.  
\*/  
if (!(result= new select\_send()))  
return 1; /\* purecov: inspected \*/  
res= explain\_query\_expression(thd, result);  
delete result;  
\}  
else  
\{  
if (!result && !(result= new select\_send()))  
return 1; /\* purecov: inspected \*/  
select\_result \*save\_result= result;  
select\_result \*analyse\_result= NULL;  
if (lex->proc\_analyse)  
\{  
if ((result= analyse\_result=  
new select\_analyse(result, lex->proc\_analyse)) == NULL)  
return true;  
\}  
res= handle\_select(thd, result, 0); /\*目前是handle\_query  
delete analyse\_result;  
if (save\_result != lex->result)  
delete save\_result;  
\}  
\}  
return res;  
\}  
\`\`\`  
  
  
select\_limit实际上是where clause；lex->describe实际上是EXPLAIN语句；handle\_select（handle\_query）实际上是mysql\_select()的一个wrapper：  
  
  
\`\`\`  
handle\_select()   
\{  
...  
res= \*\*mysql\_select\*\*(thd,  
select\_lex->table\_list.first,  
select\_lex->with\_wild, select\_lex->item\_list,  
select\_lex->where,  
&select\_lex->order\_list,  
&select\_lex->group\_list,  
select\_lex->having,  
select\_lex->options | thd->variables.option\_bits |  
setup\_tables\_done\_option,  
result, unit, select\_lex);  
...  
\}  
\`\`\`  
接下来，就要真正进入optimizer了！激动吧:-)  
  
  
\# Optimizing the Query  
\#\# Prepare  
  
  
\`\`\`  
bool mysql\_select(THD \*thd,  
TABLE\_LIST \*tables, uint wild\_num, List<Item> &fields,  
Item \*conds, SQL\_I\_List<ORDER> \*order, SQL\_I\_List<ORDER> \*group,  
Item \*having, ulonglong select\_options,  
select\_result \*result, SELECT\_LEX\_UNIT \*unit,  
SELECT\_LEX \*select\_lex)  
\{  
bool free\_join= true;  
uint og\_num= 0;  
ORDER \*first\_order= NULL;  
ORDER \*first\_group= NULL;  
DBUG\_ENTER("mysql\_select");  
if (order)  
\{  
og\_num= order->elements;  
first\_order= order->first;  
\}  
if (group)  
\{  
og\_num+= group->elements;  
first\_group= group->first;  
\}  
if (\*\*mysql\_prepare\_select\*\*(thd, tables, wild\_num, fields,  
conds, og\_num, first\_order, first\_group, having,  
select\_options, result, unit,  
select\_lex, &free\_join))  
\{  
if (free\_join)  
\{  
THD\_STAGE\_INFO(thd, stage\_end);  
(void) select\_lex->cleanup();  
\}  
DBUG\_RETURN(true);  
\}  
if (! thd->lex->is\_query\_tables\_locked())  
\{  
/\*  
If tables are not locked at this point, it means that we have delayed  
this step until after the prepare stage (i.e. this moment). This allows us to  
do better partition pruning and avoid locking unused partitions.  
As a consequence, in such a case, the prepare stage can rely only on  
metadata about tables used and not data from them.  
We need to lock tables now in order to proceed with the remaining  
stages of query optimization and execution.  
\*/  
if (\*\*lock\_tables\*\*(thd, thd->lex->query\_tables, thd->lex->table\_count, 0))  
\{  
if (free\_join)  
\{  
THD\_STAGE\_INFO(thd, stage\_end);  
(void) select\_lex->cleanup();  
\}  
DBUG\_RETURN(true);  
\}  
/\*  
Only register query in cache if it tables were locked above.  
Tables must be locked before storing the query in the query cache.  
Transactional engines must have been signalled that the statement started,  
which external\_lock signals.  
\*/  
query\_cache\_store\_query(thd, thd->lex->query\_tables);  
\}  
DBUG\_RETURN(\*\*mysql\_execute\_select\*\*(thd, select\_lex, free\_join));  
\`\`\`  
  
  
现在让我们看看mysql\_select的代码，如上所示。真正执行optimize的部分在最后的mysql\_execute\_select。在这之前，有一个准备动作是mysql\_prepare\_select，它的作用是分配optimizer要用到的JOIN。注意，在执行mysql\_execute\_select，MySQL给table上了锁：lock\_tables。  
  
  
在5.7中，对应的代码是：  
  
  
\`\`\`  
bool handle\_query() \{  
...  
select->prepare(thd);  
...  
select->optimize(thd);  
...  
select->join->exec();  
\}  
\`\`\`  
  
  
\#\# Optimize  
接下来就是mysql\_execute\_select了（optimize），MySQL使用了practice based和cost-model based相结合的方式来做optimization。我们先来看看practice based都包含哪些。  
  
  
\#\# Practice based  
\*\*Constant Propagation\*\*。例如column1=7 AND column2=column1，就会被optimize成column1=7 AND column2=7。  
\*\*Dead code elimination\*\*。例如column1 = 12 AND column2 = 13 AND column1 < column2，就会被optimize成column1 = 12 AND column2 = 13。  
\*\*Range queries\*\*。例如column1 IN (1, 2, 3)会被optimize成column1 = 1 OR column1 = 2 OR column1 = 3。  
  
  
其他的practice还有什么呢？其实在JOIN里包含了很多很多。大部分资料都没有具体提及，想研究的朋友可以去看source code。  
\#\# Cost-model baesd  
  
  
The mysql\_execute\_select() Function  
  
  
\`\`\`  
/\*  
Execute stage of mysql\_select.  
@param thd thread handler  
@param select\_lex the only SELECT\_LEX of this query  
@param free\_join if join should be freed  
@return Operation status  
@retval false success  
@retval true an error  
@note tables must be opened and locked before calling mysql\_execute\_select.  
\*/  
static bool  
mysql\_execute\_select(THD \*thd, SELECT\_LEX \*select\_lex, bool free\_join)  
\{  
bool err;  
JOIN\* join= select\_lex->join;  
DBUG\_ENTER("mysql\_execute\_select");  
DBUG\_ASSERT(join);  
if ((err= join->\*\*optimize\*\*()))  
\{  
goto err; // 1  
\}  
if (thd->is\_error())  
goto err;  
if (join->select\_options & SELECT\_DESCRIBE)  
\{  
join->explain();  
free\_join= false;  
\}  
else  
join->\*\*exec\*\*();  
err:  
if (free\_join)  
\{  
THD\_STAGE\_INFO(thd, stage\_end);  
err|= select\_lex->cleanup();  
DBUG\_RETURN(err || thd->is\_error());  
\}  
DBUG\_RETURN(join->error);  
\}  
\`\`\`  
  
  
上面代码中的join->optimize()就是要做两件事：practice based optimize和cost-model based optimize。如上面代码中的黑色部分，做完optimize之后，就到了exec阶段。exec也会用一些practice based的方法来加速执行速度，比如遇到ORDRE BY和DISTINCT会被分配到专门的处理函数来做。  
  
  
接下来让我们看看join::exec()做了什么：  
  
  
\`\`\`  
The join::exec() Function  
\{  
Opt\_trace\_context \* const trace= &thd->opt\_trace;  
Opt\_trace\_object trace\_wrapper(trace);  
Opt\_trace\_object trace\_exec(trace, "join\_execution");  
trace\_exec.add\_select\_number(select\_lex->select\_number);  
Opt\_trace\_array trace\_steps(trace, "steps");  
List<Item> \*columns\_list= &fields\_list;  
DBUG\_ENTER("JOIN::exec");  
THD\_STAGE\_INFO(thd, stage\_sending\_data);  
DBUG\_PRINT("info", ("%s", thd->proc\_info));  
result->\*\*send\_result\_set\_metadata\*\*(\*fields,  
Protocol::SEND\_NUM\_ROWS | Protocol::SEND\_EOF);  
error= \*\*do\_select\*\*(this);  
/\* Accumulate the counts from all join iterations of all join parts. \*/  
thd->\*\*inc\_examined\_row\_count\*\*(examined\_rows);  
DBUG\_PRINT("counts", ("thd->examined\_row\_count: %lu",  
(ulong) thd->get\_examined\_row\_count()));  
DBUG\_VOID\_RETURN;  
\}  
\`\`\`  
  
  
这里，do\_select是用来读取表中的数据（real data）。如下所示：  
  
  
\`\`\`  
static int  
do\_select(JOIN \*join)  
\{  
int rc= 0;  
enum\_nested\_loop\_state error= NESTED\_LOOP\_OK;  
DBUG\_ENTER("do\_select");  
...  
else  
\{  
JOIN\_TAB \*join\_tab= join->join\_tab + join->const\_tables;  
DBUG\_ASSERT(join->tables);  
error= join->first\_select(join,join\_tab,0);  
if (error >= NESTED\_LOOP\_OK)  
error= join->\*\*first\_select\*\*(join,join\_tab,1);  
\}  
join->thd->limit\_found\_rows= join->send\_records;  
/\* Use info provided by filesort. \*/  
if (join->order)  
\{  
// Save \# of found records prior to cleanup  
JOIN\_TAB \*sort\_tab;  
JOIN\_TAB \*join\_tab= join->join\_tab;  
uint const\_tables= join->const\_tables;  
// Take record count from first non constant table or from last tmp table  
if (join->tmp\_tables > 0)  
sort\_tab= join\_tab + join->tables + join->tmp\_tables - 1;  
else  
\{  
DBUG\_ASSERT(join->tables > const\_tables);  
sort\_tab= join\_tab + const\_tables;  
\}  
if (sort\_tab->filesort &&  
sort\_tab->filesort->sortorder)  
\{  
join->thd->limit\_found\_rows= sort\_tab->records;  
\}  
\}  
\{  
/\*  
The following will unlock all cursors if the command wasn't an  
update command  
\*/  
join->join\_free(); // Unlock all cursors  
\}  
  
  
fisrt\_select会调用sub\_select来真正读取数据，如下：  
  
  
The sub\_select() Function  
\{  
DBUG\_ENTER("sub\_select");  
join\_tab->table->null\_row=0;  
if (end\_of\_records)  
\{  
enum\_nested\_loop\_state nls=  
(\*join\_tab->next\_select)(join,join\_tab+1,end\_of\_records);  
DBUG\_RETURN(nls);  
\}  
\*\*READ\_RECORD\*\* \*info= &join\_tab->read\_record;  
...  
join->thd->get\_stmt\_da()->reset\_current\_row\_for\_warning();  
enum\_nested\_loop\_state rc= NESTED\_LOOP\_OK;  
bool in\_first\_read= true;  
while (rc == NESTED\_LOOP\_OK && join->return\_tab >= join\_tab)  
\{  
int error;  
if (in\_first\_read)  
\{  
in\_first\_read= false;  
error= (\*join\_tab->\*\*read\_first\_record\*\*)(join\_tab);  
\}  
else  
error= info->\*\*read\_record\*\*(info);  
DBUG\_EXECUTE\_IF("bug13822652\_1", join->thd->killed= THD::KILL\_QUERY;);  
  
  
\`\`\`  
\*\*本函数的主要功能是initialize tables，然后顺序的一条条读数据。\*\*READ\_RECORD结构就用来放数据的。到此为止，整个query解析，optimize和执行流程分析完毕。上面我们特意提到了LEX的结构用来存放parse后的plan  
  
  
\# Optimize小结  
\#\# JOIN::prepare  
  
  
\* 初始化JOIN structure，并且把JOIN structure链接到st\_select\_lex.  
\* fix\_fields() for all items (执行了fix\_fields()之后，我们就知道了item的所有信息).  
\* 把HAVING移动到WHERE if possible.  
  
  
\#\# JOIN::optimize  
  
  
\* 执行optimize。  
\* 第一个temporary table有可能被创建。  
  
  
\#\# JOIN::exec  
  
  
执行select (第二个temporary table有可能被创建)。  
  
  
\#\# JOIN::cleanup  
  
  
\* 删除所有temporary tables  
\* 删除所有其他临时变量  
  
  
\#\# JOIN::reinit  
  
  
Prepare all structures for execution of SELECT (with JOIN::exec).  
  
  
\# 其他数据结构  
count相关：  
count\_field\_types  
JOIN::make\_join\_plan()是用来初始化QEP的，具体来说是初始化JOIN\_TAB。在JOIN::make\_join\_plan()里面有一个get\_best\_combination()  
  
  
\`\`\`  
class JOIN : \*\*  
\{  
  /\*\*  
    Optimal query execution plan. Initialized with a tentative plan in  
    JOIN::make\_join\_plan() and later replaced with the optimal plan in  
    get\_best\_combination().  
  \*/  
  JOIN\_TAB \*join\_tab;  
  /// Array of QEP\_TABs  
  QEP\_TAB \*qep\_tab;  
  
  
  /\*\*  
    Array of plan operators representing the current (partial) best  
    plan. The array is allocated in JOIN::make\_join\_plan() and is valid only  
    inside this function. Initially (\*best\_ref\[i\]) == join\_tab\[i\].  
    The optimizer reorders best\_ref.  
  \*/  
  JOIN\_TAB \*\*best\_ref;  
  JOIN\_TAB \*\*map2table;    ///< mapping between table indexes and JOIN\_TABs  
    
    /\*\*  
    The cost of best complete join plan found so far during optimization,  
    after optimization phase - cost of picked join order (not taking into  
    account the changes made by test\_if\_skip\_sort\_order()).  
  \*/  
  double   best\_read;  
  /\*\*  
    The estimated row count of the plan with best read time (see above).  
  \*/  
  ha\_rows  best\_rowcount;  
\}  
\`\`\`  
  
  
Query optimization plan node.  
\`\`\`  
class JOIN\_TAB  
\{  
  /\*  
    Number of records that will be scanned (yes scanned, not returned) by the  
    best 'independent' access method, i.e. table scan or QUICK\_\*\_SELECT)  
  \*/  
  ha\_rows       found\_records;  
  /\*  
    Cost of accessing the table using "ALL" or range/index\_merge access  
    method (but not 'index' for some reason), i.e. this matches method which  
    E(\#records) is in found\_records.  
  \*/  
  ha\_rows       read\_time;  
 \}  
\`\`\`  
  
  
如果没有where的查询，在sql\_executor.cc中：  
  
  
\`\`\`  
evaluate\_join\_record(JOIN \*join, QEP\_TAB \*const qep\_tab)  
\{  
    /\*  
      There is no condition on this join\_tab or the attached pushed down  
      condition is true => a match is found.  
    \*/  
    while (qep\_tab->first\_unmatched != NO\_PLAN\_IDX && found)  
    \{  
\`\`\`  
  
  
读取数据调用关系如下。注意，这里的READ\_RECORD作为uchar buf被传进去，一条记录读出来之后会被填入到这个buf中。  
  
  
\`\`\`  
do\_select()  
\-->error= join->first\_select(join,qep\_tab,0);  
==sub\_select(JOIN \*join, QEP\_TAB \*const qep\_tab,bool end\_of\_records)  
READ\_RECORD \*info= &qep\_tab->read\_record;  
\-->info->read\_record(info)  
   -->join\_read\_next(READ\_RECORD \*info)  
      -->ha\_index\_next(uchar \* buf)   
         -->index\_next(buf)  
\`\`\`  
也就是说，读出来的数据被放在了qep\_tab->read\_record中。真正读取函数位于ha\_innodb.cc：  
  
  
\`\`\`  
ret = row\_search\_mvcc(  
buf, PAGE\_CUR\_UNSUPP, m\_prebuilt, match\_mode,  
direction);  
\`\`\`  
对于table scan的结果为两种：  
  
  
\`\`\`  
DB\_SUCCESS  
DB\_END\_OF\_INDEX  
\`\`\`  
  
  
range\_scan:  
int get\_type() const \{ return QS\_TYPE\_RANGE; \}  
  
  
get\_quick\_keys(PARAM \*param,QUICK\_RANGE\_SELECT \*quick,KEY\_PART \*key,  
      SEL\_ARG \*key\_tree, uchar \*min\_key,uint min\_key\_flag,  
      uchar \*max\_key, uint max\_key\_flag)  
  
  
/\*\* Searches for rows in the database using cursor.  
Function is mainly used for tables that are shared accorss connection and  
so it employs technique that can help re-construct the rows that  
transaction is suppose to see.  
It also has optimization such as pre-caching the rows, using AHI, etc.  
  
  
@param\[out\] buf buffer for the fetched row in MySQL format  
@param\[in\] mode search mode PAGE\_CUR\_L  
@param\[in,out\] prebuilt prebuilt struct for the table handler;  
this contains the info to search\_tuple,  
index; if search tuple contains 0 field then  
we position the cursor at start or the end of  
index, depending on 'mode'  
@param\[in\] match\_mode 0 or ROW\_SEL\_EXACT or ROW\_SEL\_EXACT\_PREFIX  
@param\[in\] direction 0 or ROW\_SEL\_NEXT or ROW\_SEL\_PREV;  
Note: if this is != 0, then prebuilt must has a  
pcur with stored position! In opening of a  
cursor 'direction' should be 0.  
@return DB\_SUCCESS or error code \*/  
dberr\_t  
row\_search\_mvcc(  
byte\* buf,  
page\_cur\_mode\_t mode,  
row\_prebuilt\_t\* prebuilt,  
ulint match\_mode,  
ulint direction)\{\}  
  
row\_update\_for\_mysql\_using\_upd\_graph(  
  
clust\_index = dict\_table\_get\_first\_index(table);  
  
  
if (prebuilt->pcur->btr\_cur.index == clust\_index) \{  
btr\_pcur\_copy\_stored\_position(node->pcur, prebuilt->pcur);  
\} else \{  
btr\_pcur\_copy\_stored\_position(node->pcur,  
     prebuilt->clust\_pcur);  
\}  
  
  
/\*\*  
  Read row via random scan from position.  
  
  
  @param\[out\] buf  Buffer to read the row into  
  @param      pos  Position from position() call  
  
  
  @return Operation status  
    @retval 0     Success  
    @retval != 0  Error (error code returned)  
\*/  
  
  
int handler::ha\_rnd\_pos(uchar \*buf, uchar \*pos)  
\{  
  int result;  
  DBUG\_ENTER("handler::ha\_rnd\_pos");  
  DBUG\_ASSERT(table\_share->tmp\_table != NO\_TMP\_TABLE ||  
              m\_lock\_type != F\_UNLCK);  
  /\* TODO: Find out how to solve ha\_rnd\_pos when finding duplicate update. \*/  
  /\* DBUG\_ASSERT(inited == RND); \*/  
  
  
  // Set status for the need to update generated fields  
  m\_update\_generated\_read\_fields= table->has\_gcol();  
  
  
  MYSQL\_TABLE\_IO\_WAIT(PSI\_TABLE\_FETCH\_ROW, MAX\_KEY, result,  
    \{ result= rnd\_pos(buf, pos); \})  
  if (!result && m\_update\_generated\_read\_fields)  
  \{  
    result= update\_generated\_read\_fields(buf, table);  
    m\_update\_generated\_read\_fields= false;  
  \}  
  DBUG\_RETURN(result);  
\}  
  
  
\`\`\`  
JOIN::optimize()  
make\_join\_readinfo(JOIN \*join, uint no\_jbuf\_after)  
QEP\_TAB::pick\_table\_access\_method(const JOIN\_TAB \*join\_tab)--> 这里把function名赋值给了read\_first\_record，function名是join\_init\_read\_record  
之后，在执行的时候sub\_select会调用read\_first\_record，即执行join\_init\_read\_record：  
join\_init\_read\_record(QEP\_TAB \*tab)-->  
init\_read\_record-->  
static int rr\_quick(READ\_RECORD \*info)  
\--QUICK\_RANGE\_SELECT::get\_next()  
   -->handler::multi\_range\_read\_next  
      -->handler::read\_range\_first  
         -->ha\_index\_read\_map  
            -->index\_read  
\`\`\`