P.Linux Laboratory

MySQL多服务器批量执行SQL脚本

P.Linux — Wed, 10 Mar 2010 08:12:37 +0000

本文内容遵从CC版权协议, 可以随意转载, 但必须以超链接形式标明文章原始出处和作者信息及版权声明

网址: http://www.penglixun.com/work/program/mysql_bat_sql_script_mybatsql.html

主要应用场景是，假设我们有一个库DB进行了水平拆分，DB1~10都需要更改表结构，如果手动到各个服务器去执行，效率太低，写了个脚本来做这个事情，叫mybatsql。

用法很简单，需要两个文件，server.list和sql.list，跟脚本放在同一目录下。
server.list中放服务器的主机名/IP，用户名，密码；sql.list中放需要批量执行的SQL。
例如：
server.list

127.0.0.1,root,111
127.0.0.2,root,111

sql.list

show status;
show variables;

这两个文件表示，我要在127.0.0.1和127.0.0.2上执行show status;show variables;语句。

也可以通过参数-l/-s指定这两个文件的地址：perl mybatsql.pl -l server_server_file -s sql_file

Note: There is a file embedded within this post, please visit this post to download the file.

#!/usr/bin/perl -w
#######################################################
# Create: P.Linux
# Function: Run DDL On Server List
# Usage: Run on any computer with Perl
# License: GPL v2
# Site: PengLiXun.COM
# Modify: 
# P.Linux 2010-03-10 
#    -Create 1.0 Release
########################################################
use strict;
use DBI;
use DBD::mysql;
use Getopt::Std;
use vars qw($opt_l $opt_s);
########################################################
# Global Status Var
# 全局状态变量
my @server_list;
my $sql;
# Connect to database via DBI
# 通过DBI连接数据库
my @dbconn;
 
# CmdLine Option vars
# 命令行参数变量
my($server_file, $sql_file);
 
# Version
my $version='1.0 Release';
 
#######################################################
# Main Program
# 主程序
#######################################################
 
# Get CmdLine Options
# 获取命令行参数
&get_option();
 
# Read Server List From File
# 从文件中读取服务器列表
&read_file();
 
# Crate MySQL Database Connect
# 创建MySQL数据库连接
&create_conn();
 
# Run SQL
# 执行SQL
&run();
 
# Disconnect from MySQL
# 从数据库断开连接
&close_conn();
 
#######################################################
# Print Usage
# 打印使用方法
#######################################################
sub print_usage () {
        printf <<EOF
 NAME:
        mybatsql
 
 SYNTAX:
        mybatsql  -l server_server_file -s sql_file
 
 FUNCTION:
        Run SQL on Server List
 
 PARAMETER:
      -l   Database Server List File DEFAULT:server.list
      -s   SQL File DEFAULT:sql.list
EOF
}
 
#######################################################
# Get Options
# 获取命令行参数
#######################################################
sub get_option(){
    my $rtn = getopts('l:s');
    unless ( "$rtn" eq "1" ) { print_usage(); exit 1;}
 
    $server_file=$opt_l?$opt_l:'server.list';
    $sql_file=$opt_s?$opt_s:'sql.list';
 
    if($ARGV[0]){
        $server_file=$ARGV[0];
    }
    if($ARGV[1]){
        $sql_file=$ARGV[1];
    }
 
    $server_file = lc($server_file);
    $sql_file = lc($sql_file);
}
 
#######################################################
# Read Server List & SQL From File
# 从文件中读取服务器列表和SQL。
#######################################################
sub read_file{
    my $i;
 
    # Read Server List File
    open(FILE,"$server_file");
    $i = 0;
    while(){
        chomp;
        $server_list[$i] = [split(/,/,$_)];
	    $i++;
    }
    close(FILE);
    # Read SQL List File
    open(FILE,"$sql_file");
    $i = 0;
    $sql = '';
    while(){
	    chomp;
	    $sql .= $_;
	    $i++;
    }
    close(FILE);
}
 
#######################################################
# Create MySQL Database Connect 
# 创建MySQL数据库连接
#######################################################
sub create_conn{
    my $i = 0;
    foreach my $server (@server_list){
	    my @srv = @{$server};
	    my $host = $srv[0];
	    my $user = $srv[1];
	    my $pwd = $srv[2];
        #print "$host.$user.$pwd\n";
        eval{
            local $SIG{ALRM} = sub { die "连接数据库超时\n" };
            alarm 20;
            $dbconn[$i] = DBI->connect("DBI:mysql:host=$host", $user, $pwd, {'RaiseError' => 1}) 
            or die "Connect to $host error:". DBI->errstr;
            alarm 0;
        };   
        if($@){
            printf "Connect to $host database error:".$@."\n";
            exit;
        }
        $i++;
    }
}
 
#######################################################
# Main Program to Run SQL on Server List
# 在服务器列表上执行一组SQL
#######################################################
sub run{
    foreach my $conn (@dbconn) {
        #print $sql;
        $conn->do($sql); 
        $conn->commit(); 
    }
}
 
#######################################################
# Disconnect from MySQL
# 从数据库断开连接
#######################################################
sub close_conn(){
    foreach my $conn (@dbconn) {
        $conn->disconnect;
    }
}

类似的文章

2010年01月26日 -- 自己写的MySQL实时监控脚本–mystat (0)
2010年03月5日 -- MySQL的CAST和IFNULL函数的问题 (0)
2010年02月11日 -- InnoDB行锁的实现分析 (2)

数据库的拆分与合并

P.Linux — Tue, 09 Mar 2010 15:24:15 +0000

本文内容遵从CC版权协议, 可以随意转载, 但必须以超链接形式标明文章原始出处和作者信息及版权声明

网址: http://www.penglixun.com/work/database/split_and_merge_database.html

数据库每天都承受着数据量的增长，慢慢的我们发现，对数据库得访问变得非常慢了，这个时候，不外乎两种做法：一是增加单机的配置，升CPU升内存升硬盘；二是“脑裂”，把数据库拆成多份分开存放。
第二个思路必然是最终的方案，因为无论如何单机的承受能力是有限的，业务量的增长必然最终还是要走第二条路。
其实拆分，并不是一个难事，按主键水平拆分，按列垂直拆分，操作上都难，最难的问题是发生在合并的时候，尤其是需要排序的时候（数据库的GROUP/DISTINCT也是先排序做的），合并会变得很麻烦。
一个很糟糕的办法是，设置一台排序专用的机器，访问数据库通过这台机器，发现要排序了就在本地排序，把结果转发给客户端。并发量一大，这台排序用的机器就悲剧了。
第二个方法是，我们希望我们从各个分库中拿出的数据，本身就是按我们所要的方式排序的，数据路由只要组装数据即可，不需要再次排序。
这个如何实现呢，来举个例子，假设我们有个社区系统，有一张用户表U(U_ID,Info,Date)三个字段，分别是主键、信息、注册时间。有一张关系表R(U_ID_1,U_ID_2)，表示U_ID_1和U_ID_2是朋友。我们经常有这样的需求，想知道某个人有哪些朋友。
假设A和B是朋友，我们就在R表插入2条记录R(A,B),(B,A)，为什么要两条呢，数据冗余啦！不错，就是要冗余，冗余可以让后面的工作很Easy。
现在数据量大的惊人，要拆表！
假设业务需求如下：
1. 用户的U.Info查询很少，但是这个部分很长。
2. 经常用U.Date经常被用来排序。
3. 经常要知道某个人有哪些好友。
4. 凡是显示用户都按注册先后排序。

那么怎么拆捏，首先第一个需求，Info查询少，实际中这部分可能包含VARCHAR、TEXT等文本字段，最好需要把它们拆分出去，单独成表，可以提高效率，因为它们不常用。U被拆分为U(U_ID,Date)，U_Info(U_ID,Info)，U_Date(U_ID,Date)。为什么这样拆分？Date不是冗余了嘛，还是为了效率，制造冗余。
然后表怎么拆分呢，当然水平拆分，按ID？那要按Date排序的时候，就悲剧了，所以可以这么分：
U表按Date分区，U_ID建立索引；U_Info/U_Date表按U_ID分区。
这样分区什么好处？为了第2和4个需求，知道了要显示的用户ID列表，到U_Date去拿Date，然后到U表去访问，因为有拆分，所以到所需的时间范围所在的实例去读出新的ID序列，这样拿到的ID就是有序的，原来的ID可以抛弃了，用新的ID序列去拿可能需要的Info，这样取出的数据就是有序的。
然后R表怎么拆呢，很简单，按U_ID_1或者U_ID_2拆都可以，为什么？因为制造了冗余，两边都是对称的，从哪边取都能获得一个人的全部好友，所以就没关系了。
这样还是有一点不方便，拆分可能扩容，怎么办，不能每次都改程序吧？这好办建立1个分区路由表，记录下所有的分区信息，这样查询前先查分区表，再去相应的实例上取数据。

于是得到Schema的设计如下图：

当需要查询A用户的全部好友并且显示列表，再获取第一个好友的详细信息，我们就这么做：
1. 从Route路由表查找A用户所在实例名：SELECT instance FROM Route WHERE Start_ID >= A AND End_ID <=A AND Table = 'R'。
2. 拿到了Instance，就连接到相应的实例去：SELECT U_ID_2 FROM R WHERE U_ID_1 = 'A'。
3. 根据拿到的U_ID，再查所在的Instance，：ELECT instance FROM Route WHERE Start_ID >= u_id_2 AND End_ID <=u_id_2 AND Table = 'U_Date'。
4. 根据拿到的Instance，连接上去，去查U.Date：SELECT Date FROM R WHERE U_ID in (u_id_2)。
5. 有了U.Date，就可以到U去重新查询排序好的ID：SELECT U_ID FROM U WHERE Date in (date)；
6. 然后拿列表中的第一个ID，去取U.Info，查Instance：SELECT instance FROM Route WHERE Start_ID >= u_id AND End_ID <=u_id AND Table = ‘U_Info’。
7. 根据拿到的Instance，连上数据库去取Info：SELECT Info FROM U_Info WHERE U_ID = u_id；
所有任务完成，没有任何的排序产生。

这样大费周折值得吗，我觉得值得，当数据量大的惊人的时候，不可能在中间节点排序，只能是取出的数据就要有序，那么这种拆分思想，就是可以避免排序的。
有了思路，我会自己做一个小实验验证我的方法可行性和效率。

类似的文章

2010年02月3日 -- 列式数据库的简单分析 (1)
2009年12月8日 -- 今天的数据库设计培训 (4)
2009年08月20日 -- 关于VS2008与一些数据源配置的问题 (0)

数据库拆分 [Flickr]

P.Linux — Tue, 09 Mar 2010 07:22:07 PST

P.Linux posted a photo:

一个数据库拆分实验计划：http://www.penglixun.com/work/database/split_and_merge_database.html

每周推特 2010-03-09

P.Linux — Mon, 08 Mar 2010 17:00:00 +0000

本文内容遵从CC版权协议, 可以随意转载, 但必须以超链接形式标明文章原始出处和作者信息及版权声明

网址: http://www.penglixun.com/life/%e6%af%8f%e5%91%a8%e6%8e%a8%e7%89%b9-2010-03-09.html

没玩过这么好的服务器，还没反应过来就导完数据了 #
加班ing，今天没有晚餐票~哇呜~等待项目发布完吃个KFC去？犹豫中 #
项目发布完成，Oh,Yeah #
RT @anyshpm: @plinux 你用什么同步微博？//Twitter Tools #
@nzinfo 投资固定建设还能创造一点价值，如果是抄投资品，那就悲剧了，最终要么是价格松动带来抛售，要么是价格超越承受范围无人接盘还是会跌，这样的经济很危险。投资可以刺激经济，抄投资品没什么效果。 in reply to nzinfo #
昨天12点项目发布成功才睡，今天我竟然按时起床了，哈哈~ #
PostgreSQL的商业版EnterpriseDB是很有潜力的~ #
分析性能问题不是一门科学，而是一门艺术 #
一激动又买了300多块钱的书，4本MySQL的，1本Perl，要全面深入学习源代码 #
一份投诉信，IDC就乖了 #
RT @xuxuzoe: 有没有人跟我一样有文件夹和文件名整理强迫症？ {me,too} #
LARGE PAGE虽说会减少缺页中断，但是也会带来更多的内存浪费，适合大块数据的随机访问 #
大学学的理论还是有点用得，从操作系统原理来看一些性能数据，就清晰了 #
看完段页式管理和文件系统，大亮啊，睡觉 #

类似的文章

2010年03月7日 -- 每周推特 2010-03-07 (0)
2010年02月28日 -- 每周推特 2010-02-28 (0)
2010年02月21日 -- 每周推特 2010-02-21 (0)

当国家的经济指标被投资品绑架之后

P.Linux — Sun, 07 Mar 2010 14:32:21 +0000

本文内容遵从CC版权协议, 可以随意转载, 但必须以超链接形式标明文章原始出处和作者信息及版权声明

网址: http://www.penglixun.com/study/economic/china_economic_status.html

