OurMySQL http://ourmysql.com 我们致力于一个MySQL知识的分享网站 Fri, 22 Jul 2011 05:49:35 +0000 en hourly 1 http://wordpress.org/?v=3.2.1 “ERROR 1235 (42000): skip-innodb is defined”的误导 http://ourmysql.com/archives/956 http://ourmysql.com/archives/956#comments Fri, 22 Jul 2011 05:49:35 +0000 OurMySQL http://ourmysql.com/?p=956 ERROR 1235 (42000): Cannot call SHOW because is defined

以上这个醒目错误提示，如果你是一个细心专业的DBA的话，可能这辈子你也遇到这样的问题，而我不是，毛躁马虎加上不专业，已经成了我的标签，所以，“幸运的”本人才遭遇到这个Error。究竟怎么一个动作导致出现这样的错误呢，下面简单描述下。

发现监控数据库的my.cnf中的关于Innodb的配置都保持默认状态，而之前只运行cacti倒是没有什么影响，它的表都是MyISAM的。因为前段采用了zabbix监控，而它的表都采用Innodb的表结构。其实，很多参数都可以在线调整，之后将变化的添加到my.cnf即可，无需修改my.cnf再重启mysqld，因为zabbix的信息收集量不小，导致binlog增长很快，磁盘容量报警，之前expire_log_days又设置为0。我觉得监控系统没必要开启binlog日志功能，所以想将log-bin注释掉不记录二进制日志，所以，必须要重启mysqld。在改动的这些参数里面，我调整了redo log的大小，将默认的10M增大到256M，也就是这么一改，重启后，扑哧让我惆怅了好一会。

当我执行show engine innodb status\G（现在我很喜欢看它的输出信息:-）之后，Error 1235就出现了，突然有点惊慌。刚开始我并没去查看error-log（这是一个非常不好的习惯，重启关闭mysqld是必须要tail -f error-log，确定正常关闭正常启动，是否有异常发生），而是跟着上面那个错误提示去找问题。风风火火的就去查看my.cnf里面是否有加skip-innodb，但是不可能呀，如果有那么之前zabbix的表也不会被创建为innodb类型的呀，后来查看error log才发现，是下面的原因导致的错误：

InnoDB: Error: log file /data/db/mysql/ib_logfile0 is of different size 0 10485760 bytes

InnoDB: than specified in the .cnf file 0 134217728 bytes!

这下明白了吧，接着我又执行show engines，发现Innodb的选项是disable的。怎么回事呢？我认为，当mysqld启动时，Innodb检查发现当前iblogfileX大小和配置文件中设置的不一致时，就会报错，但是mysqld仍然能够正常启动，但是Innodb会被自动skip掉。正常的操作应该是，首先正常关闭mysqld，然后将之前的iblogfile文件移走，最后在启动mysqld，初始化期间，如果发现iblogfile不存在会按照配置文件中指定大小重新创建一组新的。有时，以上这个错误的发生，不iblogfile的大小导致的，还可能是你的ibdata的大小问题导致的，Baron也遇到过上面的错误提示，就因为ibdata大小的设置问题。Innodb的加载是一个十分细致的过程，我们必须要谨慎小心。

这些都是不细心和操作不规范造成的；先想，记录，测试，线上，这才是一个专业负责任的做法，其实，这些田老师一开始就这么教给我，可我…都快一年了，还是没有养成这个良好的工作方式。

继续努力吧，我以不再年轻，差距还是很大。

相关文章

标签：, , ,
]]> http://ourmysql.com/archives/956/feed 2 Heartbeat+DRBD+MySQL Replication故障处理 http://ourmysql.com/archives/954 http://ourmysql.com/archives/954#comments Fri, 22 Jul 2011 05:46:51 +0000 OurMySQL http://ourmysql.com/?p=954 不久前的一次机房网络故障，再一次对我们在Heartbeat++MySQL数据库架构运维水平的一个考验，之前不止一次的测试与线上部署，还有之后大言不惭的关于该架构组件的所谓深入理解，在这一次不经意的意外面前又是“很囧”的收场，慌张呀！这次断网导致H-D-M全线异常，真是千载难逢，都让我们赶上啦lol: 下面就把这次的小幸运小幸福和大家分享下，以下是按照问题处理的先后顺序依次讲述。

- MySQL Replication同步异常

当发生网络故障一个小时后，从库io_thread和主库的连接被中断，抛出错误提示：[ERROR] Error reading packet from server: Client requested master to start from impossible position ( server_errno=1236)，没想到竟遇到了一个古董级的Bug，有点喜出望外了（心想，我也能遇到bug）。最后解决办法，只能拿备份重新做一遍主从。后来，好奇想查查，究竟是怎么导致这个问题，竟发现，从库relay log中的记录比主库binlog中的记录多了2条insert和1条update（0_0!!!…不合逻辑呀？！！）。

- DRBD状态异常

处理完数据库同步问题后，当时并没有去查看DRBD的状态，直到周一才发现出问题了，简单地通过命令cat /proc/drbd就可以查看，DRBD的状态是否正常。查看/var/log/messages知道网络故障导致DRBD发生脑裂，彼此都认为对方已经死了，然后自己都将角色作为Primary，并积极获取资源，当时的两端的连接状态都为StandAlone，角色都为Primary。在发生脑裂不久后原active node被heartbeat强制将系统重启，最后，原active node角色变为Secondary/Unknown，原standby node角色依然是脑裂时的Primary/Unknown，两端的连接状态，分别为WFConnection和StandAlone。解决方法如下：

Step 1 - On New Secondary:

# service stop

# service drbd stop

# drbdadm create-md r0

# service drbd start

# service heartbeat start

Step 2 – On New Primary:

# service drbd reload

之后就进入漫长数据同步阶段，重新将Primary上的数据块文件拷贝到Secondary上，最后完成同步。

- Heartbeat通信异常

通过查看/var/log/ha-dug日志，发现在出现网络故障后4分钟内，Heartbeat服务在active node与standby node间反复做资源释放与获取的操作，最后资源被之前的standby node获得，而之前的active node因为DRBD资源的问题，请求系统重启“CRIT: Resource STOP failure. Reboot required!”。系统重启后，Heartbeat服务并没有被开启，chkconfig里面没有把heartbeat设置为开机自启动，drbd是被设置开启自启的。其实，周日在处理问题时，没有考虑到heartbeat问题，理所当然的人为，资源是被正常切换，而认为heartbeat当时是正常（~脸红~:<太业余了…），更不好意思的是，周一发现heartbeat没有开启，我手动开启后，“习惯性”地依旧没有查看日志，就默认它了（唉…鄙视我吧！）。最后是在第3天，田老师检查整个系统，发现ha-dug里面警示异常提示。折腾了半天，最后等到晚上访问低谷的时候，采取了看上去不是方法的办法，解决如下：

# less /var/log/ha-dug      — 发现问题

On Active Node（之前的standby–>切换后active）:

WARN: Gmain_timeout_dispatch: Dispatch function for retransmit request took too long to execute: 390 ms (> 10 ms)

ERROR: Message hist queue is filling up (500 messages in queue)

On Standby Node（之前的active–>切换后standby）:

WARN: Rexmit of seq 17224382 requested. 41 is max.

在当前的active node上执行如下命令：

# top  — 注意有4个僵尸进程（zombie），同时会发现heartbeat的cpu使用达到100%左右

Tasks: 245 total,   2 running, 239 sleeping,   0 stopped,   4 zombie

PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND

2106 root      -2   0  422m 376m 4788 R 100.1  1.6   5002:17 heartbeat

# ps aux |grep defunct |grep -v grep   — 找出是哪4个僵尸进程

root     15678  0.0  0.0      0     0 ?        Z    10:57   0:00 [heartbeat] <defunct>

root     17932  0.0  0.0      0     0 ?        Z    13:48   0:00 [heartbeat] <defunct>

root     19176  0.0  0.0      0     0 ?        Z    Jul11   0:00 [] <defunct>

root     19626  0.0  0.0      0     0 ?        Z    Jul11   0:00 [heartbeat] <defunct>

既然，heartbeat服务有问题，那么很自然的就想到重启该服务，重启heartbeat是也会释放掉所有的资源的，会影响到正常业务，所以，选择到晚上闲时操作。出于安全为了不让资源切换到standby node上（其实，当时的情况heartbeat以及不能工作），我先停掉了standby node上的heartbeat，接着去停止active node上的服务，但是过了几分钟都没有相应，事实上，heartbeat的主进程已经僵死了，最后我“鼓足勇气”—kill -9 heartbeat-PID，然后先重启active node，再重启standby node，最后，查看日志一切都恢复正常了。之前，在做kill操作后，active node上的资源并没有释放，依然正常运行。
– — – END — – –
即便这次飞不小的劲，看似把问题都依依解决了，但心里依然没谱，对于之后可能发生的问题还是没有十足的把握；事实上，还是对于Heartbeat和DRBD技术本身，理解的不够透彻，Heartbeat对于资源的切换、检测后的判断以及对于日志输出的理解都还有很多疑惑，DRBD发生脑裂时资源争夺，会对数据块有多大影响，等等，所以就像田老师的感慨说的，我们之前做的仅仅就是能够把这个架构简单的打起来而已，根本谈不上专业的运维。

相关文章

标签：, , ,
]]> http://ourmysql.com/archives/954/feed 0 探索MYSQL源代码–添加一个函数 http://ourmysql.com/archives/947 http://ourmysql.com/archives/947#comments Tue, 19 Jul 2011 15:50:29 +0000 OurMySQL http://ourmysql.com/?p=947 我们来为MySQL添加一个函数，名为show disk_usage

mysql> show disk_usage;
+----------+-----------+
| Database | Size (Kb) |
+----------+-----------+
| test_row | 120400      |
+----------+-----------+
1 row in set (0.00 sec)

要修改新的函数，涉及到词法分析，我们先来修改sql/lex.h文件。
找到static SYMBOL symbols[] 这个结构体，添加一个”DISK_USAGE”这个词法，效果如下

{ "DISK",             SYM(DISK_SYM)},
/*start*/
{ "DISK_USAGE",       SYM(DISK_USAGE_SYM)},
/*end */
{ "DISTINCT",         SYM(DISTINCT)}

于是词法分析的时候会DISK_USAGE这个词法当做一个token转化为内部枚举DISK_USAGE_SYM。

有新的词法，我们为新词法添加新语法，我们来修改sql/yacc.yy文件。
来到token区域，添加一个token，名字于lex.h一样，这样语法分析器bison才能知晓词法分析器flex传过来的token对应的枚举。

%token  DISK_SYM
/*start*/
%token  DISK_USAGE_SYM
/*end*/
%token  DISTINCT

继续添加发现show disk_usage()语法匹配之后的行为
搜索关键字show: 添加新的行为

