insert into a values (8)
/*!*/;
# at 1070
#110114 16:16:11 server id 3  end_log_pos 1097 	Xid = 36
COMMIT/*!*/;
DELIMITER ;
# End of log file
ROLLBACK /* added by mysqlbinlog */;
/*!50003 SET COMPLETION_TYPE=@OLD_COMPLETION_TYPE*/;
-- Rorate binlog count: 1

#cat multi_master.conf 
[master1]
MASTER_HOST=1.2.3.4
MASTER_USER=plx
MASTER_PASSWORD=plx
MASTER_PORT=3306
MASTER_LOG_NAME=mysql-bin
MASTER_LOG_IDX=000002
MASTER_LOG_POS=521
RELAY_LOG_DIR=/tmp/
RELAY_LOG_NAME=1-relay-bin
 
[master2]
MASTER_HOST=2.3.4.5
MASTER_USER=plx
MASTER_PASSWORD=plx
MASTER_PORT=3306
MASTER_LOG_NAME=mysql-bin
MASTER_LOG_IDX=000002
MASTER_LOG_POS=581
RELAY_LOG_DIR=/tmp/
RELAY_LOG_NAME=2-relay-bin
 
[slave]
SLAVE_USER=plx
SLAVE_PASSWORD=plx

MASTER_LOG_POS=1482
NAME=master1
MASTER_USER=plx
RELAY_LOG_NAME=1-relay-bin
MASTER_LOG_IDX=2
MASTER_HOST=1.2.3.4
MASTER_LOG_NAME=mysql-bin
MASTER_PORT=3306
RELAY_LOG_DIR=/tmp/
MASTER_PASSWORD=plx
RELAY_LOG_IDX=3

#./multi_master_repl.pl 
(DEBUG) Enter: get_config()
	Info: begin
	(DEBUG) get_config --> master1
	(DEBUG) get_config --> multi_master.conf --> master1:MASTER_HOST=1.2.3.4
	(DEBUG) get_config --> multi_master.conf --> master1:MASTER_USER=plx
	(DEBUG) get_config --> multi_master.conf --> master1:MASTER_PASSWORD=plx
	(DEBUG) get_config --> multi_master.conf --> master1:MASTER_PORT=3306
	(DEBUG) get_config --> multi_master.conf --> master1:MASTER_LOG_NAME=mysql-bin
	(DEBUG) get_config --> multi_master.conf --> master1:MASTER_LOG_IDX=000002
	(DEBUG) get_config --> multi_master.conf --> master1:MASTER_LOG_POS=521
	(DEBUG) get_config --> multi_master.conf --> master1:RELAY_LOG_DIR=/tmp/
	(DEBUG) get_config --> multi_master.conf --> master1:RELAY_LOG_NAME=1-relay-bin
	(DEBUG) get_config --> Found master1.info, Read it
	(DEBUG) get_config --> master1.info --> master1:MASTER_LOG_POS=1097
	(DEBUG) get_config --> master1.info --> master1:NAME=master1
	(DEBUG) get_config --> master1.info --> master1:MASTER_USER=plx
	(DEBUG) get_config --> master1.info --> master1:RELAY_LOG_NAME=1-relay-bin
	(DEBUG) get_config --> master1.info --> master1:MASTER_LOG_IDX=2
	(DEBUG) get_config --> master1.info --> master1:MASTER_HOST=1.2.3.4
	(DEBUG) get_config --> master1.info --> master1:MASTER_LOG_NAME=mysql-bin
	(DEBUG) get_config --> master1.info --> master1:MASTER_PORT=3306
	(DEBUG) get_config --> master1.info --> master1:RELAY_LOG_DIR=/tmp/
	(DEBUG) get_config --> master1.info --> master1:MASTER_PASSWORD=plx
	(DEBUG) get_config --> master1.info --> master1:RELAY_LOG_IDX=2
	(DEBUG) get_config --> Push[master1] to Master_Info_List
	(DEBUG) get_config --> master2
	(DEBUG) get_config --> multi_master.conf --> master2:MASTER_HOST=2.3.4.5
	(DEBUG) get_config --> multi_master.conf --> master2:MASTER_USER=plx
	(DEBUG) get_config --> multi_master.conf --> master2:MASTER_PASSWORD=plx
	(DEBUG) get_config --> multi_master.conf --> master2:MASTER_PORT=3306
	(DEBUG) get_config --> multi_master.conf --> master2:MASTER_LOG_NAME=mysql-bin
	(DEBUG) get_config --> multi_master.conf --> master2:MASTER_LOG_IDX=000002
	(DEBUG) get_config --> multi_master.conf --> master2:MASTER_LOG_POS=581
	(DEBUG) get_config --> multi_master.conf --> master2:RELAY_LOG_DIR=/tmp/
	(DEBUG) get_config --> multi_master.conf --> master2:RELAY_LOG_NAME=2-relay-bin
	(DEBUG) get_config --> Found master2.info, Read it
	(DEBUG) get_config --> master2.info --> master2:MASTER_LOG_POS=1541
	(DEBUG) get_config --> master2.info --> master2:NAME=master2
	(DEBUG) get_config --> master2.info --> master2:MASTER_USER=plx
	(DEBUG) get_config --> master2.info --> master2:RELAY_LOG_NAME=2-relay-bin
	(DEBUG) get_config --> master2.info --> master2:MASTER_LOG_IDX=2
	(DEBUG) get_config --> master2.info --> master2:MASTER_HOST=2.3.4.5
	(DEBUG) get_config --> master2.info --> master2:MASTER_LOG_NAME=mysql-bin
	(DEBUG) get_config --> master2.info --> master2:MASTER_PORT=3306
	(DEBUG) get_config --> master2.info --> master2:RELAY_LOG_DIR=/tmp/
	(DEBUG) get_config --> master2.info --> master2:MASTER_PASSWORD=plx
	(DEBUG) get_config --> master2.info --> master2:RELAY_LOG_IDX=2
	(DEBUG) get_config --> Push[master2] to Master_Info_List
	(DEBUG) get_config --> multi_master.conf --> slave:SLAVE_USER=plx
	(DEBUG) get_config --> multi_master.conf --> slave:SLAVE_PASSWORD=plx
(DEBUG) Enter: get_config()
	Info: exit
(DEBUG) Enter: create_slave_threads()
	Info: begin
	(DEBUG) create_slave_threads --> Creating run_slave Threads...
(DEBUG) Enter: run_slave()
	Info: begin [tid: 1]
	(DEBUG) run_slave(0) --> NO KILL SIGNAL --> g_is_killed =>0
	(DEBUG) run_slave --> mysqlbinlog: ./mysqlbinlog -h1.2.3.4 -uplx -pplx -R -t --start-position=1097 mysql-bin.000002 > /tmp/1-relay-bin.000002
Warning: ./mysqlbinlog: unknown variable 'loose_default-character-set=utf8'
	(DEBUG) run_slave(0) --> NO KILL SIGNAL --> g_is_killed =>0
(DEBUG) Enter: import_to_slave()
	Info: begin [Param: p_master_idx=>0]
	(DEBUG) import_to_slave(0) --> NO KILL SIGNAL --> g_is_killed =>0
	(DEBUG) import_to_slave(0) --> Importing Relay Log /tmp/1-relay-bin.000002 To Slave...
	(DEBUG) create_slave_threads --> Created 2 run_slave Threads