和阳哥聊天的时候，突然意识到这个问题。
一个正常的经济体系，经济的增长点应该是在消费上，消费产生需求，需求带动生产，生产产生价值，价值回馈消费者，消费者购买产品，消费用于再生产……这样一个循环是经济良性循环的增长点，经济的增量是依靠生产和消费来互相刺激的，具有很好的可持续性，因为只要有消费，就会有生产，这个作用是循环的，但本质上是消费刺激生产。
但是当一个经济体的主要组成部分是投资品之后，维护经济的增长就只能靠一个手段，投资品不断的升值，否则，经济会迅速下滑。原理很简单，投资品，它必须有投资价值，就是它的价值必然会上涨，如果不满足这个条件，资金就会从这个投资品中撤出，价格就会下跌，这个是连锁反应，在都想止损的情况下，一旦投资品价格下跌成定局，价格下泄速度将不可逆转。
如今中国的经济，就是彻底被投资品绑架了，当房屋从家的作用变成投资的作用，当这件投资品被当做经济的主要增长点，那么，要想经济量增长，就必须维持这件投资品的高位，并且给出上涨的趋势，否则，价值一旦松动，投资者必然转而投资其他有上涨趋势的产品，于是价值继续下跌，带动更多的抛售，抛售引起更大的下跌……进入一个恶性循环。
但投资品的价值总是有一个合理点，一旦远远超出了这个合理点，将无人接盘，没有买家接盘，就会失去市场，结果也是必然引起价值下降，一样的后果。
被投资品绑架的经济，我很担忧。

类似的文章

2009年12月16日 -- 最近又收到几个Offer (0)
2009年05月27日 -- 灰色系统在经济和行政决策方面的若干简单应用 (4)

把自己的小房间收拾好了

P.Linux — Sun, 07 Mar 2010 11:22:43 +0000

本文内容遵从CC版权协议, 可以随意转载, 但必须以超链接形式标明文章原始出处和作者信息及版权声明

网址: http://www.penglixun.com/life/diary/house_cleaned.html

昨天我买的书架和从学校快递过来的包裹都到了，晚上就组装了一下，把书整理了一下。
今天晚上再稍微打扫下，呵呵。
硬硬的床板终于有垫子了，厚被子也来了，哈哈~
今天睡得很舒服。

随机显示文章

工作环境 [Flickr]

P.Linux — Sun, 07 Mar 2010 03:10:38 PST

P.Linux posted a photo:

阿里技术，擎天一柱 [Flickr]

P.Linux — Sun, 07 Mar 2010 03:10:32 PST

P.Linux posted a photo:

运维之虎 [Flickr]

P.Linux — Sun, 07 Mar 2010 03:10:23 PST

P.Linux posted a photo:

书架1 [Flickr]

P.Linux — Sun, 07 Mar 2010 03:10:17 PST

P.Linux posted a photo:

每周推特 2010-03-07

P.Linux — Sun, 07 Mar 2010 04:00:00 +0000

本文内容遵从CC版权协议, 可以随意转载, 但必须以超链接形式标明文章原始出处和作者信息及版权声明

网址: http://www.penglixun.com/life/%e6%af%8f%e5%91%a8%e6%8e%a8%e7%89%b9-2010-03-07.html

抵杭 #
公司里江西人这么多 #
我已经成了公司宅 #
有点工作的感觉了 #
把博客从Linode上迁移出来了，VPS玩够了，等有人合租再买 #
RT @xiaolai: 直接用内嵌的英英词典吧。RT @BoJia: @xiaolai 笑来老师，灵格斯在Mac的最佳代替软件什么呀？ #
百阿的培训推迟了，估计新人不到岗都抽不出时间，现在才同时支持3个项目就要耗这么多时间 #
阳哥要来杭州了，以后周末就和阳哥一起学学高数和大物，准备和09级的小朋友们一起考试 #
RT @dyf101: RT @Fenng: 大赞央视春晚会最火爆的“吊带装”(组图) http://ent.enorth.com.cn/system/2010/03/05/004525143.shtml #
迁移了数据库发现这个版本的MYSQL支持CAST和IFNULL有问题…… #
mystat更新，支持windows，已经传到服务器上了。 #
到家了，悲剧，坐公司班车不认路 #
未来一周之内温度预计从零下二度飚升至二十六度，这就是南京的霸气！ #
貌似有下雪的迹象，下雪就去西湖看看 #
mixero这个客户端真不错 #
RT @DavidFeng: RT @36172417: 江西省宜春市的旅游政务网打出“宜春，一座叫春的城市”的宣传语，宝鸡市不服了，幸好没有宝鸭市，不然太热闹了。　//我老家，太操蛋了 #
到公司加班中~ #
@chndonny 的这三句话经典啊：“认为可能会出问题的事情，一定会出问题。
没有做过的事情，风险一定非常高。
着重沟通的细节，让部门间的合作更顺畅。” #
终于可以睡觉了，把书架组装起来了，不得不批评下商家的设计，组装书架耗掉我半条命 #

类似的文章

2010年03月9日 -- 每周推特 2010-03-09 (0)
2010年02月28日 -- 每周推特 2010-02-28 (0)
2010年02月21日 -- 每周推特 2010-02-21 (0)

mystat脚本更新Windows支持

P.Linux — Sat, 06 Mar 2010 07:04:31 +0000

本文内容遵从CC版权协议, 可以随意转载, 但必须以超链接形式标明文章原始出处和作者信息及版权声明

网址: http://www.penglixun.com/work/program/mystat_win_support.html

mystat脚本更新为1.1版本，加入了Windows下的支持。
主要因为Linux版本使用了Bash的彩色显示，所以到了Windows下这个就不兼容了，会看到Bash下控制颜色的代码被现实出来，很难看。
于是加入了操作系统的判断，Windows操作系统跳过颜色控制部分，Linux系统则显示。
然后加入了Inert/Update/Delete流量的实时监控。

Note: There is a file embedded within this post, please visit this post to download the file.

类似的文章

2010年02月5日 -- mystat 1.0 release 发布 (0)
2010年01月28日 -- mystat 0.5 beta 的使用介绍 (0)
2010年01月26日 -- 自己写的MySQL实时监控脚本–mystat (0)

MySQL的CAST和IFNULL函数的问题

P.Linux — Fri, 05 Mar 2010 14:38:31 +0000

本文内容遵从CC版权协议, 可以随意转载, 但必须以超链接形式标明文章原始出处和作者信息及版权声明

网址: http://www.penglixun.com/work/database/mysql_cast_ifnull_problem.html

关于MySQL的一个CAST和IFNULL函数诡异问题，不明原因，记录一下，明天继续分析。

这个是WP-PostView插件的一段SQL：

SELECT p.ID, p.post_title,
IFNULL( CAST( pm.meta_value AS UNSIGNED ) , 0 ) AS views
FROM wp_posts AS p
LEFT JOIN wp_postmeta AS pm ON pm.post_id = p.ID
AND pm.meta_key =  "views"
WHERE p.post_date <  "2010-03-05 22:19:55"
AND p.post_status =  "publish"
AND p.post_type =  "post"
AND p.post_password =  ""
ORDER BY views DESC LIMIT 5

在我的数据库上查询结果非常诡异：

ID post_title views
10 [论文]对简易几何机械化证明的进一步研究 9
32 页面总算基本修正好了 9
51 一个很好玩的钢琴Flash游戏 9
60 修改友情链接的排列方式 9
93 UML之父——Ivar Jacobson介紹SMART方法 9

选出来的views列全部是9，不知道为什么。

如果我去掉IFNULL，

SELECT p.ID, p.post_title, 
CAST( pm.meta_value AS UNSIGNED ) AS views
FROM wp_posts AS p
LEFT JOIN wp_postmeta AS pm ON pm.post_id = p.ID
AND pm.meta_key =  "views"
WHERE p.post_date <  "2010-03-05 22:19:55"
AND p.post_status =  "publish"
AND p.post_type =  "post"
AND p.post_password =  ""
ORDER BY views DESC

得到的结果将是对的，
如果去掉CAST，

SELECT p.ID, p.post_title, IFNULL( pm.meta_value, 0 ) AS views
FROM wp_posts AS p
LEFT JOIN wp_postmeta AS pm ON pm.post_id = p.ID
AND pm.meta_key =  "views"
WHERE p.post_date <  "2010-03-05 22:19:55"
AND p.post_status =  "publish"
AND p.post_type =  "post"
AND p.post_password =  ""
ORDER BY views DESC LIMIT 5

得到的就是错的，并且只有2位数一下的结果，2位数以上的结果出不来，但不是9或者99了。

明天继续分析这个问题。
暂时通过去掉IFNULL来解决。

类似的文章

2010年03月10日 -- MySQL多服务器批量执行SQL脚本 (0)
2010年02月11日 -- InnoDB行锁的实现分析 (2)
2010年02月5日 -- mystat 1.0 release 发布 (0)

CPU负载的分析

P.Linux — Wed, 03 Mar 2010 12:21:14 +0000

本文内容遵从CC版权协议, 可以随意转载, 但必须以超链接形式标明文章原始出处和作者信息及版权声明

网址: http://www.penglixun.com/work/maintenance/cpu_load_analyse.html

最近对我的本本（4核8线程）用top命令看系统状况出现了CPU利用率超过200%的情况，非常诧异，查了下相关资料，把这个问题弄清楚了。
首先来分析下CPU Load

load average: 0.09, 0.05, 0.01

分别是1分钟、5分钟、15分钟的平均Load。
Load这个东西怎么理解呢，就像一条马路，有N个车道，如果N个进程进入车道，那么正好一人一个，再多一辆车就占不到车道，要等有一个车空出车道。
在CPU中可以理解为CPU可以并行处理的任务数，那么就是“CPU个数 * 核数”，如果CPU Load = CPU个数 * 核数那么就是说CPU正好满负载，再多一点，可能就要出问题了，有任务不能被及时分配处理器，那么保证性能的话，最好是小于CPU个数 * 核数 *0.7。

查看CPU核数可以通过：grep ‘model name’ /proc/cpuinfo

那么以哪个平均值为准呢？如果1分钟平均出现大于CPU个数 * 核数的情况，还不用担心，如果5分钟平均也是，那就要警惕了，15分钟平均也是这样，就要分析哪里出问题了，防范于未然
CPU利用率超过100%的问题，也是差不多，top命令应该是把每个核的CPU占用率加起来，算一个和，于是多核情况下会出现超过100%。

另外Context Switch Rate也是个非常值得注意的值，因为线程间切换的代价也是非常高的。

引用一个公式：Context Switch Rate = Interrupt Rate + TPS* N

对于一个多线程的程序，我觉得准备一个控制线程来调度任务是非常必要的，免得线程过于高并发，导致资源的争用和线程切换带来性能问题，最好控制并发的线程数基本等于CPU的总核数，减少这个N，获得更好的处理器性能。

参考了如下几篇文章：
压力测试衡量CPU的三个指标：CPU Utilization、Load Average和Context Switch Rate
理解Load Average做好压力测试
 理解 Linux 的处理器负载均值
 高性能服务器架构

PS. 最近博客写得少，都要长草了。顺便赞一下阿里的食堂，比我们学校食堂四年不变菜饭还贵好多了。

随机显示文章

2009年03月5日 -- 页面总算基本修正好了 (2)
2009年10月11日 -- 有趣的相对论“悖论” (1)
2009年09月28日 -- DIV中RadioButtonList居中的问题 (0)

每周推特 2010-02-28

P.Linux — Sun, 28 Feb 2010 04:00:00 +0000

本文内容遵从CC版权协议, 可以随意转载, 但必须以超链接形式标明文章原始出处和作者信息及版权声明

网址: http://www.penglixun.com/life/%e6%af%8f%e5%91%a8%e6%8e%a8%e7%89%b9-2010-02-28.html

Discovery那位老头原来叫加来道雄，理论物理学家 #
论文看得好头痛 #
name.com注册的域名，修改了指向，很快就在DNS里更新，新网注册，改了2小时了没动静 #
测试了下MySQL使用索引的极限，如果使用索引无法筛掉80%左右的数据，MySQL会选择不走索引。还没有考虑索引长度的问题，明天继续搞清楚。 #
发现MySQL索引的长度对使用索引的决策影响不是特别大，测试了int/mediumint/smallint/tinyint/varchar，大约都是在剩下20%左右结果集的时候开始使用索引。 #
where+sort的情况，MySQL走错索引的概率很高。 #
mystat脚本就快完善了，Windows下也显示正常，只是无彩色。下一步转成Curses显示，就可以通用了。然后加入socket通讯函数，就可以做成在线呈现的了 #
学生就业搞不懂学校插个什么劲，非得掺和进来 #
明天的人工智能，God Bless，烦死了 #
从Gmail上Down课件，慢的要死，转发到QQ邮箱，下载飞速，我无语了，GFW发威了么 #
天将降大任于斯人也，必先苦其心志，劳其筋骨，饿其体肤，空伐其身，行弗乱其所为，所以动心忍性，曾益其所不能。再艰难也要挺过这段时期，曾益吾所不能。 #
百感交集的夜晚，要烦协议的事情，要安慰GF，还要备考明天的人工智能 #
GF终于睡觉去了，好好看书……博弈树Alpa/Beta剪枝其实蛮简单……代数合一就更简单了……关键要格式对，Prolog命中即终止匹配，期末这里悲剧了15分，不然就过了 #
看A*算法又看到了完备性的博弈，h(x)启发函数控制纵向扩展，速度快，这样可能使搜索不完备，g(x)代价值控制横向扩展，这样可以提高完备性，但效率低。f(x)=g(x)+h(x)就可以控制好横向和纵向的扩展方向，互相牵制。 #
在这个屁股决定脑袋的行政体系里，一切莫名其妙的事情都可能发生。 #
终于领略了3D电影，就是眼睛痛，人工只能Passed，又做完一件事 #

