OurMySQL

MYSQL的DECIMAL和NUMERIC类型

OurMySQL — Mon, 26 Mar 2012 22:55:48 +0800

MYSQL, DECIMAL和NUMERIC类型说明:

DECIMAL和NUMERIC类型在MySQL中视为相同的类型。它们用于保存必须为确切精度的值，例如货币数据。

当声明该类型的列时，可以(并且通常要)指定精度和标度；例如：

salary DECIMAL(5,2)

在该例子中，5是精度，2是标度。精度表示保存值的主要位数，标度表示小数点后面可以保存的位数。

在MySQL 5.1中以二进制格式保存DECIMAL和NUMERIC值。

标准SQL要求salary列能够用5位整数位和两位小数保存任何值。因此，在这种情况下可以保存在salary列

的值的范围是从-999.99到999.99。

在标准SQL中，语法DECIMAL(M)等价于DECIMAL(M,0)。同样，语法DECIMAL等价于DECIMAL(M,0)，可以通过

计算确定M的值。在MySQL 5.1中支持DECIMAL和NUMERIC数据类型的变量形式。M默认值是10。

DECIMAL或NUMERIC的最大位数是65，但具体的DECIMAL或NUMERIC列的实际范围受具体列的精度或标度约束

。如果此类列分配的值小数点后面的位数超过指定的标度允许的范围，值被转换为该标度。(具体操作与

操作系统有关，但一般结果均被截取到允许的位数）。

MYSQL, DECIMAL和NUMERIC类型说明:
DECIMAL和NUMERIC类型在MySQL中视为相同的类型。它们用于保存必须为确切精度的值，例如货币数据。
当声明该类型的列时，可以(并且通常要)指定精度和标度；例如：
salary DECIMAL(5,2)在该例子中，5是精度，2是标度。精度表示保存值的主要位数，标度表示小数点后面可以保存的位数。
在MySQL 5.1中以二进制格式保存DECIMAL和NUMERIC值。
标准SQL要求salary列能够用5位整数位和两位小数保存任何值。因此，在这种情况下可以保存在salary列
的值的范围是从-999.99到999.99。
在标准SQL中，语法DECIMAL(M)等价于DECIMAL(M,0)。同样，语法DECIMAL等价于DECIMAL(M,0)，可以通过
计算确定M的值。在MySQL 5.1中支持DECIMAL和NUMERIC数据类型的变量形式。M默认值是10。
DECIMAL或NUMERIC的最大位数是65，但具体的DECIMAL或NUMERIC列的实际范围受具体列的精度或标度约束
。如果此类列分配的值小数点后面的位数超过指定的标度允许的范围，值被转换为该标度。(具体操作与
操作系统有关，但一般结果均被截取到允许的位数）。

目前没有相关的文章

标签：DECIMAL, MySQL基础知识, NUMERIC

mysql hash 破解提权

OurMySQL — Mon, 26 Mar 2012 22:54:07 +0800

mssql的hash保存在表master.dbo.sysxlogins中，用

select name,password from master.dbo.sysxlogins

可以提取用户hash
0x01004E04BE46023057E323AF27269E5B7DDCA140C98D225BDD3D06E8EFE8CFAEC02985B27B38059FA3B18349612B

分解：

常量部分：0×0100
Salt部分：4E04BE46
混合密文：023057E323AF27269E5B7DDCA140C98D225BDD3D
大写字母密文：06E8EFE8CFAEC02985B27B38059FA3B18349612B 后40位

有了HASH就可以破解了，用到的工具是CAIN。

转到CAIN的破解功能那里，添加一个待破解的MSSQL HASH
有三个需要写的文本框。

将salt ，混合密文跟大写字母密文填入，就可以破解了。

mysql的用户名密码保存在mysql库user表中，找到MySQL\data\mysql\目录下的 user.MYD user.MYI user.frm 三个文件，拷贝到自己的mysql数据库目录下，就可以查看用户的hash了。
用sql语句提取hash则如下：

use mysql;
select user,password from user;

得到hash：
test:*085D85329E1557C869A120C9157315A07D51E8A7 ogame:*085D85329E1557C869A120C9157315A07D51E8A7 iii6_com:*085D85329E1557C869A120C9157315A07D51E8A7 root:*5D0B157F0A3BB4DB1A0092B4F270FBDA486EC6EB

冒号左边是用户，右边是HASH
HASH值开头带”*”号的是MYSQL5的HASH
不带*号的是旧版MYSQL的HASH(也就是MYSQL323)

破解：
用passwordspro或者cain的破解器可以破解。

标签：Hash, MySQL高级应用

mysql 数据库查询随机数量条目的效率问题及解决办法

OurMySQL — Mon, 26 Mar 2012 22:51:57 +0800

最近由于需要大概研究了一下MYSQL的随机抽取实现方法。举个例子，要从tablename表中随机提取一条记录，大家一般的写法就是：SELECT * FROM tablename ORDER BY RAND() LIMIT 1。

但是，后来我查了一下MYSQL的官方手册，里面针对RAND()的提示大概意思就是，在ORDER BY从句里面不能使用RAND()函数，因为这样会导致数据列被多次扫描。但是在MYSQL 3.23版本中，仍然可以通过ORDER BY RAND()来实现随机。

但是真正测试一下才发现这样效率非常低。一个15万余条的库，查询5条数据，居然要8秒以上。查看官方手册，也说rand()放在ORDER BY 子句中会被执行多次，自然效率及很低。

搜索Google，网上基本上都是查询max(id) * rand()来随机获取数据。
SELECT * FROM `table` AS t1 JOIN (SELECT ROUND(RAND() * (SELECT MAX(id) FROM `table`)) AS id) AS t2 WHERE t1.id >= t2.id ORDER BY t1.id ASC LIMIT 5;

但是这样会产生连续的5条记录。解决办法只能是每次查询一条，查询5次。即便如此也值得，因为15万条的表，查询只需要0.01秒不到。

下面的语句采用的是JOIN，mysql的论坛上有人使用

SELECT * FROM `table` WHERE id >= (SELECT FLOOR( MAX(id) * RAND()) FROM `table` ) ORDER BY id LIMIT 1;

我测试了一下，需要0.5秒，速度也不错，但是跟上面的语句还是有很大差距。总觉有什么地方不正常。

于是我把语句改写了一下。
SELECT * FROM `table`
WHERE id >= (SELECT floor(RAND() * (SELECT MAX(id) FROM `table`)))
ORDER BY id LIMIT 1;

这下，效率又提高了，查询时间只有0.01秒

最后，再把语句完善一下，加上MIN(id)的判断。我在最开始测试的时候，就是因为没有加上MIN(id)的判断，结果有一半的时间总是查询到表中的前面几行。
完整查询语句是：
SELECT * FROM `table`
WHERE id >= (SELECT floor( RAND() * ((SELECT MAX(id) FROM `table`)-(SELECT MIN(id) FROM `table`)) + (SELECT MIN(id) FROM `table`)))
ORDER BY id LIMIT 1;

SELECT *
FROM `table` AS t1 JOIN (SELECT ROUND(RAND() * ((SELECT MAX(id) FROM `table`)-(SELECT MIN(id) FROM `table`))+(SELECT MIN(id) FROM `table`)) AS id) AS t2
WHERE t1.id >= t2.id
ORDER BY t1.id LIMIT 1;

最后在php中对这两个语句进行分别查询10次，
前者花费时间 0.147433 秒
后者花费时间 0.015130 秒
看来采用JOIN的语法比直接在WHERE中使用函数效率还要高很多。

2009-04-14 -- MySql 随机读取数据

标签：MySQL优化设计, 随机

Mysql源码学习——没那么简单的Hash

OurMySQL — Mon, 26 Mar 2012 13:49:55 +0800

Hash 链表的应用比较常见，其目的就是为了将不同的值映射到不同的位置，查找的时候直接找到相应的位置，而不需要传统的顺序遍历或是二分查找，从而达到减少查询时间的目的。常规的hash是预定义一定的桶(bucket)，规定一个hash函数，然后进行散列。然而Mysql中的hash没有固定的 bucket，hash函数也是动态变化的，本文就进行非深入介绍。

基本结构体

Hash的结构体定义以及相关的函数接口定义在include/hash.h和mysys/hash.c两个文件中。下面是HASH结构体的定义。

typedef struct st_hash {

size_t key_offset,key_length; /* Length of key if const length */

size_t blength;

ulong records;

uint flags;

DYNAMIC_ARRAY array; /* Place for hash_keys */

my_hash_get_key get_key;

void (*free)(void *);

CHARSET_INFO *charset;

} HASH;

成员名	说明
key_offset	hash时key的offset，在不指定hash函数的情况下有意义
key_length	key的长度，用于计算key值
blength	非常重要的辅助结构，初始为1，动态变化，用于hash函数计算，这里理解为bucket length（其实不是真实的bucket数）
records	实际的记录数
flags	是否允许存在相同的元素，取值为HASH_UNIQUE(1)或者0
array	存储元素的数组
get_key	用户定义的hash函数，可以为NULL
free	析构函数，可以为NULL
charset	字符集

 <font size="3"

>HASH 结构体里面包含了一个动态数组结构体DYNAMIC_ARRAY，这里就一并介绍了。其定义 在<em><strong>include/my_sys.h</strong></em> 中。</font>

typedef struct st_dynamic_array

{

uchar *buffer;

uint elements,max_element;

uint alloc_increment;

uint size_of_element;

} DYNAMIC_ARRAY;

成员名	说明
buffer	一块连续的地址空间，用于存储数据，可以看成一个数组空间
elements	元素个数
max_element	元素个数上限
alloc_increment	当元素达到上限时，即buffer满时，按照alloc_increment进行扩展
size_of_element	每个元素的长度

初始化函数

Hash初始化函数对外提供两个，my_hash_init和my_hash_init2，其区别即是否定义了growth_size（用于设置DYNAMIC_ARRAY的alloc_increment）。代码在mysys/hash.c中。

#define my_hash_init(A,B,C,D,E,F,G,H) \

_my_hash_init(A,0,B,C,D,E,F,G,H)

#define my_hash_init2(A,B,C,D,E,F,G,H,I) \

_my_hash_init(A,B,C,D,E,F,G,H,I)

/**

@brief Initialize the hash

@details

Initialize the hash, by defining and giving valid values for

its elements. The failure to allocate memory for the

hash->array element will not result in a fatal failure. The

dynamic array that is part of the hash will allocate memory

as required during insertion.

@param[in,out] hash The hash that is initialized

@param[in] charset The charater set information

@param[in] size The hash size

@param[in] key_offest The key offset for the hash

@param[in] key_length The length of the key used in

the hash

@param[in] get_key get the key for the hash

@param[in] free_element pointer to the function that

does cleanup

@return inidicates success or failure of initialization

@retval 0 success

@retval 1 failure

*/

my_bool

_my_hash_init(HASH *hash, uint growth_size, CHARSET_INFO *charset,

ulong size, size_t key_offset, size_t key_length,

my_hash_get_key get_key,

void (*free_element)(void*), uint flags)

{

DBUG_ENTER("my_hash_init");

DBUG_PRINT("enter",("hash: 0x%lx size: %u", (long) hash, (uint) size));

hash->records=0;

hash->key_offset=key_offset;

hash->key_length=key_length;

hash->blength=1;

hash->get_key=get_key;

hash->free=free_element;

hash->flags=flags;

hash->charset=charset;

DBUG_RETURN(my_init_dynamic_array_ci(&hash->array,

sizeof(HASH_LINK), size, growth_size));

}

<font size="3"

>   可以看到，_my_hash_init函数主要是初始化HASH结构体和hash->array（DYNAMIC_ARRAY结构体）。</font>

动态HASH函数

 我们首先来看下hash函数的定义：

static inline char*

my_hash_key(const HASH *hash, const uchar *record, size_t *length,

my_bool first)

{

if (hash->get_key)

return (char*) (*hash->get_key)(record,length,first);

*length=hash->key_length;

return (char*) record+hash->key_offset;

}

static uint my_hash_mask(my_hash_value_type hashnr, size_t buffmax,

size_t maxlength)

{

if ((hashnr & (buffmax-1)) < maxlength) return (hashnr & (buffmax-1));

return (hashnr & ((buffmax >> 1) -1));

}

my_hash_key参数	说明
hash	HASH链表结构
record	带插入的元素的值
length	带插入元素的值长度
first	辅助参数

 

my_hash_mask参数	说明
hashnr	my_hash_key的计算结果
buffmax	hash结构体中的blength
maxlength	实际桶的个数

你可能要问我怎么有两个？其实这和我们平时使用的差不多，第一个函数my_hash_key是根据我们的值进行Hash Key计算，一般我们在计算后，会对hash key进行一次模运算，以便计算结果在我们的bucket中。即my_hash_key的结果作为my_hash_mask的第一个输入参数。其实到这里都是非常好理解的，唯一让我蛋疼的是my_hash_mask的实现，其计算结果是和第二和第三个参数有关，即Hash结构体中的blength和records有关。动态变化的，我去..

看到这里我迷惑了，我上网经过各种百度，谷歌，终于让我找到了一封Mysql Expert的回信：

Hi!

"Yan" == Yan Yu <yan2...@facebook.com> writes:

Yan> Dear MySQL experts:

Yan> Thank you so much for your reply to my previous Qs, they are very

Yan> helpful!

Yan> Could someone please help me understand function my_hash_insert()

Yan> in mysys/hash.cc?

Yan> what are lines 352 -429 trying to achieve? Are they just some

Yan> optimization to shuffle existing

Yan> hash entries in the table (since the existing hash entries may be in

Yan> the wrong slot due to chaining

Yan> in the case of hash collision)?

The hash algorithm is based on dynamic hashing without empty slots.

This means that when you insert a new key, in some cases a small set

of old keys needs to be moved to other buckets. This is what the code

does.

Regards,

Monty

红色注释的地方是重点，dynamic hash，原来如此，动态hash，第一次听说，在网上下了个《Dynamic Hash Tables》的论文，下面图解下基本原理。

<a href="http://images.cnblogs.com/cnblogs_com/nocode/201110/201110142107072298.png"><img title="image" style="border-width: 0px; display: block; float: none; margin-left: auto; margin-right: auto;" alt="image" src="http://images.cnblogs.com/cnblogs_com/nocode/201110/201110142107114127.png" border="0" height="910" width="570"></a>

动态Hash的本质是Hash函数的设计，图中给出的动态hash函数只是论文中提到的一个例子。下面就具体解读下Mysql中的hash插入——my_hash_insert

my_hash_insert非深入解析

首先给出my_hash_insert的源代码,代码在mysys/hash.c中。

my_bool my_hash_insert(HASH *info, const uchar *record)

{

int flag;

size_t idx,halfbuff,first_index;

my_hash_value_type hash_nr;

uchar *UNINIT_VAR(ptr_to_rec),*UNINIT_VAR(ptr_to_rec2);

HASH_LINK *data,*empty,*UNINIT_VAR(gpos),*UNINIT_VAR(gpos2),*pos;

if (HASH_UNIQUE & info->flags)

{

uchar *key= (uchar*) my_hash_key(info, record, &idx, 1);

if (my_hash_search(info, key, idx))

return(TRUE); /* Duplicate entry */

}

flag=0;

if (!(empty=(HASH_LINK*) alloc_dynamic(&info->array)))

return(TRUE); /* No more memory */

data=dynamic_element(&info->array,0,HASH_LINK*);

halfbuff= info->blength >> 1;

idx=first_index=info->records-halfbuff;

if (idx != info->records) /* If some records */

{

do

{

pos=data+idx;

hash_nr=rec_hashnr(info,pos->data);

if (flag == 0) /* First loop; Check if ok */

if (my_hash_mask(hash_nr, info->blength, info->records) != first_index)

break;

if (!(hash_nr & halfbuff))

{ /* Key will not move */

if (!(flag & LOWFIND))

{

if (flag & HIGHFIND)

{

flag=LOWFIND | HIGHFIND;

/* key shall be moved to the current empty position */

gpos=empty;

ptr_to_rec=pos->data;

empty=pos; /* This place is now free */

}

else

{

flag=LOWFIND | LOWUSED; /* key isn't changed */

gpos=pos;

ptr_to_rec=pos->data;

}

else

{

if (!(flag & LOWUSED))

{

/* Change link of previous LOW-key */

gpos->data=ptr_to_rec;

gpos->next= (uint) (pos-data);

flag= (flag & HIGHFIND) | (LOWFIND | LOWUSED);

}

gpos=pos;

ptr_to_rec=pos->data;

}

else

{ /* key will be moved */

if (!(flag & HIGHFIND))

{

flag= (flag & LOWFIND) | HIGHFIND;

/* key shall be moved to the last (empty) position */

gpos2 = empty; empty=pos;

ptr_to_rec2=pos->data;

}

else

{

if (!(flag & HIGHUSED))

{

/* Change link of previous hash-key and save */

gpos2->data=ptr_to_rec2;

gpos2->next=(uint) (pos-data);

flag= (flag & LOWFIND) | (HIGHFIND | HIGHUSED);

}

gpos2=pos;

ptr_to_rec2=pos->data;

}

while ((idx=pos->next) != NO_RECORD);

if ((flag & (LOWFIND | LOWUSED)) == LOWFIND)

{

gpos->data=ptr_to_rec;

gpos->next=NO_RECORD;

}

if ((flag & (HIGHFIND | HIGHUSED)) == HIGHFIND)

{

gpos2->data=ptr_to_rec2;

gpos2->next=NO_RECORD;

}

/* Check if we are at the empty position */

idx= my_hash_mask(rec_hashnr(info, record), info->blength, info->records + 1);

pos=data+idx;

if (pos == empty)

{

pos->data=(uchar*) record;

pos->next=NO_RECORD;

}

else

{

/* Check if more records in same hash-nr family */

empty[0]=pos[0];

gpos= data + my_hash_rec_mask(info, pos, info->blength, info->records + 1);

if (pos == gpos)

{

pos->data=(uchar*) record;

pos->next=(uint) (empty - data);

}

else

{

pos->data=(uchar*) record;

pos->next=NO_RECORD;

movelink(data,(uint) (pos-data),(uint) (gpos-data),(uint) (empty-data));

}

if (++info->records == info->blength)

info->blength+= info->blength;

return(0);

}

同时给出动态hash函数如下：

static uint my_hash_mask(my_hash_value_type hashnr, size_t buffmax,

size_t maxlength)

{

if ((hashnr & (buffmax-1)) < maxlength) return (hashnr & (buffmax-1));

return (hashnr & ((buffmax >> 1) -1));

}

 

可以看出，hash函数是hash key与buffmax的模运算，buffmax即HASH结构中的blength，由my_hash_insert中最后几行代码可知：info->blength+= info->blength; 其初始值为1，即blength = 2^n，而且blengh始终是大于records。这个动态hash函数的基本意思是key%（2^n）。依然用图解这个动态hash函数。

hash函数基本清楚了，但是mysql的具体实现还是比较值得探讨的。那封回信中也提到了without empty slots，是的，它这种实现方式是根据实际的数据量进行桶数的分配。我这里大概说下代码的流程（有兴趣的还需要大家自己仔细琢磨）。

根据flag去判断是否是否唯一Hash，如果是唯一Hash，去查找Hash表中是否存在重复值(dupliacate entry)，存在则报错。
进行桶分裂，对应代码中的if (idx != info->records)分支。这个分支有些费解，稍微提示下：gpos和ptr_to_rec指示了低位需要移动的数据，gpos2和 ptr_to_rec2只是了高位需要移动的数据。LOWFIND表示低位存在值，LOWUSED表示低位是否进行了调整。HIGH的宏意义基本相同。 if (!(hash_nr & halfbuff)) 用于判断hash值存在高位还是低位。
计算新值对应的bucket号，插入。如果此位置上存在元素(一般情况都存在，除非是empty，概率比较小)，调整原始元素的位置。

2012-03-26 -- mysql hash 破解提权
2012-03-26 -- Mysql源码学习——用户认证原理与实现
2012-03-26 -- Mysql源码学习——Thread Manager
2012-03-26 -- Mysql源码学习——Connection Manager
2012-03-26 -- Mysql源码学习——八度空间
2012-03-26 -- Mysql源码学习——源码目录结构
2012-03-26 -- Mysql源码学习——打造专属语法
2012-03-26 -- Mysql源码学习——词法分析MYSQLlex
2012-03-26 -- Mysql源码学习笔记——偷窥线程
2012-03-26 -- Mysql的源码安装

标签：Hash, MySQL高级应用, 源码

Mysql源码学习——用户认证原理与实现

OurMySQL — Mon, 26 Mar 2012 13:48:33 +0800

前几节跟踪了Connection Manager和Thread Manager，在连接的过程中，还有一个身份认证的过程，就是大家所熟悉的

验证用户名和密码的过程，我们平时做一个系统的时候，很多时候都会涉及到身份验证。今天我们就来看下Mysql是如何进

行验证的。（注意是登录，不是登陆^_^）

一、用户认证原理

我们在应用程序中实现验证的方式基本上都是创建一张用户表，里面至少包含username和password两个字段，

password基本上都是加密后进行存储的。作为数据库，对用户的限制较多，不是像我说的仅仅只有username和password

这么简单了。首先粗略的讲下访问控制。

信息系统中，访问控制分为自主访问控制(DAC)和强制访问控制(MAC)。具体到DBMS，自主访问控制就是我们所熟悉

的GRANT，REVOKE，大多数数据库都支持自助的访问控制。强制访问控制就是ORACLE中的LABEL，只有很少的一些系统支持MAC。

严格来说，登录并不属于访问控制机制，而应该属于用户身份识别和认证。在Mysql中，将登录和DAC的相关接口都实现在了

sql_acl.cc中(其实说登录是用户拥有的一种权限也未尝不可，正如ORACLE中的CREATE SESSION，不过登录并不仅仅是一种权

限，还包含很多其他的属性)，从文件名大家可以看出来，ACL即ACCESS CONTROL LIST，访问控制列表，这是实现访问控制的

基本方法。下图是Mysql的整个访问控制的流程。

Mysql中用户管理模块的信息存储在系统表mysql.User中，这个表不仅仅存放了授权用户的基本信息，还存放一些权限

信息。我们首先大概看一下这个表的结构。

+-----------------------+-----------------------------------+------+-----+---------+-------+

| Field | Type | Null | Key | Default | Extra |

+-----------------------+-----------------------------------+------+-----+---------+-------+

| Host | char(60) | NO | PRI | | |

| User | char(16) | NO | PRI | | |

| Password | char(41) | NO | | | |

| Select_priv | enum('N','Y') | NO | | N | |

| Insert_priv | enum('N','Y') | NO | | N | |

| Update_priv | enum('N','Y') | NO | | N | |

| Delete_priv | enum('N','Y') | NO | | N | |

| Create_priv | enum('N','Y') | NO | | N | |

| Drop_priv | enum('N','Y') | NO | | N | |

| Reload_priv | enum('N','Y') | NO | | N | |

| Shutdown_priv | enum('N','Y') | NO | | N | |

| Process_priv | enum('N','Y') | NO | | N | |

| File_priv | enum('N','Y') | NO | | N | |

| Grant_priv | enum('N','Y') | NO | | N | |

| References_priv | enum('N','Y') | NO | | N | |

| Index_priv | enum('N','Y') | NO | | N | |

| Alter_priv | enum('N','Y') | NO | | N | |

| Show_db_priv | enum('N','Y') | NO | | N | |

| Super_priv | enum('N','Y') | NO | | N | |

| Create_tmp_table_priv | enum('N','Y') | NO | | N | |

| Lock_tables_priv | enum('N','Y') | NO | | N | |

| Execute_priv | enum('N','Y') | NO | | N | |

| Repl_slave_priv | enum('N','Y') | NO | | N | |

| Repl_client_priv | enum('N','Y') | NO | | N | |

| Create_view_priv | enum('N','Y') | NO | | N | |

| Show_view_priv | enum('N','Y') | NO | | N | |

| Create_routine_priv | enum('N','Y') | NO | | N | |

| Alter_routine_priv | enum('N','Y') | NO | | N | |

| Create_user_priv | enum('N','Y') | NO | | N | |

| Event_priv | enum('N','Y') | NO | | N | |

| Trigger_priv | enum('N','Y') | NO | | N | |

| ssl_type | enum('','ANY','X509','SPECIFIED') | NO | | | |

| ssl_cipher | blob | NO | | NULL | |

| x509_issuer | blob | NO | | NULL | |

| x509_subject | blob | NO | | NULL | |

| max_questions | int(11) unsigned | NO | | 0 | |

| max_updates | int(11) unsigned | NO | | 0 | |

| max_connections | int(11) unsigned | NO | | 0 | |

| max_user_connections | int(11) unsigned | NO | | 0 | |

+-----------------------+-----------------------------------+------+-----+---------+-------+

39 rows in set (0.01 sec)

复制代码

这个表包含了39个字段，对于我们登录来说，应该主要是使用前三个字段，即Host，User，Password。

mysql> select Host,User,Password from user;

+-----------+------+----------+

| Host | User | Password |

+-----------+------+----------+

| localhost | root | |

| 127.0.0.1 | root | |

| localhost | | |

+-----------+------+----------+

3 rows in set (0.00 sec)

复制代码

这里比我们预想的只需要用户名和密码的方式有所出入，多了一个Host字段，这个字段起到什么作用呢？！原来Mysql的登录认证不仅需要验证用户名和密码，还需要验证连接的主机地址，这样也是为了提高安全性吧。那如果我想一个用户在任何地址都可以进行登录岂不是要设置很多地址？Mysql提供了通配符，可以设置Host字段为*，这就代表可以匹配任何Host。具体看下这三行的意思，这三行的密码均为空。针对root用户，不需要输入密码，客户端的地址为本机。第三行的用户名为空，Host为localhost，说明本地的任何用户均可以进行登录，即使是个不存在的用户也可以登录成功，但是仅限于登录，没有其他相关的权限，无法进行实际操作。

二、源码跟踪

在Connection Manager中提到了login_connection函数用于检查用户名和密码等相关信息，其源码如下（重点的函数代码

会着色）：

static bool login_connection(THD *thd)
{
  NET *net= &thd->net;
  int error;
  DBUG_ENTER("login_connection");
  DBUG_PRINT("info", ("login_connection called by thread %lu",
                      thd->thread_id));

  /* Use "connect_timeout" value during connection phase */
  my_net_set_read_timeout(net, connect_timeout);
  my_net_set_write_timeout(net, connect_timeout);
error= check_connection(thd); //此处是验证的具体函数

  net_end_statement(thd);

  if (error)
  {                        // Wrong permissions
#ifdef __NT__
    if (vio_type(net->vio) == VIO_TYPE_NAMEDPIPE)
      my_sleep(1000);                /* must wait after eof() */
#endif
    statistic_increment(aborted_connects,&LOCK_status);
    DBUG_RETURN(1);
  }
  /* Connect completed, set read/write timeouts back to default */
  my_net_set_read_timeout(net, thd->variables.net_read_timeout);
  my_net_set_write_timeout(net, thd->variables.net_write_timeout);
  DBUG_RETURN(0);
}

复制代码

此函数主要是功能是调用函数check_connection进行用户认证,由于函数check_connection过长，对其进行简化，如下所示：

 static int check_connection(THD *thd)

{
  uint connect_errors= 0;
  NET *net= &thd->net;
  ulong pkt_len= 0;
  char *end;

  DBUG_PRINT("info",
             ("New connection received on %s", vio_description(net->vio)));
#ifdef SIGNAL_WITH_VIO_CLOSE
  thd->set_active_vio(net->vio);
#endif

  if (!thd->main_security_ctx.host)         // If TCP/IP connection
  {
    char ip[30];

    if (vio_peer_addr(net->vio, ip, &thd->peer_port))
    {
      my_error(ER_BAD_HOST_ERROR, MYF(0), thd->main_security_ctx.host_or_ip);
      return 1;
    }
    if (!(thd->main_security_ctx.ip= my_strdup(ip,MYF(MY_WME))))
      return 1; /* The error is set by my_strdup(). */
    thd->main_security_ctx.host_or_ip= thd->main_security_ctx.ip;
    vio_in_addr(net->vio,&thd->remote.sin_addr);
    if (!(specialflag & SPECIAL_NO_RESOLVE))
    {
      vio_in_addr(net->vio,&thd->remote.sin_addr);
      thd->main_security_ctx.host=
        ip_to_hostname(&thd->remote.sin_addr, &connect_errors);
      /* Cut very long hostnames to avoid possible overflows */
      if (thd->main_security_ctx.host)
      {
        if (thd->main_security_ctx.host != my_localhost)
          thd->main_security_ctx.host[min(strlen(thd->main_security_ctx.host),
                                          HOSTNAME_LENGTH)]= 0;
        thd->main_security_ctx.host_or_ip= thd->main_security_ctx.host;
      }
      if (connect_errors > max_connect_errors)
      {
        my_error(ER_HOST_IS_BLOCKED, MYF(0), thd->main_security_ctx.host_or_ip);
        return 1;
      }
    }
    ...

if (acl_check_host(thd->main_security_ctx.host, thd->main_security_ctx.ip))//此处验证主机名或IP是否存在

    {
      my_error(ER_HOST_NOT_PRIVILEGED, MYF(0),
               thd->main_security_ctx.host_or_ip);
      return 1;
    }
  }
  else /* Hostname given means that the connection was on a socket */
  {
   ...
  }
  vio_keepalive(net->vio, TRUE);

  ...

  char *user= end;
  char *passwd= strend(user)+1;
  uint user_len= passwd - user - 1;
  char *db= passwd;
  char db_buff[NAME_LEN + 1];           // buffer to store db in utf8
  char user_buff[USERNAME_LENGTH + 1];    // buffer to store user in utf8
  uint dummy_errors;

  uint passwd_len= thd->client_capabilities & CLIENT_SECURE_CONNECTION ?
    (uchar)(*passwd++) : strlen(passwd);
  db= thd->client_capabilities & CLIENT_CONNECT_WITH_DB ?
    db + passwd_len + 1 : 0;
  uint db_len= db ? strlen(db) : 0;

  if (passwd + passwd_len + db_len > (char *)net->read_pos + pkt_len)
  {
    inc_host_errors(&thd->remote.sin_addr);
    my_error(ER_HANDSHAKE_ERROR, MYF(0), thd->main_security_ctx.host_or_ip);
    return 1;
  }

...
  /* If username starts and ends in "'", chop them off */
  if (user_len > 1 && user[0] == '\'' && user[user_len - 1] == '\'')
  {
    user[user_len-1]= 0;
    user++;
    user_len-= 2;
  }

  if (thd->main_security_ctx.user)
    x_free(thd->main_security_ctx.user);
  if (!(thd->main_security_ctx.user= my_strdup(user, MYF(MY_WME))))
    return 1; /* The error is set by my_strdup(). */
  return check_user(thd, COM_CONNECT, passwd, passwd_len, db, TRUE);//验证用户名和密码

}

复制代码

上面的源码主要做了如下几件事情：

获取客户端的IP和主机名
acl_check_host函数验证USER表中是否存在相应的IP或HOST，如果不存在直接报错
获取用户名和密码
check_user函数验证用户名和密码(不输入用户名默认为ODBC)，如果系统表中不存在匹配的报错返回
获取用户的权限列表，验证用户的相关属性是否合法，如连接数是否超过上限，连接是否超时，操作是否超过限制等信息，如果不合法，则报错返回。

由于在一个认证的过程中涉及到的东西比较多，各个方面吧，我不能一一跟踪，只能大概了解其中的实现流程，捡重点进行

跟踪，有兴趣的童鞋自己具体跟踪吧

题外话：

Mysql中权限系统表都是在系统启动时，载入内存的（当然User表也是这样），一般情况下，不需要进行频繁的授权和回收操作，这中情况下，权限表基本保持不变，将其在系统启动的时候载入内存的好处自然是快速的进行权限判断，减少磁盘的I/O，你懂的^_^。有好处自然有坏处，就是在频繁进行授权和回收相关操作时，权限表需要重新载入内存，Mysql为了避免这种情况，在手册中已经说的很清楚了，授权和回收只会反应到磁盘中，内存的数据字典信息是不会改变的，如果想立即生效，需要调用FLUSH PRIVILEGES系统函数，这个系统函数的工作应该就是对权限系统表的RELOAD。

下篇进入实质性的介绍，通过跟踪一个建表语句，来学习Mysql是如何存储表的元数据的，即frm格式文件的剖析。

2012-03-26 -- Mysql源码学习——没那么简单的Hash
2012-03-26 -- Mysql源码学习——Thread Manager
2012-03-26 -- Mysql源码学习——Connection Manager
2012-03-26 -- Mysql源码学习——八度空间
2012-03-26 -- Mysql源码学习——源码目录结构
2012-03-26 -- Mysql源码学习——打造专属语法
2012-03-26 -- Mysql源码学习——词法分析MYSQLlex
2012-03-26 -- Mysql源码学习笔记——偷窥线程
2012-03-26 -- Mysql的源码安装
2012-03-26 -- MySQL源码学习——DBUG调试

标签：MySQL高级应用, 源码, 认证

Mysql源码学习——Thread Manager

OurMySQL — Mon, 26 Mar 2012 13:42:04 +0800

一、前言

上篇的Connection Manager中，曾提及对于一个新到来的Connection，服务器会创建一个新的线程来处理这个连接。

其实没那么简单，为了提高系统效率，减少频繁创建线程和中止线程的系统消耗，Mysql使用了线程缓冲区的概念，即如果

一个连接断开，则并不销毁承载其的线程，而是将此线程放入线程缓冲区，并处于挂起状态，当下一个新的Connection到来

时，首先去线程缓冲区去查找是否有空闲的线程，如果有，则使用之，如果没有则新建线程。本问主要介绍这个线程缓冲区，

首先介绍下基本的概念。

二、基本概念

1.线程创建函数

大家知道，Mysql现在是插件式的存储引擎，只要实现规定的接口，就可实现自己的存储引擎。故Mysql的线程创建除了

出现在主服务器框架外，存储引擎也可能会进行线程的创建。通过设置断点，在我调试的版本中，发现了两个创建线程的函数。

pthread_create：Mysql自用的创建线程函数

os_thread_create：存储引擎innobase的创建线程的函数

os_thread_create是存储引擎innobase的线程函数，先搁浅不研究了，重点看下pthread_create，首先看下其源码。

int pthread_create(pthread_t *thread_id, pthread_attr_t *attr,

pthread_handler func, void *param)

{

HANDLE hThread;

struct pthread_map *map;

DBUG_ENTER("pthread_create");

if (!(map=malloc(sizeof(*map))))

DBUG_RETURN(-1);

map->func=func; map->param=param;

pthread_mutex_lock(&THR_LOCK_thread);

#ifdef __BORLANDC__

hThread=(HANDLE)_beginthread((void(_USERENTRY *)(void *)) pthread_start,

attr->dwStackSize ? attr->dwStackSize :

65535, (void*) map);

#else

hThread=(HANDLE)_beginthread((void( __cdecl *)(void *)) pthread_start, attr->dwStackSize ? attr->dwStackSize : 65535, (void*) map);

#endif

DBUG_PRINT("info", ("hThread=%lu",(long) hThread));

*thread_id=map->pthreadself=hThread;

pthread_mutex_unlock(&THR_LOCK_thread);

if (hThread == (HANDLE) -1)

{

int error=errno;

DBUG_PRINT("error",

("Can't create thread to handle request (error %d)",error));

DBUG_RETURN(error ? error : -1);

}

VOID(SetThreadPriority(hThread, attr->priority)) ;

DBUG_RETURN(0);

}

上面代码首先构造了一个map结构体，成员分别是函数地址和传入参数。然后调用操作系统的接口，_beginthread,但是执行函数并不是传入的函数——func，而是pthread_start,参数为map。继续跟踪pthread_start。

pthread_handler_t pthread_start(void *param)

{

pthread_handler

func=((struct pthread_map *) param)->func

;

void *func_param=((struct pthread_map *) param)->param;

my_thread_init(); /* Will always succeed in windows */

pthread_mutex_lock(&THR_LOCK_thread); /* Wait for beginthread to return */

win_pthread_self=((struct pthread_map *) param)->pthreadself;

pthread_mutex_unlock(&THR_LOCK_thread);

free((char*) param); /* Free param from create */

pthread_exit((void*) (*func)(func_param));

return 0; /* Safety */

}

可以看出，pthread_start中调用了map的func元素，作为真正执行的函数体。OK,创建线程的函数跟踪到此！

2.服务器启动时创建了哪些函数？

通过在两个创建线程的地方设置断点，总结了下，在服务器启动时，创建了如下的线程。

pthread_create创建的线程：

创建线程函数	线程执行函数
create_shutdown_thread	handle_shutdown
start_handle_manager	handle_manager
handle_connections_methods	handle_connections_sockets

innobase的os_thread_create创建的线程：

创建线程函数	线程执行函数
innobase_start_or_create_for_mysql	io_handler_thread（4个）
recv_recovery_from_checkpoint_finish	trx_rollback_or_clean_all_without_sess
innobase_start_or_create_for_mysql	srv_lock_timeout_thread
	srv_error_monitor_thread
	srv_monitor_thread
	srv_master_thread

还可以在调试过程中，通过暂停来看此时服务器中的线程，如下图：

三、线程缓冲池

Mysql支持线程缓存，在多线程连接模式下，如果连接断开后，将这个线程放入空闲线程缓冲区，在下次有连接到来时，

先去缓冲池中查找是否有空闲线程，有则用之，无则创建。启动时可以设置线程缓冲池的数目：

Mysqld.exe --thread_cache_size=10

在一个连接断开时，会调用cache_thread函数，将空闲的线程加入到cache中，以备后用。源码如下：

static bool cache_thread()

{

safe_mutex_assert_owner(&LOCK_thread_count);

if (

cached_thread_count < thread_cache_size

&&

! abort_loop && !kill_cached_threads)

{

/* Don't kill the thread, just put it in cache for reuse */

DBUG_PRINT("info", ("Adding thread to cache"));

cached_thread_count++;

while (!abort_loop && ! wake_thread && ! kill_cached_threads)

(void) pthread_cond_wait(&COND_thread_cache, &LOCK_thread_count);

cached_thread_count--;

if (kill_cached_threads)

pthread_cond_signal(&COND_flush_thread_cache);

if (wake_thread)

{

THD *thd;

wake_thread--;

thd= thread_cache.get();

thd->thread_stack= (char*) &thd; // For store_globals

(void) thd->store_globals();

/*

THD::mysys_var::abort is associated with physical thread rather

than with THD object. So we need to reset this flag before using

this thread for handling of new THD object/connection.

*/

thd->mysys_var->abort= 0;

thd->thr_create_utime= my_micro_time();

threads.append(thd);

return(1);

}

return(0);

}

上面我们的启动参数设置线程缓冲区为10，此时对应代码里面的thread_cache_size = 10，cached_thread_count记录

了此刻cache中的空闲线程数目，只有在cache未满的情况下，才会将新的空闲线程加入缓冲池中。加入到缓冲区其实就是将线

程挂起，pthread_cond_wait函数便是线程等待函数，在此函数中，会调用WaitForMultipleObjects进行事件等待。具体源码

如下：

int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex,

struct timespec *abstime)

{

int result;

long timeout;

union ft64 now;

if( abstime != NULL )

{

GetSystemTimeAsFileTime(&now.ft);

/*

Calculate time left to abstime

- subtract start time from current time(values are in 100ns units)

- convert to millisec by dividing with 10000

*/

timeout= (long)((abstime->tv.i64 - now.i64) / 10000);

/* Don't allow the timeout to be negative */

if (timeout < 0)

timeout= 0L;

/*

Make sure the calucated timeout does not exceed original timeout

value which could cause "wait for ever" if system time changes

*/

if (timeout > abstime->max_timeout_msec)

timeout= abstime->max_timeout_msec;

}

else

{

/* No time specified; don't expire */

timeout= INFINITE;

}

/*

Block access if previous broadcast hasn't finished.

This is just for safety and should normally not

affect the total time spent in this function.

*/

WaitForSingleObject(cond->broadcast_block_event, INFINITE);

EnterCriticalSection(&cond->lock_waiting);

cond->waiting++;

LeaveCriticalSection(&cond->lock_waiting);

LeaveCriticalSection(mutex);

result= WaitForMultipleObjects(2, cond->events, FALSE, timeout);

EnterCriticalSection(&cond->lock_waiting);

cond->waiting--;

if (cond->waiting == 0)

{

/*

We're the last waiter to be notified or to stop waiting, so

reset the manual event.

*/

/* Close broadcast gate */

ResetEvent(cond->events[BROADCAST]);

/* Open block gate */

SetEvent(cond->broadcast_block_event);

}

LeaveCriticalSection(&cond->lock_waiting);

EnterCriticalSection(mutex);

return result == WAIT_TIMEOUT ? ETIMEDOUT : 0;

}

此处是等待时间，何处进行事件通知呢？我们再次来到上篇所提及的为新的连接创建线程的代码中：

void create_thread_to_handle_connection(THD *thd)

{

if (cached_thread_count > wake_thread)

{

/* Get thread from cache */

thread_cache.append(thd);

wake_thread++;

pthread_cond_signal(&COND_thread_cache);

}

Else

...

}

上篇文章我们其实只讲了ELSE分支，而忽略了IF分支。wake_thread代表了唤醒的线程数，即在线程缓冲区中被再次使用的

线程，如果cache中的总数>被重新使用的数目，说明还有空闲的线程，此时进入if分支，调用phtread_cond_signal唤醒上面挂起

的空闲线程。

线程管理就到此为止了，这里只是介绍了下线程缓冲区的工作原理，并没有具体去介绍如何利用EVENT进行线程的挂起和唤醒，这些都是借助了操作系统的特性，有兴趣的可以自己研究下。这篇就到此为止，下节会介绍Mysql的用户身份认证原理和实现。

PS. 男怕入错行，夜半三更忙，一行又一行

2012-03-26 -- Mysql源码学习——没那么简单的Hash
2012-03-26 -- Mysql源码学习——用户认证原理与实现
2012-03-26 -- Mysql源码学习——Connection Manager
2012-03-26 -- Mysql源码学习——八度空间
2012-03-26 -- Mysql源码学习——源码目录结构
2012-03-26 -- Mysql源码学习——打造专属语法
2012-03-26 -- Mysql源码学习——词法分析MYSQLlex
2012-03-26 -- Mysql源码学习笔记——偷窥线程
2012-03-26 -- Mysql的源码安装
2012-03-26 -- MySQL源码学习——DBUG调试

标签：MySQL高级应用, Thread Manager, 源码

Mysql源码学习——Connection Manager

OurMySQL — Mon, 26 Mar 2012 13:39:39 +0800

1.连接的线程数

Mysql支持单线程和多线程两种连接线程数。如果是单线程，则在同一时刻，只能有一个connection连接到Mysql，

其他的连接会被挂起。如果是多线程，则同一时刻可以支持多个connection同时连接到服务器。

可以通过设置服务器的启动参数来设定连接的线程数：

mysqld.exe --thread-handling=no-threads
mysqld.exe --thread-handling=one-thread-per-connection

复制代码

服务器如何通过参数来选择使用哪种方式的呢？且看服务器中的分支代码：

#ifdef EMBEDDED_LIBRARY
  one_thread_scheduler(&thread_scheduler);
#else
  if (global_system_variables.thread_handling <=
      SCHEDULER_ONE_THREAD_PER_CONNECTION)
    one_thread_per_connection_scheduler(&thread_scheduler);
  else if (global_system_variables.thread_handling == SCHEDULER_NO_THREADS)
    one_thread_scheduler(&thread_scheduler);
  else
    pool_of_threads_scheduler(&thread_scheduler);  /* purecov: tested */
#endif

复制代码

这段代码出现在get_options函数中，此函数是根据传入的服务器参数，设置相应参数的模式。由这段代码可以看出，如果定义了EMBEDDED_LIBRARY宏定义(估计应该是嵌入式使用)，则调用one_thread_scheduler，即使用单线程。如果参数小于等于SCHEDULER_ONE_THREAD_PER_CONNECTION，则调用one_thread_per_connection_scheduler，即每个连接一个线程，即多线程。至于global_system_variables.thread_handling是如何进行设置的呢？其实就是根据我们传递给服务器的参数–thread-handling进行设置的，参数的设置统一在函数get_options中，其调用mysqld_get_one_option，其中有个分支，代码如下：

case OPT_THREAD_HANDLING:
  {
    global_system_variables.thread_handling=
      find_type_or_exit(argument, &thread_handling_typelib, opt->name)-1;
    break;
  }

复制代码

对参数初始化有兴趣的可以具体的看下get_options这个函数，这里就不详细讲解了。我们来看下one_thread_scheduler和one_thread_per_connection_scheduler的源代码，看下他们都做了些什么？

void one_thread_scheduler(scheduler_functions* func)
{
  func->max_threads= 1;
#ifndef EMBEDDED_LIBRARY
  func->add_connection= handle_connection_in_main_thread;
#endif
  func->init_new_connection_thread= init_dummy;
  func->end_thread= no_threads_end;
}

void one_thread_per_connection_scheduler(scheduler_functions* func)
{
  func->max_threads= max_connections;
  func->add_connection= create_thread_to_handle_connection;
  func->end_thread= one_thread_per_connection_end;
}

复制代码

原来就是设置了一个结构体中scheduler_functions的参数，只不过这些参数是一些函数指针罢了，也就是说在具体的调用中，

只需要调用add_connection或end_thread即可，不需要知道到底是调用了哪个函数，这大概就是一种变形的多态性吧。

2.初始化网络配置

网络配置比较简单，就是设置端口，创建套接字，绑定端口，监听端口。实现全部集中在network_init函数中，由于这个函数确

实没什么好讲的，如果对socket不熟悉的话，可以去网上搜索下相关知识。这里直接给出相应的伪代码：

network_init
{
    set_ports; //设置端口号，#define MYSQL_PORT            3306
    socket； //创建套接字
    bind;       //绑定端口号
    listen； //监听端口号
}

复制代码

3.连接的方式

进程间通信的方式不止是SOCKET，还有其他很多方式。Mysql支持三种连接方式：namepipe、socket和shared memory，

即命名管道、套接字和共享内存的方式。这三种方式是可以共存的。默认只使用套接字。

TCP/IP套接字方式是MySQL在任何平台下都提供的连接方式，也是网络中使用得最多的一种方式。这种方式在TCP/IP连接上建立

一个基于网络的连接请求，一般情况下客户端在一台服务器上，而MySQL实例在另一台服务器上，这两台机器通过一个TCP/IP网络连接。

例如，我可以在Windows服务器下请求一台远程Linux服务器下的MySQL实例。

在Windows 2000、Windows XP、Windows 2003和Windows Vista以及在此之后的 Windows操作系统中，如果两个需要通

信的进程在同一台服务器上，那么可以使用命名管道，SQL Server数据库默认安装后的本地连接也使用命名管道。在MySQL数据库中，

需在配置文件中启用–enable-named-pipe选项。在MySQL 4.1之后的版本中，MySQL还提供了共享内存的连接方式，在配置文件中

添加–shared-memory。如果想使用共享内存的方式，在连接时，Mysql客户端还必须使用-protocol=memory选项。

启动时可以通过下面的参数进行设置。

mysqld.exe --enable-named-pipe
mysqld.exe --shared-memory

复制代码

除了在启动时进行参数设置外，也可以通过修改MY.INI文件进行设置。我们来看下源码中选择连接方式的分支函数handle_connections_methods：

handle_connections_methods()
{
if (hPipe != INVALID_HANDLE_VALUE)
{
       handler_count++;
       if (pthread_create(&hThread,&connection_attrib,
               handle_connections_namedpipes, 0))
       {
      sql_print_warning("Can't create thread to handle named pipes");
      handler_count--;
    }
}
    if (have_tcpip && !opt_disable_networking)
  {
    handler_count++;
    if (pthread_create(&hThread,&connection_attrib,
               handle_connections_sockets, 0))
    {
      sql_print_warning("Can't create thread to handle TCP/IP");
      handler_count--;
    }
  }

if (opt_enable_shared_memory)
  {
    handler_count++;
    if (pthread_create(&hThread,&connection_attrib,
               handle_connections_shared_memory, 0))
    {
      sql_print_warning("Can't create thread to handle shared memory");
      handler_count--;
    }
  }
}

复制代码

由于对于namepipe和memory share的通信方式不太了解，这里只研究socket的通信方式。从代码中可以看出，handle_connections_sockets便是socket的设置，我们就来看下它。

4.socket管理创建新线程 socket管理其实比较简单，直接给出其伪代码：

handle_connections_sockets
{
    select; //监视socket文件描述符
    new_socket = accept;//处理到来的客户端连接
    thd = new THD；创建THD类
    vio_tmp = vio_new(new_socket,VIO_TYPE_TCPIP, 0);   //初始化VIO结构体
    my_net_init(&thd->net, vio_tmp);//初始化thd的net结构体
    create_new_thread(thd);//为这个连接创建一个新的线程，如果是单线程模式的话，就不会创建一个新线程
}

复制代码

首先是select函数进行监视socket端口，如果监控到有连接，则通过accept函数接受客户端的连接，然后新建一个THD类，将连接参数全部设置到THD类的参数上，最后调用create_new_thread函数，这个函数便是重点。我们进入这个函数，看下做了啥。

create_new_thread
{
    ++connection_count;//全局连接数自增
    thread_count++;    //全局线程数自增
    thread_scheduler.add_connection(thd);//真正创建线程
}

复制代码

So easy,首先将全局连接数+1，全局线程数+1，然后调用add_connection函数，这个函数就是我们在上面第一步设置连接的

线程数中，one_thread_scheduler和one_thread_per_connection_scheduler中设置的一个参数。这两者的区别便是是否创建了

一个新的线程来处理到来的连接。 one_thread_scheduler是单线程方式，木有新建线程。我们重点研究 one_thread_per_connection_scheduler，其设置的add_connection函数为 create_thread_to_handle_connection：

create_thread_to_handle_connection(THD *thd)
{
    thread_created++;
    threads.append(thd); // 创建线程数自增，并加入到threads链表上
    pthread_create(&thd->real_id,&connection_attrib,
                              handle_one_connection,
                              (void*) thd);//这就是真正创建线程的地方了，函数便是handle_one_connection
}

复制代码

可见，最后调用了pthread_create函数，这个函数便是创建一个新的线程，新线程的处理函数为handle_one_connection.

5.新线程处理流程

新线程处理函数为handle_one_connection，到此位置，一个新的connection被一个新创建的线程所单独处理。我们看下其中

是如何进行处理的。

handle_one_connection(void *arg)
{
    for (;;)
    {
        lex_start(thd); //初始化词法分析结构体
        login_connection(thd); //用户认证，失败报错
        prepare_new_connection_state(THD* thd)；//Initialize THD to handle queries
         while (!net->error && net->vio != 0 &&   //循环处理command
           !(thd->killed == THD::KILL_CONNECTION))
        {
            if (do_command(thd))
              break;                   //处理失败跳出
          }
          end_connection(thd);         //关闭连接
          close_connection(thd, 0, 1);
         thread_scheduler.end_thread(thd,1);//结束线程
                  return 0;
    }
}

复制代码

首先进行了词法分析结构体的初始化，然后进行用户认证，认证成功后通过do_command循环执行客户端发过来的命令。

6.总结

整个connection manager的流程十分清晰，单线程的连接一般很少使用，大多使用多线程方式。多线程连接中其实还涉及到线程缓冲

池的概念，即如果一个连接断开后，其所创建的线程不会被销毁掉，而是放到缓冲池中，等待下一个新的connection到来时，首先去线程

缓冲池查找是否有空闲的线程，有的话直接使用，木有的话才去创建新的线程来管理这个connection。这些属于Thread Manage的内容，

下节进行Thread Manage的学习。

标签：Connection Manager, MySQL高级应用, 源码

Mysql源码学习——八度空间

OurMySQL — Mon, 26 Mar 2012 13:37:49 +0800

学习完词法分析和语法分析后，开始进入Mysql源码的正式学习之旅了。这么多模块，肿么入手呢？！还好从网上搜到了一个模块划分，以后就尽可能根据这个模块划分一步一步的跟踪源码，揭开Mysql的面纱。

我们从上至下来看各个模块的划分，首先客户端发送请求与服务器连接，通过connection manager模块，连接管理模块会调用Thread Manager模块，即线程管理模块，这里会为一个连接创建一个新的线程，专门为这个连接服务，这就保证了每个连接都有一个独立的线程为之工作，当然连接数一般也会有个限制，不然无限制的创建新的线程，操作系统也顶不住啊。接着进入了User Module，用户模块，这个模块应该是身份识别认证阶段，说白了就是检查用户名密码，当然应该还包括权限检查(只有自主访问控制，Mysql不像 Oracle，不支持role，更不用说label了。这就是简约而不简单吧，^_^)。

上面的三个模块就是登录过程中必须经历的阶段。connection manager为客户端和服务器创建连接，thread manager为新建的连接分配一个独立的线程，user Module进行身份认证。oh yeah～～

接着进入Commander Dispatcher模块，命令分发模块，大概就是一个switch case的过程，根据不同的命令，进行不同的操作。这个模块又会间接关联到Query Cache模块和Logging Module，即查询缓存模块和日志模块。Query Cache模块个人感觉至少包含结果集缓存模块，至于有木有执行计划缓存，这个就不清楚了，还需要进入源码慢慢看来。Logging Module就是传说中的日志了，日志包括redo和undo两方面吧，日志系统是一个database必备的，是实现事务特性的重要手段，而事务便是 database和file system的根本区别，不要小瞧了Logging Module啊！！

命令分发模块，根据命令的性质，将命令分给不同的子模块。SELECT分配给Optimizer即优化模块，一条select语句最重要的就是执行计划了，一个好的执行计划比一个坏的执行计划不知道要快多少倍，这就是为什么我们要建立索引，其实在经常查询的列上建立二级索引，就是为了改变执行计划，让执行计划可以选择二级索引，而抛弃聚簇索引(当然不是完全抛弃，聚簇索引是根本)。UPDATE、INSERT、DELETE交给Table Modification Module，不看也知道，这个模块主要是处理数据更新了（这里所说的更新是指数据的改变，即UID）。Repairs分配给了Table Maintenance Module，字面意义是说表维护模块，我OUT了，默认表坏了，支持修复？是何种坏了？不太了解啊…。Replication分配给了 Replication Module，就是复制模块。最后一个是Status分配给了Status Reporting Module，这个我貌似接触过，是不是所谓的那些动态试图？比如查看系统当前状态下的锁资源的占用情况等，这个模块应该是性能分析者居家旅行必备的模块吧，通过这个模块可能很快找到系统性能的瓶颈。

上面的模块又统一走到Access Control Module，访问控制模块啊，原来上面所说的User Module不包含访问控制…，这个访问控制就是简单的DAC,即检查用户是否对要访问的对象具有增、删、改、查的权限。接着进入Table Manager模块，因为Mysql支持不同的存储引擎，而这个模块是个统一的模块，个人感觉这个应该是表的字典对象管理模块，即表的一些元数据，比如这个表包含哪些列啊，各个列的类型，表的创建者，创建日期，表的存储引擎之类的信息。最下面是Abstract Storage Engine Module，即抽象存储引擎模块，Mysql的保持这么多存储引擎同时在服务器中，是通过一个handler抽象类实现的(不知道有木有抽象类的概念，小弟C++、JAVA丢了很久了…)，每个存储引擎按照规定的接口，实现一个具体的handler类，然后再调用的时候，根据上面的Table Manager模块中的存储引擎的信息，选择对应的handler类进行相应表的物理操作。

看了这个模块图，感觉思路清晰了很多。下面就一步一步的学习每个模块，当然这些模块之间也是一个执行流程顺序执行的过程。今天就写到这了，下次开始学习第一个模块：Connection Manager

PS. 貌似最近没这么忙了，加班加了好几个月终于算是稍微轻松了一点。以后把更多的业余时间放在读书学习上。

PS again. 每天下班脑子都一锅粥了，回来写点博客权当放松啦，标题的八度空间是JAY的专辑名啦，借此来比喻Mysql的各个模块^_^

2012-03-26 -- Mysql源码学习——没那么简单的Hash
2012-03-26 -- Mysql源码学习——用户认证原理与实现
2012-03-26 -- Mysql源码学习——Thread Manager
2012-03-26 -- Mysql源码学习——Connection Manager
2012-03-26 -- Mysql源码学习——源码目录结构
2012-03-26 -- Mysql源码学习——打造专属语法
2012-03-26 -- Mysql源码学习——词法分析MYSQLlex
2012-03-26 -- Mysql源码学习笔记——偷窥线程
2012-03-26 -- Mysql的源码安装
2012-03-26 -- MySQL源码学习——DBUG调试

标签：MySQL高级应用, 八度空间, 源码

Mysql源码学习——源码目录结构

OurMySQL — Mon, 26 Mar 2012 13:36:24 +0800

目录清单

目录名注释

Bdb 伯克利DB表引擎

BUILD 构建工程的脚本

Client 客户端

Cmd-line-utils 命令行工具

Config 构建工程所需的一些文件

Dbug Fred Fish的调试库

Docs 文档文件夹

Extra 一些相对独立的次要的工具

Heap HEAP表引擎

Include 头文件

Innobase INNODB表引擎

Libmysql 动态库

Libmysql_r 为了构建线程安全的libmysql库

Libmysqld 服务器作为一个嵌入式的库

Man 用户手册

Myisam MyISAM表引擎

Myisammrg MyISAM Merge表引擎

Mysql-test mysqld的测试单元

Mysys MySQL的系统库

Ndb Mysql集群

Netware Mysql网络版本相关文件

NEW-RPM 部署时存放RPM

Os2 针对OS/2操作系统的底层函数

Pstack 进行堆栈

Regex 正则表达式库（包括扩展的正则表达式函数）

SCCS 源码控制系统（不是源码的一部分）

Scripts 批量SQL脚本，如初始化库脚本

Server-tools 管理工具

Sql 处理SQL命令；Mysql的核心

Sql-bench Mysql的标准检查程序

Sql-common 一些sql文件夹相关的C文件

SSL 安全套接字层

Strings 字符串函数库

Support-files 用于在不同系统上构建Mysql的文件

Tests 包含Perl和C的测试

Tools

Vio 虚拟I/O库

Zlib 数据压缩库，用于WINDOWS

下面给出几个比较重要的目录清单：

文件清单

目录名文件名注释

Client

get_password.c 命令行输入密码

Mysql.cc MySQL命令行工具

Mysqladmin.cc 数据库weihu

Mysqldump.c 将表的内容以SQL语句输出，即逻辑备份

Mysqlimport.c 文本文件数据导入表中

Mysqlmanager-pwgen.c 密码生成

Mysqlshow.c 显示数据库，表和列

Mysqltest.c 被mysql测试单元使用的测试程序

—————————————————————————————————————-

MYSYS

Array.c 动态数组

Charset.c 动态字符集，默认字符集

Charset-def.c 包含客户端使用的字符集

Checksum.c 为内存块计算校验和，用于pack_isam

Default.c 从*.cnf和*.ini文件中查找默认配置项

Default_modify.c 编辑可选项

Errors.c 英文错误文本

Hash.c hash查找、比较、释放函数

List.c 双向链表

Make-conf.c 创建*.conf文件

Md5.c MD5算法

Mf_brkhant.c

Mf_cache.c 打开临时文件,并使用io_cache进行缓存

Mf_driname.c 解析，转换路径名

Mf_fn_ext.c 获取文件名的后缀

Mf_format.c 格式化文件名

Mf_getdate 获取日期：

yyyy-mm-dd hh:mm:ss format

mf_iocache.c 缓存I/O

mf_iocaches.c 多键值缓存

mf_loadpath.c 获取全路径名

mf_pack.c 创建需要的压缩/非压缩文件名

mf_path.c 决定是否程序可以找到文件

mf_qsort.c 快速排序

mf_qsort2.c 快速排序2

mf_radix.c 基数排序

mf_soundex.c 探测算法（EDN NOV 14, 1985）

mf_strip.c 去字符串结尾空格

mf_tempdir.c 临时文件夹的创建、查找、删除

mf_tempfile.c 临时文件的创建

mf_unixpath.c 转化文件名为UNIX风格

mf_util.c 常用函数

mf_wcomp.c 使用通配符比较

mf_wfile.c 通配符查找文件

mulalloc.c 同时分配多个指针

my_access.c 检查文件或路径是否合法

my_aes.c AES加密算法

my_alarm.c 警报相关

my_alloc.c 同时分配临时结果集缓存

my_append.c 一个文件到另一个

my_bit.c 除法使用，位运算

my_bitmap.c 位图

my_chsize.c 填充或截断一个文件

my_clock.c 时钟函数

my_compress.c 压缩

my_copy.c 拷贝文件

my_crc32.c

my_create.c 创建文件

my_delete.c 删除文件

my_div.c 获取文件名

my_dup.c 打开复制文件

my_error.c 错误码

my_file.c

my_fopen.c 打开文件

my_fstream.c 文件流读/写

my_gethostbyname.c 获取主机名

my_gethwaddr.c 获取硬件地址

my_getopt.c 查找生效的选项

my_getsystime.c time of day

my_getwd.c 获取工作目录

my_handler.c

my_init.c 初始化变量和函数

my_largepage.c 获取OS的分页大小

my_lib.c 比较/转化目录名和文件名

my_lock.c 锁住文件

my_lockmem.c 分配一块被锁住的内存

my_lread.c 读取文件到内存

my_lwrite.c 内存写入文件

my_malloc.c 分配内存

my_messnc.c 标准输出上输出消息

my_mkdir.c 创建目录

my_mmap.c 内存映射

my_net.c net函数

my_netware.c Mysql网络版
my_once.c 一次分配，永不free

my_open.c 打开一个文件

my_os2cond.c 操作系统cond的简单实现

my_os2dirsrch.c 模拟Win32目录查询

my_os2dlfcn.c 模拟UNIX动态装载

my_os2file64.c 文件64位设置

my_os2mutex.c 互斥量

my_os2thread.c 线程

my_os2tls.c 线程本地存储

my_port.c

my_pthread.c 线程的封装

my_quick.c 读/写

my_read.c 从文件读bytes

my_realloc.c 重新分配内存

my_redel.c 重命名和删除文件

my_seek.c 查找

my_semaphore.c 信号量

my_sleep.c 睡眠等待

my_static.c 静态变量

my_symlink.c 读取符号链接

my_symlink2.c 2

my_sync.c 同步内存和文件

my_thr_init.c 初始化/分配线程变量

my_wincond.c

my_windac.c WINDOWS NT/2000自主访问控制

my_winsem.c 模拟线程

my_winthread.c 模拟线程

my_write.c 写文件

ptr_cmp.c 字节流比较函数

queue,c 优先级队列

raid2.c 支持RAID

rijndael.c AES加密算法

safemalloc.c 安全的malloc

sha1.c sha1哈希加密算法

string.c 字符串函数

testhash.c 测试哈希函数（独立程序）

test_charset 测试字符集(独立)

thr_lock.c 读写锁

thr_mutex.c 互斥量

thr_rwlock.c 同步读写锁

tree.c 二叉树

typelib.c 字符串中匹配字串

SQL
derror.cc 读取独立于语言的信息文件

Des_key_file.cc 加载DES密钥

Discover.cc frm文件的查找

Field.cc 存储列信息

Filed_conv.cc 拷贝字段信息

Filesort.cc 结果集排序（内存或临时文件）

Frm_crypt.cc get_crypt_from_frm

Gen_lex_hash.cc 查找、排列SQL关键字

Gstream.c GIS

Handler.cc 函数句柄

Hash_filo.cc 静态大小HASH表，

以FIFO方式存储主机名、IP表

Ha_berkeley.cc BDB的句柄

Ha_innodb.cc INNODB句柄

Hostname.cc 根据IP获取hostname

Init.cc 初始化和unireg相关的函数

item.cc item函数

item_buff.cc item的保存和比较的缓存

item_cmpfunc.cc 比较函数的定义

item_create.cc 创建一个item

item_func.cc 数字函数

item_geofunc.cc 集合函数

item_row.cc 记录项比较

item_strfunc.cc 字符串函数

item_subselect.cc 子查询

item_sum.cc 集函数（SUM,AVG…）

item_timefunc.cc 时间日期函数

item_uniq.cc 空文件

Key.cc 创建KEY以及比较

Lock.cc 锁

Log.cc 日志

log_event.cc 日志事件

Matherr.c 处理溢出

mf_iocache.cc 顺序读写的缓存

Mysqld.cc main，处理信号和连接

mf_decimal.cc decimal类型

my_lock.c

net_serv.cc socket数据包的解析

nt_servc.cc NT服务

opt_range.cc KEY排序

opt_sum.cc 集函数优化

parse_file.cc frm解析

Password.c 密码检查

Procedure.cc

Protocol.cc 数据包打包发送给客户端

protocol_cursor.cc 存储返送数据

Records.cc 读取记录集

repl_failsafe.cc

set_var.cc 设置、读取用户变量

Slave.cc slave节点

Sp.cc 存储过程和存储函数

sp_cache.cc

sp_head.cc

sp_pcontext.cc

sp_rcontext.cc

Spatial.cc 集合函数，点线面

Sql_acl.cc ACL

sql_analyse.cc

sql_base.cc 基础函数

sql_cache.cc 查询缓存

sql_client.cc

sql_crypt.cc 加解密

sql_db.cc 创建、删除DB

sql_delete.cc DELETE语句

sql_derived.cc 派生表

sql_do.cc DO

sql_error.cc 错误和警告

sql_handler.cc

sql_help.cc HELP

sql_insert.cc INSERT

sql_lex.cc 词法分析

sql_list.cc

sql_load.cc LOAD DATA 语句

sql_manager.cc 维护工作

sql_map.cc 内存映射

sql_olap.cc

sql_parse.cc 解析语句

sql_prepare.cc

sql_rename.cc 重命名table名

sql_repl.cc 复制

sql_select.cc SELECT和JOIN优化

sql_show.cc SHOW

sql_state.c 错误号和状态的映射

sql_string.cc

sql_table.cc DROP TABLE、ALTER TABLE

sql_trigger.cc 触发器

sql_udf.cc 用户自定义函数

sql_union.cc UNION操作符

sql_update.cc UPDATE

sql_view.cc 视图

Stacktrace.c 显示堆栈（LINUX/INTEL ONLY）

Strfunc.cc

Table.cc 表元数据获取（FRM）

thr_malloc.cc

Time.cc

Uniques.cc 副本的快速删除

Unireg.cc 创建一个FRM

2012-03-26 -- Mysql源码学习——没那么简单的Hash
2012-03-26 -- Mysql源码学习——用户认证原理与实现
2012-03-26 -- Mysql源码学习——Thread Manager
2012-03-26 -- Mysql源码学习——Connection Manager
2012-03-26 -- Mysql源码学习——八度空间
2012-03-26 -- Mysql源码学习——打造专属语法
2012-03-26 -- Mysql源码学习——词法分析MYSQLlex
2012-03-26 -- Mysql源码学习笔记——偷窥线程
2012-03-26 -- Mysql的源码安装
2012-03-26 -- MySQL源码学习——DBUG调试

标签：MySQL高级应用, 源码, 目录结构

Mysql源码学习——打造专属语法

OurMySQL — Mon, 26 Mar 2012 13:32:50 +0800

接触过SQL语句的人都会看过这家或者那家的SQL手册，其语法标准应该是从SQL92开始吧，在看SQL92标准的时候，你会发现里面定义的都是一些巴科斯范式(BNF)，就是一种语法定义的标准。不管是牛X哄哄的ORACLE，还是不幸被其收购的Mysql，都会遵循里面的标准语法，当然一些扩展的语法除外，比如今天我们就会扩展一个简单的语法^-^。

OK，大家知道了SQL语法的来源，那么如何进行语法解析呢？YACC！！(Yet Another Compiler Compiler)，它的书写方式便是BNF，语法解析的利器。YACC接收来自词法分析阶段分解出来的token，然后去匹配那些BNF。今天哥就来揭开它的面纱。（关于YACC的基本使用方法，大家可以看我上一篇中提到IBM的链接，一定要看懂那个先）

继续上一节的语句SELECT @@VERSION_COMMET,为了简单，这里省去后缀limit 1。Mysql的语法文件是sql_yacc.yy,首先给出这条语句涉及到的语法节点（大体浏览下即可）:

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

query:

END_OF_INPUT

{...}

|| verb_clause

{...}

| verb_clause END_OF_INPUT

          {

            /* Single query, not terminated. */

            YYLIP->found_semicolon= NULL;

          }

verb_clause:

          statement

        | begin

        ;

statement:

          alter

        | analyze

        | backup

        | binlog_base64_event

        | call

        | change

        | check

        | checksum

        | commit

        | create

        | deallocate

        | delete

        | describe

        | do

        | drop

        | execute

        | flush

        | grant

        | handler

        | help

        | insert

        | install

        | kill

        | load

        | lock

        | optimize

        | keycache

        | partition_entry

        | preload

        | prepare

        | purge

        | release

        | rename

        | repair

        | replace

        | reset

        | restore

        | revoke

        | rollback

        | savepoint

        | select

        | set

        | show

        | slave

        | start

        | truncate

        | uninstall

        | unlock

        | update

        | use

        | xa

        ;

select:

          select_init

          {

            LEX *lex= Lex;

            lex->sql_command= SQLCOM_SELECT;

          }

        ;

select_init:

          SELECT_SYM select_init2

        | '(' select_paren ')' union_opt

        ;

select_init2:

          select_part2

          {

            LEX *lex= Lex;

            SELECT_LEX * sel= lex->current_select;

            if (lex->current_select->set_braces(0))

            {

              my_parse_error(ER(ER_SYNTAX_ERROR));

              MYSQL_YYABORT;

            }

            if (sel->linkage == UNION_TYPE &&

                sel->master_unit()->first_select()->braces)

            {

              my_parse_error(ER(ER_SYNTAX_ERROR));

              MYSQL_YYABORT;

            }

          }

          union_clause

        ;

select_part2:

          {

            LEX *lex= Lex;

            SELECT_LEX *sel= lex->current_select;

            if (sel->linkage != UNION_TYPE)

              mysql_init_select(lex);

            lex->current_select->parsing_place= SELECT_LIST;

          }

          select_options select_item_list

          {

            Select->parsing_place= NO_MATTER;

          }

          select_into select_lock_type

        ;

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

select_item_list:

 select_item_list ',' select_item

 | select_item

 | '*'

 {

 THD *thd= YYTHD;

 Item *item= new (thd->mem_root)

 Item_field(&thd->lex->current_select->context,

 NULL, NULL, "*");

 if (item == NULL)

 MYSQL_YYABORT;

 if (add_item_to_list(thd, item))

 MYSQL_YYABORT;

 (thd->lex->current_select->with_wild)++;

 }

 ;

select_item:

 remember_name select_item2 remember_end select_alias

 {

 THD *thd= YYTHD;

 DBUG_ASSERT($1 < $3);

 if (add_item_to_list(thd, $2))

 MYSQL_YYABORT;

 if ($4.str)

 {

 if (Lex->sql_command == SQLCOM_CREATE_VIEW &&

 check_column_name($4.str))

 {

 my_error(ER_WRONG_COLUMN_NAME, MYF(0), $4.str);

 MYSQL_YYABORT;

 }

 $2->is_autogenerated_name= FALSE;

 $2->set_name($4.str, $4.length, system_charset_info);

 }

 else if (!$2->name)

 {

 $2->set_name($1, (uint) ($3 - $1), thd->charset());

 }

 }

 ;

variable:

 '@'

 {

 if (! Lex->parsing_options.allows_variable)

 {

 my_error(ER_VIEW_SELECT_VARIABLE, MYF(0));

 MYSQL_YYABORT;

 }

 }

 variable_aux

 {

 $$= $3;

 }

 ;

variable_aux:

 ident_or_text SET_VAR expr

 {

 Item_func_set_user_var *item;

 $$= item= new (YYTHD->mem_root) Item_func_set_user_var($1, $3);

 if ($$ == NULL)

 MYSQL_YYABORT;

 LEX *lex= Lex;

 lex->uncacheable(UNCACHEABLE_RAND);

 lex->set_var_list.push_back(item);

 }

 | ident_or_text

 {

 $$= new (YYTHD->mem_root) Item_func_get_user_var($1);

 if ($$ == NULL)

 MYSQL_YYABORT;

 LEX *lex= Lex;

 lex->uncacheable(UNCACHEABLE_RAND);

 }

 | '@' opt_var_ident_type ident_or_text opt_component

 {

 /* disallow "SELECT @@global.global.variable" */

 if ($3.str && $4.str && check_reserved_words(&$3))

 {

 my_parse_error(ER(ER_SYNTAX_ERROR));

 MYSQL_YYABORT;

 }

 if (!($$= get_system_var(YYTHD, $2, $3, $4)))

 MYSQL_YYABORT;

 if (!((Item_func_get_system_var*) $$)->is_written_to_binlog())

 Lex->set_stmt_unsafe();

 }

 ;

下面我们仔细的来看一下整个SELECT语法节点的执行流程：

1

query->verb_clause->statement->select->select_init->select_init2->select_part2->select_item_list->select_item…->variable

语法是自上而下的，实际的解析过程是自下而上的匹配过程。词法分析首先yacc送来SELECT关键字，上一节说过为什么SELECT是关键字呢？

我们看下sql_yacc.yy，可以找到如下一个定义：

1

%token SELECT_SYM /* SQL-2003-R */

这里其实是定义了一个宏SELECT_SYM，代表一个关键字，宏定义如下：

1

#define SELECT_SYM 687

那么字符串”SELECT”和SELECT_SYM是如何联系在一起的呢？我们回头看下MYSQLlex中的find_keyword这个函数：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

static int find_keyword(Lex_input_stream *lip, uint len, bool function)

{

 const char *tok= lip->get_tok_start();

 SYMBOL *symbol= get_hash_symbol(tok, len, function);

 if (symbol)

 {

 lip->yylval->symbol.symbol=symbol;

 lip->yylval->symbol.str= (char*) tok;

 lip->yylval->symbol.length=len;

 if ((symbol->tok == NOT_SYM) &&

 (lip->m_thd->variables.sql_mode & MODE_HIGH_NOT_PRECEDENCE))

 return NOT2_SYM;

 if ((symbol->tok == OR_OR_SYM) &&

 !(lip->m_thd->variables.sql_mode & MODE_PIPES_AS_CONCAT))

 return OR2_SYM;

 return symbol->tok;

 }

 return 0;

}

static SYMBOL *get_hash_symbol(const char *s,

 unsigned int len,bool function)

{

 register uchar *hash_map;

 register const char *cur_str= s;

 if (len == 0) {

 DBUG_PRINT("warning", ("get_hash_symbol() received a request for a zero-length symbol, which is probably a mistake."));

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

 return(NULL);

 }

 if (function){

 if (len>sql_functions_max_len) return 0;

 hash_map= sql_functions_map;

 register uint32 cur_struct= uint4korr(hash_map+((len-1)*4));

 for (;;){

 register uchar first_char= (uchar)cur_struct;

 if (first_char == 0)

 {

 register int16 ires= (int16)(cur_struct>>16);

 if (ires==array_elements(symbols)) return 0;

 register SYMBOL *res;

 if (ires>=0)

 res= symbols+ires;

 else

 res= sql_functions-ires-1;

 register uint count= (uint) (cur_str - s);

 return lex_casecmp(cur_str,res->name+count,len-count) ? 0 : res;

 }

 register uchar cur_char= (uchar)to_upper_lex[(uchar)*cur_str];

 if (cur_char<first_char) return 0;

 cur_struct>>=8;

 if (cur_char>(uchar)cur_struct) return 0;

 cur_struct>>=8;

 cur_struct= uint4korr(hash_map+

 (((uint16)cur_struct + cur_char - first_char)*4));

 cur_str++;

 }

 }else{

 if (len>symbols_max_len) return 0;

 hash_map= symbols_map;

 register uint32 cur_struct= uint4korr(hash_map+((len-1)*4));

 for (;;){

 register uchar first_char= (uchar)cur_struct;

 if (first_char==0){

 register int16 ires= (int16)(cur_struct>>16);

 if (ires==array_elements(symbols)) return 0;

 register SYMBOL *res= symbols+ires;

 register uint count= (uint) (cur_str - s);

 return lex_casecmp(cur_str,res->name+count,len-count)!=0 ? 0 : res;

 }

 register uchar cur_char= (uchar)to_upper_lex[(uchar)*cur_str];

 if (cur_char<first_char) return 0;

 cur_struct>>=8;

 if (cur_char>(uchar)cur_struct) return 0;

 cur_struct>>=8;

 cur_struct= uint4korr(hash_map+

 (((uint16)cur_struct + cur_char - first_char)*4));

 cur_str++;

 }

 }

}

其中的get_hash_symbol便是去系统中查找关键字，第三个参数function代表是否去查找系统函数，我们这里是系统变量，不是函数，故为FALSE。所有的关键字都挂在了hash_map上，即symbols_map上。symbols_maps又是一堆处理过的数据：

1

2

3

4

5

6

7

8

static uchar symbols_map[11828]= {

'<', '>', 29, 0,

'!', '|', 32, 0,

'<', 'X', 150, 0,

'B', 'Y', 11, 1,

'A', 'W', 147, 2,

'A', 'V', 0, 4,

...

看一下这个文件的最上面的注释吧，看看有啥有用的信息，果然被找到了：

1

2

/* Do not edit this file! This is generated by gen_lex_hash.cc

that seeks for a perfect hash function */

看到了这个注释，心中豁然开朗，原来lex_hash.h是由gen_lex_hash.cc进行生成的，大家千万不要自己进行编辑此文件啊！！

来gen_lex_hash.cc看下吧，看到了个main函数，里面是一些生成文件的操作，在generate_find_structs函数中找到了insert_symbols，

这应该是初始化我们的symbols_map数组了吧。

1

2

3

4

5

6

7

8

9

10

void insert_symbols()

{

 size_t i= 0;

 SYMBOL *cur;

 for (cur= symbols; i<array_elements(symbols); cur++, i++){

 hash_lex_struct *root=

 get_hash_struct_by_len(&root_by_len,cur->length,&max_len);

 insert_into_hash(root,cur->name,0,(uint) i,0);

 }

}

看到函数的实现是循环取数组symbols,找到symbols定义，在文件lex.h中，看到这个数组，我想大家就会了然了:

1

{ "SELECT", SYM(SELECT_SYM)},

这就是将SELECT字符串与SELECT_SYM关联的地方了，bingo！

我们再来捋一下SELECT解析的思路，词法分析解析到SELECT后，执行find_keyword去找是否是关键字，发现SELECT是关键字，

于是给yacc返回SELECT_SYM用于语法分析。note：如果我们想要加关键字，只需在sql_yacc.yy上面添加一个%token xxx,

然后在lex.h里面加入相应的字符串和SYM的对应即可。

下面看下@@version_comment这个系统变量如何解析的，首先给出其语法节点：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

variable_aux:

...

 | '@' opt_var_ident_type ident_or_text opt_component

 {

 /* disallow "SELECT @@global.global.variable" */

 if ($3.str && $4.str && check_reserved_words(&$3))

 {

 my_parse_error(ER(ER_SYNTAX_ERROR));

 MYSQL_YYABORT;

 }

 if (!($$= get_system_var(YYTHD, $2, $3, $4)))

 MYSQL_YYABORT;

 if (!((Item_func_get_system_var*) $$)->is_written_to_binlog())

 Lex->set_stmt_unsafe();

 }

 ;

这里便是查找系统变量的地方了：get_system_var，我们跟进去看下：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

Item *get_system_var(THD *thd, enum_var_type var_type, LEX_STRING name,

 LEX_STRING component)

{

 sys_var *var;

 LEX_STRING *base_name, *component_name;

 if (component.str)

 {

 base_name= &component;

 component_name= &name;

 }

 else

 {

 base_name= &name;

 component_name= &component; // Empty string

 }

 if (!(var= find_sys_var(thd, base_name->str, base_name->length)))

 return 0;

 if (component.str)

 {

 if (!var->is_struct())

 {

 my_error(ER_VARIABLE_IS_NOT_STRUCT, MYF(0), base_name->str);

 return 0;

 }

 }

 thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT);

 set_if_smaller(component_name->length, MAX_SYS_VAR_LENGTH);

 return new Item_func_get_system_var(var, var_type, component_name,

 NULL, 0);

}

由find_sys_var函数不断跟进去，我们跟到了set_var.cc，找到了如下定义：

?

1

static sys_var_chain vars = { NULL, NULL };

系统变量都会挂载在次链上。在文件中，搜索到了version_comment:

1

2

static sys_var_const_str sys_version_comment(&vars, "version_comment",

 MYSQL_COMPILATION_COMMENT);

1

#define MYSQL_COMPILATION_COMMENT "Source distribution"

这便是将version_comment加载到vars的链表上。

OK，我们也来加一个自己的系统变量：

1

2

3

4

5

6

static sys_var_const_str sys_version_comment(&vars, "version_comment",

 MYSQL_COMPILATION_COMMENT);

/**add by nocode */

static sys_var_const_str sys_version_comment_test(&vars, "nocode_test_sysvar",

 MYSQL_COMPILATION_NOCODE_TEST_SYSVAR);

#define MYSQL_COMPILATION_COMMENT “Source distribution”
#define MYSQL_COMPILATION_NOCODE_TEST_SYSVAR “No code in heart” /*add by nocode*/

1

注释add by nocode的地方，即是新添加的系统变量和宏定义，我们的系统变量叫@@nocode_test_sysvar,其值为No code in heartOK，重新编译代码，执行SELECT语句，OK了。

1

2

3

4

5

6

7

mysql> select @@nocode_test_sysvar;

+----------------------+

| @@nocode_test_sysvar |

+----------------------+

| No code in heart |

+----------------------+

1 row in set (0.01 sec)

上面添加了一个系统变量，并没有修改语法文件sql_yacc.yy,为了加深理解，我们添加一个属于自己的语法：nocode语法，为了简单化实现，我们的目标很简单，在客户端输入no_code后显示字符串”MAKE BY NOCODE”。

定义关键字

首先在sql_yacc.yy文件中添加相应的SYMBOL

1

2

3

%token NO_SYM /* SQL-2003-R */

%token NO_CODE_SYM /* add by nocode*/

%token NO_WAIT_SYM

然后在lex.h中的symblos数组中添加nocode的字符串和符号的对应关系：

1

2

3

{ "NO", SYM(NO_SYM)},

{ "NO_CODE", SYM(NO_CODE_SYM)}, /*add by nocode*/

{ "NO_WAIT", SYM(NO_WAIT_SYM)},

ok,至此我们关键字已经添加进去了

添加语法节点

我们给语法分支节点起名叫nocode，定义如下：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

/**add by nocode*/

nocode:

 NO_CODE_SYM

 {

 THD *thd= YYTHD;

 LEX *lex= Lex;

 SELECT_LEX *sel= lex->current_select;

 Item_string* field;

 LEX_STRING tmp;

 CHARSET_INFO *cs_con= thd->variables.collation_connection;

 CHARSET_INFO *cs_cli= thd->variables.character_set_client;

 if (sel->linkage != UNION_TYPE)

 mysql_init_select(lex);

 lex->current_select->parsing_place= SELECT_LIST;

 uint repertoire= thd->lex->text_string_is_7bit &&

 my_charset_is_ascii_based(cs_cli) ? MY_REPERTOIRE_ASCII : MY_REPERTOIRE_UNICODE30;

 tmp.str = "MAKE BY NOCODE";

 tmp.length = strlen(tmp.str);

 field= new (thd->mem_root) Item_string(tmp.str, tmp.length, cs_con,

 DERIVATION_COERCIBLE,

 repertoire);

 if (field== NULL)

 MYSQL_YYABORT;

 if (add_item_to_list(thd, field))

 MYSQL_YYABORT;

 Select->parsing_place= NO_MATTER;

 lex->sql_command= SQLCOM_SELECT;

 }

 ;

最后要在statement的语法节点上加入nocode分支，我就不贴不来了。只要读到”no_code”便会进行进入这个语法分支。在这个分支里，做了一些操作，首先构造了一个SELECT类型的语句，然后对其添加了一列，这列的名称就是”MAKE BY NOCODE”…具体的细节大家自己研究吧，这都不是本文的重点。

语法添加完之后，我们重新编译项目，值得说明的是，Mysql还是项目组织还是非常好的，修改了语法文件之后，不需要我们自己去用bison编译，项目自动就帮我们编译好了，真是不错。重启服务器，在客户端输入no_code,结果如下：

1

2

3

4

5

6

7

mysql> no_code;

+----------------+

| MAKE BY NOCODE |

+----------------+

| MAKE BY NOCODE |

+----------------+

1 row in set (3.02 sec)

语法分析到此结束。这里只添加了一个很简单的语法分支，没啥用处，主要是介绍下添加分支的步骤，大家添加分支的时候要尽量使用已有的分支，既减少劳动量，同时也会减少语法冲突。唠叨两句，最近项目太紧张，压力山大，每晚都被噩梦惊醒，噩梦中总会想到算法的各种BUG，写个代码都提心吊胆的，哎，搞IT的真是悲催啊。PS 终于又更新了一篇，oh yeah，-_-ps again: 第一次用windows live writer写博客，感觉比网页方便多了～～，赞一个

2012-03-26 -- Mysql源码学习——没那么简单的Hash
2012-03-26 -- Mysql源码学习——用户认证原理与实现
2012-03-26 -- Mysql源码学习——Thread Manager
2012-03-26 -- Mysql源码学习——Connection Manager
2012-03-26 -- Mysql源码学习——八度空间
2012-03-26 -- Mysql源码学习——源码目录结构
2012-03-26 -- Mysql源码学习——词法分析MYSQLlex
2012-03-26 -- Mysql源码学习笔记——偷窥线程
2012-03-26 -- Mysql的源码安装
2012-03-26 -- MySQL源码学习——DBUG调试

标签：MySQL高级应用, YACC, 源码, 语法

OurMySQL

MYSQL的DECIMAL和NUMERIC类型

相关文章

mysql hash 破解提权

相关文章

mysql 数据库查询随机数量条目的效率问题及解决办法

相关文章

Mysql源码学习——没那么简单的Hash

基本结构体

初始化函数

动态HASH函数

my_hash_insert非深入解析

相关文章

Mysql源码学习——用户认证原理与实现

相关文章

Mysql源码学习——Thread Manager

相关文章

Mysql源码学习——Connection Manager

相关文章

Mysql源码学习——八度空间

相关文章

Mysql源码学习——源码目录结构

相关文章

Mysql源码学习——打造专属语法

相关文章