show:
        /*start*/
        SHOW DISK_USAGE_SYM
        {
                LEX *lex = Lex;
                _command = SQLCOM_SHOW_DISK_USAGE;
        }
        | /*end*/
        SHOW

到这里为止词法语法部分添加完毕。

SQLCOM_SHOW_DISK_USAGE产生什么效果呢，需要指向具体的函数。
在添加具体函数之前，还需要让SQLCOM_SHOW_DISK_USAGE成为一个合法的sql_command，我们需要修改sql/sql_lex.h。找到关键字enum enum_sql_command, 把SQLCOM_SHOW_DISK_USAGE作为一个enum添加进去

  SQLCOM_SHOW_PROFILE,
  SQLCOM_SHOW_PROFILES,
  /*start*/
  SQLCOM_SHOW_DISK_USAGE,
  /*end*/
  /*
    When a command is added here, be sure it's also added in mysqld.cc
    in "struct show_var_st _vars[]= {" ...
  */
  /* This should be the last !!! */
  SQLCOM_END
};

 

接着还要在sql/mysqld.cc 里再添加一遍， 找到关键字SHOW_VAR com_status_vars[]= {

  {"show_authors",         (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_AUTHORS]), SHOW_LONG_STATUS},
/*start*/
  {"show_disk_usage",      (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_DISK_USAGE]), SHOW_LONG_STATUS},
/*end*/
  {"show__events",   (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW__EVENTS]), SHOW_LONG_STATUS},

不添加这部会出现编译时的ASSERT错误。

接着把SQLCOM_DISK_USAGE指向具体函数， 修改sql/sql_parse.cc，关键字mysql_execute_command

  switch (lex->sql_command) {
/*start*/
  case SQLCOM_SHOW_DISK_USAGE:
        res = show_disk_usage_command(thd);
        break;
/*end*/
  case SQLCOM_SHOW_EVENTS:

好了终于指向了具体的函数show_disk_usage_command()，我们接着来实现这个函数。

在sql/mysql_priv.h添加一个申明

bool mysqld_help (THD *thd, const char *text);
/*start*/
bool show_disk_usage_command(THD *thd);
/* end */
void calc_sum_of_all_status(STATUS_VAR *to);

 

在sql/sql_show.cc添加一个具体的实现

bool show_disk_usage_command(THD *thd)
{
  DBUG_ENTER("show_disk_usage");
  List field_list;
  List dbs;
  Protocol *protocol = thd->protocol;

  /*set fields*/
  field_list.push_back(new Item_empty_string("Database", 50));
  field_list.push_back(new Item_empty_string("Size (Kb)", 30));

  if (protocol->send_fields(&field_list, Protocol::SEND_NUM_ROWS|Protocol::SEND_EOF))
    DBUG_RETURN(TRUE);

  /*set data*/
  protocol->prepare_for_resend();
  protocol->store("test_row", system_charset_info);
  protocol->store("1024000", system_charset_info);
  if (protocol->write())
    DBUG_RETURN(TRUE);

  my_eof(thd);
  DBUG_RETURN(FALSE);
}
/*end*/
bool mysqld_show_authors(THD *thd)

 

make clean; make;make install
好了，效果就可以看到了

mysql> show disk_usage;
+----------+-----------+
| Database | Size (Kb) |
+----------+-----------+
| test_row | 1024      |
+----------+-----------+
1 row in set (0.00 sec)

ps : 部分参考expert mysql
for douban: doubanclaimfdd64e647e42d240

 

相关文章

标签：, ,
]]> http://ourmysql.com/archives/947/feed 0 探索MYSQL源代码–添加一个VARIABLE http://ourmysql.com/archives/945 http://ourmysql.com/archives/945#comments Tue, 19 Jul 2011 15:48:25 +0000 OurMySQL http://ourmysql.com/?p=945 我们来为mysql添加一个variable, 名字是options_hoterrans，要达到的效果如下

mysql> show variables like '%hoterrans%';
+------------------+-------+
| _name    | Value |
+------------------+-------+
| options_hoterrans | 4     |
+------------------+-------+
1 row in set (0.00 sec)

 

mysql里的variable 有一部分是来自于my.cnf里的option。为了添加一个可配置的variale, 我们先来添加一个option, 名字是options_hoterran，没有s。

/mysqld.cc 查找关键字 my_long_options， 会找到一个很大的类型为my_options的结构体，这个结构体用于存储所有的long_options。
我们调到这个结构体的尾部，可以利用vim的{键。
在结构体的尾部有个哨兵，我们的选项就添加到哨兵的前面

struct my_option my_long_options[] =
....
  {"wait_timeout", OPT_WAIT_TIMEOUT,
   "The number of seconds the server waits for activity on a connection before closing it.",
   (uchar**) &global_system_variables.net_wait_timeout,
   (uchar**) &max_system_variables.net_wait_timeout, 0, GET_ULONG,
   REQUIRED_ARG, NET_WAIT_TIMEOUT, 1, IF_WIN(INT_MAX32/1000, LONG_TIMEOUT),
   0, 1, 0},
   /* start*/
  {"options_hoterran", OPT_HOTERRAN,
        "This is option just for test",
        (uchar**)  &global_system_variables.opt_hoterran,
        NULL,
        0, GET_ULONG,
        REQUIRED_ARG, 2, 1, 1000,
        0, 1, 0
  },                                        

   /* end */
  {0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}
};

/*start*/ /*end*/ 之间的就是我们所添加的代码，下同。

简单介绍一下my_option这个结构体

struct my_option
{
  const char *name;                     /* Name of the option */
  int        id;                        /* unique id or short option */
  const char *comment;                  /* option comment, for autom. --help */
  uchar      **value;                   /* The variable value */
  uchar      **u_max_value;             /* The user def. max variable value */
  struct st_typelib *typelib;           /* Pointer to possible values */
  ulong     var_type;
  enum get_opt_arg_type arg_type;
  longlong   def_value;                 /* Default value */
  longlong   min_value;                 /* Min allowed value */
  longlong   max_value;                 /* Max allowed value */
  longlong   sub_size;                  /* Subtract this from given value */
  long       block_size;                /* Value should be a mult. of this */
  void       *app_type;                 /* To be used by an application */
};

我们要注意其中2个字段， id：option的内部序列号; typelib:option的值指向了一个地址。
所以我们还需要添加这2个变量。

sql/mysqld.cc 里查找关键字enum options_mysqld，在这个枚举中我们添加一个枚举类型

   OPT_SLOW_QUERY_LOG_FILE,
+  /*rry start*/
+  OPT_HOTERRAN,
+  /*rry end*/
   OPT_IGNORE_BUILTIN_
 };

转到global_system_variables的类型system_variables定义处，sql/sql_class.h里。
在system_variables最末尾添加一个变量

  my_bool sysdate_is_now;
/*start*/
  u_long opt_hoterran;
/*end*/
};

目前为止，我们已经添加一个option, 你可以在my.cnf 添加

[mysqld]
....
options_hoterran=4

这个参数会被mysqld采用。

继续添加variable, 只要把上面的option与variable关联上即可。
打开sql/set_var.cc 文件，找到关键字net_wait_timeout, 修改后效果如下

 static sys_var_thd_ulong       sys_net_wait_timeout(&vars, "wait_timeout",
                                             &SV::net_wait_timeout);
+/*start*/
+static sys_var_thd_ulong        sys_opt_hoterran(&vars, "options_hoterrans",
+                                             &SV::opt_hoterran);
+/*end*/

这里是创建一个名为sys_opt_hoterran 的 sys_var_thd_ulong类，这个类的构造函数实际上就是在vars这个全局变量chain中添加一个名为options_hoterrans的variable。
SV就是上面options里的global_system_variables。

我们来看效果。

make&&make install

这里会比较慢，因为sql/sql_class.h 这个文件被修改了，而reference这个文件的target很多。

重启mysqld，mysql登上去

mysql> show variables like '%hoterrans%';
+-------------------+-------+
| Variable_name     | Value |
+-------------------+-------+
| options_hoterrans | 5     |
+-------------------+-------+
1 row in set (0.00 sec)

 

相关文章

标签：, ,
]]> http://ourmysql.com/archives/945/feed 0 探索MYSQL源代码–准备工作 http://ourmysql.com/archives/943 http://ourmysql.com/archives/943#comments Tue, 19 Jul 2011 15:46:20 +0000 OurMySQL http://ourmysql.com/?p=943 mysql源代码，编译的时候要注意添加如下选项，增加symbol

./configure --with-debug

 

使用git来查看自己对源代码做过的改动，方便发现代码的变化

sudo apt-get install  git-doc
sudo  apt-get install git-core

把mysql代码加入到git里

cd mysql-source
git init
git add *.h
git add *.c
git add *.cc

 

安装cscope，方便快速切换。
具体的步骤见这篇文章。
愿意的话可修改一下cscope.vim 文件里的nmap

nmap s :vert scs find s =expand("")
nmap g :vert scs find g =expand("")
nmap c :vert scs find c =expand("")
nmap t :vert scs find t =expand("")
nmap e :vert scs find e =expand("")
nmap f :vert scs find f =expand("")
nmap i :vert scs find i ^=expand("")$
nmap d :vert scs find d =expand("")

这样的好处就是ctrl+] 调到函数内部，ctrl+n+g 跳出垂直窗口显示代码

gdb调试会涉及到重复set args，我们可以利用gdb的macro-file来避免重复的输入。

涉及到多线程编程，为了让其他线程继续运行，需要设置
set scheduler-locking off

另外mysql对SIGINT设置了sigprocmask。启动mysqld时需设置参数–gdb

于是我们的macro-file就是

b main
r --user=mysql --gdb
set scheduler-locking off

 

开始debug

gdb mysqld -x macro-file

 

相关文章

标签：,
]]> http://ourmysql.com/archives/943/feed 0 探索MYSQL源代码–SQL历险记 http://ourmysql.com/archives/941 http://ourmysql.com/archives/941#comments Tue, 19 Jul 2011 15:44:21 +0000 OurMySQL http://ourmysql.com/?p=941 本文从一个select语句的执行过程出发, 遍历MySQL的多个几子系统.

先放图一张, 按图索骥开始我们的历险.

当客户端连接上MySQL服务端之后,发出请求之前,服务端的线程是阻塞在do_command（/parse.cc）里的my_net_read函数中(就是socket里的read).

当客户端键入sql语句(本文例子select * from zzz)发送到服务端之后, my_net_read返回, 并从tcpbuffer中读取数据写入到packet这个字符串.

packet_length= my_net_read(net);

packet的第一个字节是个标志位, 决定数据包是查询还是命令,成功,或者出错。
接下来就进入dispatch_command(sql/sql/parse.cc)这个函数, 数据类型不再需要.

return_value= dispatch_command(command, thd, packet+1, (uint) (packet_length-1));

进入dispatch_command, 我们可见

statistic_increment(thd->_var.questions, &amp;LOCK_);