类似的文章

2010年03月9日 -- 每周推特 2010-03-09 (0)
2010年03月7日 -- 每周推特 2010-03-07 (0)
2010年02月21日 -- 每周推特 2010-02-21 (0)

每周推特 2010-02-21

P.Linux — Sun, 21 Feb 2010 04:00:00 +0000

本文内容遵从CC版权协议, 可以随意转载, 但必须以超链接形式标明文章原始出处和作者信息及版权声明

网址: http://www.penglixun.com/life/%e6%af%8f%e5%91%a8%e6%8e%a8%e7%89%b9-2010-02-21.html

看了看老外的设想，跟我们的设想几乎一致，每个有Wifi的手机，可以作为一个节点，既是客户端也是服务端，只要一个自组织网络里有一个手机能连上基站，或者互联网，那么基于P2P协议，网络内每个手机都可以连上。 #
当年自己掏了那么多钱去研究这个东西，在开发板上都做好了Demo，被狗P评委给Kill了，现在老外开始搞了，还拿到了300万美金的投资，这些狗P评委还有什么可说的，不就是为了保护中国移动之类的运营商可以肆无忌惮的剥削百姓么 #
@wolfdeng 可惜被挑战杯Kill了，参赛资格都没有，杯具 in reply to wolfdeng #
@yanzisky1989 我知道了…… in reply to yanzisky1989 #
@51isoft 好吧，评委想的比我们远…… in reply to 51isoft #
我选Linux发行版就是选包管理器，现在还是偏向于源码的包管理器，在ArchLinux和Gentoo中选 #
每次听到春晚歌颂党的歌，我就感到由衷的恶心，自己做的好，要人来唱干什么，老百姓心里自然会记得，对自己作恶想掩盖，才造出一堆的歌来歌颂自己，欲盖弥彰 #
@yanzisky1989 吃饭去了…… in reply to yanzisky1989 #
又看到金龟子了，我那时候天天看她主持节目，现在竟然还在主持～金龟子也是一代神器…… #
RT @tinyfool: RT @delphij: 某前同事MSN：身为一个技术人员,当不能用本职工作为公司创造生产力的时候,还可以以休年假的方法为公司增加利润 #
RT @hsin747: 在台灣，無論是陳水扁或馬英九都必需在過年期間發紅包給民眾，為何不見北京及香港領導人發紅包給市民呀？？ #
RT @ma_shao_bo: 来自推外的技术指导：纯从技术角度给各位光棍出个主意：给所有你认识的异性发个短信说“我喜欢你”，然后忍三个小时，从回短信里的人里挑一个，剩下的再发一个短信“不好意思，喝多了……”。搞定。 #
@Natural__Light 家里呆着 in reply to Natural__Light #
@wolfdeng 现在还是偏向Arch Linux，既有二进制也有源码分发包 in reply to wolfdeng #
EMS早就可以倒闭了，限时隔天件，第四天了还不到，没打我电话就说我不在 #
买个XV6800，跟卖家买的时候谈判有歧义，又被耍了，已经气的没气了，淘宝买个AA/AAA码上EVDO算了 #
RT @yxwlmxy: RT @yeka52: 姚滨一直是清高的，在最举步维艰的时候，他不抱怨，不指责任何人。他的原则是，有能耐你就挺住，做出成绩来给别人看。别人争利益，谈条件，他从来不争不抢。他是真的不屑，认为争那些不值。 #
被称为经济适用男 #
RT @newsinchina: 其实很多老人在事实举证上是根本无法说服年轻人接受他们那老朽的观点的,然后他们往往会以长者和权威的态度中止和你平等地讨论下去! #
才发现介川是浩二 #
点优酷看到一个视频，德国高速259辆车相撞，没死一个，伤66个，这车得啥质量呀……德国车威武 #
夜深人静是写技术博文的好时候 #
想把Wordpress换个简约点的主题，搞的跟个八卦博客一样 #
RT @Aro_Carter: RT @Z1scar:～RT @crystallys: RT @singinrain: RT @Mr_Lau: CCAV不转播国足，国足夺冠了；CCAV转播冬奥会开幕式，结果火炬坏了 #
如果我向黄牛买票。黄牛说：“加10元”。我肯定说：“不，我至少加您30元。”并说：“谢谢！”。警察就知道抓这种赚辛苦钱的，加300的黄牛都TMD是内部的人，警匪一家。 #
搜括民财还要看刮来的钱用在什么地方，隋炀帝搜刮民力最后用在了开大运河上，罪在当代利在千秋。用在自己身上，那就是千古罪人，永世不得翻身。 #
原来一次性筷子是这么回事，http://goo.gl/eN8p #
还是ArchLinux用的爽，要二进制包有二进制包，要源码包有源码包 #
淘宝出信用卡了？嘛时候支付宝也开个银行好了，AliBank #
吴军老师的数学之美真不错，毕设的做法有些修正，基于文法的分词不如基于概率的分词 #
刘谦被称为国内都市泡妞魔术青年的精神领袖，”都市泡妞魔术青年“，我觉得勺子挺像，@Natural__Light 你觉得呢？ #
孙茂松教授的《Chinese word segmentation without using lexicon and hand-crafted training data》写的很好 #
备案网站只要TMD做的像个人类使用的网站，我也不会这么抵制备案 #
RT @Fenng: 保持关注 RT: @linglingfa: 今天才发现，ebay和eachnet又分开了？现在ebay.cn专心做走私，原来不用的eachnet域名又启用了。什么时候的事儿啊？这淘宝虽然强大吧，也不用如此自乱阵脚吧？ #
我这破神舟本装MacOS就是装不上，还是继续用Linux #
时间会坍塌么？有学理论物理的推友能解释下么？时间存在加速度么？ #
当年Discovery讲超弦理论理论的物理学家现在头发都白了，又在Discovery讲力场防护罩，围观中…… #
原来太阳是电浆…… #
这位老头设计的力场除了纳米碳管还不能大量生产以外，都可以做出来，看来实现并不难 #
原来Google的在线翻译并不是语义分析，而是通过概率统计，词出现的概率和句子出现的概率来计算，这实际上考虑了人类语言习惯的问题，很多时候我们说话并没有严格的语法，但是却含有很多的习惯，通过概率来反应这种习惯，做出来的翻译效果应该更接近日常用语，分词同理。 #
金价、美元同时高涨，各国货币都下跌，唯独美元猛涨。看来华尔街的财主们又在狂买黄金，炒高金价，吸引各国投资者抛售本国货币购买美金来买黄金，两者同时被水涨船高。 #
汇市上，美元兑各国货币全涨，各国货币兑美金全跌，金价和美金再次同时彪高，吸引投资者抛售本国货币购买美金买黄金炒高美金价格的招数老美玩过一次了，这次又这么多人跟风 #
还有探亲假这种东西，从未听说……不知道阿里有没有 #
我妈为啥总觉得我头大，说我们是大头儿子小头爸爸 #
民企是员工养企业，没有员工的努力就没有企业的今天；国企是企业养员工，没有企业的垄断就没有员工的今天 #
Statistical Language Models看得我天昏地转 #
RT @dttoo: tooRT @yqhbp: meRT @twjacy: 推上学生多不？ //me #
删掉了花俏的主题，换了一个很Simple的主题，感觉好多了，而简约不简单，技术的追求。 #

类似的文章

2010年03月9日 -- 每周推特 2010-03-09 (0)
2010年03月7日 -- 每周推特 2010-03-07 (0)
2010年02月28日 -- 每周推特 2010-02-28 (0)

Mystique主题与WP-PostViews Plus插件的冲突问题

P.Linux — Tue, 16 Feb 2010 17:48:29 +0000

本文内容遵从CC版权协议, 可以随意转载, 但必须以超链接形式标明文章原始出处和作者信息及版权声明

网址: http://www.penglixun.com/work/program/mystique_postviews.html

今天升级了Mystique主题到1.72版，原来的那个Bug又出现了，会在页面的顶头显示一段代码，查看了源码，发现是WP-PostViews Plus的代码和Mystique主题冲突了，我们来看原始输出的HTML：

 
/*  */
 
 
home blog col-2-right loggedin browser-chrome">

这不出问题才怪呢，正常的情况应该是

或者在上面。

刨根问底，元凶指向mystique_body_class这个函数，发现在core.php文件中。
问题在哪呢？

// Special classes for BODY element when a single post
  if (is_single()):
    $postID = $wp_query->post->ID;
    the_post();
    // Adds 'single' class and class with the post ID
    $c[] = 'single-post postid-' . $postID;
......
  // And tada!
  return $print ? print($c) : $c;

就是the_post()函数，调用the_post()时，WP-PostViews Plus的代码就被加入了，而body class= 已经输出了。
解决方法很简单，把the_post()转移到最后，就是print的下一行，这样就OK了。把这个函数里其他the_post()都删除，留一个在print的下一行就行。

随机显示文章

2009年07月9日 -- 为PHP添加数据库模块 (0)
2009年03月5日 -- 一个很好玩的钢琴Flash游戏 (3)
2009年06月11日 -- QOCI的编译 (0)

锁的粒度与死锁概率

P.Linux — Tue, 16 Feb 2010 15:55:32 +0000

本文内容遵从CC版权协议, 可以随意转载, 但必须以超链接形式标明文章原始出处和作者信息及版权声明

网址: http://www.penglixun.com/work/database/lock_granularity_deadlock_probability.html

首先，我们要定义下什么是“锁的粒度”：所谓粒度就是作用范围，锁的粒度就是锁的作用范围。数据库中锁的粒度从高到低依次划分为：数据库、表、页、行。
什么是死锁，顺带说一下吧，当多个操作竞争资源，每个操作都无法获得全部所需资源时，系统进入死锁，如无外力作用，系统将无限等待下去，死锁的四个必要条件：
（1）互斥条件：一个资源每次只能被一个进程使用。
（2）请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
（3）不剥夺条件：进程已获得的资源，在末使用完之前，不能强行剥夺。
（4）循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。
打破任何一个条件就不会发生死锁。

我们先来看一个生活场景：
有两个文具盒，一个放的是笔（圆珠笔、铅笔等等），一个放的是修正工具（橡皮擦、改正带等等）.
现在有两个人，他们要画图，可能需要的物品当然有笔和修正工具。
假设我们用全局的独享，就是两个文具盒都只能同时被一个人拥有，一个人来拿笔，连带修正工具一起归他，这样绝对不会发生图画不下去的问题，因为所要的工具都会一次性给同一个人。但是问题也很严重，资源严重浪费，因为笔和橡皮擦肯定不会同时使用，也不会同时用2支笔。
假设我们用的是文具盒的独享，就是同时一个文具盒只能被一个人拥有，一个人要笔，整个放笔的文具盒都给他，一个人要修正图画，则整个放修正工具的文具盒都给他。这可能出现的问题就是，一个人想，我要画图，橡皮擦肯定要，橡皮擦的文具盒正好在，就先把这个文具盒拿下，等笔盒回来了再继续画。另一个人拿了笔盒，画了一会要修正，一看，放橡皮擦的文具盒没了，就等文具盒放回来。这样两个人就无限等待了，只要其中一个人看到东西不全就不拿，就不会无限等。
假设我们用的是物品独享，就是一支笔、一个橡皮擦只能被一个人拥有，一个人要画图，就拿一支笔，要改就拿一个橡皮擦或者改正带。除非只有一支笔，否则不会出现无限等待。当然，只有一支笔跟独享一个文具盒没区别。

例子中的独享就是锁的概念。

再来看数据库中的实例：
假设有A,B两个数据库，A库有A1,A2两个表，B库也有B1和B2两个表，每个表都有都有N条记录（N>1）.
现在有两个操作P1和P2并发，我们来看一个场景：
P1要操作A1表的一行和B2表的一行，P2要操作A2表的一行和B1表的一行。
现在假设我们用库锁，P1先行，A库被锁住，P2后行，先锁住了B库，P1再去锁B库，已经被P2锁住了，P2去锁A库，被P1锁住了，这样P1，P2就陷入死锁，都占用部分资源。
假设我们用的是表锁呢，P1先行，A1被锁住，P2后行，A2被锁住，P1再锁B1，P2再锁B2，怎么也不会发生死锁。
采用行锁的话就更不会死锁了，操作的表都不同。
看到这里，大家就说，锁的粒度越大，越容易死锁，真的吗？那我再来个最大的锁，实例锁，一次性锁住整个实例，P1先行，整个实例被锁住，P2被阻塞，等P1操作完P2再来，肯定不会死锁，为什么？因为这已经退化成串行操作了。

也就是说，虽然一般情况下锁的粒度越大，死锁概率越大，但是，当锁的粒度成为全局锁，把操作变成串行后，就不一样了，根本不会死锁。

