Zabbix recopila datos de los hosts y los almacena en la base de datos utilizando tablas de historial y tendencias . Zabbix History mantiene datos sin procesar (cada valor recopilado por Zabbix), Trends almacena datos horarios consolidados promediados en valores mínimo, promedio y máximo.
El proceso de limpieza de Zabbix se encarga de eliminar datos históricos y de tendencias antiguas. El uso de consultas de eliminación SQL para eliminar datos antiguos de una base de datos puede tener un impacto negativo en el rendimiento de la base de datos. Como resultado, muchos de nosotros hemos recibido la molesta alerta "". El problema de que los procesos de limpieza de Zabbix estén ocupados en más del 75%
se puede resolver fácilmente mediante la partición de la base de datos. La partición crea tablas cada hora o diariamente y las elimina cuando ya no son necesarias. SQL DROP es más eficiente que las declaraciones DELETE.
Antes de continuar, haga una copia de seguridad de la base de datos de Zabbix, pero si la instalación es nueva, no es necesaria una copia de seguridad.
Descargue y descomprima el script SQL "" en el servidor de la base de datos (usando las herramientas wget o curl): zbx_db_partitiong.sql
curl -O https://bestmonitoringtools.com/dl/zbx_db_partitiong.tar.gz tar -zxvf zbx_db_partitiong.tar.gz
script "" Configurado para conservar 7 días de datos históricos y 365 días de datos de tendencias. Si estas configuraciones le resultan aceptables, vaya al paso 2. zbx_db_partitiong.sql
Sin embargo, si desea cambiar la tendencia o el número de días del historial, abra el archivo " zbx_db_partitiong.sql ", cambie la configuración como se muestra en la imagen a continuación y guarde el archivo.
Paso 2: crear un procedimiento de partición utilizando un script SQL
La sintaxis para ejecutar el script es " mysql -u '<db_username>' -p '<db_password>' <zb_database_name> < zbx_db_partitiong.sql ".
Ahora, ejecútelo con el nombre, nombre de usuario y contraseña de su base de datos Zabbix para crear el proceso de partición:
mysql -u 'zabbix' -p'zabbixDBpass' zabbix < zbx_db_partitiong.sql
El script creará el proceso de partición MySQL muy rápidamente en una nueva instalación de Zabbix. pero en bases de datos grandes esto podría durar horas.
Paso 3: automatice el proceso de partición
Hemos creado los procedimientos de partición, ¡pero no harán nada hasta que los ejecutemos!
¡Este paso es el más importante porque las particiones deben eliminarse y crearse de forma regular (diariamente) mediante el proceso de partición!
No te preocupes, no es necesario que hagas esto manualmente. Podemos utilizar dos herramientas para este tipo de tareas: MySQL Event Scheduler o Crontab - elige la herramienta que prefieras.
Tenga cuidado al configurar el programador de eventos MySQL o Crontab. Si lo configura mal, ¡Zabbix dejará de recopilar datos! Notará, a través del gráfico vacío y el error "[Z3005] Error en la consulta: [1526] La tabla no tiene partición con valor ..." en el archivo de registro de Zabbix.
Opción 1: utilizar el programador de eventos MySQL para administrar particiones automáticamente (recomendado)
De forma predeterminada, el programador de eventos MySQL está deshabilitado. Debe habilitarlo configurando " event_scheduler=ON " después de la línea "[mysqld]" en el archivo de configuración de MySQL .
[mysqld]
event_scheduler = ON
Después de realizar cambios, reinicie el servidor MySQL para que la configuración surta efecto.
sudo systemctl reiniciar mysql
¡bien! El programador de eventos MySQL debe estar habilitado, verifiquemos usando el siguiente comando:
root@dbserver:~ $ mysql -u 'zabbix' -p'zabbixDBpass' zabbix -e "MOSTRAR VARIABLES COMO 'event_scheduler';"
±----- ----------±------+
| Nombre_variable | Valor |
±----------------±------+
| planificador_eventos | ON |
±----------------±------+
Ahora podemos crear un evento que ejecutará el proceso " partition_maintenance_all " cada 12 horas.
mysql -u 'zabbix' -p'zabbixDBpass' zabbix -e "CREAR EVENTO zbx_partitioning SEGÚN EL HORARIO CADA 12 HORAS LLAME a particion_maintenance_all('zabbix');" Después de 12 horas, utilice el siguiente comando
para comprobar si el evento se ha ejecutado correctamente .
mysql -u 'zabbix' -p'zabbixDBpass' zabbix -e "SELECCIONAR * DE INFORMACIÓN_ESQUEMA.eventos\G"
Opción 2: administrar particiones automáticamente con Crontab
Crontab es una buena alternativa si no tienes acceso al programador de eventos MySQL. Abra el archivo crontab usando el comando "sudo crontab -e" y agregue el trabajo para particionar la base de datos MySQL de Zabbix (diariamente a las 03:30 a.m.) agregando la siguiente línea en cualquier parte del archivo:
30 03 * * * /usr /bin /mysql -u 'zabbix' -p'zabbixDBpass' zabbix -e "CALL particion_maintenance_all('zabbix');" > /tmp/CronDBpartitiong.log 2>&1Guarde y
cierre el archivo.
Cron ejecutará la operación (eliminará la tabla anterior y creará una nueva) todos los días y registrará todo en el archivo "". /tmp/CronDBpartitiong.log
Sin embargo, si no quiere esperar, ejecute el comando ahora desde la terminal:
root@dbserver:~ $ mysql -u 'zabbix' -p'zabbixDBpass' zabbix -e "CALL partición_maintenance_all('zabbix');" ±------------------- ---------------------------------------+ | mensaje | ±------ -------------------------------------------------- --+ | partición_create(zabbix,history,p201910150000,1571180400) | ±---------------------------------- ------------------------+ ±------------------------ ----------------------------------+
Y luego verifique el estado de la partición:
root@dbserver:~ $ mysql -u 'zabbix' -p'zabbixDBpass' zabbix -e "mostrar crear historial de tabla\G" Tabla: historial Crear tabla: CREAR TABLA historial (itemid bigint(20) unsigned NOT NULL, clock int( 11) NOT NULL DEFAULT '0', valor doble(16,4) NOT NULL DEFAULT '0.0000', ns int(11) NOT NULL DEFAULT '0', CLAVE historial_1 (itemid,reloj) ) MOTOR=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin /*!50100 PARTICIÓN POR RANGO (reloj) (PARTICIÓN p201910140000 VALORES MENOS DE (1571094000) MOTOR = InnoDB, PARTICIÓN p201910150000 VALORES MENOS DE (1571180400) MOTOR = InnoDB, PARTICIÓN p2019 10160000 VALORES MENOS DE (1571266800) MOTOR = InnoDB ) */
Como puede ver en el resultado, hemos creado 3 particiones para la tabla de historial.
Paso 4: Configurar la limpieza en la interfaz de Zabbix
Configure la limpieza en la interfaz de Zabbix, como se muestra en la siguiente figura.
Si la imagen habla por sí sola, estos son los pasos para configurar el servicio de limpieza en la interfaz de Zabbix:
- Navegue a la sección " Limpieza ": " Gestión " → " General " → " Limpieza ";
- Quite la marca de verificación de " Habilitar limpieza " en la sección "Historial y tendencias" ;
- Coloque una marca de verificación en "_Cubrir períodos de tendencias del proyecto"_ en la sección "Historial y tendencias";
- Defina el número de días para el " Período de almacenamiento de datos " para las tendencias y el historial en la sección "Historial y tendencias" (debe ser el mismo que el número de días configurado en la partición de la base de datos, si no ha cambiado la configuración predeterminada en el script, el historial debe ser de 7 días, las tendencias deben ser de 365 días);
- Haga clic en el botón " Actualizar ".
¡Ya terminaste! Tenga en cuenta que la partición eliminará el historial y las tablas de tendencias según lo que configuró durante el proceso de partición. Por ejemplo, si se ha configurado para conservar 7 días de historial, la partición comenzará a eliminar el historial el octavo día. Después de eso, elimina una tabla de historial todos los días para que la base de datos siempre tenga 7 días de datos históricos. Lo mismo ocurre con los datos de tendencias: si configura para conservar 365 días de datos de tendencias, solo comenzará a eliminar las tablas de tendencias antiguas después de 365 días.
Paso 5: cambiar la configuración de la partición (número de días para el historial y tendencias)
A veces, es posible que inicialmente establezca demasiados días de historial y tendencias para su base de datos Zabbix, por lo que el espacio en disco se llena demasiado rápido. O por el contrario, no configuras suficientes días para el historial o las tendencias. ¿Qué hacer?
No es necesario volver a ejecutar el script, simplemente cree un nuevo proceso que se ejecutará en lugar del anterior.
a) Crear un nuevo proceso de partición
Conéctese al servidor MySQL/MariaDB:
mysql -u 'zabbix' -p'zabbixDBpass' zabbix
Cree un nuevo proceso pero cambie la cantidad de días para la tendencia y el historial según sus necesidades. Yo establecería 30 días para el historial y 400 para el día de tendencia. :
DELIMITADORCREATEPROCEDURE mantenimiento de partición todos 3 0 y 400 (SCHEMANAMEVARCHAR (32)) BEGINCALL mantenimiento de partición (SCHEMANAME, ′historial′, 30, 24, 3); CALL mantenimiento de partición (SCHEMANAME, ′historylog′, 30, 24, 3); CALL mantenimiento de partición (SCHEMANAME, ′historystr′, 30, 24, 3); CALL mantenimiento de partición (SCHEMANAME, ′historialtext′, 30, 24, 3); CALL mantenimiento de partición (SCHEMANAME, ′historyuint′, 30, 24, 3); CALL mantenimiento de partición ( SCHEMANAME , ′ tendencias ′ , 400 , 24 , 3 ); CALL mantenimiento de partición (SCHEMANAME, ′trendsuint′, 400, 24, 3); FINALIZAR CREAR PROCEDIMIENTO partición_maintenance_all_30and400(SCHEMA_NAME VARCHAR(32)) COMENZAR LLAMADA partición_maintenance(SCHEMA_NAME, 'history', 30, 24, 3); LLAMAR partición_mantenimiento(SCHEMA_NAME, 'history_log', 30, 24, 3); LLAMAR partición_mantenimiento(SCHEMA_NAME, 'history_str', 30, 24, 3); LLAMAR partición_mantenimiento(SCHEMA_NAME, 'history_text', 30, 24, 3); LLAMAR partición_mantenimiento(SCHEMA_NAME, 'history_uint', 30, 24, 3); LLAMAR partición_mantenimiento(SCHEMA_NAME, 'tendencias', 400, 24, 3); LLAMAR partición_mantenimiento(SCHEMA_NAME, 'trends_uint', 400, 24, 3); FIN 3 ); FINALIZAR CREAR PROCEDIMIENTO partición_maintenance_all_30and400(SCHEMA_NAME VARCHAR(32)) COMENZAR LLAMADA partición_maintenance(SCHEMA_NAME, 'history', 30, 24, 3); LLAMAR partición_mantenimiento(SCHEMA_NAME, 'history_log', 30, 24, 3); LLAMAR partición_mantenimiento(SCHEMA_NAME, 'history_str', 30, 24, 3); LLAMAR partición_mantenimiento(SCHEMA_NAME, 'history_text', 30, 24, 3); LLAMAR partición_mantenimiento(SCHEMA_NAME, 'history_uint', 30, 24, 3); LLAMAR partición_mantenimiento(SCHEMA_NAME, 'tendencias', 400, 24, 3); LLAMAR partición_mantenimiento(SCHEMA_NAME, 'trends_uint', 400, 24, 3); FIN 3 ); FINALIZAR CREAR PROCEDIMIENTO partición_maintenance_all_30and400(SCHEMA_NAME VARCHAR(32)) COMENZAR LLAMADA partición_maintenance(SCHEMA_NAME, 'history', 30, 24, 3); LLAMAR partición_mantenimiento(SCHEMA_NAME, 'history_log', 30, 24, 3); LLAMAR partición_mantenimiento(SCHEMA_NAME, 'history_str', 30, 24, 3); LLAMAR partición_mantenimiento(SCHEMA_NAME, 'history_text', 30, 24, 3); LLAMAR partición_mantenimiento(SCHEMA_NAME, 'history_uint', 30, 24, 3); LLAMAR partición_mantenimiento(SCHEMA_NAME, 'tendencias', 400, 24, 3); LLAMAR partición_mantenimiento(SCHEMA_NAME, 'trends_uint', 400, 24, 3); FIN 'historia_cadena', 30, 24, 3); LLAMAR partición_mantenimiento(SCHEMA_NAME, 'history_text', 30, 24, 3); LLAMAR partición_mantenimiento(SCHEMA_NAME, 'history_uint', 30, 24, 3); LLAMAR partición_mantenimiento(SCHEMA_NAME, 'tendencias', 400, 24, 3); LLAMAR partición_mantenimiento(SCHEMA_NAME, 'trends_uint', 400, 24, 3); FIN 'historia_cadena', 30, 24, 3); LLAMAR partición_mantenimiento(SCHEMA_NAME, 'history_text', 30, 24, 3); LLAMAR partición_mantenimiento(SCHEMA_NAME, 'history_uint', 30, 24, 3); LLAMAR partición_mantenimiento(SCHEMA_NAME, 'tendencias', 400, 24, 3); LLAMAR partición_mantenimiento(SCHEMA_NAME, 'trends_uint', 400, 24, 3); FINCRE A TEPROCE D U REpartición _ _ _ _ _ _ _ _mno es tenencia _ _ _unl l30 y 400 ( SC HEM A _ _norteA ME V A R C H A R ( 32 ) ) COMENZAR TODA la p a r t i c i o nmmantenimiento del mantenimiento ( SCHEMA _ _ _ _ _norteUN YO ,′Hola _ _ _ _′ ,30 ,24 ,3 ) ;LLAMAR A LA PARTICIPACIÓN _ _ _ _ _ _ _ _mmantenimiento del mantenimiento ( SCHEMA _ _ _ _ _norteUN YO ,′Hola _ _ _ _yoyg _′ ,30 ,24 ,3 ) ;LLAMAR A LA PARTICIPACIÓN _ _ _ _ _ _ _ _mmantenimiento del mantenimiento ( SCHEMA _ _ _ _ _norteUN YO ,′Hola _ _ _ _st r′ ,30 ,24 ,3 ) ;LLAMAR A LA PARTICIPACIÓN _ _ _ _ _ _ _ _mmantenimiento del mantenimiento ( SCHEMA _ _ _ _ _norteUN YO ,′Hola _ _ _ _tex t _′ ,30 ,24 ,3 ) ;LLAMAR A LA PARTICIPACIÓN _ _ _ _ _ _ _ _mmantenimiento del mantenimiento ( SCHEMA _ _ _ _ _norteUN YO ,′Hola _ _ _ _tuen t′ ,30 ,24 ,3 ) ;LLAMAR A LA PARTICIPACIÓN _ _ _ _ _ _ _ _mmantenimiento del mantenimiento ( SCHEMA _ _ _ _ _norteUN YO ,′tendencias _ _ _ _′ ,400 ,24 ,3 ) ;LLAMAR A LA PARTICIPACIÓN _ _ _ _ _ _ _ _mmantenimiento del mantenimiento ( SCHEMA _ _ _ _ _norteUN YO ,′tendencias _ _ _ _tuen t′ ,400 ,24 ,3 ) ;FIN D DELIMITADOR ;
b) Actualizar el Programador de eventos MySQL o Crontab
Hemos creado el proceso de partición en el paso anterior, ¡pero aún no está activado! Ahora tenemos que reemplazar el proceso anterior por uno nuevo, que eliminará y agregará particiones regularmente. Elija una de las siguientes dos opciones, dependiendo de lo que haya configurado en su instancia de Zabbix.
Opción 1: actualizar el programador de eventos MySQL
Si creó un programador de eventos siguiendo este tutorial, use este comando para reemplazar el proceso anterior por el nuevo.
mysql -u 'zabbix' -p'zabbixDBpass' zabbix -e "ALTER EVENT zbx_partitioning ON SCHEDULE EVERY 12 HOUR DO CALL partition_maintenance_all_30and400('zabbix');"
Opción 2: actualizar Crontab
Para aquellos que usan Crontab, abra el archivo crontab usando el comando "sudo crontab -e", comente el trabajo del proceso anterior y agregue uno nuevo
# old procedure, still exists in the database so it can be used if needed # 30 03 * * * /usr/bin/mysql -u 'zabbix' -p'zabbixDBpass' zabbix -e "CALL partition_maintenance_all('zabbix');" > /tmp/CronDBpartitiong.log 2>&1 30 03 * * * /usr/bin/mysql -u 'zabbix' -p'zabbixDBpass' zabbix -e "CALL partition_maintenance_all_30and400('zabbix');" > /tmp/CronDBpartitiong.log 2>&1
. Guarde los cambios y salga de Crontab.
Paso 6: Información sobre el script de partición Zabbix
El script SQL de partición Zabbix utilizado en esta guía contiene los siguientes procedimientos de partición:
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', 7, 24, 3); CALL partition_maintenance(SCHEMA_NAME, 'history_log', 7, 24, 3); CALL partition_maintenance(SCHEMA_NAME, 'history_str', 7, 24, 3); CALL partition_maintenance(SCHEMA_NAME, 'history_text', 7, 24, 3); CALL partition_maintenance(SCHEMA_NAME, 'history_uint', 7, 24, 3); CALL partition_maintenance(SCHEMA_NAME, 'trends', 365, 24, 3); CALL partition_maintenance(SCHEMA_NAME, 'trends_uint', 365, 24, 3); END$$ DELIMITER ;