ITPub博客

首页 > 数据库 > MySQL > zabbix表分区详细步骤

zabbix表分区详细步骤

原创 MySQL 作者:yepkeepmoving 时间:2016-01-16 09:04:04 0 删除 编辑
1、连接数据库

    mysql -h <database_ip/fqdn> -u<user> -p

    Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.
    mysql>
    mysql> use zabbix;
    Reading table information for completion of table and column names
    You can turn off this feature to get a quicker startup with -A
    Database changed
    mysql>

2、改变表索引结构

    mysql> Alter table history_text drop primary key, add index (id), drop index history_text_2, add index history_text_2 (itemid, id);
    Query OK, 0 rows affected (0.49 sec)
    Records: 0  Duplicates: 0  Warnings: 0

    mysql> Alter table history_log drop primary key, add index (id), drop index history_log_2, add index history_log_2 (itemid, id);
    Query OK, 0 rows affected (2.71 sec)
    Records: 0  Duplicates: 0  Warnings: 0

    mysql>

3、存储过程创建

--增加分区的存储过程
DELIMITER $$
CREATE PROCEDURE `partition_create`(SCHEMANAME varchar(64), TABLENAME varchar(64), PARTITIONNAME varchar(64), CLOCK int)
BEGIN
        /*
           SCHEMANAME = The DB schema in which to make changes
           TABLENAME = The table with partitions to potentially delete
           PARTITIONNAME = The name of the partition to create
        */
        /*
           Verify that the partition does not already exist
        */

        DECLARE RETROWS INT;
        SELECT COUNT(1) INTO RETROWS
        FROM information_schema.partitions
        WHERE table_schema = SCHEMANAME AND table_name = TABLENAME AND partition_description >= CLOCK;

        IF RETROWS = 0 THEN
                /*
                   1. Print a message indicating that a partition was created.
                   2. Create the SQL to create the partition.
                   3. Execute the SQL from #2.
                */
                SELECT CONCAT( "partition_create(", SCHEMANAME, ",", TABLENAME, ",", PARTITIONNAME, ",", CLOCK, ")" ) AS msg;
                SET @sql = CONCAT( 'ALTER TABLE ', SCHEMANAME, '.', TABLENAME, ' ADD PARTITION (PARTITION ', PARTITIONNAME, ' VALUES LESS THAN (', CLOCK, '));' );
                PREPARE STMT FROM @sql;
                EXECUTE STMT;
                DEALLOCATE PREPARE STMT;
        END IF;
END$$
DELIMITER ;

--删除分区的存储过程
DELIMITER $$
CREATE PROCEDURE `partition_drop`(SCHEMANAME VARCHAR(64), TABLENAME VARCHAR(64), DELETE_BELOW_PARTITION_DATE BIGINT)
BEGIN
        /*
           SCHEMANAME = The DB schema in which to make changes
           TABLENAME = The table with partitions to potentially delete
           DELETE_BELOW_PARTITION_DATE = Delete any partitions with names that are dates older than this one (yyyy-mm-dd)
        */
        DECLARE done INT DEFAULT FALSE;
        DECLARE drop_part_name VARCHAR(16);

        /*
           Get a list of all the partitions that are older than the date
           in DELETE_BELOW_PARTITION_DATE.  All partitions are prefixed with
           a "p", so use SUBSTRING TO get rid of that character.
        */
        DECLARE myCursor CURSOR FOR
                SELECT partition_name
                FROM information_schema.partitions
                WHERE table_schema = SCHEMANAME AND table_name = TABLENAME AND CAST(SUBSTRING(partition_name FROM 2) AS UNSIGNED) < DELETE_BELOW_PARTITION_DATE;
        DECLARE CONTINUE HANDLER FOR NOT FOUND SET done = TRUE;

        /*
           Create the basics for when we need to drop the partition.  Also, create
           @drop_partitions to hold a comma-delimited list of all partitions that
           should be deleted.
        */
        SET @alter_header = CONCAT("ALTER TABLE ", SCHEMANAME, ".", TABLENAME, " DROP PARTITION ");
        SET @drop_partitions = "";

        /*
           Start looping through all the partitions that are too old.
        */
        OPEN myCursor;
        read_loop: LOOP
                FETCH myCursor INTO drop_part_name;
                IF done THEN
                        LEAVE read_loop;
                END IF;
                SET @drop_partitions = IF(@drop_partitions = "", drop_part_name, CONCAT(@drop_partitions, ",", drop_part_name));
        END LOOP;
        IF @drop_partitions != "" THEN
                /*
                   1. Build the SQL to drop all the necessary partitions.
                   2. Run the SQL to drop the partitions.
                   3. Print out the table partitions that were deleted.
                */
                SET @full_sql = CONCAT(@alter_header, @drop_partitions, ";");
                PREPARE STMT FROM @full_sql;
                EXECUTE STMT;
                DEALLOCATE PREPARE STMT;

                SELECT CONCAT(SCHEMANAME, ".", TABLENAME) AS `table`, @drop_partitions AS `partitions_deleted`;
        ELSE
                /*
                   No partitions are being deleted, so print out "N/A" (Not applicable) to indicate
                   that no changes were made.
                */
                SELECT CONCAT(SCHEMANAME, ".", TABLENAME) AS `table`, "N/A" AS `partitions_deleted`;
        END IF;