我们把P1和P2操作改一下，P1操作A1表的i行和A2表的j行，P2操作A1表的j行和A2表的i行（i<>j），再来看：
假设我们使用库锁，P1先行，A库就锁住，P2阻塞，P1完成P2锁A库，不会死锁。
假设我们使用表锁，P1先行，A1表锁住，P2后行，A2表锁住，P1再去锁A2表，已经被P2锁了，死锁发生。
假设我们使用行锁，P1先行，锁住A1表第i行，P2后行，锁住A1表第j行，P1再锁A2表j行，P2再锁A1表j行，完成操作。

也就是说，不能就认为所有情况都是锁的粒度越大死锁概率越大，而是要看操作的粒度，如果锁的粒度比操作的粒度大或相同，操作就会变成串行，根本不可能发生死锁。

顺便说以下，数据库中并行操作的情况很多，为什么很少发生死锁呢，因为只要打破死锁四个条件任意一个，就可以避免死锁，只会发生阻塞，一个操作释放资源后就可以继续进行。
方法很多，例如把锁的粒度提高到跟操作的粒度大，并发一个表，我就一次锁一个表，并发一个库，我就一次锁一个库，这实际上是什么呢，就是把并行弄成串行了，一般没人这么做，并发只有1，效率太低。
一般是多管齐下避免死锁，一是使用不同等级的锁，例如意向锁，互斥锁等，其实就是打破死锁第一条件——互斥条件，资源某些时候可以共享，例如读锁可以共享读，不过因为还是存在互斥锁，依然可能死锁。
第二就是可以按顺序锁资源，例如锁表只能按A->B->C的顺序锁，如果我要A,B表，锁了A表后发现B表已经被锁了，就释放A表的锁（或者使用意向锁），延时再尝试，直到所有资源都可以锁住（互斥锁/共享锁），这就是打破了死锁第二条件——请求与保持条件，不能获得全部资源就先释放锁，等能获得了再说，这样操作可以完全避免死锁。

如有不对请指正！

随机显示文章

2009年10月14日 -- 使用PCI转并口实现SJF刷写嵌入式开发板 (0)
2009年10月14日 -- ORM or ROM？ (0)
2010年02月17日 -- Mystique主题与WP-PostViews Plus插件的冲突问题 (0)

每周推特 2010-02-14

P.Linux — Sun, 14 Feb 2010 04:00:00 +0000

本文内容遵从CC版权协议, 可以随意转载, 但必须以超链接形式标明文章原始出处和作者信息及版权声明

网址: http://www.penglixun.com/life/%e6%af%8f%e5%91%a8%e6%8e%a8%e7%89%b9-2010-02-14.html

RT @ranyunfei: 美国早该如此做，这才是推进中国民主进程最妙的一招。RT @yuanxinting 北京吠得紧，这招捏住中共睾丸，可不战而屈人之兵；老美不会捏爆其睾丸！ RT @yaoraonan: 美国亮棒：要爆光中国180万官员国外子女档案 #
要想一出校门就找到好工作，就不要在学校只谈恋爱不学习，也不要只学死课本而不关心现实中的新技术，更不要只学习自己的专业。 #
此次出门是我最悲剧的一次，被骗钱，还被家里骂，不用他们管，我还饿不死，幸亏房子好了，呆着就行了 #
都是欺负我老实，知道忽悠我没事，我X你黑中介 #
@hellodba 如果不是要求很实时的话，记录下当前页条目的ID然后往后取相应条数优化效果应该蛮好的。 in reply to hellodba #
500块钱没事，我不过这两天买不起被子而已，不过我会让我身边每个人都知道5i5j是什么货色。 #
看房最好要试住，有些问题一时半会根本看不出来，也别听中介瞎忽悠，自己仔细看一看，试一试，尤其是之前没住过人的，不确信没有隐含问题之前不要交任何钱，都是出来赚钱的，中国有几个企业真正讲信用，要钱不要脸，给钱就翻脸。 #
悲剧了，花费又通知低于20了，出来的时候还100多，万恶的中国移动 #
没有被子好冷啊…… #
极度的郁闷中，套上所有外套躺着 #
@yxwlmxy 在这个没有信用的社会，我不知道说啥好了。我不想把每个人都想的那么坏，但不这么做自己总是吃亏。 in reply to yxwlmxy #
实在不好意思找家里要钱了，勒紧裤腰带扛过去 #
RT @yxwlmxy: RT @plinux: @yxwlmxy 在这个没有信用的社会，我不知道说啥好了。我不想把每个人都想的那么坏，但不这么做自己总是吃亏。//有时候吃亏就是沾光，我也有过被自己信任的人骗的经历，现在回头想想经过那些事自己更清楚地看清楚了某些人。{同感} #
RT @yujie89: “兄弟如手足，妻子如衣服”，这是中国文化中最龌龊的部分。爱自己妻子的人，才能以天下苍生为念。读林觉民之《与妻书》，当代唯有晓波和刘霞的情书才能与之媲美。 #
准备睡觉，我想坐着睡还是躺着睡，先再穿件保暖内衣再说 #
冻醒了，悲剧，不得不靠下老爸了 #
悲剧的是下雨没带钥匙，更悲剧的是门禁系统坏了呼叫不了室房主甚至管理中心，最悲剧的是发现走到车库不用刷卡就可以直接上楼…… #
mystat又发现一个bug，修复中 #
今天帮人用mystat检查出数据库的错误，非常爽，我要完善这个脚本的功能，最好能配合Web界面做成实时呈现的系统 #
bin-log中的记录延时将近1小时，太扯淡了吧，14点之后出现了13点的log，无厘头，无法还原场景，什么诡异问题？ #
求助：有没有人遇到过binlog中SQL出现的顺序跟执行明显不一致的情况？例如2点执行了一条插入，主库可以查到这条记录，1小时候这条SQL才被记录到bin-log，我现在还原不出场景，间歇性遇到。 #
@fire9 问题在于主库的bin-log有时会延时一小时才记录到，不定期出现，很诡异，出现多为update和insert语句。 in reply to fire9 #
@fire9 5.1.43最新版，我怀疑可能是Bug，现在没法还原场景，只能遇到了就去看下，出问题的都是延时1小时才写入 in reply to fire9 #
公安部立功了……中国足球总算像了次爷们 #
@NinGoo 淘宝不是想用飞天系统么 in reply to NinGoo #
不逃课的学生不是好学生。什么课都不逃，跟什么课都逃掉没什么两样。一定要掌握学习的主动性，不要像读中学一样被老师牵着鼻子走。逃课没有错，但是不要逃错课。同时，既要逃课，又要让老师给高分。（这话非常好） #
对社会的简单形容就是：全是人、全是人、全是人——但社会肯定会分出层次，只有一个办法，那就是竞争，你必须努力，必须使自己成为社会的强者，强者才能拥有一切，而不是金钱可以买到一切，否则结局就是被压在社会的底层。（精神鸦片） #
写写InnoDB的范围锁的实现代码，深入体会体会范围锁机制。 #
语言能力不行，只能用代码注释来说明问题能讲的更清晰 #
RT @rtmeme: RT @pufei RT @zetifree 澳洲小孩每周作业是一张A4纸，中国小孩每周记作业是一张A4纸 #
淘宝上也有旅游、酒店、机票、线路了 #
@hellodba 现在只通了广深线，跟地铁似的，随买票随走，往粤西方向去的专线不晓得还要多久才能修好 in reply to hellodba #
RT @Fenng:@HeseyWang 等你毕业的时候，更多的公司要博士了；等你博士毕业了，更多的公司不招聘了，那你怎么办？是你能改变自己的命运还是环境能改变你自己的命运？ #
新被子好舒服~ #
读了这么多年书，只能靠学位唬人，我想不出比这更悲惨而且丢人的人生了 #
RT @BillGates: Seth Berkeley at #ted – "we once knew a world without AIDS, we owe our children a world without AIDS…" {盖茨大叔竟然发言了} #
RT @wolfdeng:RT @huairen: 开始拼的都是做事，最后拼的都是做人。开始拼的都是能力，最后拼的都是人品。 #
粒度和死锁的问题不是个简单的对应问题，而是个非常有意思的逻辑问题，我想简单了 #
广深线大年30还这么繁忙 #
对春晚实在没兴趣 #

随机显示文章

2009年10月14日 -- starUML和argoUML的对比 (2)
2009年10月10日 -- 年级大会上的发言内容：为梦想而工作 (0)
2009年10月10日 -- 关于世界，我们知道多少？ (0)

未来10年之规划

P.Linux — Sat, 13 Feb 2010 15:46:16 +0000

本文内容遵从CC版权协议, 可以随意转载, 但必须以超链接形式标明文章原始出处和作者信息及版权声明

网址: http://www.penglixun.com/life/diary/future_10_years_plan.html

1989~2009，成长与求学之路20年，已经走完。
2010~2019，工作拼搏第一个10年，已经开始。

给自己一个规划，一步步的去实现。现在，我以我是个阿里人而自豪，未来，我要阿里以我是阿里人而骄傲。

第一目标：参与至少一个大项目，经历一次从项目立项到正式发布的全部数据库设计过程。现在最缺乏的就是经验，有阿里这样大的平台，就要铆足了劲去做事，积累经验。

第二目标：用1~2年时间编写一个功能全面的数据库辅助系统，包括实时监控、历史记录、趋势分析、故障预警、自动备份等功能。DBA工作中有很多工作都是可以自动化的，却普遍存在大量的人肉工作，编写一套DBA辅助工具，非常有必要，也方便自己工作。

第三目标：用3~5年时间写一本书——《数据库常用算法分析》，总结数据库的各种常用算法，各种数据库专用的调优书籍和数据库理论书籍都很全的，缺的是从算法角度来看数据库的书，无关具体数据库，只要了解所用数据库所用的算法，调优自然方法清晰。定这么长的时间，因为想学Knuth爷爷，充分检查错误，不想在序言中写“因作者水平有限，难免有错误……”，而是写上“如果您发现一个错误，请告知作者，将奖励您2.56RMB……”，尽力做完美，会把每一步的进展都写在博客，供大家先批评，我再修改，最后整理出版成书，不在于赚稿费，在于给自己一个技术上的总结。

第四目标：经历5~8年时间的磨练成为一位知名的运维领域专家，利用业余时间为一些有社会价值的互联网创业企业提供无偿的数据库架构顾问。

第五目标：用5~10年时间编写一个可自定义选择不同算法的数据库，或基于MySQL，或自己重新写，不在于能在生产环境用的多广，而在于让跟多人理解数据库如何运转，数据库算法对数据库产生何种影响，将各种不同的算法都写入代码，用户自选用哪种，一个设想，尽力去实现。

随机显示文章

2010年03月9日 -- 数据库的拆分与合并 (2)
2009年10月25日 -- MySQL GUI Tool在Linux下运行 (0)
2009年12月17日 -- 主动请求式与被动探测式监控的比较 (0)

InnoDB行锁的实现分析

P.Linux — Thu, 11 Feb 2010 08:27:35 +0000

本文内容遵从CC版权协议, 可以随意转载, 但必须以超链接形式标明文章原始出处和作者信息及版权声明

网址: http://www.penglixun.com/work/database/innodb_next_key_locking.html

感谢Fenng的提醒，已删除锁粒度和死锁的关系，专门撰文写了锁的粒度与死锁的关系。

InnoDB与MyISAM不同，它实现的是一个行级锁，而非MyISAM的表锁。锁的粒度越大，则~~发生死锁的概率越小、~~锁机制开销越小，但并发能力会越低。如果锁的粒度变细，则~~发生死锁的概率也会增大，~~锁机制的开销会更大，但是并发能力能提高。表锁是如何实现的呢，以MyISAM为例，是在每个表的结构中加入一个互斥变量记录锁状态，像：
struct Table {
Row rows[MAXROWS];
pthread_mutex_t lock;//表锁
};
这样做的好处就是锁非常简单，当操作表的时候，直接锁住整个表就行，锁机制的开销非常小。但是问题也很明显，并发量上不去，因为无论多小的操作，都必须锁整个表，这可能带来其他操作的阻塞。
行锁又是如何实现的呢，Oracle是直接在每个行的block上做标记，而InnoDB则是靠索引来做。InnoDB的主键索引跟一般的索引不太一样，Key后面还跟上了整行的数据，互斥变量也是加载主键索引上的，像
struct PK_Idx {
Row row;
pthread_mutex_t lock;//行锁
};
multimap pk_idx;
这样的形式。
这样做的好处是锁的粒度小，只锁住需要的数据不被更改，但是问题也很明显，锁的开销很大，每个主键索引上都要加上一个标记，~~因为锁的粒度很小~~，可能两个不同的操作各锁住一部分行等待对方释放形成死锁，不过这个是有办法解决的，把上锁的操作封装成原子操作就行，不过并发量会受些影响。

下面是类似InnoDB的Next-Key locking算法的演示:
编译需要加-lpthread参数，例如g++ inno.cpp -lpthread -o inno

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
 
#define LOCK pthread_mutex_lock(&lock)
#define UNLOCK pthread_mutex_unlock(&lock)
#define PRINT(STR, ...) LOCK;fprintf(stderr, STR,  __VA_ARGS__);UNLOCK
 
#define MAXROWS 100
 
using namespace std;
 
/* 行结构 */
struct Row {
    int     num;
    string  info;
};
 
