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列的实际范围受具体列的精度或标度约束
。如果此类列分配的值小数点后面的位数超过指定的标度允许的范围，值被转换为该标度。(具体操作与
操作系统有关，但一般结果均被截取到允许的位数）。

相关文章

• 目前没有相关的文章

可以提取用户hash

0x01004E04BE46023057E323AF27269E5B7DDCA140C98D225BDD3D06E8EFE8CFAEC02985B27B38059FA3B18349612B


分解：

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

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

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

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

相关文章

• 2012-03-26 -- Mysql源码学习——没那么简单的Hash
• 2009-07-15 -- memory型表支持Hash索引
• 2009-04-08 -- 有趣的bloom过滤器

但是，后来我查了一下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 随机读取数据

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

• 基本结构体

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

• 初始化函数

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

• 动态HASH函数

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

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

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

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

• my_hash_insert非深入解析

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

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

   可以看出，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，是的，它这种实现方式是根据实际的数据量进行桶数的分配。我这里大概说下代码的流程（有兴趣的还需要大家自己仔细琢磨）。

1. 根据flag去判断是否是否唯一Hash，如果是唯一Hash，去查找Hash表中是否存在重复值(dupliacate entry)，存在则报错。
2. 进行桶分裂，对应代码中的if (idx != info->records)分支。这个分支有些费解，稍微提示下：gpos和ptr_to_rec指示了低位需要移动的数据，gpos2和 ptr_to_rec2只是了高位需要移动的数据。LOWFIND表示低位存在值，LOWUSED表示低位是否进行了调整。HIGH的宏意义基本相同。 if (!(hash_nr & halfbuff)) 用于判断hash值存在高位还是低位。
3. 计算新值对应的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的源码安装

验证用户名和密码的过程，我们平时做一个系统的时候，很多时候都会涉及到身份验证。今天我们就来看下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);//验证用户名和密码

}

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

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

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

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

题外话：

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调试

一、前言

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

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

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

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

首先介绍下基本的概念。

二、基本概念

1.线程创建函数

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

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

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

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

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

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

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

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

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

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

pthread_create创建的线程：

innobase的os_thread_create创建的线程：

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

三、线程缓冲池

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

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

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

cached_thread_count < thread_cache_size

pthread_cond_signal(&COND_flush_thread_cache);

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

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

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

如下：

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

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

pthread_cond_signal(&COND_thread_cache);

上篇文章我们其实只讲了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支持单线程和多线程两种连接线程数。如果是单线程，则在同一时刻，只能有一个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的学习。

相关文章

• 2012-03-26 -- Mysql源码学习——没那么简单的Hash
• 2012-03-26 -- Mysql源码学习——用户认证原理与实现
• 2012-03-26 -- Mysql源码学习——Thread 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的面纱。

我们从上至下来看各个模块的划分，首先客户端发送请求与服务器连接，通过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调试

目录名 注释

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

更多内容请参考：

http://forge.mysql.com/wiki/MySQL_Internals_Files_In_MySQL_Sources#The_sql_Directory

相关文章

• 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调试

         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调试

词法分析即将输入的语句进行分词(token)，解析出每个token的意义。分词的本质便是正则表达式的匹配过程，比较流行的分词工具应该是lex，通过简单的规则制定，来实现分词。Lex一般和yacc结合使用。关于lex和yacc的基础知识请参考Yacc 与Lex 快速入门 - IBM。如果想深入学习的话，可以看下《LEX与YACC》。

然而Mysql并没有使用lex来实现词法分析，但是语法分析却用了yacc，而yacc需要词法分析函数yylex，故在sql_yacc.cc文件最前面我们可以看到如下的宏定义:

/* Substitute the variable and function names.  */
#define yyparse         MYSQLparse
#define yylex           MYSQLlex

这里的MYSQLlex也就是本文的重点，即MYSQL自己的词法分析程序。源码版本5.1.48。源码太长，贴不上来，算啦..在sql_lex.cc里面。

我们第一次进入词法分析，state默认值为MY_LEX_START，就是开始状态了，其实state的宏的意义可以从名称上猜个差不多，再比如MY_LEX_IDEN便是标识符。对START状态的处理伪代码如下：

case MY_LEX_START:
{
Skip空格
获取第一个有效字符c
state = state_map[c];
Break;
}

我困惑了，这尼玛肿么出来个state_map？找到了在函数开始出有个赋值的地方：

uchar *state_map= cs->state_map;

cs？！不会是反恐精英吧!!快速监视下cs为my_charset_latin1,哥了然了，原来cs是latin字符集，character set的缩写吧。那么为神马state_map可以直接决定状态？找到其赋值的地方，在init_state_maps函数中，代码如下所示：