这个就是show status questions的值累加.

接下的mysql_parse（sql/sql_parse.cc）, 该函数是sql语句解析的总路口.

进入该函数后首先碰到的是query_cache_send_result_to_client,故名思义这个函数是在QCache里查询是否有相同的语句, 有则立即从QCache返回结果, 于是整个sql就结束了.

QCache里不存在的sql则继续前进来到parse_sql(sql/sql_parse.cc),这个函数主要就是调用了MYSQLparse. 而MYSQLparse其实就是bison/yacc里的yyparse(^_^),

#define yyparse         MYSQLparse

是的开始解析sql了. 关于词法分析和语法匹配简单说几下.

对于一条像select * from zzz的语句首先进入词法分析,找到2个token(select, from), 然后根据token进行语法匹配, 规则在sql/yacc.yy里, 我把几个匹配到的pattern和action贴出来.

select:
          select_init
          {
            LEX *lex= Lex;
            lex->sql_command= SQLCOM_SELECT;
          }
        ;

/* Need select_init2 for subselects. */
select_init:
          SELECT_SYM select_init2
        | '(' select_paren ')' union_opt
        ;

select_paren:
          SELECT_SYM select_part2
          {
            LEX *lex= Lex;
            SELECT_LEX * sel= lex->current_select;
.....

select_from:
          FROM join_table_list where_clause group_clause having_clause
          opt_order_clause opt_limit_clause procedure_clause
          {
            Select->context.table_list=
              Select->context.first_name_resolution_table=
                (TABLE_LIST *) Select->table_list.first;
          }
....
select_item_list:
          select_item_list ',' select_item
        | select_item
        | '*'
          {
            THD *thd= YYTHD;
            Item *item= new (thd->mem_root)
                          Item_field(&amp;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 &lt; $3);

            if (add_item_to_list(thd, $2))
              MYSQL_YYABORT;
            if ($4.str)
...

可以看到action里最关键的就是add_item_to_list 和table_list的赋值.
解析后对于需要查询的表(zzz)和字段(*)这些信息都写入到thd->lex这个结构体里了.

例如其中thd->lex->query_tables就是表(zzz)的状况, thd->lex->current_select->with_wild 是表示该语句是否使用了*等等.

(gdb) p *thd->lex->query_tables
$7 = {next_local = 0x0, next_global = 0x0, prev_global = 0x855a458, db = 0x85a16b8 "test", alias = 0x85a16e0 "zzz",
  table_name = 0x85a16c0 "zzz", schema_table_name = 0x0, option = 0x0, on_expr = 0x0, prep_on_expr = 0x0, cond_equal = 0x0,

 

sql解析完了, 优化呢? 别急接着往下看.
接着进入mysql_execute_command函数，这个函数是所有sql命令的总入口.
由于是这个sql是一个select, 于是execute_sqlcom_select就是我们下个要执行的函数,又然后进入了mysql_select(^_^怒了如此复杂).

mysql_select 就是优化器的模块, 这个模块代码比较复杂. 我们可以清楚看到创建优化器，优化，执行的3个步骤, 优化细节不表.

if (!(join= new JOIN(thd, fields, select_options, result)))
...
if ((err= join->optimize()))
...
join->exec();

 

结束了优化，我们要具体执行join->exec()，该函数实际进入的是JOIN::exec()(sql_select.cc)。

exec()首先向客户端发送字段title的函数send_fields, 没数据但字段也是要的。

然后再进入do_select()，根据表的存储引擎跳入到引擎具体的实现(zzz是myisam表)。
这里mi_scan就是myisam引擎扫描文件的函数，再看到

(gdb) p info->filename
./test/zzz

这不就是zzz表对应的物理文件吗。

通过一系列的mi函数访问磁盘拿到数据之后，会通过send_data发送数据给client，并从dispatch_command返回.最后在net_end_statement结束整个sql。

一个简单的select语句背后的执行过程是非常复杂的，上面的步骤都只是点到就止。

ps: 在sql_yacc.yy可见MySQL对于Oracle中常用的dual表的嘲讽。

相关文章

标签：, ,
]]> http://ourmysql.com/archives/941/feed 0 探索MYSQL源代码-BINLOG里的时间 http://ourmysql.com/archives/939 http://ourmysql.com/archives/939#comments Tue, 19 Jul 2011 15:42:17 +0000 OurMySQL http://ourmysql.com/?p=939 今天在代码的时候无意中看到

void Item_func_now_local::store_now_in_TIME(MYSQL_TIME *now_time)
{
  THD *thd= current_thd;
  thd->variables.time_zone->gmt_sec_to_TIME(now_time,
                                             (my_time_t)thd->query_start());
  thd->time_zone_used= 1;
}

tem_func_sysdate_local::store_now_in_TIME(MYSQL_TIME *now_time)
{
  THD *thd= current_thd;
  thd->variables.time_zone->gmt_sec_to_TIME(now_time, (my_time_t) my_time(0));
  thd->time_zone_used= 1;
}

可以看到now()函数取的是这个语句执行开始时的时间

inline time_t query_start() { query_start_used=1; return start_time; }

而sysdate取得是执行到这个函数点的时间。

time_t my_time(myf flags __attribute__((unused)))
{
.....
  while ((t= time(0)) == (time_t) -1)
.....
}

所以就有了这个现象（当然别设置–sysdate-is-now ）

mysql> select sysdate(), sleep(3), sysdate();
+---------------------+----------+---------------------+
| sysdate()           | sleep(3) | sysdate()           |
+---------------------+----------+---------------------+
| 2011-03-07 15:02:48 |        0 | 2011-03-07 15:02:51 |
+---------------------+----------+---------------------+

基于statement ，源端的now(), sysdate() 等函数都是原封不动的传递到对端。
对端应用binlog的时候，sysdate()自然就会使用本地的时间，所以用sysdate()除了检测slave lag，没有别的用处， 还容易误用。

那么now() 是如何保证与源节点的时间一样呢？

通过mysqlbinlog可看到大量的set timestamp 语句。
每个event group 的最开始都会使用set timestamp来决定这次查询的开始点，而这个设置影响到group内的now()。

我们来看看set timestamp 的函数实现，从sql/_yacc.yy 的关键字set:出发，跳到sql/_parse.cc
的sql_set_variables, 再来到sql/set_var.cc的实现类

bool sys_var_timestamp::update(THD *thd,  set_var *var)
{
  thd->set_time((time_t) var->save_result.ulonglong_value);
  return 0;
}

转到set_time的实现sql/sql_class.h

class THD :public Statement,
           public Open_tables_state
{
.......
  inline void   set_time(time_t t)
  {
    start_time= user_time= t;
........

可以看到set timestamp 就是修改start_time, 而从上面的now()可以看到，now()取的就是start_time。
replication就是依靠存储在event里的set timestamp 来保证now函数的时间一致的。

ps: sysdate函数应该是源自于Oracle， dataguard是基于data block，进入block之前sysdate已经计算出写入，所以不存在这个问题。

 

相关文章

标签：, ,
]]> http://ourmysql.com/archives/939/feed 0 DROP TABLE AND LOCK_OPEN MUTEX http://ourmysql.com/archives/934 http://ourmysql.com/archives/934#comments Mon, 18 Jul 2011 15:55:47 +0000 OurMySQL http://ourmysql.com/?p=934 在Oracle中直接删除一张大表，会导致free extent 的enqueue，会导致buffer cache 的object purge，所以我们要有很多步骤，让删表变得不影响性能。

这方面MySQL目前没有好的方法。

MySQL中在对表进行drop table 命令，实际上调度的是mysql_rm_table_part2(/sql_table.cc)，其中有一段代码。

pthread_mutex_lock(&LOCK_open);
…..
error= ha_delete_table(thd, table_type, path, db, table->table_name,
….
pthread_mutex_unlock(&LOCK_open);

ha_delete_table 实际调用的是每个存储引擎对应的删除表的函数，这个函数不返回，LOCK_open 这个全局的mutex 要一直持有。

要知道LOCK_open是table_cache 的全局mutex，而任何和表相关的sql都会在open_table 这个函数中锁住这个全局的mutex，于是一个删表的操作会阻塞了所有的sql语句，碰到大表删除，show processlist 看到一堆的opening tables state。

同样的alter table 也会阻塞实例中所有的sql。

个人认为LOCK_open 这个全局的mutex粒度太粗了，应该细到每个表的table_cache上，这样drop、alter仅仅影响到该表的sql。

PS： MySQL 的worklog也提到了这个问题，说会在6.x改进。

 

相关文章

标签：, ,
]]> http://ourmysql.com/archives/934/feed 0 给PYTHON的MYSQLDB模块加功能 http://ourmysql.com/archives/932 http://ourmysql.com/archives/932#comments Mon, 18 Jul 2011 15:53:03 +0000 OurMySQL http://ourmysql.com/?p=932

使用Python操作MySQL数据库的时候常使用MySQLdb这个模块。

今天在开发的过程发现MySQLdb.connect有些参数没法设置。通过这个页面我们可以看到在connect的时候，可以设置的option和client_flags和MySQL c api相比差不少。

一个很重要的参数 MYSQL_OPT_READ_TIMEOUT没法设置，这个参数如果不设置，极致状况MySQL处于hang住，自动切换IP漂移，客户端无法重连到新MySQL。

给MySQLdb加Option很简单，只要修改_mysql.c这个把Python对象映射到MySQL操作的文件，添加参数，再加一段mysql_option即可。

下面是修改后的git diff 文件

?View Code BASH
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