/* 主键索引结构 */
struct PK_Idx {
    Row     row;
    pthread_mutex_t lock;//行锁
};
 
/* 表结构 */
struct Table {
    multimap<int, PK_Idx> pk_idx;
    multimap<int, int>      num_idx;
    multimap<string, int>   info_idx;
    Row     rows[MAXROWS];
    pthread_mutex_t lock;//表锁
};
 
Table table;
int pid;
//全局锁
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
 
/* 随机字符 */
char randChar() {
    return rand()%26+'A';
}
 
/* 随机字符串 */
void randString(string &col, int len) {
    col = "";
    for(int i=0; i<len; ++i) {
        col += randChar();
    }
}
 
/* 初始化数据 */
void init() {
    pid = 0;
    PK_Idx pk;
 
    srand((unsigned)time(0));
 
    //初始化表数据
    for(int i=0; i<MAXROWS; ++i) {
        pk.row.num = rand()%MAXROWS;
        randString(pk.row.info, rand()%10+1);
        //初始化行锁
        pk.lock = PTHREAD_MUTEX_INITIALIZER;
        //写入表数据
        table.rows[i].num = pk.row.num;
        table.rows[i].info = pk.row.info;
        //写入索引
        table.pk_idx.insert(pair<int, PK_Idx>(i, pk));
        table.num_idx.insert(pair<int, int>(pk.row.num, i));
        table.info_idx.insert(pair<string, int>(pk.row.info, i));
    }
    //初始化表锁
    table.lock = PTHREAD_MUTEX_INITIALIZER;
}
 
/*获取范围数据*/
void select_num(int begin, int end) {
    int id;
    int cur_pid;
    multimap<int,int>::iterator it, itlow, itup;
    PK_Idx *pk;
    /* 按字段范围查找ID */
    itlow = table.num_idx.lower_bound (begin);
    itup = table.num_idx.upper_bound (end);
 
    LOCK;
    cur_pid = pid++;
    UNLOCK;
    PRINT("%d : * Start Select:%d,%d *\n", cur_pid, begin, end);
    for (it=itlow; it!=itup; ++it) {
        id = it->second;
        pk = &(table.pk_idx.find(id)->second);//根据ID去查主键索引
        pthread_mutex_lock(&(pk->lock));//在主键索引上加锁
        PRINT("%d : LOCK Row %d: %d\t%s\n", cur_pid, id, pk->row.num, pk->row.info.c_str());
        Sleep(500);
    }
    for (it=itlow; it!=itup; ++it) {
        id = it->second;
        pk = &(table.pk_idx.find(id)->second);
        PRINT("%d : UNLOCK Row %d\n", cur_pid, id);
        pthread_mutex_unlock(&(pk->lock));//使用完毕依次释放锁
    }
    PRINT("%d : * Select Finished! *\n", cur_pid);
}
 
/*修改范围数据*/
void update_num(int begin, int end) {
    int id;
    int cur_pid;
    multimap<int,int>::iterator it, itlow, itup;
    PK_Idx *pk;
 
    itlow = table.num_idx.lower_bound (begin);
    itup = table.num_idx.upper_bound (end);
 
    LOCK;
    cur_pid = pid++;
    UNLOCK;
    PRINT("%d : * Start Update:%d,%d *\n", cur_pid, begin, end);
    for (it=itlow; it!=itup; ++it) {
        id = it->second;
        pk = &(table.pk_idx.find(id)->second);
        pthread_mutex_lock(&(pk->lock));
        PRINT("%d : LOCK Row %d: %d\t%s\n", cur_pid, id, pk->row.num, pk->row.info.c_str());
        Sleep(500);
    }
    for (it=itlow; it!=itup; ++it) {
        id = it->second;
        pk = &(table.pk_idx.find(id)->second);
        PRINT("%d : UNLOCK Row %d\n", cur_pid, id);
        pthread_mutex_unlock(&(pk->lock));
    }
    PRINT("%d : * Update Finished! *\n", cur_pid);
}
 
 
void* test_select(void *) {
    int begin, end;
    srand((unsigned)time(0));
    while(1) {
        begin = rand()%(MAXROWS/2);
        end = begin+rand()%(MAXROWS/2);
        select_num(begin, end);
        Sleep(500);
    }
}
 
void* test_update(void *) {
    int begin, end;
    srand((unsigned)time(0));
    while(1) {
        begin = rand()%(MAXROWS/5);
        end = begin+rand()%(MAXROWS/5);
        update_num(begin, end);
        Sleep(500);
    }
}
 
void test() {
    pthread_t id[2];
    if(pthread_create(&id[0], NULL, test_select, NULL) != 0)
    {
        PRINT("%s", "Create Thread Error!\n");
    }
 
    if(pthread_create(&id[1], NULL, test_update, NULL) != 0)
    {
        PRINT("%s", "Create Thread Error!\n");
    }
 
    while(1){
		Sleep(500);
	}
}
 
int main() {
    init();
    test();
    return 0;
}

类似的文章

2010年01月14日 -- XtraDB 1.0.6-9编译错误的解决 (0)
2009年09月30日 -- MySQL参数调优 (0)
2010年03月10日 -- MySQL多服务器批量执行SQL脚本 (0)

每周推特 2010-02-07

P.Linux — Sun, 07 Feb 2010 04:00:00 +0000

本文内容遵从CC版权协议, 可以随意转载, 但必须以超链接形式标明文章原始出处和作者信息及版权声明

网址: http://www.penglixun.com/life/%e6%af%8f%e5%91%a8%e6%8e%a8%e7%89%b9-2010-02-07.html

RT @jason5ng32: 中国政府在处理冯正虎事件的这80多天表现出的专制、冷漠、狂妄、傲慢，同冯正虎先生始终坚持的执著、坚持、非暴力、耐心、温和、对话形成鲜明的对比 #GFW /via @daxa #
洗衣服把水都洗黑了，没有洗衣机我真活不下去，洗完手都冻僵了，米有热水好悲剧。妈妈冬天洗衣服不容易…… #
今天洗了好多东西，洗黑了一桶又一桶的水，我的手已经麻木了…… #
伯克利为计算机世界贡献了多少跨时代的产品啊~ #
人活着不是为了上学工作赚钱买房子然后制造下一个循环，得活出点味道来，不要总是拿现实太残酷说话，任何恶劣的环境都不能成为懦弱的借口 #
我觉得真正理解科学，研究科学的人，是不会排斥所谓的玄学、宗教，都是以承认某些无法证明的公理为基础，只是科学使用的公理更接近人类理性认知。否则哪来的基督教徒的诺贝尔奖，信神就不懂科学，没有这种理论。 #
@kisafran 奇函数则f(x)=-f(-x),那么f(x)-f(-x)/x=f(x) f(x)/x=(xf(x) f(x))/x<0，那么假设x<1，f(x)<0,xf(x) f(x)<0，成立。反之不成立。所以解集是x<1。不知道对否,高等数学大一学到大四。 in reply to kisafran #
RT @OnlyLonely1984: 这个真的是太郁闷了 RT @tinyfool: RT @doubleaf: 在北京到西安的火车上，隔壁有俩人票是一样的，同一天同一个铺位，还都是真票。。列车长来了，说找车站去。。 {难道是售票系统没有事务保证~} #
跟GF讨论宇宙和量子力学的问题……对薛定谔同志的东西，我知道他证明了什么有什么意义，但恕我真的不会用，那个薛定谔方程，我死也不知道怎么算…… #
超弦理论已经超过了我的认知范围……平行宇宙是我理解的极限了~咳咳，我还是搞数据库去吧……GF竟然能理解薛定谔的猫，鼓掌~ #
RT @rtmeme: RT @911023 RT @pufei: RT @hsqianshuiting: 一只派驻美国的熊猫回天朝，那畜生要上CCAV，冯正虎先生回国，可以上除了CCAV以外的其他国家电视 #
RT @cosbeta: 永远要跑在市场的前面才有利可图，国外的厂家大抵如此，他们在引领市场 {eBay就是来早了被淘宝干掉了，关键要看经营，如果eBay走现在淘宝的免费道路，不收费，先积攒用户，现在就不是淘宝的天下了} #
讨论科学和伪科学就是扯淡，从可证伪性来说，数学就是最大的伪科学，数学理论存在大量不可证伪的地方。但是说数学不是科学，是伪科学，不被砖头砸死才怪。 #
RT @Fenng: 世界排名前 50 的网站，大约有 1/10 (5个左右)的技术团队是不到 50 人的。 #
从玄学扯到宇宙，从量子力学扯到相对论平行宇宙，从神扯到科学的公理，然后扯到科学与伪科学界定，又扯到可证伪性，然后扯到数学不可证伪，然后又跳跃到集合论的不完备性，现在扯到哥德尔不完备定理，我已经进入状态了，跟GF继续扯…… #
@Fenng .NET我觉得还是设计上的问题，一上手，太好用了，太方便了，深入下去，我想做做这个行不行，不好意思不行，我换个方法看行不行，不好意思也不行，到最后越用越觉得不爽。.NET有微软再强大的支持也不能和Java活跃的社区相比。 in reply to Fenng #
RT @number5: "久经GFW考验的穿墙战士“ — 我曾经在某论坛用过的title #GFW #
爱国者3型能防御东风2就不让卖了，凭什么不让别人自卫，谁就活该挨打 #
当Google发展成一个崇拜的对象，占据人们生活的每个部分，也需要克制一下，任何一个公司掌握如此多人的生活都是非常可怕的 #
RT @wangpei: 一老外朋友看到北京对美国军售的激烈反应，忧心忡忡地问我：“两国会断交吗？”我说：“不会。”他问why，我说：“夫妻吵架，小媳妇负气回娘家而已。”他听不懂。 #
看有没有哪个同学有Nexus One，很想试试。 #
有了Partition，Merge引擎可以退役了 #
对于写多读少的表，采用HASH分区更能把负载平衡出去，写压力不会集中到一个分区；对于读多写少的表，采用RANGE分区更能平衡压力，读数据可以在少的分区内完成；对于数据分布明显依赖于某个字段的，则采用LIST手动分配来平衡负载。#learnmysql #
RT @yxwlmxy: RT @ktmud: 永远不要轻易否定别人的工作，有些你作为外行看起来很简单的东西，真正实现起来会很麻烦。在此深刻检讨一下。此事也充分说明，有一个明确而细致的前期规划是多么重要。 #
王者之国，使人民富裕。霸者之国，使士人富裕。仅存之国，士大夫富裕。无道之国，国库富裕。 #
不吐出我的转移码，我就一天一封邮件到ICANN，绝不交转移费，反正发邮件又不要钱 #
Cygwin好慢呀…… #
RT @hellodba: New blog post: Oracle Exadata技术浅析 http://www.hellodba.net/2010/02/oracle_exadata.html #
高僧都是扫地的，牛人都是卖书的 #
RT @fire9: 希望Larry老大兑现对MySQL的10大承诺。 {说话算话就不是埃里森了} #
InfiniDB专门用作数据分析的引擎，比较有意思，来编译用下试试。#learnmysql #
RT @ShooterPlayer: 『Nginx XSLT模块性能与稳定性测试』 http://is.gd/7v2Vy XSLT模块性能比php提高10%以上，而且大为稳定。而纯静态xml xslt组合则可以提高服务能力3倍以上… #
MySQL要是需要授权了，新的引擎必将大量出现，群雄涿鹿，看谁能最后一统江湖。InfiniDB、MariaDB、Falcon都是很好的引擎～也可能特殊用途的引擎能各分一块山头，像适用OLAP的InfiniDB等等～ #
Infobright和InfiniDB都是列式存储，很适合全表选取一个或者几个字段，OLAP这样很合适。它们都是基于MySQL框架的，MySQL的数据引擎式的架构太有前瞻性了，为开源数据库/数据仓库的发展作出了不可磨灭的贡献～#learnmysql #
Infobaright压缩比不是吹的，40多M的导入文件，导入后才1M多，吓到我了。 #
基于列存储的引擎真的太爽了，晚上写篇博文分析下它的实现原理，比行存储更适合做大数据分析。 #
终于把C指针给梳理清楚了，被折磨死了……语言不常用就忘了。 #
在写行式存储和列式存储在动态和静态结构下分别在内存和磁盘上的性能，共[行式|列式][静态|动态][内存|磁盘]八种情况，采用STL的multimap做索引，内部红黑数实现，自己写的Splay平衡树性能实在拿不出手。 #
内存中静态表行式和列式存储的测试结果，共1000000条记录，匹配466440行，行式存储完全索引，耗时50ms，列式存储<=0ms，震惊了…… #
列式存储的大数据查询效率惊人…… #
RT @ryangato: RT @secretaryzhang: RT @hr6r: Cisco Evil ! 一边协助建造 #GFW ，一边卖VPN，真是不得好死！ #
文件中读取测试，列式存储大数据获取比行式存储仍然要大，列式不存在索引的情况下，小数据读取行式占有，如果列上存在计算，列式存储优势明显。 #
算完了大学的开销，学费住宿费24K，生活费38K，败家19K，大学一共花了81K 。奖学金20K，教奥赛19K，项目18K，工资7K，大学共收入64K。正负相抵大学花费17K。 #
辗转反侧，睡不着，想不通为什么我的列式存储比Infobright慢那么多，处理方式有何不同，Infobright也是单文件无索引，是不是有隐含的类似索引的指针还是文件组织方式上有什么特殊的地方？我的程序时间消耗在文件指针的移动上。 #
RT @amoiist: RT @shaohuachen: 可耐滴老虎，满载而归。2 。。http://img.ly/rGv #fzhenghu #
对列式存储的测试程序做了个改进，采用多个文件指针，分别指向每个列的启示位置，这样通过条件查找的时候定位到id就可以使用要选择列的指针直接去取，时间从1000多ms降低到200多ms，如果能将一个表的多个列分别存储在一个文件，效率还能高。 #
当同样的表存在于多个实例时，最多只能有一个实例中的表是自增ID，否则同步数据的时候很可能产生ID不一致的情况。A实例的表产生自增ID，同步到B实例的表的时候也插入ID，但ID要做主键约束唯一，这样同步起来才不会出现主键不一致。#learnmysql #
RT @tjmao: 买电脑我只有一个要求：可以装上10个8个虚拟机同时运行。主要区分一下，网购和网银的一台，不联网的一台，平时上网用的一台，剩下的用于开发…… {我要4个跑RAC，3个跑MySQL Cluster，再来1个写程序就行了} #
每个翻墙女的背后，一定有一个翻墙男，或者她的室友/密友背后有一个翻墙男…… #
RT @Fenng: 阿里巴巴旗下公司 2009 年招聘超过 6000 人。相当惊人。http://www.jobsdigg.com/story/2643/ #
测试Twitter/新浪围脖/人人网实时同步 #
RT @rtmeme: RT @GTPAD RT @beckyeeky: KDS还是非常Insight的：问：打过胎的女人还能要吗？答，死过人的二手房你还敢住吗？ (via 淫淫) #
RT @hidecloud: 静茹是我们这批80后的一个童话。看到她的幸福，也同时感受到我们的成长与年华逝去。 #
美不胜收的数据图，http://goo.gl/3CIW，运维中另一个美妙的世界就是数据图。 #
RT @yxwlmxy: RT @KrzyCube: RT @yeka52: RT @xjb: 世界上任何书籍都不能带给你好运，但是它们能让你悄悄成为你自己–赫尔曼.黑塞 #
RT @bang590: RT @feelinglucky: RT @huairen: 宗曦@om19 同学成功求婚。。。。杭州兄弟见证求婚现场。祝福 http://is.gd/7FeqE //祝福~有没有全过程解析~我好学习学习~ #
求SAE邀请码～有朋友方便的话给我个邀请码～ #
准备在国内搭建一个博客镜像，国外实在有点慢，数据库架在国外，网页放在国内一个副本，文件每天打包传到国外备份。不得不说GFW撑起了一个巨大的产业。 #
博客加速方案:购买国内一合租主机，存放网页，数据库/VPN/Twitter API毫无疑问继续留在美国VPS。文件上传到国外主机，通过FTP协议同步传输到国内主机。反正我有多个域名，一个指向国内，一个指向国外，挂掉任何一个都还能用。这么折腾就为了博客快一点，顺便练练程序。 #
业余也看看Wordpress源码，看能不能改成读写分离的结构，这样的话就写国外，读国内，那爽多了，呵呵～ #
RT @yanzisky1989: 呃。看到韩寒开新浪围脖了。为了关注他，我也只好开通围脖。囧。我这记性，说不定哪天会忘记密码的说。 {搞个密码管理软件嘛} #
给程式设计师的Vim入门图解说明 http://goo.gl/lGme #
小小的总结了下我的前20年，努力把我接下来的20年过的更精彩。 #
RT @onlyswan: 不知道。RT @qianshuiting: @onlyswan 求四万姐帮忙：知道有什么软件能够轻松的实现数据分类吗？就是类似于淘宝搜索后能够把搜索出来的东西按地区排列、按价格排列、按信用度高低排列，我需要有这样的功能的软件 {这是靠索引做的} #
从总结中看，从我小学四年级第一次跟着杂志上瞎搞Red Hat 6开始，现在接触Linux 10年了，不过我应用Linux的水平…哎…不说了，伤心。当年好好用Linux就好了，那时代Win98和RH6相比其实RH6蛮好的，反正我都不会玩，学Win还是RH都差不多。 #
RT @blogkid: 早上炒菠菜炒多了，下锅之后，多到搅不开。还好菠菜越炒越少。后来想着也许是年前最后一次做饭，把一锅菠菜都吃了。 {早饭自己做啊，那得起多早呀} #
@blogkid 百度的上班时间果然很开放，来学校讲座的就说上班时间是很随意的，看来不是忽悠的 in reply to blogkid #
RT @DarthAnarchy: RT @rtmeme: RT @pufei RT @nyliulei 经典语录：收费时说：“这符合国际惯例！”服务时却说：“要考虑中国国情！”（vir新浪微博） #
Google App神器，我土了～才用起来 #
RT @FTChinese 华远集团董事长任志强：“房地产打下去GDP就掉下去了，GDP掉下去，温总理比我们开发商还急。” #
RT @yxwlmxy: 如果你是硬件厂商，希望你的硬件能在 Linux kernel 下运作，那么就必须要有驱动程序。如果驱动程序的程序代码公开，等于硬件规格也公开的差不多了。许多厂商不愿意这么做，所以就提供编好的驱动程序，但不提供原始码。 #
RT @zheng: 现在公务员、国企、事业单位人超多，为了证明自己存在的理由，就必须不断地找事，没事找事。。。 #
RT @hecaitou: 淘宝UED博客亮了，看回帖：http://tinyurl.com/ygqlgru #
注册了个域名dbawiki.org，准备搞个wiki，把自己今后做数据库的一些总结全部放上去，也欢迎大家一起修改。 #
@jeffz_cn 应该是02和05两次，上交搞ACM恨，ACM班的就做题和上专业课就行了。清华还没这么猛，虽然清华招的苗子更好。 in reply to jeffz_cn #
面向对象设计解决业务执行逻辑问题，数据库设计解决数据高效的问题，由OR-mapping来连接它们 #
RT @yxwlmxy: RT @lianyue: 欲望、私心、逐利，都是人正常的构成，一点也不可耻。宣称自己没有这些东西的人才值得警惕。 #
@NinGoo Google App Engine的存储就是这样，可以把一个对象丢进去，再完整的拿出来，GAE也提供Python或者Java的SDK，可能实现方法跟GAE类似。C/C 的二进制读写也可以把一个结构体/对象完整的写入文件并且读取，只要不涉及指针。 in reply to NinGoo #
@NinGoo 《Python核心编程》，我最早看的这本，不过错误也蛮多，Python版本变化语法都有些小变化，有时很郁闷，书上程序都调通Python差不多就通了，入门看起来很吃力。《Python学习手册》这本蛮好的，现在看这本，相对简单。 in reply to NinGoo #
@housyhou 收到，即刻查阅，这是哪个版本的问题，1.0么 in reply to housyhou #
@housyhou 可能InnoDB参数变化了，我也查查程序 in reply to housyhou #
@housyhou 我大约知道是什么错，不过我要输出一下我才知道，我的程序结构化拆的很离散，是一个变量没定义，你懂Perl么？在1470行上面写上if(!defined($status[$now]->{"$val"}))print $val;运行一下就停止然后看控制台输出什么。 in reply to housyhou #
@housyhou 大概知道，你的版本没有这两个参数，所以运算的时候就没有初始化，不知道你打了Patch后有哪些参数。show global variables like "%innodb%"看看有哪些结果，发个邮件给我行么，penglixun(at)gmail.com in reply to housyhou #

