MySQL Replication

231gsd

MySQL日志类型
        二进制日志
        事务日志
        错误日志
        一般查询日志
        中继日志
        慢查询日志

二进制日志
        默认存放于数据目录
        命名格式：mysql-bin.xxxxxx
                滚动：达到单个文件的最大上限,flush logs,服务器重启

二进制日志格式
        基于语句
        基于行
        混合

mysql-bin.index：二进制日志文件索引文件

查看当前正在使用的二进制日志文件
mysql> SHOW MASTER STATUS;

查看存在的二进制文件
mysql> SHOW BINARY LOGS;

查看二进制日志文件内容
mysql> SHOW BINLOG EVENTS IN "file";

event:
        timestamp
        position,offset
        event

MySQL隔离级别：
        READ-UNCOMMITED
        READ-COMMITTED
        REPEATABLE-READ
        SERIALIZABLE

MySQL Replication-------MySQL复制

Master服务器，Slave服务器
当Master服务器上产生与写操作相关的操作时，Master会在二进制日志文件中记录这些操作，同时Master将二进制日志文件中的内容同步到Slave服务器一份，Slave服务器收到信息时，会保存到自己的二进制日志文件中，再从二进制日志文件中读取相关内容，更新自己中的数据

Master服务器上的日志称为二进制日志
Slave服务器上的日志称为relay log  中继日志

MySQL支持一主多从模型

异步复制：Master服务器操作完成，当操作作为事件写入二进制日志，即反馈成功
半同步复制：当有多台slave服务器时，master向离自己最近的slave服务器同步二进制日志文件后，即反馈成功
        MySQL 5.5前不支持半同步，5.5时由google研发半同步补丁后支持


MySQL主、从复制的作用：
        辅助实现备份
        高可用
        异地容灾
        scale out：分摊负载(Master负责写操作,Slave负责读操作)    rw-spliting  读写分离
                通过MySQL代理识别MySQL的读、写操作


主从架构中，不使用MySQL代理，如何让主的负责写操作，从的负责读操作？


双主模型：无法减轻写操作



读写分离工具：
        mysql-proxy
        amoeba

数据拆分工具：
        cobar


MySQL可以一主对多从，但一个从服务器只能属于一个主服务器


MySQL 5.6：gtid,multi-thread replication


配置MySQL复制基本步骤：

一、master
1、启用二进制日志
log-bin = master-bin
log-bin-index = master-bin.index

2、选择一个唯一的server id
server-id = { 1---2^32-1 }

3、创建具有复制权限的用户
REPLICATION SLAVE： 具有从master二进制日志中复制事件的权限
REPLICAITON CLIENT：具有连接master服务，获取相关信息的权限

二、slave
1、启用中继日志
relay-log =
relay-log-index =

2、选择唯一的server-id
server-id = { 1 - 2^32-1 }

3、连接至主服务器，并开始复制数据
mysql>CHANGE MASTER TO MASTER_HOST='',MASTER_PORT='',MASTER_LOG_FILE='',MASTER_LOG_POS='',MASTER_USER='',MASTER_PASSWORD='' ;
mysql> START SLAVE;

复制线程：
        master: dump thread
                用于向slave服务器传递二进制日志文件中事件
        slave:　IO_thread, SQL_thread
                io_thread：用于读取master服务器传递的二进制日志文件的事件，并保存至relay log
                sql_thread：用于从relay log中读取事件，在slave服务器上执行


mysql> START SLAVE; 会启动slave服务器上的两个复制线程
mysql> START SLAVE io_thread;  仅启动io_thread线程
mysql> START SLAVE sql_thread； 仅启动sql_thread线程

MySQL主、从复制配置
环境描述 ：
        172.16.1.1 server1.bj.com  Master
        172.16.1.2 server2.bj.com  Slave
        软件 ： mysql-5.5.46-linux2.6-i686.tar.gz


1、在master上安装Mysql,并编辑其配置文件

安装myql
# mkdir -p /mydata/data
# useradd mysql
# chown -R mysql.mysql /mydata/data/

# tar zxf mysql-5.5.46-linux2.6-i686.tar.gz -C /usr/local/
# cd /usr/local/
# ln -s mysql-5.5.46-linux2.6-i686/ mysql
# chown -R root.mysql /usr/local/mysql/*

# cp support-files/my-large.cnf /etc/my.cnf
# cp support-files/mysql.server /etc/init.d/mysqld
# chkconfig --add mysqld