diff --git a/_mysql.c b/_mysql.c
index d42cc54..61a9b34 100644
--- a/_mysql.c
+++ b/_mysql.c
@@ -489,9 +489,10 @@ _mysql_ConnectionObject_Initialize(
"named_pipe", "init_command",
"read_default_file", "read_default_group",
"client_flag", "ssl",
-                                 "local_infile",
+                                 "local_infile", "read_timeout",
NULL } ;
int connect_timeout = 0;
+       int read_timeout = 0;
int compress = -1, named_pipe = -1, local_infile = -1;
char *init_command=NULL,
*read_default_file=NULL,
@@ -500,7 +501,7 @@ _mysql_ConnectionObject_Initialize(
self-&gt;converter = NULL;
self-&gt;open = 0;
check_server_init(-1);
-       if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|ssssisOiiisssiOi:connect",
+       if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|ssssisOiiisssiOii:connect",
kwlist,
&amp;host, &amp;user, &amp;passwd, &amp;db,
&amp;port, &amp;unix_socket, &amp;conv,
@@ -509,7 +510,8 @@ _mysql_ConnectionObject_Initialize(
&amp;init_command, &amp;read_default_file,
&amp;read_default_group,
&amp;client_flag, &amp;ssl,
-                                        &amp;local_infile /* DO NOT PATCH FOR RECONNECT, IDIOTS
+                                        &amp;local_infile, &amp;read_timeout
+                                        /* DO NOT PATCH FOR RECONNECT, IDIOTS
IF YOU DO THIS, I WILL NOT SUPPORT YOUR PACKAGES. */
))
return -1;
@@ -540,6 +542,12 @@ _mysql_ConnectionObject_Initialize(
mysql_options(&amp;(self-&gt;connection), MYSQL_OPT_CONNECT_TIMEOUT,
(char *)&amp;timeout);
}
+
+        if (read_timeout) {
+                unsigned int timeout = read_timeout;
+                mysql_options(&amp;(self-&gt;connection), MYSQL_OPT_READ_TIMEOUT, (char *)&amp;timeout);
+        }
+
if (compress != -1) {
mysql_options(&amp;(self-&gt;connection), MYSQL_OPT_COMPRESS, 0);
client_flag |= CLIENT_COMPRESS;

代码修改完毕， setup.py install 即可，如果出现mysql_config找不到的问题。你还要修改setup_posix.py文件。

hoterran@hoterran-laptop:~/Projects/MySQL-python-1.2.3$ git diff setup_posix.py
diff --git a/setup_posix.py b/setup_posix.py
index 86432f5..f4f08f1 100644
--- a/setup_posix.py
+++ b/setup_posix.py
@@ -23,7 +23,7 @@ def mysql_config(what):
         if ret/256 &gt; 1:
             raise EnvironmentError("%s not found" % (mysql_config.path,))
     return data
-mysql_config.path = "mysql_config"
+mysql_config.path = "/usr/local/mysql/bin/mysql_config"

 def get_config():
     import os, sys

编译通过，我们来试试添加的read_timeout这个参数。

conn = .connect(host = DB_SERVER,user = DB_USERNAME,passwd = DB_PASSWORD,db = DB_NAME, port=int(DB_PORT), client_flag = 2, read_timeout = 10)

然后执行语句前，你试着把mysql用gdb hang住10s后，python就会异常抛错

OperationalError: (2013, 'Lost connection to MySQL server during query')
 >/home/hoterran/Projects/dbaas/trunk/dbtest.py(18)()
 >mydb.execute_(conn, )
(Pdb)
--Return--
> /home/hoterran/Projects/dbaas/trunk/dbtest.py(18)()-&gt;None
> mydb.execute_(conn, )
(Pdb)
OperationalError: (2013, 'Lost connection to MySQL server during query')
> <string>(1)<module>()->None

ps: 在_mysql.c找到一句很搞的话

/* DO NOT PATCH FOR RECONNECT, IDIOTS
IF YOU DO THIS, I WILL NOT SUPPORT YOUR PACKAGES. */

 

相关文章

标签：, , ,
]]> http://ourmysql.com/archives/932/feed 0 探索MYSQL源代码-在SHOW PROCESSLIST里添加字段 http://ourmysql.com/archives/930 http://ourmysql.com/archives/930#comments Mon, 18 Jul 2011 15:50:50 +0000 OurMySQL http://ourmysql.com/?p=930 show processlist是诊断MySQL常用的命令，它会列出THD对象里所有的线程当前状况。

下面将为show processlist添加一个新的列，表示当前连接查询之后返回的行数，字段名为my_row_count。

当你要修改一个命令的时候，最好从sql/_yacc.yy出发，根据命令的关键字语法匹配到后续的动作。打开sql/_yacc.yy后搜索关键字show:，就找到了所有show命令的语法规则。继续往下找就能看到，

| opt_full PROCESSLIST_SYM
{ Lex->sql_command= SQLCOM_SHOW_PROCESSLIST;}
| ....

找到了相应的sql命令SQLCOM_SHOW_PROCESSLIST，命令对应的行为呢？

我们来到sql/sql_parse.cc的dispatch_command函数，这是所有命令和查询的总路口，搜索关键字SQLCOM_SHOW_PROCESSLIST会发现，

case SQLCOM_SHOW_PROCESSLIST:
if (!thd->security_ctx->priv_user[0] && check_global_access(thd,PROCESS_ACL))
    break;
mysqld_list_processes(thd, (thd->security_ctx->master_access & PROCESS_ACL ? NullS :
thd->security_ctx->priv_user), lex->verbose);
break;

是的msyqld_list_processes就是服务端处理show processlist 的函数。如果你配置好cscope和ctag，这里就可以很方便的快速切换进入这个函数。

进入mysqld_list_processes（sql/sql_show.cc）之后，可以看到这个函数还是比较简单，先是往field_list插入一些item，这些item就是show processlist的字段title， 很熟悉把。这里我们添加一个字段名my_row_count。

field_list.push_back(field=new Item_empty_string("Info",max_query_length));
field->maybe_null=1;
/* start */
field_list.push_back(field=new Item_int("my_row_count", MY_INT32_NUM_DECIMAL_DIGITS));
field->maybe_null=1;
/* end */
if (protocol->send_fields(&field_list,
Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
DBUG_VOID_RETURN;

可以看到上面代码最后的send_fields就是把字段名发送给客户端。
接下来就是从tmp对象（THD）把内容复制给thd_info对象（thread_info）。

thd_info->query=(char*) thd->strmake(tmp->query,length);
}
/* start */
thd_info->my_row_count = tmp->my_row_count;
/* end */
pthread_mutex_unlock(&tmp->LOCK_thd_data);

接下来把thd_info 打包到protocol，随后就发送出去了。

protocol->store(thd_info->query, system_charset_info);
/*start*/
protocol->store((ulonglong) thd_info->my_row_count);
/*end*/
if (protocol->write())
 ....

好了show processlist 函数添加的新列就结束了。接下来我们要填充my_row_count的值， 这就涉及到为THD类的添加新的成员。

打开sql/sql_class.h,查找关键字sent_row_count，然后添加一个my_row_count成员。

ha_rows    sent_row_count;
/* start */
ha_rows  my_row_count;
/* end */

再打开sql/sql_class.cc 为my_row_count赋初值。

cuted_fields= sent_row_count= row_count=my_row_count =  0L;

接着在sql/sql_class.cc 为每次select进行累加，找到函数 bool select_send::send_data(List &items)

thd->sent_row_count++;
/* start */
thd->my_row_count++;
/* end */

好了，重新make &&sudo make install，这里花费时间比较长，因为sql_class被修改，很多lib、binary需要重新编译。

编译后就可以看到

mysql> show processlist;
+----+------+-----------------+------+---------+------+-------+------------------+--------------+
| Id | User | Host            | db   | Command | Time | State | Info             | my_row_count |
+----+------+-----------------+------+---------+------+-------+------------------+--------------+
|  3 | root | localhost:39325 | NULL | Query   |    0 | NULL  | show processlist |            3 |
+----+------+-----------------+------+---------+------+-------+------------------+--------------+
1 row in set (0.00 sec)

mysql> insert into test.dddd values(1);
Query OK, 1 row affected (0.10 sec)

mysql> select * from test.dddd;
+------+
| a    |
+------+
|    1 |
|    1 |
|    1 |
+------+
3 rows in set (0.00 sec)

mysql> show processlist;
+----+------+-----------------+------+---------+------+-------+------------------+--------------+
| Id | User | Host            | db   | Command | Time | State | Info             | my_row_count |
+----+------+-----------------+------+---------+------+-------+------------------+--------------+
|  3 | root | localhost:39325 | NULL | Query   |    0 | NULL  | show processlist |            6 |
+----+------+-----------------+------+---------+------+-------+------------------+--------------+
1 row in set (0.00 sec)

 

相关文章

标签：, ,
]]> http://ourmysql.com/archives/930/feed 0 探索MYSQL源代码-客户端连接过程和用户认证体系 http://ourmysql.com/archives/928 http://ourmysql.com/archives/928#comments Mon, 18 Jul 2011 15:48:50 +0000 OurMySQL http://ourmysql.com/?p=928 本文从源代码角度详细解释使用mysql客户端连上MySQL的服务端的过程以及通过用户认证的过程。

用户在客户端键入

mysql -h a.b.c.d -u root -pxxxx

最终都会调用到mysql_real_connect(/client.c的1856行的宏CLI_MYSQL_REAL_CONNECT)，我们从这个函数出发。

先上图

发件人 MySQL
  1. 客户端发起socket连接，等待三次握手的通过。
  2. 三次握手通过之后，客户端进入client_safe_read阻塞，同时服务端从handle_connection_sockets函数的select处返回，获知有新的连接。
  3. 服务端创建线程（这里就不说thread cache了），然后开始对这个连接进行校验。
  4. login_connection（sql/sql_connect.c）下的check_connection为的主校验函数。
  5. check_connection首先回调用acl_check_host(sql/sql_acl.cc) 判断该ip是否能够连接。
  6. acl_check_host依次查找2个对象来做判断：一个是动态数组acl_wild_hosts，另一个是hash表acl_check_hosts。
    7. VOID(my_init_dynamic_array(&amp;acl_wild_hosts,sizeof(struct acl_host_and_ip), acl_users.elements,1));
VOID(hash_init(&amp;acl_check_hosts,system_charset_info,acl_users.elements,0,0, (hash_get_key) check_get_key,0,0));

    这2个对象都是在mysqld启动的时候，通过init_check_host函数从mysq.users表里读出并加载的。
    其中acl_wild_hosts用于存放有统配符的主机，acl_check_hosts存放具体的主机。

  7. 通过acl_check_host校验后，来到create_random_string(sql/sql_connect.c)。这个函数随机的产生一个20字节的scramble串，用于接下来密码SHA1加密。
    8. (gdb) p thd-&gt;scramble
$3 = "p}DwPf4kCJ+8vk5cuD3q
  8. 服务端通过net_write_command函数把这个scramble以及当前的服务端版本发送给客户端，然后自己阻塞在my_net_read里，等待客户端的命令，这里的阻塞有个最小握手时间MIN_HANDSHAKE_SIZE。
  9. 客户端从cli_safe_read阻塞中返回，获知版本和scramble。进行版本匹配后，对输入的密码进行sha1加密（加密的公司后面详细说明），然后再发送给服务端。
  10. 服务端从my_net_read返回来，拿到登录的用户名和密码。
  11. 来到check_user(sql/sql_connect.c)函数，其中的acl_getroot是对密码进行了校验，关键函数是check_scramble。下面详细说明密码比较过程，伪代码方便理解。

    12. ===客户端的 scrabmle======
    password 来自于用户键入的密码
    scramble 来自于create_random_string 产生的20字节的随机字符
    reply 就是发送给服务端的加密密码

    scramble(password, scramble)
{
        hash_stage1 = sha1(password) 

        hash_stage2 = sha1(hash_stage1)

        to = sha1(scramble, hash_stage2)

        reply = xor(to, hash_stage1)
}

    ===服务端的check_scramble =====
    reply 来自于客户端发送的加密密码
    scramble create_random_string 产生的随机字符
    store_password 就是mysql.user 表的password的字段（password函数实际上进行了两次的sha1加密）

    check_scramble(reply, scramble, store_password)
{
        to = sha1(scramble, store_password)

        my_hash_stage1 = xor(to, reply)

        return store_password == sha1(my_hash_stage1)
}

    拿reply进行异或的逆运算得到sha1加密的密码，然后与数据库内的做比较。
    关键点就是异或的特点 A XOR B XOR B = A

  12. acl_getroot通过后，连接就通过了用户认证。
  13. 告知客户端认证正常，接下来的sql执行步骤可见我以前的博文

 