随机显示文章

我的20年

P.Linux — Fri, 05 Feb 2010 14:17:23 +0000

本文内容遵从CC版权协议, 可以随意转载, 但必须以超链接形式标明文章原始出处和作者信息及版权声明

网址: http://www.penglixun.com/life/diary/my_20_years.html

1989年11月10日，P.Linux闪亮登场，2009年11月10日，终于走完了第一个20年，在此记录一下。

1990~1991，太小，没回忆。

—-学前阶段—-
1992年，3岁，幼儿园小班。
记的当初是被妈妈拉着去幼儿园的，打小我就不喜欢上学。记得应该是这个时候，爸爸去了广东打工。
1993年，4岁，幼儿园中班。
妈妈腰经常痛，我立志要当军官，让警卫照顾妈妈，这个志向一直持续了十余年直到国防科大梦想的破灭。

1994年，5岁，幼儿园大班。
看动画片知道有机器人这种东西，跟妈妈说，我要做一个机器人帮妈妈做家务，这个志向一直持续到现在，一直对人工智能的东西感兴趣。这个时候知道了银河巨型机这种东西，知道是国防科大搞的，结合我的两个志向，决定以后上国防科大，国防科大就是未来十余年我奋斗的目标。

1995年，6岁，进入小学学前班。
记得这个时候，外婆去世了，外婆照顾了我很久，陪我睡觉的时候去世的，当时小，蒙了，后来才一直哭。

—-小学阶段—-
1996年，7岁，升入小学一年级。
这个时候应该是有门课叫自然，非常喜欢，对自然科学的兴趣就是这个时候产生的。
好像还一门课叫社会，对人文科学的兴趣是看社会课本产生的。

1997年，8岁，升入小学二年级。
没有什么特殊的事情，不知道是不是这个时候，跟我的同桌，有一次好几门课都是同时第一，很多人说我们抄袭~我X……

1998年，9岁，升入小学三年级。
这个时候开始有了数学奥赛，开始周末去补课，第一次知道补课，此后补课一直伴随我~
也是这一年，爸爸从广东带了电脑给我，我第一次碰了电脑，开始很喜欢打一个射击游戏，很原始，都打通关了。此后很长一段时间都打游戏。学习开始不太行，不过打游戏练就了我极快的反应能力和敲键盘速度，对以后的发展是好是坏说不清

1999年，10岁，升入小学四年级。
游戏玩腻了，不晓得在什么地方知道了Red Hat这种东西，就跑去电脑城买光盘，Red Hat 6吧好像，就买了一张回家，不知道怎么折腾的，就给装上了……此后就知道了Linux这个东西~在Win98和RH6的抉择中，因为老爸帮我装了Win98，就放弃RH6了，要是当年一直用RH，早就成Linux专家了。

2000年，11岁，升入小学五年级。
要竞赛了，我的数学却开始不行了，班主任施老师那个郁闷~
不过很意外，比赛完我觉得没戏了，却意外得了二等奖，排名还比较前，差一点就一等奖。
这一年就是先郁闷，然后意外的惊喜。

—-初中阶段—-
2001年，12岁，保入初中一年级。
因为华罗庚金杯赛二等奖，幸运的进了宜春中学的奥赛班。第一次分班考试，不知道哪根筋错位了，考了满分……不过此后就不行了。
应该是这个时候，跟学校的组团去了北京，第一次离开父母出远门。

2002年，13岁，升入初中二年级。
好像这个时候从临时教室搬到学校里面了吧，成绩很诡异，一次高一次低，就是这样大幅度波动，跟股市差不多。数学竞赛基本废了，再也没有获奖过。
不过这个时候，家里开了网络，结识了一些黑客朋友，开始瞎折腾网络和破解技术，同时学习C、C++语言。其实开始就是瞎拿本书看看，叫《C++程序设计》，敲出Hello World的时候那个兴奋呀，此后就开始玩C++，后来又开始学习一点C。那时候觉得C++就是比C多了++，囧~
后来结识了张皖龙，一起研究了一些程序设计问题，本来想一起做些东西，不过相隔两地，也没有SVN这种东西，也没做起来，第一次多人协作。

2003年，14岁，升入初中三年级。
参加个什么生物竞赛，拿了个一等奖，我总是在不正确的时候喜欢不正确的科目，这个时候生物还不是考试科目，我却非常喜欢。参加省理科实验班考试，差半分，郁闷至极……
不过后来学校决定把没有达到分数线一定距离的人也招入校实验班，我就这样进去了，免了中考，玩了半年。好好学了学C++，程序设计这个时候提升最快。

—-高中阶段—-
2004年，15岁，保入高中一年级。
因为被特招进了高中，又是在所谓的校实验班，还是有竞赛，不过已经没了兴趣。成绩起伏也很大，英语彻底的悲剧，从100分到150分的卷子，总分不断提高，不过我的成绩很稳定的在90分。老师也无语了，努力P用都没有，我相信学习需要一点天赋了。
然后跟余竟老师认识了，开始是我开了自己的个人主页，照搬了余竟老师网站上关于学校的介绍，余老师很生气，说我盗版，汗……不过就这样认识了，从余老师口里知道宜春中学也搞信息学奥赛，我很激动。
这个时候又从老爸口里知道了吴文虎老师，带国家信息学奥赛的，也知道了信息学获奖可以保送国防科大，就立志要搞计算机竞赛……
开始接触Pascal，有点C++基础，上手还快，不过对数据结构和算法这种东西还是迷茫了很久~不过后来突然开窍，从写成绩分析的小程序开始，对算法开始极度感兴趣。