# scripts/mysql_install_db --user=mysql --datadir=/mydata/data/

编辑配置文件
# vim /etc/my.cnf
log-bin=master-bin   //启用二进制日志文件
log-bin-index=master-bin.index  //启用二进制日志索引文件
datadir=/mydata/data
binlog_format=mixed
server-id = 1      //指定服务器server-id，不能相同

# /etc/init.d/mysqld start
Starting MySQL....                                         [  OK  ]


登录mysql服务器，创建拥有复制权限的用户

mysql> GRANT REPLICATION SLAVE ON *.* TO 'repluser'@'172.16.1.2' IDENTIFIED BY 'replpass';
mysql> FLUSH PRIVILEGES;


2、在slave服务器上安装mysql，并编辑其配置文件

# vim /etc/my.cnf
server-id = 11     //指定服务器server-id，不能相同
datadir=/mydata/data
innodb_file_per_table=1
relay-log=relay-log      //启用中继日志文件  
relay-log-index=relay-log.index  //启用中继日志索引文件

# /etc/init.d/mysqld start
Starting MySQL...                                          [  OK  ]

登录mysql服务器，连接master服务器
登录mysql服务器上的mysql，查看当前正在使用的二进制日志文件名称，及其事件位置
master：
# mysql -u root
mysql> SHOW MASTER STATUS;
+-------------------+----------+--------------+------------------+
| File              | Position | Binlog_Do_DB | Binlog_Ignore_DB |
+-------------------+----------+--------------+------------------+
| master-bin.000001 |      339 |              |                  |
+-------------------+----------+--------------+------------------+
1 row in set (0.00 sec)

mysql> SHOW BINLOG EVENTS IN 'master-bin.000001';
+-------------------+-----+-------------+-----------+-------------+------------------------------------------------------------------------------------+
| Log_name          | Pos | Event_type  | Server_id | End_log_pos | Info                                                                               |
+-------------------+-----+-------------+-----------+-------------+------------------------------------------------------------------------------------+
| master-bin.000001 |   4 | Format_desc |         1 |         107 | Server ver: 5.5.46-log, Binlog ver: 4                                              |
| master-bin.000001 | 107 | Query       |         1 |         264 | GRANT REPLICATION SLAVE ON *.* TO 'repluser'@'172.16.1.2' IDENTIFIED BY 'replpass' |
| master-bin.000001 | 264 | Query       |         1 |         339 | FLUSH PRIVILEGES                                                                   |
+-------------------+-----+-------------+-----------+-------------+----------------------------------------------------------------------------
3 rows in set (0.00 sec)

mysql> CHANGE MASTER TO MASTER_HOST='172.16.1.1',MASTER_USER='repluser',MASTER_PASSWORD='replpass',MASTER_LOG_FILE='master-bin.000001',MASTER_LOG_POS=339;
Query OK, 0 rows affected (0.05 sec)

查看slave服务器状态：
mysql> SHOW SLAVE STATUS\G;
*************************** 1. row ***************************
               Slave_IO_State:
                  Master_Host: 172.16.1.1  
                  Master_User: repluser
                  Master_Port: 3306
                Connect_Retry: 60
              Master_Log_File: master-bin.000001
          Read_Master_Log_Pos: 339
               Relay_Log_File: relay-log.000001
                Relay_Log_Pos: 4
        Relay_Master_Log_File: master-bin.000001
             Slave_IO_Running: No
            Slave_SQL_Running: No
              Replicate_Do_DB:
          Replicate_Ignore_DB:
           Replicate_Do_Table:
       Replicate_Ignore_Table:
      Replicate_Wild_Do_Table:
  Replicate_Wild_Ignore_Table:
                   Last_Errno: 0
                   Last_Error:
                 Skip_Counter: 0
          Exec_Master_Log_Pos: 339
              Relay_Log_Space: 107
              Until_Condition: None
               Until_Log_File:
                Until_Log_Pos: 0
           Master_SSL_Allowed: No
           Master_SSL_CA_File:
           Master_SSL_CA_Path:
              Master_SSL_Cert:
            Master_SSL_Cipher:
               Master_SSL_Key:
        Seconds_Behind_Master: NULL
Master_SSL_Verify_Server_Cert: No
                Last_IO_Errno: 0
                Last_IO_Error:
               Last_SQL_Errno: 0
               Last_SQL_Error:
  Replicate_Ignore_Server_Ids:
             Master_Server_Id: 0
1 row in set (0.00 sec)