相关文章

标签：, , , ,
]]> http://ourmysql.com/archives/928/feed 0 MYSQL DAEMON PLUGIN EXAMPLE http://ourmysql.com/archives/925 http://ourmysql.com/archives/925#comments Mon, 18 Jul 2011 15:44:18 +0000 OurMySQL http://ourmysql.com/?p=925 5.1 版本开始MySQL开始支持plugin API，允许在mysqld运行时载入或者卸载组件，而不需要重启mysqld。

API涵盖了UDF、full-text、advanced schema等功能，其中的daemon plugin个人认为是非常的有用。其功能是在plugin载入后可以创建额外的后台线程于mysqld主线程一同协同工作。

plugin API的具体实现在sql/_plugin.h 和sql/_plugin.cc两个文件中。载入plugin使用dl_open系的动态加载共享库的方法打开so文件，获得需要执行的加载函数和卸载函数的指针。daemon plugin 的启动和storage plugin 启动一样，由init_server_components(/mysqld.cc) 里的plugin_init函数来启动。

开发的plugin的时候，只需要关心API接口文件include/plugin.h（我把mysql安装在/usr/local/mysql，所以这个文件在/usr/local/mysql/include/mysql/plugin.h），里面可以看到一些API函数和宏。

plugin的几个相关命令

show plugins 可查询系统内所有的激活的plugin，也包括storage plugin。

mysql>show plugins;
+------------+--------+----------------+--------------+---------+
| Name       |  | Type           | Library      | License |
+------------+--------+----------------+--------------+---------+
|      | ACTIVE | STORAGE ENGINE | NULL         | GPL     |
| CSV        | ACTIVE | STORAGE ENGINE | NULL         | GPL     |
| MEMORY     | ACTIVE | STORAGE ENGINE | NULL         | GPL     |
|      | ACTIVE | STORAGE ENGINE | NULL         | GPL     |
| MyISAM     | ACTIVE | STORAGE ENGINE | NULL         | GPL     |
| MRG_MYISAM | ACTIVE | STORAGE ENGINE | NULL         | GPL     |
+------------+--------+----------------+--------------+---------+

mysql.plugin 表也可以获得目前的plugin，但不包括storage plugin，加载错误的plugin也会包含在内，例如so不存在。

plugin_dir参数用于告知系统plugin的目录，这个参数必须在mysqld启动前指定，如果不设置，默认目录为/usr/local/mysql/lib/mysql/plugin/（/usr/local/mysql是我的MySQL安装目录）。

?View Code BASH
1
2
3
4
5
6

mysql&gt; show variables like 'plugin_dir';
+---------------+-------------------------+
| Variable_name | Value                   |
+---------------+-------------------------+
| plugin_dir    | /usr/local/mysql/plugin |
+---------------+------------------------

加载plugin

?View Code BASH
1

mysql&gt;INSTALL PLUGIN plugin_name SONAME 'plugin_library'

这里的plugin_name后面会讲到，plugin_library即为要加载的共享库so文件的名字，目录必须是上面的plugin_dir。

加载插件后，通过前面的show plugins、mysql.plugin 可以看到你的plugin。

卸载plugin

?View Code BASH
1

mysql&gt;UNINSTALL PLUGIN plugin_name

编写plugin

plugin模式的软件领域分明是oop继承、重载的用武之地，MySQL却使用了预编译宏和函数指针不是那么优雅的完成了这个任务（个人很喜欢这种方法，虽然代码丑陋了点）。另外说几句MySQL虽然看起来是c++写的，但实际上较少的使用c++的一些特性，只在内部几个模块用到模板类。跑题了，开始写plugin。

下面编写一个plugin，作用是加载后创建一个线程在后台持续的把MySQL内的一些信息打印到err.log日志。

首先介绍一下include/plugin.h里的st_mysql_plugin这个结构体，所有的plugin 都必须是基于这个结构体，填充必须的内容。

struct st_mysql_plugin
{
    int type;                    /* 插件类型，这里填MYSQL_DAEMON_PLUGIN 即可 */
    void *info;                 /* 插件类型描述符，对于daemon类来说没用，指向一个常量即可   */
    const char *name;          /* 插件名，这个就是前面的install 命令里的plugin_name  */
    const char *author;       /* 插件作者，随意 */
    const char *descr;        /* 插件描述，随意  */
    int license;                /* PLUGIN_LICENSE_GPL */
    int (*init)(void);           /* install 命令之后调用的函数 */
    int (*deinit)(void);       /* uninstall 命令之后调用的函数 */
    unsigned int version;     /* 插件版本，随意*/
    struct st_mysql_show_var   /* 指向的show_var，可不填*/
    struct st_mysql_sys_var     /* 指向的sys_var，可不填*/
    void * __reserved1;        /* 不填*/
};

声明plugin需要使用2个预编译宏，你可以在include/plugin.h 查看mysql_declare_plugin，mysql_declare_plugin_end两个宏的具体内容。

struct st_mysql_daemon monitor_plugin =
{
    MYSQL_DAEMON_INTERFACE_VERSION
};

mysql_declare_plugin(monitor_plugin)
{
    MYSQL_DAEMON_PLUGIN,
    &monitor_plugin,
    "monitor",
    "hoterran",
    "test",
    PLUGIN_LICENSE_GPL,
    monitor_plugin_init,
    monitor_plugin_deinit,
    0x0100,
    NULL,
    NULL,
    NULL,
}
mysql_declare_plugin_end;

结构体中的monitor_plugin_init和monitor_plugin_deinit就是接下来要编写的加载和卸载对应的函数。

下面是全部代码monitor.c

#include <string.h>
#include <unistd.h>
#include <stdio.h>
#include <plugin.h>
#include <mysql_version.h>
#include <my_global.h>
#include <my_sys.h>
#include <pthread.h>

extern ulong		thread_id;
extern uint		thread_count;
extern ulong		max_connections;

static pthread_t	G_thread;

pthread_handler_t func(void *p)
{
    while(1) {
         sleep(5);
         fprintf(stderr, "Thread id [%ld] Thread_count: %u Max_connections:%lu\n",
             thread_id, thread_count, max_connections);
         }
}

static int monitor_plugin_init(void *p)
{
    if (pthread_create(&amp;G_thread, NULL, func, NULL) != 0) {
        fprintf(stderr, "Monitor plugin init failure");
        return 1;
    }

    fprintf(stderr, "%s", "Monitor plugin init\n");
    return 0;
}

static int monitor_plugin_deinit(void *p)
{
    pthread_cancel(G_thread);
    pthread_join(G_thread, NULL);
    fprintf(stderr, "%s", "Monitor_plugin deinit\n");

    return 0;
}

struct st_mysql_daemon monitor_plugin =
{
    MYSQL_DAEMON_INTERFACE_VERSION
};

mysql_declare_plugin(monitor_plugin)
{
    MYSQL_DAEMON_PLUGIN,
    &monitor_plugin,
    "monitor",
    "hoterran",
    "test",
    PLUGIN_LICENSE_GPL,
    monitor_plugin_init,
    monitor_plugin_deinit,
    0x0100,
    NULL,
    NULL,
    NULL,
}
mysql_declare_plugin_end;

编译

?View Code BASH
1
2
3

gcc -g -Wall -I/usr/local/mysql/include/mysql -DMYSQL_DYNAMIC_PLUGIN   -c -o monitor.o monitor.c
gcc -shared -o libmonitor.so monitor.o
sudo cp libmonitor.so /usr/local/mysql/plugin/

加载

?View Code BASH
1
2

mysql&gt;install plugin monitor soname 'libmonitor.so';
Query OK, 0 rows affected (0.01 sec)

观察日志可以看到具体的输出。

?View Code BASH
1
2
3
4
5
6
7
8

....
[New Thread 0xb4296b70 (LWP 3895)]
[New Thread 0xb1e34b70 (LWP 4042)]
Monitor plugin init
Thread id [2] Thread_count: 1 Max_connections:151
Thread id [2] Thread_count: 1 Max_connections:151
Thread id [2] Thread_count: 1 Max_connections:151
....
?View Code BASH
1
2
3
4
5
6
7
8
9
10
11
12
13
14

mysql&gt;show plugins;
+------------+--------+----------------+---------------+---------+
| Name       | Status | Type           | Library       | License |
+------------+--------+----------------+---------------+---------+
| monitor    | ACTIVE | DAEMON         | libmonitor.so | GPL     |
+------------+--------+----------------+---------------+---------+
 
mysql&gt; select * from mysql.plugin;
+------------+---------------+
| name       | dl            |
+------------+---------------+
....
| monitor    | libmonitor.so |
+------------+---------------+

好了，插件的编写工作就完成了，够简单吧。

在MySQL的附带demo里有个heartbeat的例子，MySQL的ref里面也有另外一个full-text的例子。

 

如何使用daemon plugin ，时还没想好，淘宝的同事 @ningoo有把zookeeper client 作为deamon plugin 想法。

 

相关文章

标签：,
]]> http://ourmysql.com/archives/925/feed 0 利用PLUGIN更快的添加STATUS VARIABLES http://ourmysql.com/archives/923 http://ourmysql.com/archives/923#comments Mon, 18 Jul 2011 15:39:10 +0000 OurMySQL http://ourmysql.com/?p=923 在MySQL里添加一个system、 variables的比较复杂的，需要修改sql/_show.cc，/mysqld.cc, 还要修改sql/_yacc.yy，然后重新编译等等，前面的文章可见其复杂度，很容易出错。

daemon 除了允许添加后台线程，也允许添加status，且不需要修改mysqld的代码。

#include <string.h>
#include <unistd.h>
#include <stdio.h>
#include <plugin.h>
#include <mysql_version.h>
#include <my_global.h>
#include <my_sys.h>
#include <pthread.h>

static int get_value(MYSQL_THD thd, struct st_mysql_show_var* var, char *buff) {
	struct st_mysql_show_var *status = (struct st_mysql_show_var*) buff;

	var->type = SHOW_ARRAY;
	var->value= (char* )status;

	status->value = "aaa";
	status->type = SHOW_CHAR;
	status->name = "test1";

	status++;
	status->name = 0;

	return 0;

}

struct st_mysql_daemon sys_status =
{
	MYSQL_DAEMON_INTERFACE_VERSION
};