2005年，16岁，升入高中二年级。
为了计算机竞赛，两上北京清北学堂学习，见到了传说中的刘汝佳老师~哈哈~去南昌，遇到易Pretty，现在这些结识的朋友都保送到各个名校了~我最挫~而且刘博洋这个时候也去了北京清北学堂，后来到了南航才知道。
这是第一次自己一个人出远门。
在学校成绩开始下滑，不过文科还好，因为文科我不太需要看也能学得不错，老师全以为我学文科，不过我还是学了理科，觉得不行就补补，文科我自己看都会了，不用专门学。
第一次参加信息学比赛，初生牛犊不怕虎，不小心笔试全市第一，不过应该也没几个人。
然后参加复赛，以为没戏了，结果不小心竟然还踩线获奖了，一等奖分数线100分，我110，幸好全输出NO骗了10分~
获奖后一天国防科大的政委来学校了，愿意招我，那个兴奋呀……就去了趟国防科大跟政委面谈。
后来中科大少年班又发了考试邀请，听到考试我就崩溃了，算了。
后来参加全国夏令营，很悲剧，不说了……忘用高精度，最后一题本来方法正确，没用高精度，悲剧，泪目……加上RP不好，哈密顿通路才算出那么点。
这个时候很郁闷，本来想去好一点的学校，爸妈想走点关系趋好学校，我还是决定，靠自己能去哪算哪，就去了南航~扛着家里的压力，留下来了。
这一年也写出了我第一个人工智能程序，能做高中课本中简单的集合证明，本质就是双向宽搜，把公式序列化而已，写了五百多行，获得了全国青少年科技创新三等奖，当时觉得是个大程序，现在看来不过个小程序而已。
也开始写一些应用软件，写了一个锁屏幕类似屏保的软件，还获得了全省软件设计二等奖，很水的奖。

—-大学阶段—-
2006年，17岁，保送大学一年级
来到大学，踌躇满志，好好学习，天天向上（因为开始没电脑），所有课都过了，就挂了个高数实在不会，高中还没学完呢。不过补考还是过了。
这个时候还是想搞竞赛的，不过感觉自己做题能力已经很不行了，有点做应用开发的想法。
读了一年之后，又想去国防科大，不过政委不答应我学计算机，放弃之，就此留在南航了~

2007年，18岁，升入大学二年级。
这个时候，参加了个项目，第一次知道在大学可以做项目，不过没怎么上课，就挂了很多课，有的课现在还挂着~
第一次知道了Oracle这种东西，知道了.Net，开始学习数据库，学习Oracle DB，学习.Net，做网站，做应用。基本上放弃了竞赛，只担任了几次裁判。

2008年，19岁，升入大学三年级。
对Oracle到了狂热的程度，对数据库疯狂的热爱，报名参加Oracle University学习，获得Oracle认证专家，我承认很水，基本靠背题。400道题，全英文，我竟然5天全背完了，我真佩服自己，不过靠着OCP的头衔还是忽悠了不少人，实际上Oracle的水平，不说了，伤心。
比较值得纪念的是我想了1年多的矢量化识别算法终于完稿了，投递出去很不幸，审稿人心情不好，就说训练部分没写细节，打回，没有任何其他说明，非常愤怒。后来自己把程序写出来了，很复杂的字也能识别，训练就是体力活，写进论文才是水。论文的事就耽搁了，给了班主任，让他折腾去吧。

2009年，20岁，升入大学四年级。
最值得纪念的事情是见了Fenng，七公，Sky，Jacky等传说中的大牛。最重大的转折是在途牛实习，从Oracle转到了MySQL运维，MySQL的轻量、灵活非常吸引我，一发而不可收拾，对MySQL的各种架构形式都折腾了一下，知道了LVS这种神器，知道了Sphinx这种第三方索引工具，知道了Memecached这种K/V存储机制，结合理论理解了数据库中的各种算法，开始很喜欢用脚本语言……
这一年对自己的提升是非常大的，平时的积累还是非常重要的，有理论基础，再深入应用去钻研，会得到意想不到的提高。
最开心的事情，是如愿以偿的进入了阿里巴巴，能成为马云旗下的一员，能和大牛们一起工作，做最好的电子商务平台。

第一个20年，是求学的20年，就这样过去了。
下一个20年，是工作拼搏的20年，要更加精彩，为自己加油！

随机显示文章

2009年05月24日 -- Windows虚拟按键小程序 (2)
2009年10月14日 -- DBA必备能力总结 (4)
2009年07月9日 -- 为PHP添加数据库模块 (0)

mystat 1.0 release 发布

P.Linux — Fri, 05 Feb 2010 07:21:06 +0000

本文内容遵从CC版权协议, 可以随意转载, 但必须以超链接形式标明文章原始出处和作者信息及版权声明

网址: http://www.penglixun.com/work/program/mystat_release.html

mystat是一款MySQL数据库实时监控脚本，Perl编写，基于MySQL的show global status和show global variables结果进行分析实时显示。能通过参数控释轮询间隔、轮询次数、监控项目。使用了strict;DBI;Switch;DBD::mysql;Getopt::Std;Term::ANSIColor;这几个Perl模块，通过CPAN都可以安装。
我已经尽力测试Bug，不过使用场景各异，如果发现Bug，请联系我，penglixun(at)gmail.com。

脚本包括如下参数
-i 轮询间隔默认1s
-c 轮询次数默认无限
-n 监控项目默认basic
包括: all(全部项目), basic(基本项目), innodb(InnoDB项目), myisam(MyISAM项目)四个套装
以及下面的单项：
traffic – Network Traffic
kbuffer – Key Buffer
qcache – Query Cache
thcache – Thread Cache
tbcache – Table Cache
tmp – Temporary Table
query – Queries Statistics
select – Select Statistics
sort – Sort Statistics
innodb_bp – InnoDB Buffer Pool
项目之间可能有交叉的部分，取最大并集。
-d 取消项目默认noneDB
包括: var(变量部分), innodb(InnoDB部分), none(无)
同时跟-n出现一样的项目，则优先处理-d。也就是说-n innodb -d innodb，不会显示innodb的部分。
-h 主机名默认空
-u 用户名默认空
-p 密码默认空

例如：perl mystat.pl -n traffic,qcache,kbuffer,sort -d var -h 127.0.0.1 -u cactiuser -p cacti
显示如下

猛击这里下载：Note: There is a file embedded within this post, please visit this post to download the file.

再来一张图：

显示项含义可以看代码里面的注释，非常清晰，一行计算代码有2～3行注释，说的很明白了。

代码结构
print_usage //显示用法
get_option //获取命令参数，设置命令默认值
set_env //获取系统环境变量
do_loop //循环控制函数
format_val //格式化数据为K/M/G/T单位
same_char //打印若干个相同的字符，用于排版
quit //退出操作，关闭数据库连接
init_val //初始化最大值
init //初始化总控函数
get_stat_traffic //获取流量相关数据
get_stat_kbuffer //获取索引缓冲相关数据
get_stat_qcache //获取查询缓存相关数据
get_stat_thcache //获取线程缓存相关数据
get_stat_tbcache //获取表缓存相关数据
get_stat_tmp //获取临时表相关数据
get_stat_select //获取SELECT相关数据
get_stat_sort //获取排序相关数据
get_stat_innodb_bp //获取InnoDB缓冲池相关数据
get_stat //获取数据总控函数
display_header //显示表头信息和版权信息
display_var_title //显示数据库变量栏标题信息
display_var_cache //显示数据库变量缓存相关信息
display_var_buffer//显示数据库变量缓冲相关信息
display_var_log //显示数据库变量日志相关信息
display_var_conn //显示数据库变量连接相关信息
display_var_query //显示数据库变量查询相关信息
display_vars //显示数据库变量总控函数
display_stat_traffic //显示数据库状态流量相关信息
display_stat_kbuffer //显示数据库状态索引缓冲相关信息
display_stat_qcache //显示数据库状态查询缓存相关信息
display_stat_thcache //显示数据库状态线程缓存相关信息
display_stat_tbcache //显示数据库状态表缓存相关信息
display_stat_query //显示数据库状态查询语句相关信息
display_stat_select //显示数据库状态选择相关信息
display_stat_sort //显示数据库状态排序相关信息
display_stat_tmp //显示数据库状态临时表相关信息
display_stat_innodb_bp //显示数据库状态InnoDB缓冲池相关信息
display_stat //显示数据库状态总控函数
calc_val //计算数值模板，包括当前值/平均值/最大值/最小值
calc_stat_traffic //计算数据库状态流量相关信息
calc_stat_kbuffer //计算数据库状态索引缓冲相关信息
calc_stat_qcache //计算数据库状态查询缓存相关信息
calc_stat_thcache //计算数据库状态线程缓存相关信息
calc_stat_tbcache //计算数据库状态表缓存相关信息
calc_stat_query //计算数据库状态查询语句相关信息
calc_stat_select //计算数据库状态选择语句相关信息
calc_stat_sort //计算数据库状态排序相关信息
calc_stat_tmp //计算数据库状态临时表相关信息
calc_stat_innodb_bp //计算数据库状态InnoDB缓冲池相关信息
calc_stat //计算数据库状态总控函数
refresh_all //每次刷新数据控制

类似的文章

2010年01月28日 -- mystat 0.5 beta 的使用介绍 (0)
2010年01月26日 -- 自己写的MySQL实时监控脚本–mystat (0)
2010年03月10日 -- MySQL多服务器批量执行SQL脚本 (0)

列式数据库的简单分析

P.Linux — Wed, 03 Feb 2010 14:04:03 +0000

本文内容遵从CC版权协议, 可以随意转载, 但必须以超链接形式标明文章原始出处和作者信息及版权声明

网址: http://www.penglixun.com/work/database/column-oriented_dbms_analyse.html

这些天看数据仓库的内容，发现一个新内容——列式存储。曾经有想过把数据库行列转置作成索引，不过没有深想，没想到列式数据库已经开始发展起来了。
首先看下WIKI上对列式数据库的解释：

列式数据库是以列相关存储架构进行数据存储的数据库，主要适合与批量数据处理和即席查询。相对应的是行式数据库，数据以行相关的存储体系架构进行空间分配，主要适合与小批量的数据处理，常用于联机事务型数据处理。
数据库以行、列的二维表的形式存储数据，但是却以一维字符串的方式存储，例如以下的一个表：
EmpId Lastname Firstname Salary
1 Smith Joe 40000
2 Jones Mary 50000
3 Johnson Cathy 44000
这个简单的表包括员工代码(EmpId), 姓名字段(Lastname and Firstname)及工资(Salary).
这个表存储在电脑的内存(RAM)和存储(硬盘)中。虽然内存和硬盘在机制上不同，电脑的操作系统是以同样的方式存储的。数据库必须把这个二维表存储在一系列一维的“字节”中，又操作系统写到内存或硬盘中。
行式数据库把一行中的数据值串在一起存储起来，然后再存储下一行的数据，以此类推。
1,Smith,Joe,40000;2,Jones,Mary,50000;3,Johnson,Cathy,44000;
列式数据库把一列中的数据值串在一起存储起来，然后再存储下一列的数据，以此类推。
1,2,3;Smith,Jones,Johnson;Joe,Mary,Cathy;40000,50000,44000;
这是一个简化的说法。

昨天装了下两个基于MySQL的数据仓库，infindb和infobright，看了文档发现它们都是列式数据库，把40多M的数据导入infobright，没想到数据文件只有1M多，压缩比令我惊讶！
然后测试了下选择某一列，在列上做计算，都比MyISAM和InnoDB要快，看了一些原理文档，就自己模拟了一下，写了个程序测试。
从内存中读取效率很高，但是从磁盘中读取（假设行式数据库的索引在内存中）比行式数据库要慢（开始在Twitter上说比行式快是程序写错了），不过我觉得还是我设计上的问题，至少Infobright就比MyISAM/InnoDB快，列式应该也有其特殊的索引机制和缓存机制，例如每列分开存在不同的文件，这样文件指针转移会更快。
2010-02-04补充：采用了多个文件指针后，列式存储明显加速，如果给每个列一个文件指针，效率会非常高，也可以肯定，如果每个列单独存储一个文件，效率还会提高。现在文件中列式表读取效率降低了4/5，接近行式表了。继续优化还能提高。

代码请展开：

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
 
#define MAXINT RAND_MAX
#define MAXROWS 1000000
#define MINVAL 1
#define MAXVAL 150000000
 
using namespace std;
 
 
/*计时器*/
class Timer {
public :
    //构造函数
    Timer ();
    //析构函数
    ~Timer ();
    //开始计时
    void begin();
    //计时结束
    void end();
    //获取时间,ms
    double get_time();
private :
    clock_t start, finish;
    double time;
};
 
Timer::Timer () {
    start = 0;
    finish = 0;
}
 
Timer::~Timer () {
    start = 0;
    finish = 0;
}
 
void Timer::begin () {
    start = clock();
}
 
void Timer::end () {
    finish = clock();
}
 
double Timer::get_time() {
    time = (double)(finish-start)/CLOCKS_PER_SEC*1000;
    return time;
}
 
//计时器
Timer timer;
 
/*记录各种结构表的空间占用*/
struct Size {
    struct {
        struct {
            int _static;
            int _dynamic;
        } col,row;
    } mem,file;
} size;
 
/*记录各种结构表的文件指针*/
struct File {
    struct {
        struct {
            fstream _static;
            fstream _dynamic;
        } table,index;
    } col,row;
} file;
 