(DEBUG) Enter: run_slave()
	Info: begin [tid: 2]
	(DEBUG) run_slave(1) --> NO KILL SIGNAL --> g_is_killed =>0
	(DEBUG) run_slave --> mysqlbinlog: ./mysqlbinlog -h2.3.4.5 -uplx -pplx -R -t --start-position=1541 mysql-bin.000002 > /tmp/2-relay-bin.000002
Warning: ./mysqlbinlog: unknown variable 'loose_default-character-set=utf8'
	(DEBUG) run_slave(1) --> NO KILL SIGNAL --> g_is_killed =>0
(DEBUG) Enter: import_to_slave()
	Info: begin [Param: p_master_idx=>1]
	(DEBUG) import_to_slave(1) --> NO KILL SIGNAL --> g_is_killed =>0
	(DEBUG) import_to_slave(1) --> Importing Relay Log /tmp/2-relay-bin.000002 To Slave...
(DEBUG) Enter: update_master_info()
	Info: begin [Param: p_master_idx=>0]
(DEBUG) Enter: update_master_info()
	Info: begin [Param: p_master_idx=>1]
	(DEBUG) update_master_info(0) --> Now Master-Log is mysql-bin.000002 Pos is 1482
(DEBUG) Enter: update_master_info_file()
	Info: begin [Param: p_master_idx=>0]
	(DEBUG) update_master_info_file(0) --> NO KILL SIGNAL --> g_is_killed =>0
	(DEBUG) update_master_info_file(0) --> Writing master1.info --> MASTER_LOG_POS=1482
	(DEBUG) update_master_info_file(0) --> Writing master1.info --> NAME=master1
	(DEBUG) update_master_info_file(0) --> Writing master1.info --> MASTER_USER=plx
	(DEBUG) update_master_info_file(0) --> Writing master1.info --> RELAY_LOG_NAME=1-relay-bin
	(DEBUG) update_master_info_file(0) --> Writing master1.info --> MASTER_LOG_IDX=2
	(DEBUG) update_master_info_file(0) --> Writing master1.info --> MASTER_HOST=1.2.3.4
	(DEBUG) update_master_info_file(0) --> Writing master1.info --> MASTER_LOG_NAME=mysql-bin
	(DEBUG) update_master_info_file(0) --> Writing master1.info --> MASTER_PORT=3306
	(DEBUG) update_master_info_file(0) --> Writing master1.info --> RELAY_LOG_DIR=/tmp/
	(DEBUG) update_master_info_file(0) --> Writing master1.info --> MASTER_PASSWORD=plx
	(DEBUG) update_master_info_file(0) --> Writing master1.info --> RELAY_LOG_IDX=3
	(DEBUG) update_master_info_file(0) --> Created master1.info
(DEBUG) Enter: update_master_info_file(0)
	Info: exit
(DEBUG) Enter: update_master_info(0)
	Info: exit
(DEBUG) Enter: import_to_slave(0)
	Info: exit
(DEBUG) Enter: run_slave(0)
	Info: exit
	(DEBUG) update_master_info(1) --> Now Master-Log is mysql-bin.000002 Pos is 2120
(DEBUG) Enter: update_master_info_file()
	Info: begin [Param: p_master_idx=>1]
	(DEBUG) update_master_info_file(1) --> NO KILL SIGNAL --> g_is_killed =>0
	(DEBUG) update_master_info_file(1) --> Writing master2.info --> MASTER_LOG_POS=2120
	(DEBUG) update_master_info_file(1) --> Writing master2.info --> NAME=master2
	(DEBUG) update_master_info_file(1) --> Writing master2.info --> MASTER_USER=plx
	(DEBUG) update_master_info_file(1) --> Writing master2.info --> RELAY_LOG_NAME=2-relay-bin
	(DEBUG) update_master_info_file(1) --> Writing master2.info --> MASTER_LOG_IDX=2
	(DEBUG) update_master_info_file(1) --> Writing master2.info --> MASTER_HOST=2.3.4.5
	(DEBUG) update_master_info_file(1) --> Writing master2.info --> MASTER_LOG_NAME=mysql-bin
	(DEBUG) update_master_info_file(1) --> Writing master2.info --> MASTER_PORT=3306
	(DEBUG) update_master_info_file(1) --> Writing master2.info --> RELAY_LOG_DIR=/tmp/
	(DEBUG) update_master_info_file(1) --> Writing master2.info --> MASTER_PASSWORD=plx
	(DEBUG) update_master_info_file(1) --> Writing master2.info --> RELAY_LOG_IDX=3
	(DEBUG) update_master_info_file(1) --> Created master2.info
(DEBUG) Enter: update_master_info_file(1)
	Info: exit
(DEBUG) Enter: update_master_info(1)
	Info: exit
(DEBUG) Enter: import_to_slave(1)
	Info: exit
(DEBUG) Enter: run_slave(1)
	Info: exit
(DEBUG) Enter: create_slave_threads()
	Info: exit

plx@plinux-Laptop:~/Dropbox/MySQLScript$ ./AutoCreateIndex.pl -e "SELECT * FROM foo1 a,foo2 b WHERE 'fdsfsa'=a.col1 AND b.col2 = 'abc' AND a.col1=b.col2 AND a.col3 >1 ORDER BY b.col3,b.col1"
ALTER TABLE foo1 ADD INDEX idx (col1,col3);
ALTER TABLE foo2 ADD INDEX idx (col2,col3,col1);
plx@plinux-Laptop:~/Dropbox/MySQLScript$ ./AutoCreateIndex.pl -e "SELECT * FROM t1 where t1 =1 and t2=2"
ALTER TABLE t1 ADD INDEX idx (t2,t1);
plx@plinux-Laptop:~/Dropbox/MySQLScript$ ./AutoCreateIndex.pl -e "SELECT * FROM t1 where col1=1 and col2=4"
ALTER TABLE t1 ADD INDEX idx (col1,col2);
plx@plinux-Laptop:~/Dropbox/MySQLScript$ ./AutoCreateIndex.pl -e "SELECT * FROM t1 where col1>1 and col2=4"
ALTER TABLE t1 ADD INDEX idx (col2,col1);

CREATE TABLE `hosts` (
    id int unsigned not null primary key auto_increment comment '主键',
    host_name varchar(32) not null comment '主机名',
    host_ip varchar(16) not null comment '主机IP'
);
ALTER TABLE `hosts` ADD UNIQUE uk_Hosts_HostName (host_name);
 
CREATE TABLE `instances` (
    id int unsigned not null primary key auto_increment comment '主键',
    instance_type enum('mysql','oracle','pgsql') not null comment '实例类型',
    instance_name varchar(32) not null comment '实例登录名',
    instance_password varchar(64) not null comment '实例登录密码',
    instance_port smallint unsigned not null comment '实例连接端口',
    host_id int unsigned not null comment '关联主机ID'
);
 
CREATE TABLE `schemas` (
    id int unsigned not null primary key auto_increment comment '主键',
    schema_name varchar(32) not null comment '数据库名',
    instance_id int unsigned not null comment '关联实例ID'
);
 
CREATE TABLE `clusters` (
    id int unsigned not null primary key auto_increment comment '主键',
    cluster_name varchar(32) not null comment '集群名',
    cluster_comment varchar(256) not null comment '集群注释'
);
 