static struct st_mysql_show_var sys_status_var[] =
{
	{"plugin_test", (char *)&get_value, SHOW_FUNC},
	{0, 0, 0}
};

mysql_declare_plugin(sys_status)
{
	MYSQL_DAEMON_PLUGIN,
	&sys_status,
	"sys_status",
	"hoterran",
	"test",
	PLUGIN_LICENSE_GPL,
	NULL,
	NULL,
	0x0100,
	sys_status_var,
	NULL,
	NULL,
}
mysql_declare_plugin_end;

上面添加了一个名字叫做plugin_test的status组，第一个status叫 plugin_test_test1，第二个status->name=0是个哨兵。

get_value(MYSQL_THD *thd, struct st_mysql_show_var* var, char* buff)，其中thd为线程THD类， var就是你要填充的内容， buff是预先分配好的1024字节的一个变量，你不需要另外malloc了。先把status的内容填充到buff里，再把status赋值到var->value，就算结束了。

例子里status->value只是简单赋值为”aaaa”，你要加工获得想获得你想要的信息。

编译、安装、加载同上一篇文章。最后的效果如下

mysql> show status like '%plugin_test_test1%';
+-------------------+-------+
| _name     | Value |
+-------------------+-------+
| plugin_test_test1 | aaa   |
+-------------------+-------+
1 row in set (0.00 sec)

 

相关文章

标签：, ,
]]> http://ourmysql.com/archives/923/feed 0 InnoDB的多版本一致性读的实现 http://ourmysql.com/archives/920 http://ourmysql.com/archives/920#comments Wed, 30 Mar 2011 05:56:37 +0000 OurMySQL http://ourmysql.com/?p=920

InnoDB是支持MVCC多版本一致性读的，因此和其他实现了MVCC的系统如Oracle，PostgreSQL一样，读不会阻塞写，写也不会阻塞读。虽然同样是MVCC，各家的实现是不太一样的。Oracle通过在block头部的事务列表，和记录中的锁标志位，加上回滚段，个人认为实现上是最优雅的方式。 而PostgreSQL则更是将多个版本的数据都放在表中，而没有单独的回滚段，导致的一个结果是回滚非常快，却付出了查询性能降低的代价。

InnoDB的实现更像Oracle，同样是将数据的旧版本存放在单独的回滚段中，但是也有不同。之前还以为整体实现都会跟Oracle不会有太大的出入，也一直没有太在意去看具体实现。今晚晚上下班准备回家时，刚好路过几个同事在交流分享这个问题，遇到一个疑问：

我们知道，InnoDB表会有三个隐藏字段，6字节的DB_ROW_ID，6字节的DB_TX_ID，7字节的DB_ROLL_PTR（指向对应回滚段的地址），这个可以通过innodb monitor看到，当然如果你熟悉innodb文件结构，也可以直接od ibd文件来验证。一致性读主要跟后两者有关系。InnoDB内部维护了一个递增的tx id counter，其当前值可以通过show engine status获得

echo "show engine innodb \G" | mysql -uroot | grep "Trx id counter"

假设有一个表，当前已经有两条记录。这时候我们开始一个实验，开启两个session，A和B，都设置autocommit=0

MySQL>set global autocommit=0;

T1时间：
A开始一个事务，执行一条select，可以看到已有的两条记录，show engine innodb status可以知道A的tx id，假设为7430
T2时间：
B开始一个事务，执行一条select，可以看到已有的两条记录，可以知道B的tx id，为7431
T3时间：
A中insert一条记录，此时A再select能看到，所以返回三条记录，而B无法看到，还是返回两条记录。
T4时间：
A中执行commit提交事务，分别在A和B中select，得到的结果和T3时间相同。

Ok，假设一致性读是根据事务先后，也就是tx id来比较的话，如果B事务的一致性读是通过B的tx id即7431来和A事务中insert的这条记录的tx id即7430来比较的话，由于A.tx_id < B.tx_id，那么B应该能都到A的记录（tx id是递增的，所以越小说明事务越早开始），但如果能读到，则显然不符合多版本一致性。

因此结果是正确的，那么就是InnoDB的一致性读的实现方式不是像我们按照经验来测试的那样了。通过google和察看代码，原来InnoDB还真是有一个感觉上很山寨的设计，由于tx id是事务一开始就分配的，事务中的变化也没有记录一个类似于Oracle的SCN的逻辑时钟，于是由了如下的实现：

InnoDB每个事务在开始的时候，会将当前系统中的活跃事务列表（trx_sys->trx_list）创建一个副本（read view），然后一致性读去比较记录的tx id的时候，并不是根据当前事务的tx id，而是根据read view最早一个事务的tx id（read view->up_limit_id）来做比较的，这样就能确保在事务B之前没有提交的所有事务的变更，B事务都是看不到的。当然，这里还有个小问题要处理一下，就是当前事务自身的变更还是需要看到的。

有兴趣的可以去仔细看看代码的实现，在storage/innobase/read/read0read.c中实现了创建read view的函数read_view_open_now，在storage/innobase/include/read0read.ic中实现了判断一致性读是否可见的read_view_sees_trx_id。以下代码摘自5.5.8：

UNIV_INTERN
read_view_t*
read_view_open_now(
/*===============*/
	trx_id_t	cr_trx_id,	/*!< in: trx_id of creating
					transaction, or 0 used in purge */
	mem_heap_t*	heap)		/*!< in: memory heap from which
					allocated */
{
	read_view_t*	view;
	trx_t*		trx;
	ulint		n;
	ut_ad(mutex_own(&kernel_mutex));
	view = read_view_create_low(UT_LIST_GET_LEN(trx_sys->trx_list), heap);
	view->creator_trx_id = cr_trx_id;
	view->type = VIEW_NORMAL;
	view->undo_no = 0;
	/* No future transactions should be visible in the view */
	view->low_limit_no = trx_sys->max_trx_id;
	view->low_limit_id = view->low_limit_no;
	n = 0;
	trx = UT_LIST_GET_FIRST(trx_sys->trx_list);
	/* No active transaction should be visible, except cr_trx */
	while (trx) {
		if (trx->id != cr_trx_id
		    && (trx->conc_state == TRX_ACTIVE
			|| trx->conc_state == TRX_PREPARED)) {
			read_view_set_nth_trx_id(view, n, trx->id);
			n++;
			/* NOTE that a transaction whose trx number is <
			trx_sys->max_trx_id can still be active, if it is
			in the middle of its commit! Note that when a
			transaction starts, we initialize trx->no to
			IB_ULONGLONG_MAX. */
			if (view->low_limit_no > trx->no) {
				view->low_limit_no = trx->no;
			}
		}
		trx = UT_LIST_GET_NEXT(trx_list, trx);
	}
	view->n_trx_ids = n;
	if (n > 0) {
		/* The last active transaction has the smallest id: */
		view->up_limit_id = read_view_get_nth_trx_id(view, n - 1);
	} else {
		view->up_limit_id = view->low_limit_id;
	}
	UT_LIST_ADD_FIRST(view_list, trx_sys->view_list, view);
	return(view);
}
UNIV_INLINE
ibool
read_view_sees_trx_id(
/*==================*/
	const read_view_t*	view,	/*!< in: read view */
	trx_id_t		trx_id)	/*!< in: trx id */
{
	ulint	n_ids;
	ulint	i;
	if (trx_id < view->up_limit_id) {
		return(TRUE);
	}
	if (trx_id >= view->low_limit_id) {
		return(FALSE);
	}
	/* We go through the trx ids in the array smallest first: this order
	may save CPU time, because if there was a very long running
	transaction in the trx id array, its trx id is looked at first, and
	the first two comparisons may well decide the visibility of trx_id. */
	n_ids = view->n_trx_ids;
	for (i = 0; i < n_ids; i++) {
		trx_id_t	view_trx_id
			= read_view_get_nth_trx_id(view, n_ids - i - 1);
		if (trx_id <= view_trx_id) {
			return(trx_id != view_trx_id);
		}
	}
	return(TRUE);
}

参考：
http://dev.mysql.com/doc/refman/5.1/en/innodb-multi-versioning.html
http://wangyuanzju.blog.163.com/blog/static/130292009107101544125/
http://bbs.chinaunix.net/thread-1773206-1-1.html

相关文章

标签：, ,
]]> http://ourmysql.com/archives/920/feed 1 PHP查询MySQL大量数据的内存占用分析 http://ourmysql.com/archives/917 http://ourmysql.com/archives/917#comments Thu, 24 Feb 2011 05:32:58 +0000 OurMySQL http://ourmysql.com/?p=917 这篇文章主要是从原理, 手册和源码分析在PHP中查询MySQL返回大量结果时, 内存占用的问题, 同时对使用MySQL C API也有涉及.

昨天, 有同事在PHP讨论群里提到, 他做的一个项目由于MySQL查询返回的结果太多(达10万条), 从而导致PHP内存不够用. 所以, 他问, 在执行下面的代码遍历返回的MySQL结果之前, 数据是否已经在内存中了? -

while ($row = mysql_fetch_assoc($result)) {
    // ...
}

当然, 这种问题有许多优化的方法. 不过, 就这个问题来讲, 我首先想到, MySQL是经典的C/S(Client/Server, 客户端/服务器)模型, 在遍历结果集之前, 底层的实现可能已经把所有的数据通过网络(假设使用TCP/IP)读到了Client的缓冲区, 也有另一种可能, 就是数据还在Server端的发送缓冲区里, 并没有传给Client.

在查看PHP和MySQL的源码之前, 我注意到PHP手册里有两个功能相近的函数:

mysql_query()
mysql_unbuffered_query()

两个函数的字面意思和说明证实了我的想法, 前一个函数执行时, 会把所有的结果集从Server端读到Client端的缓冲区中, 而后一个则没有, 这就是”unbuffered(未缓冲)”的意思.

那就是说, 如果用mysql_unbuffered_query()执行了一条返回大量结果集的SQL语句, 在遍历结果之前, PHP的内存是没有被结果集占用的. 而用mysql_query()来执行同样的语句的话, 函数返回时, PHP的内存占用便会急剧增加, 立即耗光内存.

如果阅读PHP的相关代码, 可以看到这两个函数的实现上的异同:

/* {{{ proto resource mysql_query(string query [, int link_identifier])
   Sends an  query to MySQL */
PHP_FUNCTION(mysql_query)
{
    php_mysql_do_query(INTERNAL_FUNCTION_PARAM_PASSTHRU, MYSQL_STORE_RESULT);
}
/* }}} */

/* {{{ proto resource mysql_unbuffered_query(string query [, int link_identifier])
   Sends an SQL query to MySQL, without fetching and buffering the result rows */
PHP_FUNCTION(mysql_unbuffered_query)
{
    php_mysql_do_query(INTERNAL_FUNCTION_PARAM_PASSTHRU, MYSQL_USE_RESULT);
}
/* }}} */