/*静态行式表结构*/
struct StaticRowTable {
    int     id;
    char    name[255];
    int     num;
    double  score;
    bool    flag;
} * static_row_table;
 
/*静态行式表索引*/
struct StaticRowTableIndex {
    multimap<int,int>    id;
    multimap<char*,int>  name;
    multimap<int,int>    num;
    multimap<double,int> score;
    multimap<bool,int>   flag;
} static_row_table_index;
 
/*静态列式表结构*/
struct StaticColTable {
    int*     id;
    char     (*name)[255];
    int*     num;
    double*  score;
    bool*    flag;
} static_col_table;
 
/*动态行式表结构*/
struct DynamicRowTable {
    int    id;
    int    char_len;
    char   *name;
    int    num;
    double score;
    bool   flag;
} * dynamic_row_table;
 
/*动态行式表索引*/
struct DynamicRowTableIndex {
    multimap<int,int>    id;
    multimap<char*,int>  name;
    multimap<int,int>    num;
    multimap<double,int> score;
    multimap<bool,int>   flag;
} dynamic_row_table_index;
 
/*动态列式表结构*/
struct DynamicColTable {
    int*    id;
    int*    char_len;
    char**  name;
    int*    num;
    double* score;
    bool*   flag;
} * dynamic_col_table;
 
/*随机字符*/
char randChar() {
    return rand()%26+'A';
}
 
/*随机字符串*/
void randString(char col[], int len) {
    for(int i=0; i<len; ++i) {
        col[i] = randChar();
    }
}
 
/*初始化表数据*/
void init_StaticTable() {
    double time;
 
    cout << "+-----静态数据-----+" << endl;
 
    //分配空间
    cout << "分配空间中......" << endl;
    timer.begin();
    static_row_table = new StaticRowTable[MAXROWS];
    static_col_table.id = new int[MAXROWS];
    static_col_table.name = new char[MAXROWS][255];
    static_col_table.num = new int[MAXROWS];
    static_col_table.score = new double[MAXROWS];
    static_col_table.flag = new bool[MAXROWS];
    timer.end();
    time = timer.get_time();
    cout << "空间分配完毕!" << endl
         << "分配空间耗时: " 
         << time << "ms" << endl;
 
    //产生随机数据和索引
    cout << "生成数据中......" << endl;
    timer.begin();
    for(int i=0; i<MAXROWS; ++i) {
        static_col_table.id[i] = 
        static_row_table[i].id = i;
        static_row_table_index.id.insert(pair<int,int>(static_row_table[i].id,i));
 
        randString(static_row_table[i].name, rand()%20+1);
        strcpy(static_col_table.name[i],static_row_table[i].name);
        static_row_table_index.name.insert(pair<char*,int>(static_col_table.name[i],i));
 
        static_col_table.num[i] =
        static_row_table[i].num = rand();
        static_row_table_index.num.insert(pair<int,int>(static_row_table[i].num,i));
 
        static_col_table.score[i] = 
        static_row_table[i].score = rand()/rand();
        static_row_table_index.score.insert(pair<double,int>(static_row_table[i].score,i));
 
        static_col_table.flag[i] = 
        static_row_table[i].flag = rand()%2;
        static_row_table_index.flag.insert(pair<bool,int>(static_row_table[i].flag,i));
    }
    timer.end();
    time = timer.get_time();
    cout << "数据生成完毕!" << endl;
    cout << "生成数据耗时: " 
         << time << "ms" << endl;
 
 
    //初始化文件指针
    timer.begin();
    file.row.table._static.open("row_table_static.dat", ios::binary | ios::out);
    file.row.index._static.open("row_index_static.dat", ios::binary | ios::out);
    file.col.table._static.open("col_table_static.dat", ios::binary | ios::out);
 
    if( !file.row.table._static ||
        !file.row.index._static ||
        !file.col.table._static) {
        cout << "打开文件失败" << endl;
    }
 
    cout << "正在将数据写入文件......" << endl;
    for(int i=0; i<MAXROWS; ++i) {
        file.row.table._static.write(reinterpret_cast<char *>(&static_row_table[i]),
                                    sizeof(StaticRowTable));
    }
    file.row.table._static.close();
    for(int i=0; i<MAXROWS; ++i) {
        file.row.index._static.write(reinterpret_cast<char *>(&static_row_table_index),
                                    sizeof(StaticRowTableIndex));
    }
    file.row.index._static.close();
 
    for(int i=0; i<MAXROWS; ++i) {
        file.col.table._static.write(reinterpret_cast<char *>(&static_col_table.id[i]),
                                    sizeof(int));
    }
    for(int i=0; i<MAXROWS; ++i) {
        file.col.table._static.write(reinterpret_cast<char *>(static_col_table.name[i]),
                                    sizeof(char[255]));
    }
    for(int i=0; i<MAXROWS; ++i) {
        file.col.table._static.write(reinterpret_cast<char *>(&static_col_table.num[i]),
                                    sizeof(int));
    }
    for(int i=0; i<MAXROWS; ++i) {
        file.col.table._static.write(reinterpret_cast<char *>(&static_col_table.score[i]),
                                    sizeof(double));
    }
    for(int i=0; i<MAXROWS; ++i) {
        file.col.table._static.write(reinterpret_cast<char *>(&static_col_table.flag[i]),
                                    sizeof(bool));
    }
    file.col.table._static.close();
    timer.end();
    time = timer.get_time();
    cout << "数据写入完毕!" << endl;
    cout << "写入数据耗时: " 
         << time << "ms" << endl;
 
    //计算总占用空间
    size.mem.row._static = sizeof(*static_row_table)*MAXROWS
                    +sizeof(static_row_table_index)*MAXROWS;
    size.mem.col._static = (sizeof(int)*2+sizeof(double)
                    +sizeof(bool)
                    +sizeof(char)*255)*MAXROWS;
 
    cout << "静态行式存储耗费空间: " 
         << size.mem.row._static/1024/1024 << "M" << endl;
    cout << "静态列式存储耗费空间: " 
         << size.mem.col._static/1024/1024 << "M" << endl;
}
 
void init_DynamicTable() {
    double time;
 
    cout << "+-----动态数据-----+" << endl;
}
 
void init() {
    double time1, time2;
 
    srand(time(0));
 
    cout << "======生成数据======" << endl;
 
    init_StaticTable();
    init_DynamicTable();
}
 
/*
SELECT name
FROM table 
WHERE num BETWEEN MINVAL AND MAXVAL;
*/
 
 
/*测试内存中静态行存储*/
int Mem_Static_testRow() {
    double time;
    int count = 0;
    int id;
    multimap<int,int>::iterator it,itlow,itup;
 
    cout << "正在测试内存中读取行式静态表......" << endl;
    timer.begin();
    itlow = static_row_table_index.num.lower_bound (MINVAL);
    itup = static_row_table_index.num.upper_bound (MAXVAL);
 
    for (it=itlow; it!=itup; ++it) {
        id = (*it).second;
        StaticRowTable row = static_row_table[id];
        //结果
        //cout << row.id;
        /*cout << '\t' << */row.name;
        //cout << '\t' << row.num;
        //cout << endl;
        //计数
        ++count;
    }
    timer.end();
    time = timer.get_time();
    cout << "内存中行式静态表读取测试完毕!" << endl;
    cout << "读取耗时:" << time << " ms" << endl;
 
    return count;
}
 
/*测试磁盘中静态行存储*/
int File_Static_testRow() {
    double time;
    int count = 0;
    int id;
    char *name;
    int num;
    int pos;
    StaticRowTable row;
    multimap<int,int>::iterator it,itlow,itup;
 
    //初始化文件指针
    cout << "正在测试磁盘中读取行式静态表......" << endl;
    timer.begin();
    file.row.table._static.open("row_table_static.dat", ios::binary | ios::in);
    //file.row.index._static.open("row_index_static.dat", ios::binary | ios::in);
 
    if(!file.row.table._static) {
        cout << "打开文件失败" << endl;
    }
    //假设索引在内存中
    itlow = static_row_table_index.num.lower_bound (MINVAL);
    itup = static_row_table_index.num.upper_bound (MAXVAL);
 
    for (it=itlow; it!=itup; ++it) {
        id = (*it).second;
        pos = sizeof(StaticRowTable)*id;
        file.row.table._static.seekg(pos);
        file.row.table._static.read(reinterpret_cast<char *>(&row),
                                    sizeof(StaticRowTable));
        //结果
        //cout << row.id;
        /*cout << '\t' << */row.name;
        //cout << '\t' << row.num;
        //cout << endl;
        //计数
        ++count;
    }
    file.row.table._static.close();
    //file.row.index._static.close();
    timer.end();
    time = timer.get_time();
    cout << "磁盘中行式静态表读取测试完毕!" << endl;
    cout << "读取耗时:" << time << " ms" << endl;
 
    return count;
}
 
/*测试磁盘中静态列存储*/
int Mem_Static_testCol() {
    double time;
    int count = 0;
    int id;
    int num;
    char *name;
 
    cout << "正在测试内存中列式静态表读取......" << endl;
    timer.begin();
    for(int i=0; i<MAXROWS; ++i) {
        int num = static_col_table.num[i];
        if(num>MINVAL and num<MAXVAL) {
            //结果
            //cout << i;
            /*cout << '\t' << */static_col_table.name[i];
            //cout << '\t' << static_col_table.num[i];
            //cout << endl;
            //计数
            ++count;
        }
    }
    timer.end();
    time = timer.get_time();
    cout << "内存中列式静态存储表读取测试完毕!" << endl;
    cout << "读取耗时:" << time << " ms" << endl;
 
    return count;
}
 
/*测试磁盘中静态列存储*/
int File_Static_testCol() {
    double time;
    int count = 0;
    int id;
    int num;
    char *name = new char[255];
    int pos_num;
    int pos_name;
    int pos;
 
    cout << "正在测试磁盘中列式静态表读取......" << endl;
    timer.begin();
    file.col.table._static.open("col_table_static.dat", ios::binary | ios::in);
    fstream tmpfile("col_table_static.dat", ios::binary | ios::in);
 
    if(!file.col.table._static || !tmpfile) {
        cout << "打开文件失败" << endl;
    }
 
    pos_name = sizeof(int)*MAXROWS;
    pos_num = (sizeof(int)
            +sizeof(char[255]))*MAXROWS;
    file.col.table._static.seekg(pos_num);
    for(int i=0; i<MAXROWS; ++i) {
        file.col.table._static.read(reinterpret_cast<char *>(&num),
                                    sizeof(int));
        if(num>MINVAL and num<MAXVAL) {
            //结果
            id = i;
            //cout << id;
            pos = pos_name+sizeof(char[255])*id;
            tmpfile.seekg(pos);
            tmpfile.read(reinterpret_cast<char *>(name),
                        sizeof(char[255]));
            /*cout << '\t' << */name;
            //cout << '\t' << num;
            //cout << endl;
            //计数
            ++count;
        }
    }
    file.col.table._static.close();
    timer.end();
    time = timer.get_time();
    cout << "磁盘中列式静态存储表读取测试完毕!" << endl;
    cout << "读取耗时:" << time << " ms" << endl;
 
    return count;
}
 
void test() {
    int count1, count2, count3, count4;
 
    cout << "=====内存存取测试=====" << endl;
    cout << "+----静态表测试中----+" << endl;
    cout << "*行式存储*" << endl;
    //内存中静态行式存储表
    count1 = Mem_Static_testRow();
    //内存中静态列式存储表
    count2 = Mem_Static_testCol();
    cout << "*列式存储*" << endl;
    //磁盘中静态行式存储表
    count3 = File_Static_testRow();
    //磁盘中静态行式存储表
    count4 = File_Static_testCol();
 
    if (count1==count2 and count2==count3 and count3==count4) {
        cout << "共匹配:" << count1 << " 行" << endl;
    } else {
        cout << "错误:每次匹配行数不同" << endl;
    }
 
}
 
int main() {
    init();
    test();
    cout << "All OK!" << endl;
    return 0;
}

2010-02-04测试结果：
======生成数据======
+—–静态数据—–+
分配空间中……
空间分配完毕!
分配空间耗时: 0ms
生成数据中……
数据生成完毕!
生成数据耗时: 4180ms
正在将数据写入文件……
数据写入完毕!
写入数据耗时: 2480ms
静态行式存储耗费空间: 495M
静态列式存储耗费空间: 259M
+—–动态数据—–+
=====内存存取测试=====
+—-静态表测试中—-+
*行式存储*
正在测试内存中读取行式静态表……
内存中行式静态表读取测试完毕!
读取耗时:10 ms
正在测试内存中列式静态表读取……
内存中列式静态存储表读取测试完毕!
读取耗时:0 ms
*列式存储*
正在测试磁盘中读取行式静态表……
磁盘中行式静态表读取测试完毕!
读取耗时:190 ms
正在测试磁盘中列式静态表读取……
磁盘中列式静态存储表读取测试完毕!
读取耗时:210 ms
共匹配:69650 行
All OK!

类似的文章

2010年02月2日 -- 数据仓库相关概念 (0)
2010年03月9日 -- 数据库的拆分与合并 (2)
2009年12月8日 -- 今天的数据库设计培训 (4)