/* Fill state_map with states to get a faster parser */
  for (i=0; i < 256 ; i++)
  {
    if (my_isalpha(cs,i))
      state_map[i]=(uchar) MY_LEX_IDENT;
    else if (my_isdigit(cs,i))
      state_map[i]=(uchar) MY_LEX_NUMBER_IDENT;
#if defined(USE_MB) && defined(USE_MB_IDENT)
    else if (my_mbcharlen(cs, i)>1)
      state_map[i]=(uchar) MY_LEX_IDENT;
#endif
    else if (my_isspace(cs,i))
      state_map[i]=(uchar) MY_LEX_SKIP;
    else
      state_map[i]=(uchar) MY_LEX_CHAR;
  }
  state_map[(uchar)'_']=state_map[(uchar)'$']=(uchar) MY_LEX_IDENT;
  state_map[(uchar)'\'']=(uchar) MY_LEX_STRING;
  state_map[(uchar)'.']=(uchar) MY_LEX_REAL_OR_POINT;
  state_map[(uchar)'>']=state_map[(uchar)'=']=state_map[(uchar)'!']= (uchar) MY_LEX_CMP_OP;
  state_map[(uchar)'<']= (uchar) MY_LEX_LONG_CMP_OP;
  state_map[(uchar)'&']=state_map[(uchar)'|']=(uchar) MY_LEX_BOOL;
  state_map[(uchar)'#']=(uchar) MY_LEX_COMMENT;
  state_map[(uchar)';']=(uchar) MY_LEX_SEMICOLON;
  state_map[(uchar)':']=(uchar) MY_LEX_SET_VAR;
  state_map[0]=(uchar) MY_LEX_EOL;
  state_map[(uchar)'\\']= (uchar) MY_LEX_ESCAPE;
  state_map[(uchar)'/']= (uchar) MY_LEX_LONG_COMMENT;
  state_map[(uchar)'*']= (uchar) MY_LEX_END_LONG_COMMENT;
  state_map[(uchar)'@']= (uchar) MY_LEX_USER_END;
  state_map[(uchar) '`']= (uchar) MY_LEX_USER_VARIABLE_DELIMITER;
  state_map[(uchar)'"']= (uchar) MY_LEX_STRING_OR_DELIMITER;

　　先来看这个for循环，256应该是256个字符了，每个字符的处理应该如下规则：如果是字母，则state = MY_LEX_IDENT；如果是数字，则state = MY_LEX_NUMBER_IDENT，如果是空格，则state = MY_LEX_SKIP，剩下的全为MY_LEX_CHAR。

for循环之后，又对一些特殊字符进行了处理，由于我们的语句“select @@version_comment limit 1”中有个特殊字符@，这个字符的state进行了特殊处理，为MY_LEX_USER_END。

对于my_isalpha等这几个函数是如何进行判断一个字符属于什么范畴的呢？跟进去看下，发现是宏定义：

#define    my_isalpha(s, c)  (((s)->ctype+1)[(uchar) (c)] & (_MY_U | _MY_L))

Wtf，肿么又来了个ctype，c作为ctype的下标，_MY_U | _MY_L如下所示，

#define    _MY_U   01    /* Upper case */
#define    _MY_L   02    /* Lower case */

ctype里面到底存放了什么？在ctype-latin1.c源文件里面，我们找到了my_charset_latin1字符集的初始值：

CHARSET_INFO my_charset_latin1=
{
    8,0,0,                           /* number    */
    MY_CS_COMPILED | MY_CS_PRIMARY, /* state     */
    "latin1",                        /* cs name    */
    "latin1_swedish_ci",              /* name      */
    "",                                /* comment   */
    NULL,                         /* tailoring */
    ctype_latin1,
    to_lower_latin1,
    to_upper_latin1,
    sort_order_latin1,
    NULL,           /* contractions */
    NULL,           /* sort_order_big*/
    cs_to_uni,             /* tab_to_uni   */
    NULL,           /* tab_from_uni */
    my_unicase_default, /* caseinfo     */
    NULL,           /* state_map    */
    NULL,           /* ident_map    */
    1,                  /* strxfrm_multiply */
    1,                  /* caseup_multiply  */
    1,                  /* casedn_multiply  */
    1,                  /* mbminlen   */
    1,                  /* mbmaxlen  */
    0,                  /* min_sort_char */
    255,        /* max_sort_char */
    ' ',                /* pad char      */
    0,                  /* escape_with_backslash_is_dangerous */
    &my_charset_handler,
    &my_collation_8bit_simple_ci_handler
};

可以看出ctype = ctype_latin1；而ctype_latin1值为：

static uchar ctype_latin1[] = {
    0,
   32, 32, 32, 32, 32, 32, 32, 32, 32, 40, 40, 40, 40, 40, 32, 32,
   32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
   72, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
  132,132,132,132,132,132,132,132,132,132, 16, 16, 16, 16, 16, 16,
   16,129,129,129,129,129,129,  1,  1,  1,  1,  1,  1,  1,  1,  1,
    1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1, 16, 16, 16, 16, 16,
   16,130,130,130,130,130,130,  2,  2,  2,  2,  2,  2,  2,  2,  2,
    2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2, 16, 16, 16, 16, 32,
   16,  0, 16,  2, 16, 16, 16, 16, 16, 16,  1, 16,  1,  0,  1,  0,
    0, 16, 16, 16, 16, 16, 16, 16, 16, 16,  2, 16,  2,  0,  2,  1,
   72, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
   16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
    1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
    1,  1,  1,  1,  1,  1,  1, 16,  1,  1,  1,  1,  1,  1,  1,  2,
    2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
    2,  2,  2,  2,  2,  2,  2, 16,  2,  2,  2,  2,  2,  2,  2,  2
};