CREATE TABLE `cluster_relations` (
    id  int unsigned not null primary key auto_increment comment '主键',
    cluster_id int unsigned not null  comment '关联集群ID',
    target_id int unsigned not null  comment '关联目标ID',
    target_type enum('instance','schema') not null default 'schema' comment '目标类型',
    UNIQUE KEY (cluster_id, target_id)
);
 
CREATE TABLE `users` (
    id INT unsigned NOT NULL PRIMARY KEY AUTO_INCREMENT comment '主键',
    user_name VARCHAR(32) NOT NULL comment '用户名',
    user_password VARCHAR(64) NOT NULL comment '用户密码'
);

/*
操作说明
1.插入操作，"i 关键字" -- 若存在，则提示；若不存在，则插入关键字。 
2.删除操作，"d 关键字"。
3.输出B+树操作，"p 1或2" -- 两种输出模式，模式1输出整个树结构，模式2按从小到大顺序输出所有关键字。
4.测试，"t 1或2" -- 1测试插入，2测试查找
*/
 
#include <cstdlib>
#include <iostream>
#include <fstream>
#include <string>
#include <sys/time.h>
#include <ctime>
#include <limits.h>
 
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;
}
 
 
// 定义B+树的阶数
#define M 4
// B+树结点定义
struct BPlusNode
{
    int  amount;      // 该结点中已保存的键值个数
    long key[M];      // 键值数组
    long children[M]; // 子结点位置数组
    long father;      // 父结点位置
    long left;        // 同一层中的左结点位置
    long right;       // 同一层中的右结点位置
    bool isactive;    // 有效位
    bool isleave;     // 标志该结点是否叶结点
};
// 函数头定义
bool findkey   (long key, long &position); // 查找包含给定键值的结点位置
bool insertkey (long key, long position);  // 插入一个新键值
bool deletekey (long key, long position);  // 删除给定的键值
void printkey  (long mode);                // 按照给定模式输出B+树
void testBtree (int type) ;    //测试B树
// 全局变量
static long pre;             // 上一个被访问的结点
static long cur;             // 当前指向的结点
static long root;            // 根结点位置
static long smallest;        // 保存最小关键值的叶结点
static long nodenewposition; // 新插入的结点位置
 
// 主函数
int main() {
    Timer     timer;
    BPlusNode node;
    char    command;
    fstream     iofile;
    long keynumber;
    long position = -1;
 
    // 检测索引文件是否存在，若不存在则创建一个初始化的索引文件，其中包含根结点位置，最小键值位置和一个空结点
    fstream infile ("BPlusTreeData.dat", ios::binary|ios::in);
    if (!infile) {    
        node.amount = 1;//如果不存在，则创建根结点，且阶数M=4
        for (int i = 0; i < M; ++i) {
            node.key[i] = 0;
            node.children[i] = 0;
        }
        node.father = 0;
        node.left = 0;
        node.right = 0;
        node.isactive = true;
        node.isleave = true;
        root = 8;//root为什么＝8？
        smallest = 8;
        fstream outfile ("BPlusTreeData.dat", ios::binary|ios::out);//输出文件BPlusTreeData.dat
        outfile.seekp(0, ios::beg);//指针移到begin处，文件开头
        outfile.write((char *)&root, sizeof(long));//输出根结点
        outfile.write((char *)&smallest, sizeof(long));//输出最小关键字
        outfile.write((char *)&node, sizeof(BPlusNode));//输出头指针？
        outfile.close();
    }
    infile.close();
    // 循环获取命令行，执行给定的命令
    while (true) {
        cin >> command >> keynumber;
        // 插入一个新的键值，该值不能与已有关键值重复
        switch (command) {
        case 'i' :
            timer.begin();
            if (findkey(keynumber, position)) {
                cout << keynumber << " is already in this B+ tree" << endl;
            } else if (insertkey(keynumber, position)) {
                timer.end();
                cout << "Successful inserted in " << timer.get_time() << " ms" << endl;
            } else 
                cout << "Action falled" << endl;
            break;
        case 'd' :  // 删除给定的键值
            if (deletekey(keynumber, position))
               cout << "Successful deleted" << endl;
            break;
        case 'p' :
            // 按照指定模式输出B+数
            // 模式“1”输出整棵树结构
            // 模式“2”按照从小到大的顺序输出所有键值
            timer.begin();
            printkey(keynumber);
            timer.end();
            cout << "Printed in " << timer.get_time() << " ms" << endl;
            break;
        case 't':
            timer.begin();
            testBtree(keynumber);
            timer.end();
            cout << "Test in " << timer.get_time() << " ms" << endl;
            break;
        case 'e':
            return 0;
        default :
            cout << "Please make sure the command is correct" << endl;
            continue;
        }
    }
}
 
// 查找包含给定键值的结点位置，若找到则返回“true”
// “position”保存最后访问的结点位置
bool findkey (long key, long &position) {
    BPlusNode node;
    long point;
    fstream iofile ("BPlusTreeData.dat", ios::binary|ios::in|ios::out);
    iofile.seekp(0, ios::beg);
    iofile.read((char *)&root, sizeof(long));
    iofile.seekp(root, ios::beg);
    while (true) {
        cur = iofile.tellp();
        iofile.read((char *)&node, sizeof(BPlusNode));
        if(!node.isactive) 
            continue;
 
        // B+树只在叶结点保存记录信息
        // 所以查找必须执行到叶结点
        if(!node.isleave) { // 如果该结点不是叶结点，则根据键值决定访问哪个子结点
            for (int i = 1; i < node.amount; ++i) {
                point = -1;
                if (node.key[i] > key) {
                    point = node.children[i-1];
                    break;
                }
            }
            if (point == -1) 
                point = node.children[node.amount-1];
            iofile.seekp(point, ios::beg);
            pre = cur;
        } else { // 如果该结点是叶结点，则顺序访问结点中的键值
            for (int i = 1; i < node.amount; ++i) {
                if (node.key[i] == key) {
                    position = cur;
                    iofile.close();
                    return true;
                }
            }
            position = cur;
            iofile.close();
            return false;
        }
    }
}
 
// 按照给定格式输出B+数
void printkey (long mode) {
    BPlusNode node;
    int i = 1, k = 1;
    fstream iofile("BPlusTreeData.dat", ios::binary|ios::in|ios::out);
 
    // 从根结点开始广度遍历，输出整棵B+树结构
    if (mode == 1) {
        iofile.seekp(0, ios::beg);
        iofile.read((char *)&root, sizeof(long));
        iofile.seekp(root, ios::beg);
        do {
            cur = iofile.tellp();
            cout << "level " << k << ":";
            do {
                iofile.read((char *)&node, sizeof(BPlusNode));
                cout << "     node " << i << ": ";
                for (int j = 1; j < node.amount; ++j)
                    cout << node.key[j] << " ";
                if (node.right == 0) {
                    i = 1;
                    cout << endl;
                    break;
                }
                iofile.seekp(node.right, ios::beg);
                ++i;
            } while(true);
            iofile.seekp(cur, ios::beg);
            iofile.read((char *)&node, sizeof(BPlusNode));
            if (node.children[0] == 0)
                break;
            iofile.seekp(node.children[0], ios::beg);
            ++k;
        } while (true);
       iofile.close();
    } else if (mode == 2) { // 从包含最小键值的叶结点开始按照从小到大的顺序输出所有键值
        iofile.seekp(4, ios::beg);
        iofile.read((char *)&smallest, sizeof(long));
        iofile.seekp(smallest, ios::beg);
        do {
            iofile.read((char *)&node, sizeof(BPlusNode));
            for (int l = 1; l < node.amount; ++l)
                cout << node.key[l] << " ";
            if (node.right == 0) {
                cout << endl;
                break;
            }
            iofile.seekp(node.right, ios::beg);
        } while(true);
        iofile.close();
     }
}
 