END$$
DELIMITER ;

--维护分区的存储过程

DELIMITER $$
CREATE PROCEDURE `partition_maintenance`(SCHEMA_NAME VARCHAR(32), TABLE_NAME VARCHAR(32), KEEP_DATA_DAYS INT, HOURLY_INTERVAL INT, CREATE_NEXT_INTERVALS INT)
BEGIN
        DECLARE OLDER_THAN_PARTITION_DATE VARCHAR(16);
        DECLARE PARTITION_NAME VARCHAR(16);
        DECLARE OLD_PARTITION_NAME VARCHAR(16);
        DECLARE LESS_THAN_TIMESTAMP INT;
        DECLARE CUR_TIME INT;

        CALL partition_verify(SCHEMA_NAME, TABLE_NAME, HOURLY_INTERVAL);
        SET CUR_TIME = UNIX_TIMESTAMP(DATE_FORMAT(NOW(), '%Y-%m-%d 00:00:00'));

        SET @__interval = 1;
        create_loop: LOOP
                IF @__interval > CREATE_NEXT_INTERVALS THEN
                        LEAVE create_loop;
                END IF;

                SET LESS_THAN_TIMESTAMP = CUR_TIME + (HOURLY_INTERVAL * @__interval * 3600);
                SET PARTITION_NAME = FROM_UNIXTIME(CUR_TIME + HOURLY_INTERVAL * (@__interval - 1) * 3600, 'p%Y%m%d%H00');
                IF(PARTITION_NAME != OLD_PARTITION_NAME) THEN
            CALL partition_create(SCHEMA_NAME, TABLE_NAME, PARTITION_NAME, LESS_THAN_TIMESTAMP);
        END IF;
                SET @__interval=@__interval+1;
                SET OLD_PARTITION_NAME = PARTITION_NAME;
        END LOOP;

        SET OLDER_THAN_PARTITION_DATE=DATE_FORMAT(DATE_SUB(NOW(), INTERVAL KEEP_DATA_DAYS DAY), '%Y%m%d0000');
        CALL partition_drop(SCHEMA_NAME, TABLE_NAME, OLDER_THAN_PARTITION_DATE);

END$$
DELIMITER ;