看到这里哥再一次了然了，这些值都是经过预计算的，第一个0是无效的，这也是为什么my_isalpha(s, c)定义里面ctype要先+1的原因。通过_MY_U和_MY_L的定义，可以知道，这些值肯定是按照相应的ASCII码的具体意义进行置位的。比如字符’A'，其ASCII码为65，其实大写字母，故必然具有_MY_U，即第0位必然为1，找到ctype里面第66个（略过第一个无意义的0）元素，为129 = 10000001，显然第0位为1(右边起)，说明为大写字母。写代码的人确实比较牛X，如此运用位，哥估计这辈子也想不到了，小小佩服下。State的问题点到为止了。

继续进行词法分析，第一个字母为s，其state = MY_LEX_IDENT（IDENTIFIER:标识符的意思）,break出来，继续循环，case进入MY_LEX_IDENT分支：

Case MY_LEX_IDENT：
{
由s开始读，直到空格为止
If（读入的单词为关键字）
{
nextstate = MY_LEX_START；
Return tokval;        //关键字的唯一标识
}
Else
{
return IDENT_QUOTED 或者 IDENT；表示为一般标识符
}
}

这里SELECT肯定为关键字，至于为什么呢？下节的语法分析会讲。

解析完SELECT后，需要解析@@version_comment,第一个字符为@,进入START分支，state = MY_LEX_USER_END；

进入MY_LEX_USER_END分支，如下：