// 在位于“position”的结点中插入一个新键值“key”
// 按照B+树的规则，根据情况分裂结点 
bool insertkey (long key, long position) {
    fstream iofile;
    iofile.open("BPlusTreeData.dat", ios::binary|ios::in|ios::out);
    BPlusNode node;
    BPlusNode nodenew;
    BPlusNode nodetemp1, nodetemp2;
    long keytemp[M];
    long childrentemp[M+1];
    iofile.seekp(0, ios::end);
    long posEnd = iofile.tellp();
    //根节点分裂之后新建根节点
    if (position == 0) {
        iofile.seekp(0, ios::beg);
        iofile.read((char *)&root, sizeof(long));
        iofile.seekp(root, ios::beg);
        iofile.read((char *)&node, sizeof(BPlusNode));
        nodenew.amount = 2;
        nodenew.key[1] = key;
        nodenew.children[0] = root;
        nodenew.children[1] = nodenewposition;
        nodenew.father = 0;
        nodenew.left = 0;
        nodenew.right = 0;
        nodenew.isactive = true;
        nodenew.isleave = false;
        iofile.seekp(8, ios::beg);
        do {
            cur = iofile.tellp();
            iofile.read((char *)&nodetemp2, sizeof(BPlusNode));
        } while(nodetemp2.isactive && iofile.tellp() < posEnd);
        if (nodetemp2.isactive) {
            nodenewposition = iofile.tellp();
            iofile.write((char *)&nodenew, sizeof(BPlusNode));
        } else {
            iofile.seekp(cur, ios::beg);
            nodenewposition = cur;
            iofile.write((char *)&nodenew, sizeof(BPlusNode));
        }
        root = nodenewposition;
        iofile.seekp(0, ios::beg);
        iofile.write((char *)&root, sizeof(long));
        for (int i = 0; i <= 1; ++i) {
            iofile.seekp(nodenew.children[i], ios::beg);
            iofile.read((char *)&nodetemp1, sizeof(BPlusNode));
            nodetemp1.father = nodenewposition;
            iofile.seekp(nodenew.children[i], ios::beg);
            iofile.write((char *)&nodetemp1, sizeof(BPlusNode));
        }
        iofile.close();
        return true;
    } else { // 没有分裂到根结点
        int insertposition = 0;
        iofile.seekp(position, ios::beg);
        iofile.read((char *)&node, sizeof(BPlusNode));
        if (node.amount < M) { // 结点中还有空位保存新插入的键值，不需要分裂
            // 按照从小到大的顺序重新排列原有键值和新插入的键值
            bool issort1 = false;
            for (int i = 1; i < node.amount; ++i) {
                if (node.key[i] > key) {
                    for (int j = node.amount - i, k = 0; j > 0; --j, ++k)
                        node.key[node.amount-k] = node.key[node.amount-k-1];
                    node.key[i] = key;
                    insertposition = i;
                    issort1 = true;
                    break;
                }
            }
            if (!issort1) {
                node.key[node.amount] = key;
                insertposition = node.amount;
            }
            node.amount++;
            if (!node.isleave) {
                for (int p = node.amount-1; p > insertposition; --p)
                    node.children[p] = node.children[p-1];
                node.children[insertposition] = nodenewposition;
            }
            iofile.seekp(position, ios::beg);
            iofile.write((char *)&node, sizeof(BPlusNode));
            iofile.close();
            return true;
        } else { // 结点中没有空位保存新插入的键值，必须分裂成两个结点
            long nextinsertkey = 0;
            // 按照从小到大的顺序重新排列原有键值和新插入的键值
            // 并且按照键值的顺序重新排列保存子结点位置的数组
            bool issort2 = false;
            for (int m = 1, n = 0, o = 0; m < M; ++m, ++o) {
                if (node.key[m] < key || issort2) {
                    keytemp[m-1+n] = node.key[m];
                    childrentemp[o+n] = node.children[o];
                } else {
                    keytemp[m-1] = key;
                    childrentemp[o] = node.children[o];
                    childrentemp[o+1] = nodenewposition;
                    n = 1;
                    --m;
                    issort2 = true;
                }
            }
            if (!issort2) {
                keytemp[M-1] = key;
                childrentemp[M-1] = node.children[M-1];
                childrentemp[M] = nodenewposition;
            }
            node.amount = M/2+1;
            if (!node.isleave) { // 按照内部结点的方式创建新结点
                nodenew.amount = M/2;
                for (int i = 0, j = 1; i <= M; ++i) {
                    if (i < M/2) {
                        node.key[i+1] = keytemp[i];
                        node.children[i] = childrentemp[i];
                    } else if (i == M/2) {
                        nextinsertkey = keytemp[i];
                        node.children[i] = childrentemp[i];
                    } else if (i < M) {
                        nodenew.key[j] = keytemp[i];
                        nodenew.children[j-1] = childrentemp[i];
                        node.key[i] = 0;
                        ++j;
                    } else if (i == M) { 
                        nodenew.children[j-1] = childrentemp[i];
                    }
                }
                nodenew.isleave = false;
            } else { // 按照叶结点的方式创建新结点
                nodenew.amount = M/2+1;
                for (int i = 0, j = 1; i < M; ++i) {
                    if (i < M/2) {
                        node.key[i+1] = keytemp[i];
                    } else {
                        nodenew.key[j] = keytemp[i];
                        if (i < M-1)
                            node.key[i+1] = 0;
                        ++j;
                    }
                }
                nextinsertkey = nodenew.key[1];
                nodenew.isleave = true;
                for (int n = 0; n < M; ++n)
                    nodenew.children[n] = 0;
            }
            nodenew.key[0] = 0;
            nodenew.father = node.father;
            nodenew.left = position;
            nodenew.right = node.right;
            nodenew.isactive = true;
            // 查找新结点的插入位置
            // 若索引文件中存在一个曾经被删除的结点，则用新结点覆盖掉这个结点
            // 若不存在这样的结点，则将新结点添加到索引文件尾部
            iofile.seekp(8, ios::beg);
            do{
                cur = iofile.tellp();
                iofile.read((char *)&nodetemp2, sizeof(BPlusNode));
            } while(nodetemp2.isactive && iofile.tellp() < posEnd);
            if (nodetemp2.isactive) {
                nodenewposition = iofile.tellp();
                iofile.write((char *)&nodenew, sizeof(BPlusNode));
            } else {
                iofile.seekp(cur, ios::beg);
                nodenewposition = cur;
                iofile.write((char *)&nodenew, sizeof(BPlusNode));
            }
            node.right = nodenewposition;
            iofile.seekp(position, ios::beg);
            iofile.write((char *)&node, sizeof(BPlusNode));
            iofile.close();
            if (insertkey(nextinsertkey, nodenew.father))  // 递归调用插入算法将分裂后需要插入到父结点的键值插入到父结点中
                return true;
            else 
                return false;
        }
    }
}
 