ERROR:
No query specified

启动slave服务器
mysql> START SLAVE;
Query OK, 0 rows affected (0.00 sec)

再次查看slave服务器状态，查看Slave_IO_Running，Slave_SQL_Running两个状态分别为YES,表明slave服务器正常启动
mysql> SHOW SLAVE STATUS\G;
*************************** 1. row ***************************
               Slave_IO_State: Waiting for master to send event
                  Master_Host: 172.16.1.1
                  Master_User: repluser
                  Master_Port: 3306
                Connect_Retry: 60
              Master_Log_File: master-bin.000001
          Read_Master_Log_Pos: 339
               Relay_Log_File: relay-log.000002
                Relay_Log_Pos: 254
        Relay_Master_Log_File: master-bin.000001
             Slave_IO_Running: Yes
            Slave_SQL_Running: Yes
              Replicate_Do_DB:
          Replicate_Ignore_DB:
           Replicate_Do_Table:
       Replicate_Ignore_Table:
      Replicate_Wild_Do_Table:
  Replicate_Wild_Ignore_Table:
                   Last_Errno: 0
                   Last_Error:
                 Skip_Counter: 0
          Exec_Master_Log_Pos: 339
              Relay_Log_Space: 404
              Until_Condition: None
               Until_Log_File:
                Until_Log_Pos: 0
           Master_SSL_Allowed: No
           Master_SSL_CA_File:
           Master_SSL_CA_Path:
              Master_SSL_Cert:
            Master_SSL_Cipher:
               Master_SSL_Key:
        Seconds_Behind_Master: 0
Master_SSL_Verify_Server_Cert: No
                Last_IO_Errno: 0
                Last_IO_Error:
               Last_SQL_Errno: 0
               Last_SQL_Error:
  Replicate_Ignore_Server_Ids:
             Master_Server_Id: 1
1 row in set (0.00 sec)

ERROR:
No query specified

3、在master服务器上任意创建数据库，在slave服务器验证数据是否同步复制，如果在slave服务器上可以查看到master服务器创建的数据库，表明复制成功

查看已经连接到master服务器的slave服务器
mysql> SHOW SLAVE HOSTS;
+-----------+------+------+-----------+
| Server_id | Host | Port | Master_id |
+-----------+------+------+-----------+
|        11 |      | 3306 |         1 |
+-----------+------+------+-----------+
1 row in set (0.00 sec)


配置slave服务器不允许进行写操作：

修改变量read_only的值，该变量对SUPER用户无效
mysql> SHOW GLOBAL VARIABLES LIKE 'read_only';
+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| read_only     | OFF   |
+---------------+-------+
1 row in set (0.00 sec)

# vim /etc/my.cnf
[mysqld]
read_only=ON  

重启mysqld服务
# /etc/init.d/mysqld restart
mysql> SHOW GLOBAL VARIABLES LIKE 'read_only';
+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| read_only     | ON    |
+---------------+-------+
1 row in set (0.00 sec)


mysqld服务重启后，复制线程也会自动启动。因为在mysql数据目录下存放了两个文件master.info,relay-log.info

master.info：用于保存连接master服务器时所用的用户名、密码，master服务器IP等信息
# cat master.info
18
master-bin.000001
422
172.16.1.1
repluser
replpass
3306
60
0

relay.info：用于保存master服务器二进制日志文件名称及其位置；以slave服务器上中继日志文件及位置
# cat relay-log.info
./relay-log.000004
254
master-bin.000001
422


配置master服务器立刻同步二进制日志文件(产生写操作后，立刻写入二进制日志文件)
修改变量sync_binlog的值
mysql> SHOW GLOBAL VARIABLES LIKE 'sync_binlog';
+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| sync_binlog   | 0     |
+---------------+-------+
1 row in set (0.00 sec)

# vim /etc/my.cnf
[mysqld]
sync_binlog=1  


实现半同步复制
在master服务器上安装semisync_master.so插件
在slave服务器上安装semisync_slave.so插件

1、在master服务器上安装semisync_master.so插件
mysql> INSTALL PLUGIN rpl_semi_sync_master SONAME 'semisync_master.so';
Query OK, 0 rows affected (0.00 sec)

开启rpl_semi_sync_master_enabled变量
[mysqld]
rpl_semi_sync_master_enabled=ON

2、在slave服务器上安装semisync_slave.so插件
mysql> INSTALL PLUGIN rpl_semi_sync_slave SONAME 'semisync_slave.so';
Query OK, 0 rows affected (0.04 sec)