--检查分区、创建第一个分区的存储过程
DELIMITER $$
CREATE PROCEDURE `partition_verify`(SCHEMANAME VARCHAR(64), TABLENAME VARCHAR(64), HOURLYINTERVAL INT(11))
BEGIN
        DECLARE PARTITION_NAME VARCHAR(16);
        DECLARE RETROWS INT(11);
        DECLARE FUTURE_TIMESTAMP TIMESTAMP;

        /*
         * Check if any partitions exist for the given SCHEMANAME.TABLENAME.
         */
        SELECT COUNT(1) INTO RETROWS
        FROM information_schema.partitions
        WHERE table_schema = SCHEMANAME AND table_name = TABLENAME AND partition_name IS NULL;

        /*
         * If partitions do not exist, go ahead and partition the table
         */
        IF RETROWS = 1 THEN
                /*
                 * Take the current date at 00:00:00 and add HOURLYINTERVAL to it.  This is the timestamp below which we will store values.
                 * We begin partitioning based on the beginning of a day.  This is because we don't want to generate a random partition
                 * that won't necessarily fall in line with the desired partition naming (ie: if the hour interval is 24 hours, we could
                 * end up creating a partition now named "p201403270600" when all other partitions will be like "p201403280000").
                 */
                SET FUTURE_TIMESTAMP = TIMESTAMPADD(HOUR, HOURLYINTERVAL, CONCAT(CURDATE(), " ", '00:00:00'));
                SET PARTITION_NAME = DATE_FORMAT(CURDATE(), 'p%Y%m%d%H00');

                -- Create the partitioning query
                SET @__PARTITION_SQL = CONCAT("ALTER TABLE ", SCHEMANAME, ".", TABLENAME, " PARTITION BY RANGE(`clock`)");
                SET @__PARTITION_SQL = CONCAT(@__PARTITION_SQL, "(PARTITION ", PARTITION_NAME, " VALUES LESS THAN (", UNIX_TIMESTAMP(FUTURE_TIMESTAMP), "));");

                -- Run the partitioning query
                PREPARE STMT FROM @__PARTITION_SQL;
                EXECUTE STMT;
                DEALLOCATE PREPARE STMT;
        END IF;
END$$
DELIMITER ;

--维护上述所有存储过程的存储过程
DELIMITER $$
CREATE PROCEDURE `partition_maintenance_all`(SCHEMA_NAME VARCHAR(32))
BEGIN
                CALL partition_maintenance(SCHEMA_NAME, 'history', 28, 24, 14);
                CALL partition_maintenance(SCHEMA_NAME, 'history_log', 28, 24, 14);
                CALL partition_maintenance(SCHEMA_NAME, 'history_str', 28, 24, 14);
                CALL partition_maintenance(SCHEMA_NAME, 'history_text', 28, 24, 14);
                CALL partition_maintenance(SCHEMA_NAME, 'history_uint', 28, 24, 14);
                CALL partition_maintenance(SCHEMA_NAME, 'trends', 730, 24, 14);
                CALL partition_maintenance(SCHEMA_NAME, 'trends_uint', 730, 24, 14);
END$$
DELIMITER ;

4、存储过程调用方式

--单独调用维护某个表创建、删除、增加分区存储过程
语法格式:
CALL partition_maintenance('<zabbix_db_name>', '<table_name>', <days_to_keep_data>, <hourly_interval>, <num_future_intervals_to_create>)
说明:
zabbix_db_name:数据库的名称
table_name:要创建分区表的表名称
days_to_keep_data:保存分区表数据的天数,超出这个天数的分区表将被删除,单位是天
hourly_interval:每隔多少小时创建一个分区,单位是小时
num_future_intervals_to_create:每次创建几个分区
案例:
CALL partition_maintenance('zabbix', 'history', 28, 24, 14);  --对zabbix数据库的history表创建分区,数据保留28天,每隔24小时创建一个分区,每次创建14个分区

--调用维护预定义的表创建、删除、增加分区的存储过程
CALL partition_maintenance_all('zabbix');

5、Housekeeper自维护功能关闭

There are a couple more steps that need to be done on the Zabbix Web UI on 2.2.x (or the zabbix_server.conf file in the case of Zabbix 2.0.x) to shut off housekeeping on the history/trend tables.

Zabbix 2.0.x(这个版本的直接关闭所有Housekeeper功能即可)

For those of you still stuck using the 2.0.x series of Zabbix there is no way to disable specific functionality of the housekeeper. You will have to disable the housekeeper entirely. This can be done by setting the "DisableHousekeeping" parameter in zabbix_server.conf to "1". You then need to restart the zabbix_server process. Keep in mind that with the housekeeper disabled, data in the "housekeeper" table in the database will never be removed. Also, old events, audit entries, and user sessions will never be deleted automatically.