// 删除给定的键值
// 该算法不符合B+树的删除规则
// 只是简单地将除被删除键值外的其它键值重新插入一遍
bool deletekey (long key, long position) {
    fstream iofile;
    iofile.open("BPlusTreeData.dat", ios::binary|ios::in|ios::out);
    BPlusNode node;
    long *keynumbertemp = new long[1000];
    long number = 0;
    long posEnd;
    iofile.seekp(0, ios::end);
    posEnd = iofile.tellp();
    iofile.seekp(4, ios::beg);
    iofile.read((char *)&smallest, sizeof(long));
    iofile.seekp(smallest, ios::beg);
    do {
        iofile.read((char *)&node, sizeof(BPlusNode));
        for (int i = 1; i < node.amount; ++i) {
            keynumbertemp[number] = node.key[i];
            ++number;
        }
        if (node.right == 0) {
            --number;
            break;
        }
        iofile.seekp(node.right, ios::beg);
    } while(true);
    node.amount = 1;
    for (int j = 0; j < M; ++j) {
        node.key[j] = 0;
        node.children[j] = 0;
    }
    node.father = 0;
    node.left = 0;
    node.right = 0;
    node.isactive = true;
    node.isleave = true;
    root = 8;
    smallest = 8;
    iofile.seekp(0, ios::beg);
    iofile.write((char *)&root, sizeof(long));
    iofile.write((char *)&smallest, sizeof(long));
    iofile.write((char *)&node, sizeof(BPlusNode));
    for (;iofile.tellp() < posEnd;){
        iofile.read((char *)&node, sizeof(BPlusNode));
        node.isactive = false;
        iofile.seekp(-long(sizeof(BPlusNode)), ios::cur);
        iofile.write((char *)&node, sizeof(BPlusNode));
    }
    iofile.close();
    for (int k = 0; k <= number; ++k) {
        if (keynumbertemp[k] == key)
            continue;
        findkey(keynumbertemp[k], position);
        insertkey(keynumbertemp[k], position);
    }
    return true;
}
 
// 测试模块
void testBtree (int type) {
    srand(time(0));
    long keynumber, position;
    switch (type) {
    case 1:
        for (int i = 0; i < 5000; ++i) {
            if (i % 1000 == 0) {
                cout << "Insert " << i << " Nodes" << endl;
            }
            keynumber = rand() % LONG_MAX;
            if (! findkey(keynumber, position)) {
                insertkey(keynumber, position);
            }
        }
        break;
    case 2:
        for (int i = 1; i <= 10000; ++i) {
            if (i % 1000 == 0) {
                cout << "Select " << i << " Nodes" << endl;
            }
            keynumber = rand() % LONG_MAX;
            findkey(keynumber, position);
        }
        break;
    }
}

#!/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(<FILE>){
        chomp;
        $server_list[$i] = [split(/,/,$_)];
	    $i++;
    }
    close(FILE);
    # Read SQL List File
    open(FILE,"$sql_file");
    $i = 0;
    $sql = '';
    while(<FILE>){
	    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;
    }
}

<body class=" 
<!-- Start Of Script Generated By WP-PostViews Plus --> 
<script type="text/javascript"> 
/* <![CDATA[ */
jQuery.ajax({type:'GET',url:'http://www.penglixun.com/wp-content/plugins/wp-postviews-plus/postviews_plus.php',data:'todowppvp=&type=index&id=1',cache:false,dataType:'script'});
/* ]]> */
</script> 
<!-- End Of Script Generated By WP-PostViews Plus --> 
home blog col-2-right loggedin browser-chrome">

<!-- Start Of Script Generated By WP-PostViews Plus --> 
<script type="text/javascript"> 
/* <![CDATA[ */
jQuery.ajax({type:'GET',url:'http://www.penglixun.com/wp-content/plugins/wp-postviews-plus/postviews_plus.php',data:'todowppvp=&type=index&id=1',cache:false,dataType:'script'});
/* ]]> */
</script> 
<!-- End Of Script Generated By WP-PostViews Plus --> 
<body class="home blog col-2-right loggedin browser-chrome">

// 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;

#!/usr/bin/perl -w
#############################################
# Create: P.Linux
# Function: Check MySQL Status
# Usage: Run on any computer
# Modify: 
# P.Linux 2010-01-22 
#    Create 0.1 Alpha
# P.Linux 2010-01-26 
#    Update 0.2 Alpha
#    Add color
#    Add stat Monitor
# P.Linux 2010-01-27
#    Update 0.3 Alpha 
#    Move all traffic infromation to one area
#    Add a simple warning function using color
#############################################
use strict;
use DBI;
use Curses;
use Getopt::Std;
use Term::ANSIColor;
use vars qw($opt_i $opt_c $opt_n);
#############################################
 
# Catch ctrl+c Quit
$SIG{TERM}=$SIG{INT} = \&quit;
 
# Set env var from shell profile
set_env();
 
# Autoflush for print
$| = 1;
 
# Global System Var
my $USERNAME='';
my $PASSWORD='';
my $HOSTNAME='localhost';
 
# Global Status Var
my $now;
my $status_res;
my @status;
 
# CmdLine Option vars
my($interval, $count, $name);
 
# Version
my $version='0.3Alpha';
 
#############################################
# Main Program
#############################################
 
# Get CmdLine Options
&get_option();
 
# Connect to database as root via DBI
my $dbconn;
 
eval{
    local $SIG{ALRM} = sub { die "连接数据库超时\n" };
    alarm 20;
    $dbconn = DBI->connect("DBI:mysql:host=$HOSTNAME", $USERNAME, $PASSWORD, {'RaiseError' => 1}) or die "Connect to MySQL database error:". DBI->errstr;
    alarm 0;
};
 
if($@){
    print "Connect to MySQL database error:".$@."\n";
    exit;
}
 
# Do loop
&do_loop();
 
# Disconnect from MySQL
$dbconn->disconnect;
 
###########################################
## Print Usage
###########################################
sub print_usage () {
        print <<EOF
 NAME:
        mystat
 
 SYNTAX:
        mystat -i interval -c count -n statname
 
 FUNCTION:
        Report Status Information of MySQL
 
 PARAMETER:
     -i    interval interval time,default 1 seconds
     -c    count        times
     -n    name         statistics name
 
EOF
}
 
#########################################################
## Get Options
#########################################################
sub get_option(){
    my $rtn = getopts('i:c:n:');
    unless ( "$rtn" eq "1" ) { print_usage(); exit 1;}
 
    $interval=$opt_i?$opt_i:1;
    $count=$opt_c?$opt_c+1:0;
    $name=$opt_n?$opt_n:'nothing';
 
    if($interval !~ /[0-9]/ || $count !~ /[0-9]/) { print_usage(); exit 1;}
    if(($ARGV[0] && $ARGV[0] !~ /[0-9]/) || ($ARGV[1] && $ARGV[1] !~ /[0-9]/)) { print_usage(); exit 1;}
 
    if($ARGV[0]){
        $interval=$ARGV[0];
    }
    if($ARGV[1]){
        $count=$ARGV[1]+1;
    }
    if($ARGV[2]){
    $name=$ARGV[2];
    }
 
    $name=lc($name);
}
 