开启rpl_semi_sync_slave_enabled 变量
[mysqld]
rpl_semi_sync_slave_enabled=ON

重启io_thread线程
mysql> STOP SLAVE io_thread;
mysql> START SLAVE io_thread;


在master服务器上查看rpl相关状态变量
mysql> SHOW GLOBAL STATUS LIKE '%rpl%';
+--------------------------------------------+-------------+
| Variable_name                              | Value       |
+--------------------------------------------+-------------+
| Rpl_semi_sync_master_clients               | 1           |

由上述变量值，可以看到半同步客户端的数量为1

在半同步模型下，只要master服务器与slave服务器通信产生故障，master服务器会自动降级为异步


双主模型：
1、在两台服务器上各自建立一个具有复制权限的用户；
2、修改配置文件 ：
master
[mysqld]
server-id=1
log-bin=master-bin
relay-log=relay-log
relay-log-index=relay-log.index
auto-increment-increment=2
auto-increment-offset=1

slave
[mysqld]
server-id=2
log-bin=master-bin
relay-log=relay-log
relay-log-index=relay-log.index
auto-increment-increment=2
auto-increment-offset=2

3、如果此时两台服务器均为新建立，且无其它写操作，各服务器只需记录当前自己二进制日志文件及事件位置 ，以之作为另外的服务器复制起始位置即可
mysql> SHOW MASTER STATUS;

4、各服务器接下来指定对另一台服务器为自己的主服务器即可
master:
mysql> CHANGE MASTER TO

slave:
mysql> CHANGE MASTER TO


数据过滤复制
仅将master中的指定数据库、数据表复制到slave服务器

通过设置master服务器或者slave服务器上相关变量实现

master服务器变量：
        binlog-do-db: 仅将指定的数据库写操作记录到二进制日志文件，同步向slave服务器
        binlog-ignore-db
        不建议使用master服务器变量设置，因为会导致二进制日志文件不完整

slave服务器变量
        replicate-do-db：仅复制指定的数据库
        replicate-ignore-db

        表级复制
        replicate-do-table
        replicate-ignore-table

        通过使用通配符(% _)表示表名称
        replicate-wild-do-table
        replicate-wild-ignore-table

在配置文件中配置变量，通过SHOW SLAVE STATUS\G;指定可以查看到过滤结果

MySQL 5.6实现复制
        GTID(Global Transaction Identifiers)：
                服务器的UUID(128随机字符串)结合每个事务的ID组成的标识，用于标识每一个事务
                借助于GTID可以提高可用性
        多线程复制：
                slave服务器启动多个sql_thread线程，读取中断日志文件内容，完成同步操作
                一个数据库只能启动一个线程，不能启动多个线程
                slave-parallel-worker=#  指定启动的线程数，尽可能与数据库个数一致
                        0：表示禁用多线程复制

工具：
        mysqlreplicate：追踪GTID跳过已经执行过的事务，快速启动slave服务器
        mysqlrplcheck： 检查复制环境是否满足需求的工具
        mysqlrplshow：发现并生成复制拓扑图
        mysqlfailover：快速自动或者手动提升slave服务器为master
        mysqlrpladmin：调试工具，将某一个服务器down或者up


MySQL 5.6中使用复制功能，[mysqld]配置段中至少应该启用如下选项：
binlog-format：二进制日志格式，有row,statement和mixed选项  使用row或者mixed
log-slave-updates: 当slave服务器从relay log中读取事件执行时，是否记录到本地的二进制日志     
gitd-mode：是否启用GTID功能  
enforce-gtid-consistency：是否强制GTID具有一致性功能
report-port:
report-host
master-info-repository: 决定将slave服务器的连接信息记录到文件中还是表中
relay-log-info-repository：让从服务器记录连接的主服务器的信息，记录到文件中还是表中
sync-master-info：启用可确保无信息丢失
slave-paralles-workers：设置从服务器的SQL线程数
binlog-checksum,master-verify-checksum,slave-sql-verify-checksum：启用复制有关的所有校验功能
binlog-rows-query-log-events：启用之可用于在二进制日志记录事件相关信息,可降低故障排除的复杂度
log-bin：启用二进制日志
server-id ：同一个复制拓扑中所有服务器的id号必须惟一


一、简单主从模式配置步骤

1、配置主从节点的配置文件