case MY_LEX_USER_END:        // end '@' of user@hostname
      switch (state_map[lip->yyPeek()]) {
      case MY_LEX_STRING:
      case MY_LEX_USER_VARIABLE_DELIMITER:
      case MY_LEX_STRING_OR_DELIMITER:
    break;
      case MY_LEX_USER_END:
    lip->next_state=MY_LEX_SYSTEM_VAR;
    break;
      default:
    lip->next_state=MY_LEX_HOSTNAME;
    break;

哥会心的笑了，两个@符号就是系统变量吧～～,下面进入MY_LEX_SYSTEM_VAR分支

case MY_LEX_SYSTEM_VAR:
      yylval->lex_str.str=(char*) lip->get_ptr();
      yylval->lex_str.length=1;
      lip->yySkip();                                    // Skip '@'
      lip->next_state= (state_map[lip->yyPeek()] ==
            MY_LEX_USER_VARIABLE_DELIMITER ?
            MY_LEX_OPERATOR_OR_IDENT :
            MY_LEX_IDENT_OR_KEYWORD);
      return((int) '@');

所作的操作是略过@，next_state设置为MY_LEX_IDENT_OR_KEYWORD，再之后便是解析MY_LEX_IDENT_OR_KEYWORD了，也就是version_comment了，此解析应该和SELECT解析路径一致，但不是KEYWORD。剩下的留给有心的读者了（想起了歌手经常说的一句话：大家一起来，哈哈）。

Mysql的词法解析的状态还是比较多的，如果细究还是需要点时间的，但这不是Mysql的重点，我就浅尝辄止了。下节会针对上面的SQL语句讲解下语法分析。

PS: 一直想好好学习下Mysql，总是被这样或那样的事耽误，当然都是自己的原因，希望这次能走的远点…..

PS again：本文只代表本人的学习感悟，如有异议，欢迎指正。

相关文章

• 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源码学习笔记——偷窥线程
• 2012-03-26 -- Mysql的源码安装
• 2012-03-26 -- MySQL源码学习——DBUG调试

　　安装完Mysql 后，使用VS打开源码开开眼，我嘞个去，这代码和想象中怎么差别这么大呢？感觉代码有些凌乱，注释代码都写的比较随意，好像没有什么统一的规范，不同的文 件中代码风格也有差异，可能Mysql经过了很多牛人的手之后，集众牛人之长吧。也可能是我见识比较浅薄，适应了自己的代码风格，井底之蛙了，总之还是怀 着敬畏的心情开始咱的源码之旅吧。本人菜鸟，大神轻拍。

Mysql可以启动起来了，应该怎么学习呢？总不能从main开始一步一步的 看吧，Mysql作为比较底层的大型软件，涉及到数据库实现的方方面面，没有厚实的数据库理论基础和对Mysql各个模块相当的熟悉，从main开始势必 会把自己引入某个死胡同啊，什么都看，最后啥也不会，咱伤不起。

经过思考后，我想还是通过客户端来调试服务器，从而学习服务器代码比较现实。 也就是通过客户端的动作，看服务器的反应。比如从客户端的登录动作来看SERVER如何进行通信、用户识别、鉴定以及任务分配的，通过CREATE TABLE，来看SERVER如何解析DDL语句以及针对不同的存储引擎采取的不同的物理存储方式，通过INSERT语句，来看SERVER如何进行 Btree的操作。通过SELECT语句来看如何进行SQL语句语法树的创建和优化的，通过ROLL BACK，来看SERVER事务是如何实现的。这里主要是通过跟踪代码学习Mysql数据库实现的思想，对于具体的代码不去做过多的追究(主要是我对 C++不是很熟悉)，好读书，不求甚解，呵呵。

由此，暂时准备了以下几条SQL语句，来有针对的进行SERVER的分析

大家都知道，mysql可以通过多个客户端，进行并发操作，当然也包括登录 了。在别人登录的时候，其他的用户可能正在进行一些其它的操作，因此对于登录我们猜测应该有专门的线程负责客户端和服务器的连接的创建，以保证登录的及时 性，对于每个连接的用户，应该用一个独立的线程进行任务的执行。

首先介绍下mysql中创建线程的函数，创建线程的函数貌似就是 _begin_thread，CreateThread，我们通过VS在整个解决方案中进行查找，bingo！在my_winthread.c中找到了调 用_begin_thread的函数pthread_create，在os0thread.c中找到了调用CreateThread的函数 os_thread_create，一个系统怎么封装两个系统函数呢？？再仔细看下，发现my_winthread.c是在项目mysys下，而 os0thread.c是在项目innobase下。innobase！！这不就是innodb的插件式存储引擎么，原来这是存储引擎自己的封装的底层函 数，哥心中豁然开朗了。我想Mysql应用范围如此之广，除了开源之外，插件式的存储引擎功不可没啊，用户可以根据自己的实际应用采取不同的存储引擎，对于大公司，估计会开发自己的存储引擎。

下面分析下pthread_create是如何调用_begin_thread的，先粗略看下源码。 

关键的代码是下面三句：

从这可以看出，创建的新线程的名字是个固定的函数——pthread_start,而我们传进来的想创建的函数func是挂载在了map上了，函数的参数同样的挂载在map上了，这样我们就可以推理出在pthread_start函数中，肯定会出现这样的代码：

map->func(map->param)；

mysql没有选择直接_beginthread(func, stack_size, param)的形式，而是进行了一次封装，不知道这样的好处是什么，可能牛人的思想不是我这样小菜鸟能顿悟的，跑题了～～

至此，我们只在pthread_create函数上设置断点，调试启动mysqld，断点停下来，看下系统的线程状况：

我们第一次进入pthread_create，任何线程都没开始创建呢，按理说系统线程应该就只有一个主线程，可现在多了这么多，这些应该是innodb存储引擎创建的线程了（具体是在plugin_init）。根据线程的名称，结合注释，猜测了下这些线程的作用。

Io_handler_thread：从名称可以知道这些是I/O线程，负责进行磁盘I/O。

Svr_error_monitor_thread：应该是服务器出错监控线程。

Svr_lock_timeout_thread：应该是和上锁相关的线程。

Svr_master_thread：

/*************************************************************************

The master thread controlling the server. */

服务器控制线程，应该是具体进行作业的线程。

Svr_monitor_thread:

/*************************************************************************

A thread prints the info output by various InnoDB monitors. */

监控线程，负责打印信息。

淡然飘过吧，不去细究了，我们只关心pthread_create创建的线程。根据调试，发现多了几个线程同名的线程_threadstart，如下所示：

调试时看堆栈可以知道这三个线程的创建者和作用，如下所示

创建者：调用pthread_create进行创建线程的函数。

处理函数：调用pthread_create所创建的线程的具体的线程函数。

由名称我们就可以看出，handle_connections_sockets应该是处理连接的线程了，从顺序上看，也应该是这样，只有系统中所有的其他必须的线程创建完毕后，才能创建监听线程(连接线程)，即监听线程应该是系统最后创建的。

    找到了我们LOGIN需要的线程了，下次针对这个线程，分析下如何进行登录的，以及登录后为用户分配哪些资源。时间不早啦，洗洗睡了

相关文章

• 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源码学习——DBUG调试

Step 1:

　　下载Mysql源代码，在http://dev.mysql.com/downloads/mysql/ 网站中，包含两种格式的Mysql，MSI Installer 和 ZIP Archive，MSI Installer是直接安装程序，ZIP Archive中包含两种大小的ZIP，从大小可以看出，较小的是源码。Install和ZIP的具体区别请参考：http://dev.mysql.com/doc/refman/5.1/en/windows-choosing-package.html。

Step 2：

　　别告诉我你没有VS，呃，好吧，你是外星人。

Step 3：

　　下载CMAKE，安装后，在CMD中测试是否安装成功。至于是干啥的，后面再讲吧。下载地址http://www.cmake.org

Step4：

　　下载bision，因为Mysql的词法和语法分析是使用的lex和yacc，下载地址：http://gnuwin32.sourceforge.net/packages/bison.htm

Step 5：

　　将下载下来的ZIP文件解压，我解压到了D:\open_src\mysql 中，CMD进入mysql目录下，执行脚本文件：

脚本后面带有三个参数，具体的参数根据自己的需要进行设置，这里选择了INNODB的存储引擎，

貌似这个很流行，提供的可选参数如下：

打开configure.js脚本文件，如下所示：

由此可见configure.js是利用我们传入的参数和configure.in文件，生成一个configure.data文件，其内容如下所示：

Step 6：

执行win目录下的build-vs9.bat批处理文件，打开这个文件，只有一条语句：

cmake -G “Visual Studio 9 2008″

cmake是一个跨平台的自动化构建系统，即根据平台和编译器生成不同的make文件(UNIX下的叫法)。

　　build-vs9.bat中CMAKE的参数是 Visual Studio 9 2008，即Generates Visual Studio 9 2008 project files。Cmake执行时，会使用step 5中生成的configure.data文件，具体咋使用的我也小白了，咱就不研究了。最后会在mysql根目录下生成一个VS的解决方案文件 MySql.sln。

Step 7：

　　设置数据目录，Mysqld启动时，首先去WINDIR中找my.ini配置文件，可以通过如下命令获取WINDIR的路径：

如果没有my.ini文件，可以自己创建一个，看到如下内容：

设置了两个参数，mysql的参数路径，我们通过修改这两个参数来指向我们具体的目录。

如果不想自己创建的话，可以将win目录下的data目录整体拷贝到sql目录下。

step 8：

将sql目录下的share目录整体拷贝下mysql根目录下，因为 SERVER启动时需要在Mysql/share目录下找一个errmsg.txt，用于记录错误信息，当然你也可以不进行整体的目录拷贝，只将 errmsg.txt拷贝过去也行，但是确保是这样的路径mysql/share/errmsg.txt.

step 9：

启动mysql服务器，mysql解决方案中，服务器是mysqld项目，客户端是mysql项目，分别编译这两个项目。在编译 sql_locale.cc文件时，会出现ERROR，用ULTRA EDIT打开sql_locale.cc文件，另存为UTF-8格式，覆盖原文件即可。使用VS启动服务器mysqld，使用命令行启动客户端 mysql：

服务器可以在VS下进行调试了，yeah～～

相关文章

• 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源码学习——DBUG调试

一、前言

在规模稍微大点的项目中，为了方便快速找到bug的所在，我们往往需要在代码中加入一些调试用的代码，比如加入一些printf，打印出一些重点的信息； 加入assert，进行断言判断。这些比较随意的调试代码会使整个系统显得比较凌乱。于是Fred Fish开发了一套用于嵌入代码中的库，开发人员只需要调用相应的函数即可加入调试信息。

对于MySQL这种多线程的程序来说，调试也是比较困难的，MySQL选择了DBUG作为其调试代码（在原始代码的基础上进行了略微的改造），充分说明了DBUG的实用性，本文就DBUG的原始代码进行介绍。

二、DBUG下载与使用

这里以linux下的开发进行介绍。

首先需要下载DBUG源码，下载地址：http://sourceforge.net/projects/dbug/

解压后在dbug/src下即是debug所需的源码文件：dbug.h dbug.c

dbug/example.c是一个简单的例子，源码如下：

我们将example.c放到src目录下，然后编译example文件：

运行example输出如下：

函数sub1调用了三次sub2，三次的参数分别是’Hello world!’ ，’Hello earth!’ ，’Hello programmer!’ ，最后return 0.

下面初略介绍下上面用到的几个宏定义：

DBUG_PUSH (“d:t:O”);  设置调试的启动参数，参数列表在MySQL手册上也有：

DBUG_PROCESS (“example”); 设置进程名为example

DBUG_ENTER (“sub1″); 表示进入函数sub1

DBUG_PRINT (“info”, (“Got argument: ‘%s’”, arg)); 和printf效果差不多，打印出需要的调试信息。

DBUG_RETURN (0);  在return 0 的基础上，打印出return 0的调试信息。

三、小结

本文简单介绍了DBUG的使用方法，没有深究，源码很少，却很实用，在源码的注释部分，我看到了是Fred Fish1987年写的，呃，我才刚出生….，没想到现在还在看那时候的代码，可能这就是所谓的经典吧。

兄弟们，你们还在为复杂环境下的bug调试而苦恼么？还在为堆栈被写乱掉无从下手而凌乱么？淡定吧，一起来用DBUG吧～～

相关文章

• 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的源码安装

方法三：

别人的今天问起，随手转了一下，很简单，这里截图说明一下
用phpmyadmin导入库test中后发现，这个库中有UTF8和latin1两种编码，如下图

先把test备份为test1库，在WIN下操作的话就是把：路径\MySQL\data下的test目录备份一下，改名为test1目录
在phpmyadmin中把所有为UTF8的表删除，在命令行中运行
D:\PHPServer\MySQL\bin>mysqldump -uroot -p –quick –compatible=mysql40 –default-character-set=latin1 –extended-insert=FALSE test > /root/test.sql

说明一下D:\PHPServer\MySQL\bin是我的安装目录，test为数据库，d:/test.sql为生成的数据文件，程序会提示你输入root的用户密码，输入后，等几分钟，test.sql就生成好了

通过phpmyadmin建立一个新库，库名：test2 ，采集字符集设定为utf8-general-li

再将刚才生成sql文件导入新数据库

D:\PHPServer\MySQL\bin>mysql -uroot -p –default-character-set=utf8 test2 < /root/test.sql

输入root密码，等几分钟，zxs.sql就导入成功了，到这还没完，因为这里只是把latin1编码的转换为utf8了
最后，停止mysql，把test2目录下的所有文件覆盖到我们刚刚备份的test1目录下，这样，test1目录就是我们要得到了转换好了的UTF8数据库了，OK，收工
当然，方法很简单，就是把latin1编码的表单独分离出来转为UTF8后再盖原来的库，这样多种编码也都可以完美的转换，这种情况也非常常见，换主机，升mysql版本等都会出现这种情况的。

相关文章

• 目前没有相关的文章

MDL，Meta Data lock，元数据锁，一般称为字典锁。字典锁与数据锁相对应。字典锁是为了保护数据对象被改变，一般是一些DDL会对字典对象改变，如两个TX，TX1先查询表，然后TX2试图DROP，字典锁就会lock住TX2，知道TX1结束（提交或回滚）。数据锁是保护表中的数据，如两个TX同时更新一行时，先得到row lock的TX会先执行，后者只能等待。

• MDL的设计目标

字典锁在设计的时候是为了数据库对象的元数据。到达以下3个目的。

1. 提供对并发访问内存中字典对象缓存(table definatin cache，TDC)的保护。这是系统的内部要求。

2. 确保DML的并发性。如TX1对表T1查询，TX2同是对表T1插入。

3. 确保一些操作的互斥性，如DML与大部分DDL(ALTER TABLE除外)的互斥性。如TX1对表T1执行插入，TX2执行DROP TABLE，这两种操作是不允许并发的，故需要将表对象保护起来，这样可以保证binlog逻辑的正确性。（貌似之前的版本存在字典锁是语句级的，导致binlog不合逻辑的bug。）

• 支持的锁类型

数据库理论中的基本锁类型是S、X，意向锁IS、IX是为了层次上锁而引入的。比如要修改表中的数据，可能先对表上一个表级IX锁，然后再对修改的数据上一个行级X锁，这样就可以保证其他试图修改表定义的事物因为获取不到表级的X锁而等待。

MySQL中将字典锁的类型根据不同语句的功能，进一步细分，细分的依据是对字典的操作和对数据的操作。细分的好处是能在一定程度上提高并发效率，因为如果只定义X和S两种锁，必然导致兼容性矩阵的局限性。MySQL不遗余力的定义了如下的锁类型。

可以看到MySQL在ALTER TABLE的时候还是允许其他事务进行读表操作的。需要注意的是读操作的事物需要在ALTER TABLE获取MDL_SHARED_NO_WRITE锁之后，否则无法并发。这种应用场景应该是对一个较大的表进行ALTER时，其他事物仍然可以读，并发性得到了提高。

• 锁的兼容性

锁的兼容性就是我们经常看到的那些兼容性矩阵，X和S必然互斥，S和S兼容。MySQL根据锁的类型我们也可以知道其兼容矩阵如下：

1代表兼容，0代表不兼容。你可能发现X和IX竟然兼容，没错，其实这里的IX已经不是传统意义上的IX，这个IX是用在范围锁上，所以和X锁不互斥。

• 数据结构

涉及到的和锁相关的数据结构主要是如下几个：

MDL_context：字典锁上下文。包含一个事物所有的字典锁请求。

MDL_request：字典锁请求。包含对某个对象的某种锁的请求。

MDL_ticket：字典锁排队。MDL_request就是为了获取一个ticket。

MDL_lock：锁资源。一个对象全局唯一。可以允许多个可以并发的事物同时获得。

涉及到的源码文件主要是sql/mdl.cc

• 锁资源

锁资源在系统中是共享的，即全局的，存放在static MDL_map mdl_locks;的hash链表中，对于数据库中的一个对象，其hashkey必然是唯一的，对应一个锁资源。多个事务同时对一张表操作时，申请的lock也是同一个内存对象。获取mdl_locks中的lock需要通过全局互斥量保护起来mysql_mutex_lock(&m_mutex); m_mutex是MDL_map的成员。

• 上锁流程

一个会话连接在实现中对应一个THD实体，一个THD对应一个MDL_CONTEXT，表示需要的mdl锁资源，一个MDL_CONTEXT中包含多个MDL_REQUEST，一个MDL_REQUEST即是对一个对象的某种类型的lock请求。每个mdl_request上有一个ticket对象，ticket中包含lock。

上锁的也就是根据MDL_REQUEST进行上锁。

稍微解释下，首先是在mdl_request本身去查看有没有相等的或者stronger的ticket，如果存在，则直接使用。否则创建一个ticket，查找上锁对象对应的lock，没有则创建。检查lock是否可以被赋给本事务，如果可以直接返回，否则等待这个lock；

• 锁等待与唤醒

字典对象的锁等待是发生在两个事物对同一对象上不兼容的锁导致的。当然，由于lock的唯一性，先到先得，后到的只能等待。

如何判断一个lock是否可以grant给一个TX？这需要结合lock结构来看了，lock上有两个成员，grant和wait，grant代表此lock允许的事物都上了哪些锁，wait表示等待的事务需要上哪些锁。其判断一个事物是否可以grant的逻辑如下：

即首先判断grant中的锁类型和当前事务是否兼容，然后判断wait中的锁类型和当前事务是否兼容。细心的话，会想到，wait中的锁类型是不需要和当前事务进行兼容性比较的，这是不是说这个比较是多余的了？其实也不是，因为wait的兼容性矩阵和上面的矩阵是不一样的，wait的兼容性矩阵感觉是在DDL等待的情况下，防止DML继续进来（wait矩阵就不写出来了，大家可以去代码里看下）。

比如：

TX1                                                      TX2                                                       TX3

SELECT T1

DROP  T1

SELECT T1

这时候TX2会阻塞，TX3也会阻塞，被TX2阻塞，也就是说被wait的事件阻塞了，这样可能就是为了保证在DDL等待时，禁止再做DML了，因为在DDL面前，DML显得确实不是那么重要了。

如何唤醒被等待的事务呢？比如唤醒TX2，当TX1结束时，会调用release_all_locks_for_name，对被锁住的事务进行唤醒，具体操作封装在reschedule_waiters函数中，重置等待时间的标记位进行唤醒,重点代码如下:

今天把mdl系统总体上看了一下，对锁的请求、等待以及唤醒有了初步了解。并发性的问题是最难调试的，大家如果想做锁方面的实验，可以利用VS调试中的冻结线程的功能，这样就可以确保并发情况控制完全按照你设计思路去呈现。

相关文章

• 目前没有相关的文章

一、概述
MySQL有三种锁的级别：页级、表级、行级。
MyISAM和MEMORY存储引擎采用的是表级锁（table-level locking）；BDB存储引擎采用的是页面锁（page-level
locking），但也支持表级锁；InnoDB存储引擎既支持行级锁（row-level locking），也支持表级锁，但默认情况下是采用行级锁。
MySQL这3种锁的特性可大致归纳如下：
表级锁：开销小，加锁快；不会出现死锁；锁定粒度大，发生锁冲突的概率最高,并发度最低。
行级锁：开销大，加锁慢；会出现死锁；锁定粒度最小，发生锁冲突的概率最低,并发度也最高。
页面锁：开销和加锁时间界于表锁和行锁之间；会出现死锁；锁定粒度界于表锁和行锁之间，并发度一般。
二、MyISAM表锁
MyISAM存储引擎只支持表锁，是现在用得最多的存储引擎。
1、查询表级锁争用情况
可以通过检查table_locks_waited和table_locks_immediate状态变量来分析系统上的表锁定争夺：
mysql> show status like ‘table%’;
+———————–+———-+
| Variable_name | Value |
+———————–+———-+
| Table_locks_immediate | 76939364 |
| Table_locks_waited | 305089 |
+———————–+———-+
2 rows in set (0.00 sec)Table_locks_waited的值比较高，说明存在着较严重的表级锁争用情况。

2、MySQL表级锁的锁模式
MySQL的表级锁有两种模式：表共享读锁（Table Read Lock）和表独占写锁（Table Write
Lock）。MyISAM在执行查询语句（SELECT）前，会自动给涉及的所有表加读锁，在执行更新操作（UPDATE、DELETE、INSERT等）前，会自动给涉及的表加写锁。
所以对MyISAM表进行操作，会有以下情况：
a、对MyISAM表的读操作（加读锁），不会阻塞其他进程对同一表的读请求，但会阻塞对同一表的写请求。只有当读锁释放后，才会执行其它进程的写操作。
b、对MyISAM表的写操作（加写锁），会阻塞其他进程对同一表的读和写操作，只有当写锁释放后，才会执行其它进程的读写操作。
下面通过例子来进行验证以上观点。数据表gz_phone里有二百多万数据，字段id,phone,ua,day。现在同时用多个客户端同时对该表进行操作分析。
a、当我用客户端1进行一个比较长时间的读操作时，分别用客户端2进行读和写操作：
client1:
mysql>select count(*) from gz_phone group by ua;
75508 rows in set (3 min 15.87 sec) client2:
select id,phone from gz_phone limit 1000,10;
+——+——-+
| id | phone |
+——+——-+
| 1001 | 2222 |
| 1002 | 2222 |
| 1003 | 2222 |
| 1004 | 2222 |
| 1005 | 2222 |
| 1006 | 2222 |
| 1007 | 2222 |
| 1008 | 2222 |
| 1009 | 2222 |
| 1010 | 2222 |
+——+——-+
10 rows in set (0.01 sec)
mysql> update gz_phone set phone=’11111111111′ where id=1001;
Query OK, 0 rows affected (2 min 57.88 sec)
Rows matched: 1 Changed: 0 Warnings: 0
说明当数据表有一个读锁时，其它进程的查询操作可以马上执行，但更新操作需等待读锁释放后才会执行。
b、当用客户端1进行一个较长时间的更新操作时，用客户端2,3分别进行读写操作：
client1:
mysql> update gz_phone set phone=’11111111111′;
Query OK, 1671823 rows affected (3 min 4.03 sec)
Rows matched: 2212070 Changed: 1671823 Warnings: 0 client2:
mysql> select id,phone,ua,day from gz_phone limit 10;
+—-+——-+——————-+————+
| id | phone | ua | day |
+—-+——-+——————-+————+
| 1 | 2222 | SonyEricssonK310c | 2007-12-19 |
| 2 | 2222 | SonyEricssonK750c | 2007-12-19 |
| 3 | 2222 | MAUI WAP Browser | 2007-12-19 |
| 4 | 2222 | Nokia3108 | 2007-12-19 |
| 5 | 2222 | LENOVO-I750 | 2007-12-19 |
| 6 | 2222 | BIRD_D636 | 2007-12-19 |
| 7 | 2222 | SonyEricssonS500c | 2007-12-19 |
| 8 | 2222 | SAMSUNG-SGH-E258 | 2007-12-19 |
| 9 | 2222 | NokiaN73-1 | 2007-12-19 |
| 10 | 2222 | Nokia2610 | 2007-12-19 |
+—-+——-+——————-+————+
10 rows in set (2 min 58.56 sec) client3:
mysql> update gz_phone set phone=’55555′ where id=1;
Query OK, 1 row affected (3 min 50.16 sec)
Rows matched: 1 Changed: 1 Warnings: 0
说明当数据表有一个写锁时，其它进程的读写操作都需等待读锁释放后才会执行。

3、并发插入
原则上数据表有一个读锁时，其它进程无法对此表进行更新操作，但在一定条件下，MyISAM表也支持查询和插入操作的并发进行。
MyISAM存储引擎有一个系统变量concurrent_insert，专门用以控制其并发插入的行为，其值分别可以为0、1或2。
a、当concurrent_insert设置为0时，不允许并发插入。
b、当concurrent_insert设置为1时，如果MyISAM表中没有空洞（即表的中间没有被删除的行），MyISAM允许在一个进程读表的同时，另一个进程从表尾插入记录。这也是MySQL的默认设置。
c、当concurrent_insert设置为2时，无论MyISAM表中有没有空洞，都允许在表尾并发插入记录。

4、MyISAM的锁调度
由于MySQL认为写请求一般比读请求要重要，所以如果有读写请求同时进行的话，MYSQL将会优先执行写操作。这样MyISAM表在进行大量的更新操作时（特别是更新的字段中存在索引的情况下），会造成查询操作很难获得读锁，从而导致查询阻塞。
我们可以通过一些设置来调节MyISAM的调度行为：
a、通过指定启动参数low-priority-updates，使MyISAM引擎默认给予读请求以优先的权利。
b、通过执行命令SET LOW_PRIORITY_UPDATES=1，使该连接发出的更新请求优先级降低。
c、通过指定INSERT、UPDATE、DELETE语句的LOW_PRIORITY属性，降低该语句的优先级。
上面3种方法都是要么更新优先，要么查询优先的方法。这里要说明的就是，不要盲目的给mysql设置为读优先，因为一些需要长时间运行的查询操作，也会使写进程“饿死”。只有根据你的实际情况，来决定设置哪种操作优先。这些方法还是没有从根本上同时解决查询和更新的问题。
在一个有大数据量高并发表的mysql里，我们还可采用另一种策略来进行优化，那就是通过mysql主从（读写）分离来实现负载均衡，这样可避免优先哪一种操作从而可能导致另一种操作的堵塞。下面将用一个篇幅来说明mysql的读写分离技术。

相关文章

• 2012-02-22 -- mysql-锁表机制分析

相关文章

• 2012-02-13 -- 类型转换对 MySQL 选择索引的影响
• 2010-09-27 -- 冗余索引对查询效率的影响
• 2010-03-09 -- Innodb 表和索引结构
• 2009-11-18 -- Memory & MyISAM 引擎小注意！
• 2009-09-13 -- Mysql combine index
• 2009-07-17 -- 查看索引使用情况
• 2009-07-15 -- memory型表支持Hash索引
• 2009-06-30 -- mysql索引简单介绍
• 2009-05-01 -- mysql索引的一个技巧
• 2009-02-10 -- MySQL里建立索引应该考虑数据库引擎的类型

相关文章

• 2012-02-22 -- MyISAM和InnoDB的不同优化
• 2009-07-13 -- MyISAM和InnoDB的插入性能测试
• 2008-10-14 -- MySQL中MyISAM引擎与InnoDB引擎性能简单测试
• 2008-10-14 -- MyISAM和InnoDB的异同
• 2012-03-25 -- MySQL 5.0 5.1 下InnoDB的预热方法
• 2012-03-25 -- 测试快速关闭innodb的方法
• 2012-03-25 -- MySQL5.1 InnoDB Plugin 启动信息详解 以及与MySQL5.0的InnoDB启动信息对比
• 2012-03-25 -- 安装mysql with innodb 支持，支持事务的mysql
• 2011-07-22 -- “ERROR 1235 (42000): skip-innodb is defined”的误导
• 2011-03-30 -- InnoDB的多版本一致性读的实现

这个在镜像库部署的时候，会经常发现开发人员查一下没用索引的语句或者没有limit n的语句，这些没语句会对数据库造成很大的影响，例如一个几千万条记录的大表要全部扫描，或者是不停的做filesort，对数据库和服务器造成io影响等。这是镜像库上面的情况。

而到了线上库，除了出现没有索引的语句，没有用limit的语句，还多了一个情况,mysql连接数过多的问题。说到这里，先来看看以前我们的监控做法

1. 部署zabbix等开源分布式监控系统，获取每天的数据库的io，cpu，连接数

2. 部署每周性能统计，包含数据增加量，iostat，vmstat，datasize的情况

3. Mysql slowlog收集，列出top 10

以前以为做了这些监控已经是很完美了，现在部署了mysql节点进程监控之后，才发现很多弊端

第一种做法的弊端: zabbix太庞大，而且不是在mysql内部做的监控，很多数据不是非常准备，现在一般都是用来查阅历史的数据情况

第二种做法的弊端：因为是每周只跑一次，很多情况没法发现和报警

第三种做法的弊端: 当节点的slowlog非常多的时候，top10就变得没意义了，而且很多时候会给出那些是一定要跑的定期任务语句给你。。参考的价值不大

最后总结一下节点监控的好处

1． 轻量级的监控，而且是实时的，还可以根据实际的情况来定制和修改

2． 设置了过滤程序，可以对那些一定要跑的语句进行过滤

3． 及时发现那些没有用索引，或者是不合法的查询，虽然这很耗时去处理那些慢语句，但这样可以避免数据库挂掉，还是值得的

4.  在数据库出现连接数过多的时候，程序会自动保存当前数据库的processlist，DBA进行原因查找的时候这可是利器

5.  使用mysqlbinlog 来分析的时候，可以得到明确的数据库状态异常的时间段

相关文章

• 目前没有相关的文章