#############################################
## Main Loop to get MySQL Status
#############################################
sub do_loop{
    $now = 0;
    init();
    if($count){
        for(my $c=0;$c<$count;$c++){
            refresh_all();
            sleep $interval;
        }
    }
    else{ # if $count == 0 then loop time is unlimit
        for(my $c=0;;$c++){
            refresh_all();
            sleep $interval;
        }
    }
}
 
#########################################################
## Set env from profile
#########################################################
sub set_env {
    my $user='plx';
    chomp($user);
    my $profile="/home/".$user."/.profile";
    if (! -e $profile ){
        $profile="/home/".$user."/.bash_profile"
    }
    open(NEWENV, ". $profile && env|");
    while (<NEWENV>){
        if (/(\w+)=(.*)/){
            $ENV{$1}="$2";
        }
    }
    close NEWENV;
}
 
#######################################################
## Catch Ctrl+C
#######################################################
sub quit {
    print "\nExit...\n";
    $dbconn->disconnect;
    exit 1;
}
 
#######################################################
## Initialization
#######################################################
sub init {
    get_stat();
    $status_res->{'Max_Bytes_traffic'} = 0;
    $status_res->{'Max_Bytes_received'} = 0;
    $status_res->{'Max_Bytes_sent'} = 0;
    $status_res->{'Max_Sort_rows'} = 0;
    $status_res->{'Max_Sort_times'} = 0;
    $status_res->{'Max_Sort_load'} = 0;
}
 
#######################################################
##### Print Value
#######################################################
sub print_val {
    my ($val)=$_[0];
    my ($fmt)=$_[1];
    my $ret = $val/1024/1024/1024 < 1
                        ? $val/1024/1024 < 1
                            ? printf("$fmt K", $val/1024)
                            : printf("$fmt M", $val/1024/1024)
                        : printf("$fmt G", $val/1024/1024/1024);
}
 
#######################################################
#### Print Same Char
#######################################################
sub print_char {
    my ($ch)=$_[0];
    my ($cnt)=$_[1];
    for(my $c=0; $c<$cnt; $c++) {
        print "$ch";
    }
}
 
#######################################################
### Print Header
#######################################################
sub print_header {
    print color("red");
    #print "+";print_char('-',75);print "+\n";
    print "+";print_char('-',29);print "mystat Ver ".$version;print_char('-',29);print "+\n";
    print "+";print_char('-',27);print "Powered by PengLiXun.NET";print_char('-',26);print "+\n";
    #print "+";print_char('-',75);print "+\n";
    print color("reset");
}
 
#######################################################
### Display Version & Hostname & Uptime
#######################################################
sub display_var_title {
    # Display Version & Hostname
    my $ver = $status_res->{'version'};
    print "|--MySQL $ver";
    printf "%25s", "@ ".$status_res->{'hostname'}." (".$status_res->{'version_compile_machine'}.")";
    # Display Uptime
    my($sec,$min,$hour,$day) = gmtime($status_res->{'Uptime'});
    $day = $day-1;
    printf "   Uptime:%3sd%3sh%3sm%3ss", $day, $hour, $min, $sec;
    printf "---%2ss--|\n",$interval;
}
 
#######################################################
### Display Cache
#######################################################
sub display_var_cache {
    my $query = $status_res->{'query_cache_size'};
    my $thd = $status_res->{'thread_cache_size'};
    my $tbl = defined($status_res->{'table_open_cache'})
                        ? $status_res->{'table_open_cache'}
                        : $status_res->{'table_cache'};
    #print color("green");
    print "\t|Query Cache: ";
    print_val($query, "%3s");
    printf " | Thread Cache: %5s", $thd;
    printf " | Table Cache: %5s|\n", $tbl;
    #print color("reset");
}
 
#######################################################
### Display Buffer
#######################################################
sub display_var_buffer {
    my $key = $status_res->{'key_buffer_size'};
    my $join = $status_res->{'join_buffer_size'};
    my $sort = $status_res->{'sort_buffer_size'};
    print "\t|Key Buffer: ";
    print_val($key, "%4s");
    print " | Sort Buffer: ";
    print_val($sort, "%4s");
    print " | Join Buffer: ";
    print_val($join, "%3s");
    print "|\n";
}
 
#######################################################
### Display Log Status
#######################################################
sub display_var_log {
    my $g_log = $status_res->{'log'};
    my $b_log = $status_res->{'log_bin'};
    my $s_log = $status_res->{'log_slow_queries'};
    printf "\t|General Log: %5s", $g_log;
    printf " | Bin Log: %10s", $b_log;
    printf " | Slow Log: %8s|\n", $s_log;
}
 
#######################################################
### Display Connections
#######################################################
sub display_var_conn {
    my $max_conn = $status_res->{'max_connections'};
    my $max_used = $status_res->{'Max_used_connections'};
    my $act_conn = $status_res->{'Threads_connected'};
    my $used_rate = $max_used/$max_conn*100;
    my $now_rate = $act_conn/$max_conn*100;
    printf "\t|Act User:%4s(%2.0f%%)", $act_conn, $now_rate;
    if ($used_rate>80) {
        printf " | ";
        printf color("red");
        printf "Max Used:%5s(%2.0f%%)", $max_used, $used_rate;
        printf color("reset");
        printf color("green");
    } else {
         printf " | Max Used:%5s(%2.0f%%)", $max_used, $used_rate;
    }
    printf " | Max Connect:%6s|\n", $max_conn;
}
 
#######################################################
### Display Query
#######################################################
sub display_var_query {
    my $select = $status_res->{"Com_select"};
    my $insert = $status_res->{"Com_insert"};
    my $update = $status_res->{"Com_update"};
    my $delete = $status_res->{"Com_delete"};
    my $sql = $select+$insert+$update+$delete;
    my $select_rate = $select/$sql*100;
    my $insert_rate = $insert/$sql*100;
    my $update_rate = $update/$sql*100;
    my $delete_rate = $delete/$sql*100;
    printf "\t|SELECT:%5.2f%%", $select_rate;
    printf " | INSERT:%5.2f%%", $insert_rate;
    printf " | UPDATE:%5.2f%%", $update_rate;
    printf " | DELETE:%5.2f%%|\n", $delete_rate;
}
 
#######################################################
##### Print Variables
#######################################################
sub print_vars {
    print color("blue");
    display_var_title();
    print color("reset");
    print color("green");
    display_var_cache();
    display_var_buffer();
    display_var_log();
    display_var_conn();
    display_var_query();
    print color("reset");
}
 