两个函数都调用了php_mysql_do_query(), 只差了第2个参数的不同, MYSQL_STORE_RESULT和MYSQL_USE_RESULT. 再看php_mysql_do_query()的实现:

if(use_store == MYSQL_USE_RESULT) {
    mysql_result=mysql_use_result(&mysql->conn);
} else {
    mysql_result=mysql_store_result(&mysql->conn);
}

mysql_use_result()和mysql_store_result()是MySQL的C API函数, 这两个C API函数的区别就是后者把结果集从MySQL Server端全部读取到了Client端, 前者只是读取了结果集的元信息.

回到PHP, 使用mysql_unbuffered_query(), 可以避免内存的立即占用. 如果在遍历的过程不对结果进行”PHP缓存”(如放到某数组中), 则整个执行过程虽然操作了十万条或者百万条或者更多的数据, 但PHP占用的内存始终是非常小的.

相关文章

标签：, , ,
]]> http://ourmysql.com/archives/917/feed 1 数据库设计范式的理解 http://ourmysql.com/archives/915 http://ourmysql.com/archives/915#comments Mon, 21 Feb 2011 02:49:04 +0000 OurMySQL http://ourmysql.com/?p=915 前言
为什么要写这篇文章呢，从去年年底开始，就和很多做技术的朋友交流过，从数据库设计到数据库架构各个方面的内容。有一些朋友执着于ORM，执着于所谓的数据库设计，却忘记了一切技术是要为业务服务这个基石。当然这文章里也有一些自己的理解，想向大家表达。

范式是什么
范式是符合某一种级别的关系模式的集合。关系数据库中的关系必须满足一定的要求，即满足不同的范式。目前关系数据库有六种范式：第一范式（1NF）、第二范式（2NF）、第三范式（3NF）、第四范式（4NF）、第五范式（5NF）和第六范式（6NF）。满足最低要求的范式是第一范式（1NF）。在第一范式的基础上进一步满足更多要求的称为第二范式（2NF），其余范式以次类推。一般说来，数据库只需满足第三范式（3NF）就行了。

范式的原理

  • 第一范式（1NF）无重复的列所谓第一范式（1NF）是指数据库表的每一列都是不可分割的基本数据项，同一列中不能有多个值，即实体中的某个属性不能有多个值或者不能有重复的属性。如果出现重复的属性，就可能需要定义一个新的实体，新的实体由重复的属性构成，新实体与原实体之间为一对多关系。在第一范式（1NF）中表的每一行只包含一个实例的信息。简而言之，第一范式就是无重复的列。

    说明：在任何一个关系数据库中，第一范式（1NF）是对关系模式的基本要求，不满足第一范式（1NF）的数据库就不是关系数据库。

  • 第二范式（2NF）属性完全依赖于主键[消除部分子函数依赖]第二范式（2NF）是在第一范式（1NF）的基础上建立起来的，即满足第二范式（2NF）必须先满足第一范式（1NF）。第二范式（2NF）要求数据库表中的每个实例或行必须可以被惟一地区分。为实现区分通常需要为表加上一个列，以存储各个实例的惟一标识。

    例如员工信息表中加上了员工编号（emp_id）列，因为每个员工的员工编号是惟一的，因此每个员工可以被惟一区分。这个惟一属性列被称为主关键字或主键、主码。

    第二范式（2NF）要求实体的属性完全依赖于主关键字。所谓完全依赖是指不能存在仅依赖主关键字一部分的属性，如果存在，那么这个属性和主关键字的这一部分应该分离出来形成一个新的实体，新实体与原实体之间是一对多的关系。为实现区分通常需要为表加上一个列，以存储各个实例的惟一标识。简而言之，第二范式就是属性完全依赖于主键。

  • 第三范式（3NF）属性不依赖于其它非主属性[消除传递依赖]满足第三范式（3NF）必须先满足第二范式（2NF）。简而言之，第三范式（3NF）要求一个数据库表中不包含已在其它表中已包含的非主关键字信息。例如，存在一个部门信息表，其中每个部门有部门编号（dept_id）、部门名称、部门简介等信息。

    那么在的员工信息表中列出部门编号后就不能再将部门名称、部门简介等与部门有关的信息再加入员工信息表中。如果不存在部门信息表，则根据第三范式（3NF）也应该构建它，否则就会有大量的数据冗余。简而言之，第三范式就是属性不依赖于其它非主属性。

范式的说明

  • 第一范式：1NF是对属性的原子性约束，要求属性具有原子性，不可再分解；通俗的理解是字段还可以再分吗？如过不能，则是符合1NF的设计。
  • 第二范式：2NF是对记录的惟一性约束，要求记录有惟一标识，即实体的惟一性；简单的解释，比如你和一个女生约会建立一张表，不用每条约会记录都记录她的身高、体重，将身高体重单独的存在一张表中供查询即可。
  • 第三范式：3NF是对字段冗余性的约束，即任何字段不能由其他字段派生出来，它要求字段没有冗余。
    打个比方，比如评论表，如果你将用户ID，用户头像都放在这留言表中，就是不合适的了。用户头像是依赖于用户ID，而不依赖该评论。

我对范式的理解
一个严格恪守数据库设计范式来进行数据库设计的人，必定是个傻球；
一个没有研究过数据库设计范式就进行数据库设计的人，必定也是个傻球；

在现代数据库设计中，尤其是web 2.0的系统中的数据库设计，我可以断言，大多数都是违反2NF、3NF的，少数设计甚至是违反1NF的。数据库设计范式只是对数据库惯用设计的一些说明，并不能定性为标准。

而从数据库的发展来看，以MySQL举例，随着MySQL实现越来越多的功能，它的宣传材料上会越来越多的出现以前被MySQL所摒弃的复杂设计理念，并且宣称这是MySQL所独创或一贯倡导的。这是一个数据库系统发展所必然经历的过程。而这却会给MySQL的使用者以极大的误导，从而忽视了是否新特性是业务所真正需要的。

数据库设计不是一种编程语言这么简单，与面向对象、面向过程无关。数据库设计代表的是一种与应用开发语言完全不同的思想。现在绝大多数的程序，无论任何人采用什么方式进行程序开发，其最终还是会回归到对数据库的操作上（当然如果你的程序只是个教学演示则不在此范围内）。

数据库发展
各种缓存方案，说到底是以key为基础的数据解决方案，而数据库与应用层之间的中间件，为了实现逻辑的简单和高性能，更多的也会是基于key的实现。比如我所使用过的腾讯的TTC。

从下面的列表可以看出当前SNS的网站对于高并发、高性能的数据库解决方案有多么渴求，Facebook贡献了Cassandra、Linkedin贡献了Voldemort、mixi.jp贡献了Tokyo Cabinet和Tokoy Tyrant、green.jp贡献了Flare、甚至包括Google的BigTable。

总结
写到这里，我发现单单是这些新的数据库解决方案就有太多可写的内容，而这些已经超过了本文所要说明的主要内容，而现在所写的内容就全当是个引子吧，我写的很意犹未尽。后面会就反范式设计实例，内存缓存方案、NoSQL数据库等逐渐展开。

PS：这篇文章写的很杂乱，尤其是后面两端，见谅！

相关文章

  • 目前没有相关的文章
标签：,
]]> http://ourmysql.com/archives/915/feed 1 MySQL延时备份之实现 http://ourmysql.com/archives/912 http://ourmysql.com/archives/912#comments Mon, 21 Feb 2011 02:42:05 +0000 OurMySQL http://ourmysql.com/?p=912 在实际工作中,经常有一不小心误删除数据库或表而后悔莫及的事件发生,这有没有后悔药可吃呢？今天介绍的延时备份就可以做到。

延时备份让slave滞后于master一段时间,当你误操作时只要立即停止slave的同步,即可轻松地从延时备份库中找回你误删的数据。

下面介绍使用maatkit工具集中mk-slave-delay来实现延时备份。

1、     maatkit工具集简介

官方:http://www.maatkit.org/doc/

maatkit是一个包括多个实用MySQL的工具集，使用它们，可以让你的MySQL服务器使用起来更加方便也更加安全。maatkit是开源的软件,你可以自由的改进软件并将自己作出的改进版本向社会发行传播。

maatkit工具目前包含26个不同功能的工具。

主要有：

mk-archiver,mk-audit,mk-find,mk-kill,mk-,mk-query-digest,mk-parallel-dump,mk-parallel-restore,mk-show-grants ,mk-slave-delay,mk-slave-move,mk-slave-restart等工具。

顾名思义mk-slave-delay是延时备份工具。mk-slave-delay控制MySQL slave端，使它滞后于其master。

2、     maatkit安装

下载:http://code.google.com/p/maatkit/

安装步骤：

tar -zxf maatkit-<version>.tar.gz

cd maatkit-<version>

perl Makefile.PL

make install

###

# make install

….

Installing /usr/bin/mk-index-usage

Installing /usr/bin/mk-slave-delay

Installing /usr/bin/mk-archiver

Installing /usr/bin/mk-checksum-filter

Installing /usr/bin/mk-slave-prefetch

Installing /usr/bin/mk-log-player

Installing /usr/bin/mk-query-profiler

Installing /usr/bin/mk-slave-move

Installing /usr/bin/mk-query-digest

Installing /usr/bin/mk-show-grants

Installing /usr/bin/mk-parallel-restore

Installing /usr/bin/mk-profile-compact

Installing /usr/bin/mk-find

Installing /usr/bin/mk-table-checksum

Installing /usr/bin/mk-fifo-split

Installing /usr/bin/mk-error-log

Installing /usr/bin/mk-visual-explain

Installing /usr/bin/mk--advisor

Installing /usr/bin/mk-kill

Installing /usr/bin/mk-heartbeat

Installing /usr/bin/mk-purge-logs

Installing /usr/bin/mk-query-advisor

Installing /usr/bin/mk-parallel-dump

Installing /usr/bin/mk-merge-mqd-results

Installing /usr/bin/mk-duplicate-key-checker

Installing /usr/bin/mk-upgrade

Installing /usr/bin/mk-deadlock-logger

Installing /usr/bin/mk-slave-restart

Installing /usr/bin/mk-slave-find

Installing /usr/bin/mk-loadavg

Installing /usr/bin/mk-table-sync

3、     文档帮助

man /usr/bin/mk-slave-delay

/usr/bin/mk-slave-delay –help

4、     mk-slave-delay使用

示例：

mk-slave-delay –delay 1m –interval 15s –run-time 10m slavehost

延时运行10分钟，slave滞后master1分钟,15秒检查下次延时情况。

详细参数说明：

Usage: mk-slave-delay [OPTION...] SLAVE-HOST [MASTER-HOST]

Options:

–ask-pass            Prompt for a password when connecting to MySQL

–charset=s       -A  Default character set

–config=A            Read this comma-separated list of config files; if

specified, this must be the first option on the command

line

–[no]continue        Continue normally on exit (default yes)

–daemonize           Fork to the background and detach from the shell