master
[mysqld]
binlog-format=ROW
log-bin=master-bin
log-slave-updates=true
gtid-mode=on
enforce-gtid-consistency=true
relay-log-info-repository=TABLE
sync-master-info=1
slave-parallel-workers=2
binlog-checksum=CRC32
master-verify-checksum=1
slave-sql-verify-checksum=1
binlog-rows-query-log_events=1
server-id=1
report-port=3306
port=3306
datadir=/mydata/data
socket=/tmp/mysql.sock
report-host=10.1.1.1

slave
[mysqld]
binlog-format=ROW
log-bin=master-bin
log-slave-updates=true
gtid-mode=on
enforce-gtid-consistency=true
master-info-repository=TABLE
relay-log-info-repository=TABLE
sync-master-info=1
slave-parallel-workers=2
binlog-checksum=CRC32
master-verify-checksum=1
slave-sql-verify-checksum=1
binlog-rows-query-log_events=1
server-id=11
report-host=10.1.1.2
report-port=3306
port=3306
datadir=/mydata/data
socket=/tmp/mysql.socket

2、在master节点创建具有复制权限的用户
mysql> GRANT REPLICATION SLAVE ON *.* TO 'repluser'@'10.1.1.2' IDENTIFIED BY 'replpass';
mysql> FLUSH PRIVILEGES;

3、在slave节点连接master服务器，并启动slave节点
mysql> CHANGE MASTER TO MASTER_HOST='10.1.1.1',MASTER_USER='repluser',MASTER_PASSWORD='replpass',MASTER_AUTO_POSITION=1;
mysql> START SLAVE;

MySQL读写分离

MySQL Proxy
        依赖lua脚本实现读写分离、查询过滤和修改、负载均衡、HA
Amoeba(Java)
        实现读写分离、查询过滤和修改、负载均衡、HA
        xml格式配置文件
Cobar(Java)
        分库、分表



MySQL Proxy安装配置

在10.1.1.3上安装MySQL Proxy通用二进制软件，实现读写分离

1、建立代理用户
# useradd mysql-proxy

2、安装MySQL proxy软件
# tar zxf mysql-proxy-0.8.3-linux-glibc2.3-x86-32bit.tar.gz -C /usr/local/
# cd /usr/local/
# ln -sv mysql-proxy-0.8.3-linux-glibc2.3-x86-32bit/ mysql-proxy
"mysql-proxy" -> "mysql-proxy-0.8.3-linux-glibc2.3-x86-32bit/"

# vim /etc/bashrc
export PATH=$PATH:/usr/local/mysql-proxy/bin
# source /etc/bashrc

3、启动mysql-proxy
# mysql-proxy --proxy-address=0.0.0.0:3306 --proxy-read-only-backend-addresses=10.1.1.2:3306 --proxy-backend-addresses=10.1.1.1:3306 --proxy-lua-script=/usr/local/mysql-proxy/share/doc/mysql-proxy/rw-splitting.lua --daemon --plugins=proxy --plugins=admin --log-level=debug --log-file=/var/log/mysql-proxy.log --admin-username=admin --admin-password=admin --admin-lua-script=/usr/local/mysql-proxy/share/doc/mysql-proxy/admin.lua

# tail /var/log/mysql-proxy.log
2015-12-20 19:19:06: (critical) plugin proxy 0.8.3 started
2015-12-20 19:19:06: (critical) plugin admin 0.8.3 started
2015-12-20 19:19:06: (debug) max open file-descriptors = 1024
2015-12-20 19:19:06: (message) proxy listening on port 0.0.0.0:3306
2015-12-20 19:19:06: (message) added read/write backend: 10.1.1.1:3306
2015-12-20 19:19:06: (message) added read-only backend: 10.1.1.2:3306

# netstat -antp | grep mysql-proxy
tcp        0      0 0.0.0.0:4041                0.0.0.0:*                   LISTEN      5698/mysql-proxy   
tcp        0      0 0.0.0.0:3306                0.0.0.0:*                   LISTEN      5698/mysql-proxy   