#######################################################
### Display Traffic Information
#######################################################
sub display_stat_traffic {
    my $now_received = $status_res->{'Now_Bytes_received'};
    my $now_sent = $status_res->{'Now_Bytes_sent'};
    my $now_traffic = $status_res->{'Now_Bytes_traffic'};
    my $max_received = $status_res->{'Max_Bytes_received'};
    my $max_sent = $status_res->{'Max_Bytes_sent'};
    my $max_traffic = $status_res->{'Max_Bytes_traffic'};
    my $all_received = $status_res->{'Bytes_received'};
    my $all_sent = $status_res->{'Bytes_sent'};
    my $all_traffic = $status_res->{'Bytes_traffic'};
 
    print color("blue");
    print "+";print_char('-',2);
    print "Network Traffic";print_char('-',60);print "+\n";
    print color("reset");
 
    print_char(' ',2);
    print "Now Traf:";
    print_val($now_traffic, "%9.2f");
    print "B/s";
    print " | ";
    print "Now Recv:";
    print_val($now_received, "%9.2f");
    print "B/s";
    print " | ";
    print "Now Sent:";
    print_val($now_sent, "%9.2f");
    print "B/s";
    print "\n";
 
    print_char(' ',2);
    print "Max Traf:";
    print_val($max_traffic, "%9.2f");
    print "B/s";
    print " | ";
    print "Max Recv:";
    print_val($max_received, "%9.2f");
    print "B/s";
    print " | ";
    print "Max Sent:";
    print_val($max_sent, "%9.2f");
    print "B/s";
    print "\n";
 
    print_char(' ',2);
    print "All Traf:";
    print_val($all_traffic, "%11.4f");
    print "B";
    print " | ";
    print "All Recv:";
    print_val($all_received, "%11.4f");
    print "B";
    print " | ";
    print "All Sent:";
    print_val($all_sent, "%11.4f");
    print "B";
    print "\n";
}
 
#######################################################
### Display Key Buffer
#######################################################
sub display_stat_key {
    my $key_buffer = $status_res->{'key_buffer_size'};
    my $key_blocks_used = $status_res->{'Key_blocks_used'};
    my $key_blocks_unused = $status_res->{'Key_blocks_unused'};
    my $key_used_rate =$status_res->{'Key_used_rate'};
    my $key_free_rate = $status_res->{'Key_free_rate'};
    my $key_used = $status_res->{'Key_used'};
    my $key_free = $status_res->{'Key_free'};
 
    my $key_read_requests = $status_res->{'Key_read_requests'};
    my $key_reads = $status_res->{'Key_reads'};
    my $key_read_hit_rate =$status_res->{'Key_read_hit_rate'}; 
 
    my $key_write_requests = $status_res->{'Key_write_requests'};
    my $key_writes = $status_res->{'Key_writes'};
    my $key_write_hit_rate = $status_res->{'Key_write_hit_rate'};
 
    my $key_avg_hit_rate = $status_res->{'Key_avg_hit_rate'};
 
    print color("blue");
    print "+";
    print_char('-',2);
    print "Key Buffer";
    print_char('-',65);print "+\n";
    print color("reset");
 
    print_char(' ',2);
    printf "Buffer Used:";
    print_val($key_used, "%10.2f");
    printf "B (%6.2f%%)", $key_used_rate;
    printf "  |  ";
    printf "Buffer Free:";
    print_val($key_free, "%10.2f");
    printf "B (%6.2f%%)", $key_free_rate;
    printf "\n";
 
    print_char(' ',2);
    printf "Avg Hit:%13.2f %%", $key_avg_hit_rate;
    printf " | ";
    printf "Read Hit:%12.2f %%", $key_read_hit_rate;
    printf " | ";
    printf "Write Hit:%11.2f %%\n", $key_write_hit_rate;
}
#######################################################
### Display Query Cache
#######################################################
sub display_stat_qcache {
    my $query_cache_size = $status_res->{'query_cache_size'};
    my $qcache_free_memory = $status_res->{'Qcache_free_memory'};
    my $qcache_free_blocks = $status_res->{'Qcache_free_blocks'};
    my $qcache_hits = $status_res->{'Qcache_hits'};
    my $qcache_inserts = $status_res->{'Qcache_inserts'};
    my $qcache_lowmem_prunes = $status_res->{'Qcache_lowmem_prunes'};
    my $qcache_not_cached = $status_res->{'Qcache_not_cached'};
    my $qcache_queries_in_cache = $status_res->{'Qcache_queries_in_cache'};
    my $qcache_total_blocks = $status_res->{'Qcache_total_blocks'};
    my $qcache_frag_rate = $status_res->{'Qcache_frag_rate'};
    my $qcache_used_rate = $status_res->{'Qcache_used_rate'};
    my $qcache_hit_rate = $status_res->{'Qcache_hit_rate'};
 
    print color("blue");
    print "+";print_char('-',2);
    print "Query Cache";print_char('-',64);print "+\n";
    print color("reset");
 
    print_char(' ',2);
    printf "Qcache Used: %8.2f %%", $qcache_used_rate;
    printf " | ";
    printf "Qcache Hit: %9.2f %%", $qcache_hit_rate;
    printf " | ";
    printf "Fragmentation: %6.2f %%", $qcache_frag_rate;
    printf "\n";
    print_char(' ',2);
    printf "Query in Cache:%8s", $qcache_queries_in_cache;
    printf " | ";
    printf "Query Low Mem Prunes:%10s", $qcache_lowmem_prunes;    
    printf "\n";
}
 
#######################################################
### Display Sort
#######################################################
sub display_stat_sort {
    my $now_sort_rows = $status_res->{'Now_Sort_rows'};
    my $now_sort_times = $status_res->{'Now_Sort_times'};
    my $now_sort_load = $status_res->{'Now_Sort_load'};
    my $now_sort_range = $status_res->{'Now_Sort_range'};
    my $now_sort_scan = $status_res->{'Now_Sort_scan'};
    my $now_sort_merge_passes = $status_res->{'Now_Sort_merge_passes'};
    my $max_sort_rows = $status_res->{'Max_Sort_rows'};
    my $max_sort_times = $status_res->{'Max_Sort_times'};
    my $max_sort_load = $status_res->{'Max_Sort_load'};
 
 
    print color("blue");
    print "+";
    print_char('-',2);
    print "Sort";
    print_char('-',71);
    print "+\n";
    print color("reset");
 
    print_char(' ',2);
    printf "Now Rows:%7.0f Rows/s", $now_sort_rows;
    printf " | ";
    printf "Now Times:%5.0f Times/s", $now_sort_times;
    printf " | ";
    printf "Now Load:%4.0f Rows/Time", $now_sort_load;
    printf "\n";
 
    print_char(' ',2);
    printf "Max Rows:%7.0f Rows/s", $max_sort_rows;
    printf " | ";
    printf "Max Times:%5.0f Times/s", $max_sort_times;
    printf " | ";
    printf "Max Load:%4.0f Rows/Time", $max_sort_load;
    printf "\n";
 
    print_char(' ',2);
    printf "Scan: %9.0f Times/s", $now_sort_scan;
    printf " | ";
    printf "Range: %8.0f Times/s", $now_sort_range;
    printf " | ";
    printf "Merge: %8.0f Times/s", $now_sort_merge_passes;
    printf "\n";
}
 
#######################################################
#### Print Status
#######################################################
sub print_stat {
    display_stat_traffic();  
    display_stat_key();
    display_stat_qcache();
    display_stat_sort();
}
 
#######################################################
##### Get MySQL Variables & Status
#######################################################
sub get_stat {
    # Get MySQL Version 
    my $sql = "SELECT version();";
    my $ver = $dbconn->selectrow_arrayref($sql);
    $status_res->{"version"} = $ver->[0];
 
    # Get MySQL Variables
    $sql = "SHOW GLOBAL VARIABLES;";
    my $vars = $dbconn->selectall_arrayref($sql);
    foreach my $row(@$vars){
        $status_res->{"$row->[0]"} = $row->[1];
    }
 
    # Get MySQL Status
    $sql="SHOW GLOBAL STATUS;";
    my $stat=$dbconn->selectall_arrayref($sql);
    foreach my $row(@$stat){
        $status[$now]->{"$row->[0]"} = $row->[1];
        $status_res->{"$row->[0]"} = $row->[1];
    }
}
 