Zabbix 2.2.x(这个版本关闭部分Housekeeper功能即可

Zabbix 2.2 introduced more granular control over the housekeeper. All of the options are available in the Zabbix UI in the "Administration" -> "General" section. Make sure you select "Housekeeping" in the drop-down in the upper right. You should see a screen similar to the following:
Zabbix housekeeping config 2.2.x.png
    Make sure that the checkboxes with the title "Enable internal housekeeping" are unchecked for both History and Trends.
    Make sure that the checkboxes with the title "Override item <trend/history> period" are checked for both History and Trends.
    Set the "Data storage period (in days)" box for history and trends to the amount of time you are retaining both. In the examples that were given, the correct values are 28 and 730 (as seen in the screenshot).

6、创建定时任务,定时对标自动分区

01 01 * * * /opt/software/mysql/bin/mysql -uzabbix -pzabbix zabbix -e "CALL partition_maintenance_all('zabbix');"

--至此 ,zabbix历史表分区结束

7、说明信息

--四个主要存储过程
    partition_create - This will create a partition on the given table in the given schema.
    partition_drop - This will drop partitions older than the given timestamp on the given table in the given schema.
    partition_maintenance - This function is what is called by users. It is responsible for parsing the given parameters and then creating/dropping partitions as needed.
    partition_verify - Checks if partitioning is enabled on the given table in the given schema. If it is not enable, it creates a single partition.
--四个存储过程参数解释
partition_create

Procedure definition: partition_create(SCHEMANAME varchar(64), TABLENAME varchar(64), PARTITIONNAME varchar(64), CLOCK int)
Example: CALL partition_create("zabbix", "history", "p20131216", 1387267200);

    SCHEMANAME = The DB schema in which to make changes
    TABLENAME = The table on which to create PARTITIONNAME
    PARTITIONNAME = The name of the partition to create
    CLOCK = PARTITIONNAME will be created to hold values with a "clock" column value less than this

partition_drop

Procedure definition: partition_drop(SCHEMANAME VARCHAR(64), TABLENAME VARCHAR(64), DELETE_BELOW_PARTITION_DATE VARCHAR(64))
Example: CALL partition_drop("zabbix", "history", "20131216");

    SCHEMANAME = The DB schema in which to make changes
    TABLENAME = The table on which to delete PARTITIONNAME
    DELETE_BELOW_PARTITION_DATE = The oldest partition date to allow. All partitions older than this date will be deleted. The format is yyyymmdd.

partition_maintenance

Procedure definition: partition_maintenance(SCHEMA_NAME VARCHAR(32), TABLE_NAME VARCHAR(32), KEEP_DATA_DAYS INT, HOURLY_INTERVAL INT, CREATE_NEXT_INTERVALS INT)
Example: CALL partition_maintenance('zabbix', 'history', 28, 24, 14);

    SCHEMA_NAME = The DB schema in which to make changes
    TABLE_NAME = The table on which to make changes
    KEEP_DATA_DAYS = The maximum number of days worth of partitions to keep. All partitions older than this number of days will be deleted.
    HOURLY_INTERVAL = The hourly interval between partitions. For example, daily partitioning would have a value of 24, hourly partitioning would have a value of 1.
    CREATE_NEXT_INTERVALS = The number of intervals worth of partitions to create in advance.

partition_verify

Procedure definition: partition_verify(SCHEMANAME VARCHAR(64), TABLENAME VARCHAR(64), HOURLYINTERVAL INT(11))
Example: CALL partition_verify("zabbix", "history");

    SCHEMANAME = The DB schema in which to make changes
    TABLENAME = The table on which to check for partitions
    HOURLY_INTERVAL = The hourly interval between partitions. For example, daily partitioning would have a value of 24, hourly partitioning would have a value of 1.

8、分区参考文档

https://www.zabbix.org/wiki/Docs/howto/mysql_partition































来自 “ ITPUB博客 ” ,链接:http://blog.itpub.net/27067062/viewspace-1977373/,如需转载,请注明出处,否则将追究法律责任。

上一篇: 没有了~
下一篇: SQL Profile 实验01
请登录后发表评论 登录
全部评论

注册时间:2014-12-08

  • 博文量
    76
  • 访问量
    119433