启动选项说明：
--proxy-address=0.0.0.0:3306        指定MySQL代理监听的IP地址及端口 , 默认端口为4040
--proxy-read-only-backend-addresses=10.1.1.2:3306        指定只读MySQL服务器的IP地址及端口
--proxy-backend-addresses=10.1.1.1:3306         指定可读、写mysql服务器的IP地址及端口
--proxy-lua-script=/usr/local/mysql-proxy/share/doc/mysql-proxy/rw-splitting.lua        指定用于实现读、写分离功能的lua脚本
--daemon：以守护进程的方式运行mysql-proxy
--plugins=proxy         指定使用proxy代理模块
--plugins=admin         指定使用admin管理模块
--admin-username=admin        指定登录管理模块的用户名
--admin-password=admin         指定登录管理模块的密码
--admin-lua-script=/usr/local/mysql-proxy/share/doc/mysql-proxy/admin.lua         指定管理模块使用的lua脚本
--log-level=debug                 指定记录的日志级别
--log-file=/var/log/mysql-proxy.log         指定mysql proxy启动时的日志文件

4、测试读、写分离功能

在10.1.1.1 Master服务器上创建可远程登录的管理员账号
mysql> GRANT ALL ON *.* TO 'root'@'10.1.1.%' IDENTIFIED BY 'redhat';
mysql> FLUSH PRIVILEGES;

将10.1.1.2作为另外一个客户端，连接代理服务器，测试读写分离功能


在10.1.1.2上以root用户登录代理服务器，并执行创建数据库的指令
# mysql -u root -p -h 10.1.1.3 -e 'CREATE DATABASE fe;'
Enter password:

以管理用户admin登录10.1.1.3上的管理界面，查看后端服务器状态，发现10.1.1.1的状态转换为UP，表明写操作被分配到了10.1.1.1上
# mysql -u admin -p -h 10.1.1.3 --port=4041

mysql> SELECT * FROM backends;
+-------------+---------------+---------+------+------+-------------------+
| backend_ndx | address       | state   | type | uuid | connected_clients |
+-------------+---------------+---------+------+------+-------------------+
|           1 | 10.1.1.1:3306 | up      | rw   | NULL |                 0 |
|           2 | 10.1.1.2:3306 | unknown | ro   | NULL |                 0 |
+-------------+---------------+---------+------+------+-------------------+
2 rows in set (0.00 sec)       

在10.1.1.2上以root用户登录代理服务器，并执行查询操作


MySQL Proxy管理lua脚本 ：
function set_error(errmsg)
        proxy.response = {
                type = proxy.MYSQLD_PACKET_ERR,
                errmsg = errmsg or "error"
        }
end

function read_query(packet)
        if packet:byte() ~= proxy.COM_QUERY then
                set_error("[admin] we only handle text-based queries (COM_QUERY)")
                return proxy.PROXY_SEND_RESULT
        end

        local query = packet:sub(2)

        local rows = { }
        local fields = { }

        if query:lower() == "select * from backends" then
                fields = {
                        { name = "backend_ndx",
                          type = proxy.MYSQL_TYPE_LONG },

                        { name = "address",
                          type = proxy.MYSQL_TYPE_STRING },
                        { name = "state",
                          type = proxy.MYSQL_TYPE_STRING },
                        { name = "type",
                          type = proxy.MYSQL_TYPE_STRING },
                        { name = "uuid",
                          type = proxy.MYSQL_TYPE_STRING },
                        { name = "connected_clients",
                          type = proxy.MYSQL_TYPE_LONG },
                }

                for i = 1, #proxy.global.backends do
                        local states = {
                                "unknown",
                                "up",
                                "down"
                        }
                        local types = {
                                "unknown",
                                "rw",
                                "ro"
                        }
                        local b = proxy.global.backends[i]

                        rows[#rows + 1] = {
                                i,
                                b.dst.name,          -- configured backend address
                                states[b.state + 1], -- the C-id is pushed down starting at 0
                                types[b.type + 1],   -- the C-id is pushed down starting at 0
                                b.uuid,              -- the MySQL Server's UUID if it is managed
                                b.connected_clients  -- currently connected clients
                        }
                end
        elseif query:lower() == "select * from help" then
                fields = {
                        { name = "command",
                          type = proxy.MYSQL_TYPE_STRING },
                        { name = "description",
                          type = proxy.MYSQL_TYPE_STRING },
                }
                rows[#rows + 1] = { "SELECT * FROM help", "shows this help" }
                rows[#rows + 1] = { "SELECT * FROM backends", "lists the backends and their state" }
        else
                set_error("use 'SELECT * FROM help' to see the supported commands")
                return proxy.PROXY_SEND_RESULT
        end

        proxy.response = {
                type = proxy.MYSQLD_PACKET_OK,
                resultset = {
                        fields = fields,
                        rows = rows
                }
        }
        return proxy.PROXY_SEND_RESULT
end