#######################################################
####### Calc Result Status
#######################################################
sub calc_stat {
    # Calc Traffic
    $status_res->{'Bytes_traffic'} = $status_res->{'Bytes_received'} + $status_res->{'Bytes_sent'};    
 
    $status_res->{'Now_Bytes_received'} = 
        ($status[$now]->{'Bytes_received'} - $status[1-$now]->{'Bytes_received'})/$interval;
    $status_res->{'Now_Bytes_sent'} = 
        ($status[$now]->{'Bytes_sent'} - $status[1-$now]->{'Bytes_sent'})/$interval;
    $status_res->{'Now_Bytes_traffic'} = 
        ($status_res->{'Now_Bytes_received'} + $status_res->{'Now_Bytes_sent'})/$interval; 
 
    if ($status_res->{'Max_Bytes_traffic'} < $status_res->{'Now_Bytes_traffic'}) {
        $status_res->{'Max_Bytes_traffic'} = $status_res->{'Now_Bytes_traffic'};
    }
    if ($status_res->{'Max_Bytes_received'} < $status_res->{'Now_Bytes_received'}) {
        $status_res->{'Max_Bytes_received'} = $status_res->{'Now_Bytes_received'};
    }
    if ($status_res->{'Max_Bytes_sent'} < $status_res->{'Now_Bytes_sent'}) {
        $status_res->{'Max_Bytes_sent'} = $status_res->{'Now_Bytes_sent'};
    }
 
    $status_res->{'Qcache_frag_rate'} = 
            $status_res->{'Qcache_total_blocks'}
         ? $status_res->{'Qcache_free_blocks'}/$status_res->{'Qcache_total_blocks'}*100
         : 0;
    $status_res->{'Qcache_used_rate'} = 
            $status_res->{'query_cache_size'}
         ? ($status_res->{'query_cache_size'}-$status_res->{'Qcache_free_memory'})/$status_res->{'query_cache_size'}*100
         : 0;
    $status_res->{'Qcache_hit_rate'} = 
            $status_res->{'Qcache_hits'}
         ? $status_res->{'Qcache_hits'}/$status_res->{'Qcache_inserts'}*100
         : 0;
 
    # Calc Key Buffer
    $status_res->{'Key_used_rate'} = 
        ($status_res->{'Key_blocks_used'}/($status_res->{'Key_blocks_unused'}+$status_res->{'Key_blocks_used'}))*100;
    $status_res->{'Key_free_rate'} = 100 - $status_res->{'Key_used_rate'};
    $status_res->{'Key_used'} = $status_res->{'Key_used_rate'}/100*$status_res->{'key_buffer_size'};
    $status_res->{'Key_free'} = $status_res->{'Key_free_rate'}/100*$status_res->{'key_buffer_size'};
 
    $status_res->{'Key_write_hit_rate'} = 
        (1 -  $status_res->{'Key_writes'}/ $status_res->{'Key_write_requests'})*100;
    $status_res->{'Key_read_hit_rate'} = 
        (1 -  $status_res->{'Key_reads'}/ $status_res->{'Key_read_requests'})*100; 
    $status_res->{'Key_avg_hit_rate'} = 
        ($status_res->{'Key_write_hit_rate'}+$status_res->{'Key_read_hit_rate'})/2;
 
    # Calc Sort 
    $status_res->{'Now_Sort_rows'} = 
        ($status[$now]->{'Sort_rows'} - $status[1-$now]->{'Sort_rows'})/$interval;
    $status_res->{'Now_Sort_range'} = 
        ($status[$now]->{'Sort_range'} - $status[1-$now]->{'Sort_range'})/$interval;
    $status_res->{'Now_Sort_scan'} = 
        ($status[$now]->{'Sort_scan'} - $status[1-$now]->{'Sort_scan'})/$interval;
    $status_res->{'Now_Sort_merge_passes'} = 
        ($status[$now]->{'Sort_merge_passes'} - $status[1-$now]->{'Sort_merge_passes'})/$interval;
    $status_res->{'Now_Sort_times'} = 
        $status_res->{'Now_Sort_range'}+$status_res->{'Now_Sort_scan'}+$status_res->{'Now_Sort_merge_passes'};
    $status_res->{'Now_Sort_load'} =
           $status_res->{'Now_Sort_times'}
        ? $status_res->{'Now_Sort_rows'}/$status_res->{'Now_Sort_times'}
        : 0;
 
    if ($status_res->{'Max_Sort_times'} < $status_res->{'Now_Sort_times'}) {
        $status_res->{'Max_Sort_times'} = $status_res->{'Now_Sort_times'};
    }
    if ($status_res->{'Max_Sort_rows'} < $status_res->{'Now_Sort_rows'}) {
        $status_res->{'Max_Sort_rows'} = $status_res->{'Now_Sort_rows'};
    }
    if ($status_res->{'Max_Sort_load'} < $status_res->{'Now_Sort_load'}) {
        $status_res->{'Max_Sort_load'} = $status_res->{'Now_Sort_load'};
    }
}
 
#######################################################
###### Refresh All Status
#######################################################
sub refresh_all {
    my ($cnt)=@_;
    $now = 1-$now;
    get_stat();
    calc_stat();
    system "clear";
    print_header();
    print_vars();
    print_stat();
}

#include <iostream>
#include <cstdlib>
#include <time.h>
#include <math.h>
#define MAXN 10000
#define LIMIT 500
 
int a[MAXN];
int last;
int count_sw, count_cmp;
 
//初始化测试数据
void init () {
	srand(time(0));
	//参与查询的数据
	for(int i=0; i<MAXN; ++i) {
		a[i] =  rand()%MAXN;
	}
	return ;
}
void swap(int &x, int &y) {
	int t ;
	t = x;
	x = y;
	y = t;
	return ;
}
 
void qsort(int arr[], int start, int end) {
	if(start < end) {
		int mid = arr[rand()%(end-start) + start];
		int i = start - 1;
		int j = end + 1;
		while (true) {
			while (arr[++i] > mid) count_cmp++;
			while (arr[--j] < mid) count_cmp++;
			if(i>=j) break;
			swap(arr[i], arr[j]);
			count_sw++;
		}
		qsort (arr, start, i-1);
		qsort (arr, j+1, end);
	}
	return ;
}
 
void topK(int arr[], int start, int end, int k) {
	if(start < end) {
		int mid = arr[rand()%(end-start) + start];
		int i = start - 1;
		int j = end + 1;
		while (true) {
			while (arr[++i] > mid) count_cmp++;
			while (arr[--j] < mid) count_cmp++;
			if(i>=j) break;
			swap(arr[i], arr[j]);
			count_sw++;
		}
		if(i-start > k) {
			last = i-1;
			topK (arr, start, i-1, k);
		} else{
			qsort(arr, start, last);
		}
	}
	return ;
}
 
int main() {
	init();
	count_sw = 0;
	count_cmp = 0;
	topK(c, 0, MAXN-1,10);
	cout << "Result:" << MAXN << endl;
	for(int i=0; i<10; ++i) {
		cout << c[i] << endl;
	}
	cout << "Swaps:" << count_sw << endl;
	cout << "Campare:" << count_cmp << endl;
	return 0;
}