–defaults-file=s -F  Only read mysql options from the given file

–delay=m             How far the slave should lag its master (default 1h).

Optional suffix s=seconds, m=minutes, h=hours, d=days;

if no suffix, s is used.

–help                Show help and exit

–host=s          -h  Connect to host

–interval=m          How frequently mk-slave-delay should check whether the

slave needs to be started or stopped (default 1m).

Optional suffix s=seconds, m=minutes, h=hours, d=days;

if no suffix, s is used.

–log=s               Print all output to this file when daemonized

–password=s      -p  Password to use when connecting

–pid=s               Create the given PID file when daemonized

–port=i          -P  Port number to use for connection

–quiet           -q  Don’t print informational messages about operation

–run-time=m          How long mk-slave-delay should run before exiting.

Optional suffix s=seconds, m=minutes, h=hours, d=days;

if no suffix, s is used.

–set-vars=s          Set these MySQL variables (default wait_timeout=10000)

–socket=s        -S  Socket file to use for connection

–use-master          Get positions from master, not slave

–user=s          -u  User for login if not current user

–version             Show version and exit

5、     延时原理

mk-slave-delay 定时地 starts /stops slave的sql_thread,以使其达到滞后master的目的。

2011-02-15T14:46:19 START SLAVE until master 2011-02-15T06:46:17 apollo226-bin.000290/779116659

2011-02-15T14:46:19 START SLAVE until master 2011-02-15T06:46:18 apollo226-bin.000290/781852897

6、     应用布署

脚本my_slave_delay.sh集中控制延时备份DB服务器.

服务器信息以host_ip port 的格式存在delay_host配置文件中。

head delay_host.txt

10.xx.xx.xxx 3601

usage1: sh my_slave_delay.sh

usage2: sh my_slave_delay.sh [delay_host] [delay] [interval]

my_slave_delay核心代码：

delay_host=$1

delay_host=${delay_host:-”delay_host.txt”}

delay=$2

delay=${delay:-”8h”}

interval=$3

interval=${interval:-”2m”}

log_file=”my_slave_delay.log”

my_slave_delay(){

cat $delay_host |grep -v ‘#’ | while read host port

do

echo ” /usr/bin/mk-slave-delay  -h $host -P $port –interval=$interval  –delay=$delay &”

echo ” /usr/bin/mk-slave-delay  -h $host -P $port –interval=$interval  –delay=$delay &”>>$log_file

/usr/bin/mk-slave-delay  -h $host -P $port –interval=$interval  –delay=$delay &

sleep 1

done

}

### 取消延时

my_slave_start(){

echo “my_slave_start”

ps aux |grep “mk-slave-delay -h” -i |grep -v “grep” |  awk ‘{print $2,$14,$16}’ | while read pid host port ;

do

echo “stop slave delay <$host:$port>”;

kill  -9 $pid

echo “slave start _thread <$host:$port>”

echo “slave start sql_thread;” | mysql -h $host -P$port -N

done;

echo “my_slave_start done.”

}

7、     参考

http://www.maatkit.org/doc/mk-slave-delay.html

相关文章

标签：, ,
]]> http://ourmysql.com/archives/912/feed 0 SQL到NOSQL的思维转变 http://ourmysql.com/archives/910 http://ourmysql.com/archives/910#comments Sun, 30 Jan 2011 03:00:44 +0000 OurMySQL http://ourmysql.com/?p=910 NOSQL系统一般都会宣传一个特性，那就是性能好，然后为什么呢？关系型数据库发展了这么多年，各种优化工作已经做得很深了，NOSQL系统一般都是吸收关系型数据库的技术，然后，到底是什么因素束缚了关系型数据库的性能呢？我们从系统设计的角度看这个问题。

1, 索引支持。关系型数据库创立之初没有想到今天的互联网应用对可扩展性提出如此高的要求，因此，设计时主要考虑的是简化用户的工作，SQL语言的产生促成数据库接口的标准化，从而形成了Oracle这样的数据库公司并带动了上下游产业链的发展。关系型数据库在单机存储引擎支持索引，比如Mysql的Innodb存储引擎需要支持索引，而NOSQL系统的单机存储引擎是纯粹的，只需要支持基于主键的随机读取和范围查询。NOSQL系统在系统层面提供对索引的支持，比如有一个用户表，主键为user_id，每个用户有很多属性，包括用户名，照片ID(photo_id)，照片URL，在NOSQL系统中如果需要对photo_id建立索引，可以维护一张分布式表，表的主键为<photo_id, user_id>形成的二元组。关系型数据库由于需要在单机存储引擎层面支持索引，大大降低了系统的可扩展性，使得单机存储引擎的设计变得很复杂。

2, 事务并发处理。关系型数据库有一整套的关于事务并发处理的理论，比如锁的粒度是表级，页级还是行级，多版本并发控制机制MVCC，事务的隔离级别，死锁检测，回滚，等等。然而，互联网应用大多数的特点都是多读少些，比如读和写的比例是10 : 1，并且很少有复杂事务需求，因此，一般可以采用更为简单的copy-on-write技术：单线程写，多线程读，写的时候执行copy-on-write，写不影响读服务。NOSQL系统这样的假设简化了系统的设计，减少了很多操作的overhead，提高了性能。

3, 动态还是静态的数据结构。关系型数据库的存储引擎总是一颗磁盘B+树，为了提高性能，可能需要有insert buffer聚合写，query cache缓存读，经常需要实现类似Linux page cache的缓存管理机制。数据库中的读和写是互相影响的，写操作也因为时不时需要将数据flush到磁盘而性能不高。简而言之，关系型数据库存储引擎的数据结构是通用的动态更新的B+树，然而，在NOSQL系统中，比如Bigtable中采用SSTable + MemTable的数据结构，数据先写入到内存的MemTable，达到一定大小或者超过一定时间才会dump到磁盘生成SSTable文件，SSTable是只读的。如果说关系型数据库存储引擎的数据结构是一颗动态的B+树，那么SSTable就是一个排好序的有序数组。很明显，实现一个有序数据比实现一个动态B+树且包含复杂的并发控制机制要简单高效地多。

4, Join操作。关系型数据库需要在存储引擎层面支持Join，而NOSQL系统一般根据应用来决定Join实现的方式。举个例子，有两张表：用户表和商品表，每个用户下可能有若干个商品，用户表的主键为<user_id, item_id>，用户和商品的关联属性存放在用户表中，商品表的主键为item_id，商品属性包括商品名，商品URL，等等。假设应用需要查询一个用户的所有商品并显示商品的详细信息，普通的做法是先从用户表查找指定用户的所有item_id，然后对每个item_id去商品表查询详细信息，即执行一次数据库Join操作，这必然带来了很多的磁盘随机读，并且由于Join带来的随机读的局部性不好，缓存的效果往往也是有限的。在NOSQL系统中，我们往往可以将用户表和商品表集成到一张宽表中，这样虽然冗余存储了商品的详细信息，却换来了查询的高效。

关系型数据库的性能瓶颈往往不在SQL语句解析上，而是在于需要支持完备的SQL特性。互联网公司面临的问题是应用对性能和可扩展性要求很高，并且DBA和开发工程师水平比较高，可以通过牺牲一些接口友好性来换取更好的性能。NOSQL系统的一些设计，比如通过宽表实现Join操作，互联网公司的DBA和开发工程师也做过，NOSQL系统只是加强了这种约束。从长远来看，可以总结一套约束集合，并且定义一个SQL子集，只需要支持这个SQL子集就可以在不牺牲可扩展性的前提下支持比如90%以上的互联网应用。我想，NOSQL技术发展到这一步的时候就算是比较成熟了，这也是我们最终想做的事情。我们在设计和使用NOSQL系统的时候也可以适当转化一下思维，如下：

1, 更大的数据量。很多人在使用Mysql的过程遇到记录条数超过一定值，比如2000W的时候，数据库性能开始下降，这个值的得出往往需要经过大量的测试。然而，大多数的NOSQL系统可扩展性都比较好，能够支持更大的数据量，因此也可以采用一些空间换时间的做法，比如通过宽表的方式实现Join。

2, 性能预估更加容易。关系型数据库由于复杂的并发控制，insert buffer及类似page cache的读写优化机制，性能估算相对较难，很多时候需要凭借经验或者经过测试才能得出系统的性能。然后，NOSQL系统由于存储引擎实现，并发控制机制等相对简单，可以通过硬件的性能指标在系统设计之处大致预估系统的性能，性能预估可操作性相对更强。

相关文章

标签：,
]]> http://ourmysql.com/archives/910/feed 0 处理Mysql的MySql-bin.0000X日志文件 http://ourmysql.com/archives/908 http://ourmysql.com/archives/908#comments Fri, 28 Jan 2011 08:30:09 +0000 OurMySQL http://ourmysql.com/?p=908 mysql运行一段时间后，在mysql目录下出现一堆类似 .000***，从mysql-bin.000001开始一直排列下来，而且占用了大量硬盘空间，高达几十个G.  对于这些超大空间 占用量的文件我们应该怎么办呢?
首先咱们来分析下mysql数据库文件夹中的mysql-bin.00001是什么文件？

mysql-bin.000001、mysql- bin.000002等文件是数据库的操作日志，例如UPDATE一个表，或者DELETE一些数据，即使该语句没有匹配的数据，这个命令也会存储到日志 文件中，还包括每个语句执行的时间，也会记录进去的。

任何处理呢？

/usr/local/mysql/bin/mysql -u root -p

输入密码登陆mysql后,运行命令:
reset master;

相关文章

标签：, , ,
]]> http://ourmysql.com/archives/908/feed 0 mysql unknown command ‘\”‘问题解决办法 http://ourmysql.com/archives/906 http://ourmysql.com/archives/906#comments Mon, 24 Jan 2011 08:22:13 +0000 OurMySQL http://ourmysql.com/?p=906 在还原备份数据库的时候，遇到一个问题。

原来的服务器环境使用的windows，然后使用mysqldump备份出来的数据库怎么也不能在linux下的数据库中导入。导入的时候总是出现：

unknown command ‘\”‘

于是将 \’ 全部替换成 ‘  结果还是不行，导入不了。

但是直接将数据库文件copy过去就可以用的。copy过去后在dump出来。结果还是一样的效果

unknown command ‘\”‘

郁闷至极。

经过多是导出导入发现，原来默认安装的mysql使用的是utf8编码，而我本机安装的是mysql gbk数据库。这样一来，备份文件恢复的时候可能就出现了格式错误。

后来在dump的时候指定字符集 mysqldump加个参数： -default-character-set=gbk，再次导入备份文件，一切顺利。

mysqldump -u root -p  –opt –allow-keywords –default-character-set=gbk databases > /PATH/XXX.

非默认字符集，在导入导出注意指定相应的字符集

相关文章

标签：,
]]> http://ourmysql.com/archives/906/feed 0