AI 助理
备案控制台
开发者社区 数据库 文章 正文

自己开发的MYMON工具监控MYSQL运行状态帮助文档

2017-01-23 1660
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
RDS MySQL Serverless 基础系列，0.5-2RCU 50GB
推荐场景：
学生管理系统数据库设计 搭建个人博客
云数据库 RDS MySQL，集群系列 2核4GB
推荐场景：
搭建个人博客
云数据库 RDS MySQL，高可用系列 2核4GB
简介： 本工具为采集show global status 实时输出的一个监控工具，工具源码大约1000行代码 本文主要为说明文档，并且带有核心源码。 一、此工具展示方式：      工具将show global status中一些重要的值按照用户输入的描述和次数不断的打印到前台或者打印到 指定文件中，用于帮助DBA进行性能诊断或者瓶颈判断。

本工具为采集 show global status 实时输出的一个监控工具，工具源码大约1000行代码
本文主要为说明文档，并且带有核心源码。


一、此工具展示方式： 
    工具将show global status中一些重要的值按照用户输入的描述和次数不断的打印到前台或者打印到
指定文件中，用于帮助DBA进行性能诊断或者瓶颈判断。
二、此工具运行原理：
   将show global status的值根据用户输入的秒数记录，前一次的值为oldvalue,新的值为newvalue，存储
在内存中，然后判断是否为累计值还是当前值，如果是累计值则newvalue-oldvalue，如果为当前值则
输出，这样则保证了输出的正确性
三、工具特点：
1、监控账号低权限只需要useage权限
2、远程连接功能
3、根据用户需要将数据写入到指定文件
4、运行日志记录，检测出错输入日志
5、5.6 5.7支持、没有测试5.5
6、核心源码开源
7、可以根据需求随时定制输出，当然需要联系本人

注意：
WINDOWS不支持，编译版本只有LINUX 64BIT.
并且此工具依赖MYSQL连接动态库文件


四、、工具使用帮助
[root@testmy 6]# ./mymon 
Author: gaopeng QQ:22389860 Mail: gaopp_200217@163.com 
Info:This tool collect data from 'show global status' and show interval (-t) seconds data change
help DBA to diagnose performance problem,when error or (-d) run log is at current dir name 
is mymon.log.
WIN32 platform is not support
Useage:./mymon [-u username] [-p password] -S socketfile/{-h hosname -P port} -t seconds -n times [-l logfile] [-d]
[-?]           :help info;
[-u username]  :connect to mysqld username,when no username requisite is optional;
[-p password]  :connect to mysqld password,when no password requisite is optional;
[-S socketfile]:connect to mysqld socket file;
[-h hostname]  :connect to mysqld host;
[-P port]      :connect to mysqld port;
                socketfile or [hostname port]  must;
[-t seconds]   :seconds of interval,this is necessary;
[-n times]     :how many times you watch,this is necessary;
[-l logfile]   :when you want to write information to a logfile provide a logfile name
                when a logfile provide no information at foreground,is optional;
[-d]           :more running log at logfile,otherwise error log in mymon.log;


   注意本地连接用-S连接指定socketfile即可，远程使用 -h -P连接 使用IP和端口连接 ,-l 可以直接把输出写入到指定的文件，
-d就是debug模式一般不用本工具会记录一个日志在当前目录下名字为：mymon.log，这是运行日志如果有错误会记录到日志，
开启-d 会计入更多的信息，但是一般不需要用，主要是我调试代码的时候用的.当然-t 和 -n就像帮助说的是间隔的秒数和
持续的次数，使用中如果输出有值为-1则代表值没有采集到.
   一般只需要在线上一台服务器上放上本工具，使用远程连接连接到如何服务器即可，如：
   ./mymon -h 192.168.190.91 -P3306 -t 5 -n 100 -ummon2 -pgelc123 -l /root/mysqlog/20170123mysql.log
   表示连接到服务器192.168.190.91 3306端口 5秒输出一次 输出100次，输出保留到文件/root/mysqlog/20170123mysql.log
   但是注意SysTime: Sun Jan 22 16:13:30 2017 输出是运行程序系统的当前时间，但是Uptime当然就是MYSQLD服务器的时间


四、如果获得和使用
获取：
我一共编译好了4个版本
5.7 社区版本       mymon5.7c
5.7 percona版本  mymon5.7p
5.6 社区版本        mymon5.6c
5.6 perconna版本 mymon5.6p
百度云盘如下：
http://pan.baidu.com/s/1jIa6OfG


如果要使用更老的版本，请联系我。


使用：
下载后上传到 LINUX操作系统,
mkdir mon
cp mymon5.7p ./mon/
chmod 755 mymon5.7p
然后必须找到相应的库文件位置一般在安装位置的lib目录下，如：
[root@testmy 9]# ./mymon5.7c
./mymon5.7c: error while loading shared libraries: libmysqlclient.so.20: cannot open shared object file: No such file or directory
[root@testmy 9]# export LD_LIBRARY_PATH=/mysqldata/mysql5.7/lib
[root@testmy 9]# ./mymon5.7c
Author: gaopeng QQ:22389860 Mail: gaopp_200217@163.com 
就可以正常运行，顺便说一下5.6为 so.18 5.7为so.20跟老的为5.6以前版本


关于MYSQL监控用户权限：监控部需要什么权限，只要建立一个用户即可
mysql> create user moni@'%' identified by 'gelc123';
Query OK, 0 rows affected (0.22 sec)
mysql> show grants for  moni@'%' ;
+----------------------------------+
| Grants for moni@%                |
+----------------------------------+
| GRANT USAGE ON *.* TO 'moni'@'%' |
+----------------------------------+
1 row in set (0.06 sec)


这也最小化了顾虑，因为这个账户基本没有什么权限，如果不放心程序，可以将程序放到远程连接到线上数据库如：
./mymon5.6c -umoni -pgelc123 -h192.168.190.93 -P3307 -n 1 -t 1 -l /tmp/mysqlmon.log


这样这个程序既不会有权限而且也不在线上数据库服务器，而且可以集中管理，但是一点注意：
SysTime: Sun Jan 22 16:13:30 2017 输出是运行程序系统的当前时间，但是Uptime当然就是MYSQLD服务器的时间




五、此工具展示内容：
展示的内容并不是固定，后期根据需求可以进行简单的加入指标即可，当前输出为如下：
------------------------------------------MYMON--------------------------------------------
SysTime: Sun Jan 22 16:13:30 2017
Uptime:6963226    Connections:1       Aborted_clients:0       Max_used_connections:1319    
--------------------------------------MYSQLINFO-------------------------------------------
[###Threads info and qc  and :]
Threads_connected:252         Threads_running:4             Qcache_free_memory:0            
Qcache_hits:0                 Qcache_not_cached:0           Qcache_inserts:0                
[###Table read info:]
Handler_read_first:211        Handler_read_key:8804         Handler_read_next:42346         
Handler_read_last:0           Handler_read_rnd:73           Handler_read_rnd_next:717694
[###Sorts and temp tables info:]
Sort_rows:0                   Sort_merge_passes:0
Created_tmp_tables:163        Created_tmp_disk_tables:152
[###Table join info:]
Select_full_join:1            Select_scan:207
[###Open table cache and binlog cache info:]
Table_open_cache_hits:4938    Table_open_cache_misses:0
Binlog_cache_use:820          Binlog_cache_disk_use:0
[###Hanler_xxx and Com_xxx info:]
Handler_delete:34574          Handler_update:675            Handler_write:1364
Handler_commit:5833           Handler_rollback:10
Com_commit:156                Com_rollback:5
U(counts):631     D(counts):159     I(counts):47      S(counts):4955    
--------------------------------------INNODBINFO------------------------------------------
[###Innodb_lock info:]
Innodb_row_lock_time:0                Innodb_row_lock_waits:0
Innodb_row_lock_current_waits:38
[###Innodb_buffer_pool info:]
Innodb_buf_pool_pages_total:1965840   Innodb_buf_pool_pages_dirty:19154
Innodb_buf_pages_data:1940433         Innodb_buf_pages_free:8116
Innodb_buffer_pool_wait_free:0        Innodb_buffer_pool_pages_misc:17291
Innodb_dblwr_pages_written:1188       Innodb_dblwr_writes:80
Innodb_buffer_pool_pages_flushed:2249
read_ahead:0          ahead_evict:0          ahead_rnd:0   
[###Innodb_log info:]
Innodb_log_writes:796                 Innodb_log_waits:0
Innodb_os_log_pending_fsyncs:0        Innodb_os_log_pending_writes:0
Innodb_os_log_written:44073472
[###Innodb_data read/writes info:]
Innodb_data_reads:684                 Innodb_data_read:11206656
Innodb_data_writes:2067               Innodb_data_written:63603200
Innodb_data_fsyncs:1017               Innodb_data_pending_fsyncs:0
Innodb_buffer_pool_reads(physics reads):423
Innodb_buffer_pool_read_requests(logic reads):2869823
[###Innodb_data rows info:]
U(rows):675     D(rows):34575   I(rows):194     S(rows):767094  
---------------------------------------TOTALINFO------------------------------------------
Bytes_received:911280         Bytes_sent:8653956


六、监控值说明：
(本部分，带有作者自己的理解，如果有误请指出)


文中
当前值输出：保持show global status的当前值输出
累计值相减输出：用上一次的值减去下一次的值输出，间隔为用户指定的秒数


第一部分：
SysTime: Sun Jan 22 16:13:30 2017
Uptime:6963226    Connections:1       Aborted_clients:0       Max_used_connections:1319    


Uptime:The number of seconds the MySQL server has been running.(当前值输出 单位秒)
Connections:The number of connection attempts (successful or not) to the MySQL server.(累计值相减输出 单位次数)
Aborted_clients:The number of connections that were aborted because the client died without closing the connection
                properly.(累计值相减输出，单位连接数)
Max_used_connections:The maximum number of connections that have been in use simultaneously since the server started.
                     (当前值输出，单位连接数)
第二部分：
[###Threads info and qc  and :]
Threads_connected:252         Threads_running:4             Qcache_free_memory:0            
Qcache_hits:0                 Qcache_not_cached:0           Qcache_inserts:0        


Threads_connected：The number of currently open connections.(当前值输出 单位连接数)
Threads_running：The number of threads that are not sleeping.(当前值输出 单位连接数)
Qcache_free_memory:The amount of free memory for the query cache.(当前值输出 单位字节数)
Qcache_hits:The number of query cache hits.(累计值相减输出 单位次数)
Qcache_not_cached:The number of noncached queries.(累计值相减输出 单位次数)
Qcache_inserts:The number of queries added to the query cache.(累计值相减输出 单位次数)


第三部分：
本部分全部是(累计值相减输出 单位次数)
[###Table read info:]
Handler_read_first:211        Handler_read_key:8804         Handler_read_next:42346         
Handler_read_last:0           Handler_read_rnd:73           Handler_read_rnd_next:717694


Handler_read_first:
         /*索引中第一条记录被读的次数。如果较高，它表明服务器正执行大量全索引扫描；例如，SELECT * order by id，假定id列有索引。
         * eg:
         * +----+-------------+-------+------------+-------+---------------+---------+---------+------+------+----------+-------+
         * | id | select_type | table | partitions | type  | possible_keys | key     | key_len | ref  | rows | filtered | Extra |
         * +----+-------------+-------+------------+-------+---------------+---------+---------+------+------+----------+-------+
         * |  1 | SIMPLE      | testj | NULL       | index | NULL          | PRIMARY | 276     | NULL |   19 |   100.00 | NULL  |
         * +----+-------------+-------+------------+-------+---------------+---------+---------+------+------+----------+-------+
         */
Handler_read_key:
         /*根据索引读一行的请求数。如果较高，说明查询和表的索引正确。本值可能是ref或者const也可能是range，只是代表索引KEY命中使用了索引
         * eg:
         * mysql> explain select * from testshared3 where id>1;
         * +----+-------------+-------------+------------+-------+---------------+------+---------+------+------+----------+-----------------------+
         * | id | select_type | table       | partitions | type  | possible_keys | key  | key_len | ref  | rows | filtered | Extra                 |
         * +----+-------------+-------------+------------+-------+---------------+------+---------+------+------+----------+-----------------------+
         * |  1 | SIMPLE      | testshared3 | NULL       | range | id            | id   | 5       | NULL |    1 |   100.00 | Using index condition |
         * +----+-------------+-------------+------------+-------+---------------+------+---------+------+------+----------+-----------------------+
         */
Handler_read_next:
         /*按照索引顺序读下一行的请求数,如果索引不唯一或者使用唯一索引的前缀或者范围都会触发这个值,简单的说只有唯一命中不触发这个值
         * 这个值如果比较大说明需要连续访问下一个key的次数非常多
         *
         *eg:
         *mysql> explain select * from testshared3 where id=1;
         *+----+-------------+-------------+------------+------+---------------+------+---------+-------+--------+----------+-------+
         *| id | select_type | table       | partitions | type | possible_keys | key  | key_len | ref   | rows   | filtered | Extra |
         *+----+-------------+-------------+------------+------+---------------+------+---------+-------+--------+----------+-------+
         *|  1 | SIMPLE      | testshared3 | NULL       | ref  | id            | id   | 5       | const | 523260 |   100.00 | NULL  |
         *+----+-------------+-------------+------------+------+---------------+------+---------+-------+--------+----------+-------+
         *
         *| Handler_read_key      | 49      |
         *| Handler_read_next     | 897698  |
         */
Handler_read_last:
        /*
         * 查询读索引最后一个索引键的请求数。当使用ORDER BY时，服务器优先发出使用第一个索引的请求，之后顺序往后扫描索引。当使用ORDER BY DESC时，
         * 服务器优先发出使用最后一个索引的请求， 之后向前扫描索引。
         * 例如：select … order by id desc limit 10;
         */


Handler_read_rnd,Handler_read_rnd_next:这两个值较大则可能遇到了全表扫描及type=ALL


这一部分则可以大体掌握当前数据库全表扫描和索引使用的大概情况  
第四部分：
[###Sorts and temp tables info:]
Sort_rows:0                   Sort_merge_passes:0
Created_tmp_tables:163        Created_tmp_disk_tables:152


Sort_rows:The number of sorted rows.(累计值相减输出 单位行数)
Sort_merge_passes:The number of merge passes that the sort algorithm has had to do.(累计值相减输出 单位次数)
Created_tmp_tables:The number of internal temporary tables created by the server while executing statements.(累计值相减输出 单位次数)
Created_tmp_disk_tables:The number of internal on-disk temporary tables created by the server while executing statements.(累计值相减输出 单位次数)


很明显这一部分说明了排序和临时表使用情况，可以帮助DBA进行判断


第五部分：
[###Table join info:]
Select_full_join:1            Select_scan:207

Select_full_join:The number of joins that perform table scans because they do not use indexes. 
                 If this value is not 0, you should carefully check the indexes of your tables
                 (累计值相减输出 单位次数)
Select_scan:The number of joins that did a full scan of the first table. (累计值相减输出 单位次数)

这两个值则说明了jion的时候是否使用到了索引，特别是Select_full_join，应该比较低，否则说明被驱动表没有使用到索引
应该引起重视，优化语句，一般来讲Select_scan比较高是正常的因为驱动表如果没有谓词条件使用全表扫描是正常的方式


第六部分：
[###Open table cache and binlog cache info:]
Table_open_cache_hits:4938    Table_open_cache_misses:0
Binlog_cache_use:820          Binlog_cache_disk_use:0


Table_open_cache_hits:The number of hits for open tables cache lookups.(累计值相减输出 单位次数)
Table_open_cache_misses:The number of misses for open tables cache lookups. (累计值相减输出 单位次数)
Binlog_cache_use: The number of transactions that used the binary log cache. (累计值相减输出 单位事物数)
Binlog_cache_disk_use:The number of transactions that used the temporary binary log cache but that exceeded the value 
                                 of binlog_cache_size and used a temporary file to store statements from the transaction.(累计值相减输出 单位事物数)
明显这部分说明了binlog_cache_size和 table_open_cache是否合适


第七部分：
本部分全部是(累计值相减输出 单位次数)
[###Hanler_xxx and Com_xxx info:]
Handler_delete:34574          Handler_update:675            Handler_write:1364
Handler_commit:5833           Handler_rollback:10
Com_commit:156                Com_rollback:5
U(counts):631     D(counts):159     I(counts):47      S(counts):4955    

U(counts):631     D(counts):159     I(counts):47      S(counts):4955  
这一行是Com_update\Com_delete\Com_insert\Com_select的简写

Handler_xxx:这一批值说明的是相应操作处理的次数
Com_xxx:这一批值说明是相应操作对应语句发出的次数

比如Handler_commit 和 Com_commit这不同，如果是隐含提交和自动提交不用发起commit，但是
commit是处理了的，那么Handler_commit增加而Com_rollback不变，又比如手动执行一个commit
Com_commit增加Handler_commit不变，因为虽然发起了commit命令并不需要处理实验如下：


mysql> show status like '%commit%';
+----------------+-------+
| Variable_name  | Value |
+----------------+-------+
| Com_commit     | 1     |
| Com_xa_commit  | 0     |
| Handler_commit | 4     |
+----------------+-------+
3 rows in set (0.01 sec)


mysql> commit;
Query OK, 0 rows affected (0.00 sec)


mysql> show status like '%commit%';
+----------------+-------+
| Variable_name  | Value |
+----------------+-------+
| Com_commit     | 2     |
| Com_xa_commit  | 0     |
| Handler_commit | 4     |
+----------------+-------+
3 rows in set (0.00 sec)


第八部分：
[###Innodb_lock info:]
Innodb_row_lock_time:0                Innodb_row_lock_waits:0
Innodb_row_lock_current_waits:38


Innodb_row_lock_time:The total time spent in acquiring row locks for InnoDBtables, in milliseconds.(累计值相减输出 单位毫秒)
Innodb_row_lock_waits:The number of times operations on InnoDB tables had to wait for a row lock.(累计值相减输出 单位次数)
Innodb_row_lock_current_waits:The number of row lockscurrently being waited for by operations on InnoDB tables.(当前值输出 单位个数)


明显这一部分是对innodb 锁的状态的监控


第九部分：


[###Innodb_buffer_pool info:]
Innodb_buf_pool_pages_total:1965840   Innodb_buf_pool_pages_dirty:19154
Innodb_buf_pages_data:1940433         Innodb_buf_pages_free:8116
Innodb_buffer_pool_wait_free:0        Innodb_buffer_pool_pages_misc:17291
Innodb_dblwr_pages_written:1188       Innodb_dblwr_writes:80
Innodb_buffer_pool_pages_flushed:2249
read_ahead:0          ahead_evict:0          ahead_rnd:0       


Innodb_buf_pool_pages_total:及Innodb_buffer_pool_pages_data The total size of the InnoDB buffer pool, in pages.(当前值输出 单位页)
Innodb_buf_pool_pages_dirty:及Innodb_buffer_pool_pages_dirty The current number of dirty pagesin the InnoDB buffer pool.(当前值输出 单位页)
Innodb_buf_pages_data:及Innodb_buffer_pool_pages_data The number of pagesin the InnoDB buffer poolcontaining data. The number includes both dirtyand
                      clean pages.(当前值输出 单位页)
Innodb_buf_pages_free:及Innodb_buffer_pool_pages_free The number of free pagesin the InnoDB buffer pool.(当前值输出 单位页)
Innodb_buffer_pool_wait_free:Normally, writes to the InnoDB buffer poolhappen in the background. When InnoDBneeds to read or
                             create a pageand no clean pages are available, InnoDBflushes some dirty pagesfirst and waits for that
                             operation to finish. This counter counts instances of these waits.(累计值相减输出 单位次数)


Innodb_buffer_pool_pages_misc:The number of pages in the InnoDB buffer pool that are busy because they have
                              been allocated for administrative overhead, such as row locks or the adaptive hash
                              index. This value can also be calculated as Innodb_buffer_pool_pages_total ?
                              Innodb_buffer_pool_pages_free ? Innodb_buffer_pool_pages_data.(当前值输出 单位页)


Innodb_dblwr_pages_written:The number of pages that have been written to the doublewrite buffer.(累计值相减输出 单位页)
Innodb_dblwr_writes:The number of doublewrite operations that have been performed. (累计值相减输出 单位次数)
Innodb_buffer_pool_pages_flushed:The number of requests to flush pages from the InnoDB buffer pool.(累计值相减输出 单位次数)


这部分是innodb_buffer_pool的重点包含了脏页,数据页,空闲页等信息,以及刷磁盘的次数


第十部分：
[###Innodb_log info:]
Innodb_log_writes:796                 Innodb_log_waits:0
Innodb_os_log_pending_fsyncs:0        Innodb_os_log_pending_writes:0
Innodb_os_log_written:44073472




Innodb_log_writes:The number of physical writes to the InnoDB redo logfile.(累计值相减输出 单位次数)
Innodb_log_waits:The number of times that the log buffer was too small and a wait was required for it to be flushed before
                               continuing.(累计值相减输出 单位次数)
Innodb_os_log_pending_fsyncs:The number of pending fsync() operations for the InnoDB redo logfiles.(累计值相减输出 单位次数)
Innodb_os_log_pending_writes:The number of pending writes to the InnoDB redo logfiles.(累计值相减输出 单位次数)
Innodb_os_log_written:The number of bytes written to the InnoDB redo logfiles.(累计值相减输出 单位字节)


这部分说明了 innodb redo 写的信息，如写了多少数据，多少次等待，如果Innodb_os_log_pending_writes和Innodb_os_log_pending_fsyncs
不为0则说明遭遇了I/O等待。而Innodb_log_waits不为0则考虑innodb_log_buffer_size 是否过小。
注意：不管innodb_flush_method设置如何 redo始终使用kernel buffer。


第十一部分：
[###Innodb_data read/writes info:]
Innodb_data_reads:684                 Innodb_data_read:11206656
Innodb_data_writes:2067               Innodb_data_written:63603200
Innodb_data_fsyncs:1017               Innodb_data_pending_fsyncs:0
Innodb_buffer_pool_reads(physics reads):423
Innodb_buffer_pool_read_requests(logic reads):2869823


Innodb_data_reads:The total number of data reads.(累计值相减输出 单位次数)
Innodb_data_read:The amount of data read since the server was started(累计值相减输出 单位字节数)
Innodb_data_writes:The total number of data writes.(累计值相减输出 单位次数)
Innodb_data_written:The amount of data written so far, in bytes.(累计值相减输出 单位字节数)
Innodb_data_fsyncs:The number of fsync()operations so far. The frequency of fsync()calls is influenced by the setting
                            of the innodb_flush_method configuration option.(累计值相减输出 单位次数)
Innodb_data_pending_fsyncs:The current number of pending fsync()operations. The frequency of fsync()calls is influenced by
                           the setting of the innodb_flush_method configuration option.(累计值相减输出 单位次数)
Innodb_buffer_pool_reads(physics reads):The number of logical reads that InnoDB could not satisfy from the buffer pool, and had to read 
                                                        directly from disk.(累计值相减输出 单位次数)
Innodb_buffer_pool_read_requests(logic reads):The number of logical read requests.(累计值相减输出 单位次数)
read_ahead:及Innodb_buffer_pool_read_ahead:The number of pages read into the InnoDB buffer pool by the read-ahead background thread.(累计值相减输出 单位页)
ahead_evict:及Innodb_buffer_pool_read_ahead_evicted:The number of pagesread into the InnoDB buffer poolby the read-aheadbackground thread that were
                                                                                subsequently evictedwithout having been accessed by queries.(累计值相减输出 单位页)
ahead_rnd:及Innodb_buffer_pool_read_ahead_rnd:The number of “random”read-aheads initiated by InnoDB. This happens when a query scans a large
                                                                        portion of a table but in random order.(累计值相减输出 单位次数)


这一部分可以看出逻辑读取的命中率，预读效率等，注意Innodb_data_pending_fsyncs和Innodb_data_fsyncs如果开启了O_DIRECT,那么innodb_buffer的内存
数据不会出现在kernel buffer，那么fsyncs pending的情况会少得多。如果这两个值较大注意磁盘I/O


第十二部分：
本部分全部是(累计值相减输出 单位行数)
U(rows):675     D(rows):34575   I(rows):194     S(rows):767094  


U:Innodb_rows_updated
D:Innodb_rows_deleted
I:Innodb_rows_inserted
S:Innodb_rows_read


这部分真正的反应了DML和SELECT的行数，注意和Com_xxx和Handler_xxx的区别


第十三部分：
Bytes_received:911280         Bytes_sent:8653956


没什么好说的自己查文档


七、内存溢出检测
    使用：
valgrind --tool=memcheck --leak-check=full  ./mymon5.7c -S/mysqldata/mysql5.7sla/mysqld3307.sock -t 1 -n 10
    
==5120== LEAK SUMMARY:
==5120==      definitely lost: 0 bytes in 0 blocks
==5120==      indirectly lost: 0 bytes in 0 blocks
==5120==      possibly lost: 232 bytes in 2 blocks
==5120==      still reachable: 8,176 bytes in 2 blocks
==5120==      suppressed: 0 bytes in 0 blocks
==5120== Reachable blocks (those to which a pointer was found) are not shown.
==5120== To see them, rerun with: --leak-check=full --show-reachable=yes
==5120== 
==5120== For counts of detected and suppressed errors, rerun with: -v
==5120== ERROR SUMMARY: 2 errors from 2 contexts (suppressed: 6 from 6)
可以看到没有内存溢出


八、核心源码


点击(此处)折叠或打开

  1. main主调函数：
  2. /*************************************************************************
  3.   > File Name: main.c
  4.   > Author: gaopeng QQ:22389860 all right reserved
  5.   > Mail: gaopp_200217@163.com
  6.   > Created Time: Wed 08 Feb 2017 08:01:58 AM CST
  7.  ************************************************************************/

  9. #include"type.h"

  11. int useage(void)
  12. {
  13.         printf(
  14.             "Author: gaopeng QQ:22389860 Mail: gaopp_200217@163.com \n"
  15.                         "Info:This tool collect data from 'show global status' and show interval (-t) seconds data change\n"
  16.                         "help DBA to diagnose performance problem,when error or (-d) run log is at current dir name \n"
  17.                         "is mymon.log.\n"
  18.                         "WIN32 platform is not support\n"
  19.                         "Useage:./mymon [-u username] [-p password] -S socketfile/{-h hosname -P port} -t seconds -n times [-l logfile] [-d]\n"
  20.                         "[-?] :help info;\n"
  21.                         "[-u username] :connect to mysqld username,when no username requisite is optional;\n"
  22.                         "[-p password] :connect to mysqld password,when no password requisite is optional;\n"
  23.                         "[-S socketfile]:connect to mysqld socket file;\n"
  24.                         "[-h hostname] :connect to mysqld host;\n"
  25.                         "[-P port] :connect to mysqld port;\n"
  26.                         " socketfile or [hostname port] must;\n"
  27.                         "[-t seconds] :seconds of interval,this is necessary;\n"
  28.                         "[-n times] :how many times you watch,this is necessary;\n"
  29.                         "[-l logfile] :when you want to write information to a logfile provide a logfile name\n"
  30.                         " when a logfile provide no information at foreground,is optional;\n"
  31.                         "[-d] :more running log at logfile,otherwise error log in mymon.log;\n"
  32.                 );
  33.         return 0;
  34. }


  37. int wel(void)
  38. {
  39.         printf(
  40.             "welcome used this mysql monitor tool\n"
  41.                   "Author: gaopeng QQ:22389860 Mail: gaopp_200217@163.com \n"
  42.                         "Info:This tool collect data from 'show global status' and show interval (-t) seconds data change\n"
  43.                         "help DBA to diagnose performance problem,when error or (-d) run log is at current dir name \n"
  44.                         "is mymon.log.\n"
  45.                         "WIN32 platform is not support\n"
  46.                         "Useage:./mymon [-u username] [-p password] -S socketfile/{-h hosname -P port} -t seconds -n times [-l logfile] [-d]\n"
  47.                         "more help info in ./mymon -h\n"
  48.                         );
  49.         return 0;
  50. }

  52. int getpar( char (*par)[500],int n)
  53. {
  54.         int i;
  55.         for(i=0;i<4;i++)
  56.         {
  57.                 printf("your parameter is %s\n",*(par+i));
  58.         }
  59. }

  61. int checkpar(char (*par)[500],int t,int n)
  62. {
  63.         if(strlen(*(par+2)) == 0 && (strlen(*(par+4)) == 0 || strlen(*(par+5)) == 0 ))
  64.         {

  66.                 useage();
  67.                 return -1;
  68.         }

  70.         if(t==0||n==0)
  71.         {
  72.                 useage();
  73.                 return -1;
  74.         }
  75.         return 0;
  76. }

  78. int main(int argc,char* argv[])
  79. {
  80.         int ch;
  81.         int t = 0; //t how long
  82.         int n = 0;//n count
  83.         FILE* fd = 0;//log file fs
  84.         unsigned int mport = 0;//mysql connect port

  86.         debug = 0;
  87.         write_file = 0;
  88.         PAR par;
  89.         setbuf(stdout,NULL);//stdio buffer disable
  90.         memset(par,0,sizeof(PAR));
  91.         if(argc<2)
  92.         {
  93.                 useage();
  94.                 return -1;
  95.         }
  96.         while ((ch = getopt(argc, argv, "u:p:S:t:n:l:h:P:d?")) != -1)
  97.         {
  98.                 switch (ch)
  99.                 {
  100.                         case 'u':
  101.                                 if(strlen(optarg)>MAX_PAR_LEN)
  102.                                 {
  103.                                         printf("MYMON:username max length more than 500 bytes\n");
  104.                                         return -1;
  105.                                 }
  106.                                 strcpy(par[0],optarg);
  107.                                 break;
  108.                         case 'h':
  109.                                 if(strlen(optarg)>MAX_PAR_LEN)
  110.                                 {
  111.                                         printf("MYMON:hostname max length more than 500 bytes\n");
  112.                                         return -1;
  113.                                 }
  114.                                 strcpy(par[4],optarg);
  115.                                 break;
  116.                         case 'P':
  117.                                 if(strlen(optarg)>MAX_PAR_LEN)
  118.                                 {
  119.                                         printf("MYMON:port max length more than 500 bytes\n");
  120.                                         return -1;
  121.                                 }
  122.                                 strcpy(par[5],optarg);
  123.                                 sscanf (par[5],"%u",&mport);
  124.                                 break;
  125.                         case 'p':
  126.                                 if(strlen(optarg)>MAX_PAR_LEN)
  127.                                 {
  128.                                         printf("MYMON:password max length more than 500 bytes\n");
  129.                                         return -1;
  130.                                 }
  131.                                 strcpy(par[1],optarg);
  132.                                 break;
  133.                         case 'S':
  134.                                 if(strlen(optarg)>MAX_PAR_LEN)
  135.                                 {
  136.                                         printf("MYMON:socket max length more than 500 bytes\n");
  137.                                         return -1;
  138.                                 }
  139.                                 strcpy(par[2],optarg);
  140.                                 break;
  141.                         case 't':
  142.                                 sscanf (optarg,"%d",&t);
  143.                                 break;
  144.                         case 'n':
  145.                                 sscanf (optarg,"%d",&n);
  146.                                 break;
  147.                         case 'l':
  148.                                 if(strlen(optarg)>MAX_PAR_LEN)
  149.                                 {
  150.                                         printf("MYMON:logfile name max length more than 500 bytes\n");
  151.                                         return -1;
  152.                                 }
  153.                                 strcpy(par[3],optarg);
  154.                                 if((fd = fopen(par[3],OPENFLAG)) == NULL)
  155.                                 {
  156.                                         perror("MYMON:");
  157.                                         return -1;
  158.                                 }
  159.                                 write_file = 1;
  160.                                 setbuf(fd,NULL);//stdio buffer disable
  161.                                 break;
  162.                         case 'd':
  163.                                 debug = 1;
  164.                                 break;
  165.                         default:
  166.                         case '?':
  167.                                 useage();
  168.                                 return -1;
  169.                 }
  170.         }

  172.         if(checkpar(par,t,n) == -1)
  173.         {
  174.                 printf("MYMON:must parameter error\n");
  175.                 return -1;
  176.         }
  177.         wel();
  178.         if(conn(par,t,n+1,fd,mport) !=0)
  179.                 {
  180.                         printf("MYMON:error pelase check log\n");
  181.                         return -1;
  182.                 }
  183.         if(write_file == 1)
  184.                 {
  185.                         fclose(fd);
  186.                 }
  187.         return 0;
  188. }


点击(此处)折叠或打开

  1. fun.c功能实现接口函数
  2. /*************************************************************************
  3.   > File Name: fun.c
  4.   > Author: gaopeng QQ:22389860 all right reserved
  5.   > Mail: gaopp_200217@163.com
  6.   > Created Time: Wed 08 Feb 2017 10:08:56 AM CST
  7.  ************************************************************************/
  8.  /*
  9.         This file frist store new and old data to one data struct
  10.         **struct->*struct->struct
  11.         struct have three pointer
  12.         statname
  13.         olddata
  14.         newdata

  16.         Then sub new and old data to one struct array
  17.         Last use array to print data
  18. */

  20.  

  22. #include"type.h"
  23. #include"fun.h"

  25. /*
  26.  * field pointer to status name
  27.  * olddata pointer to prev data
  28.  * newdata pointer to now data
  29.  */


  32. typedef struct MDATA
  33. {
  34.         char* statname;
  35.         char* olddata;
  36.         char* newdata;
  37. } MDATA;

  39. typedef struct D_STROE
  40. {
  41.         char statname[MAXSTATNAME];
  42.         int64_t data;
  43. } D_STROE;


  46. /* ret=0 is sucss ret<0 is false*/
  47. int handle_data(MYSQL_RES *result/*in*/,uint64_t row_count,unsigned int row_field,FILE* fd,MDATA* *datap/*in*/,int i);
  48. /* ret=0 is sucss ret<0 is false*/
  49. int memaloc(MDATA** *datap/*out*/,uint64_t row_count);
  50. /* ret=0 is sucss ret<0 is false*/
  51. int sub_store_data(MDATA* *datap,D_STROE* *last_data/*out*/,uint64_t row_count,int* lenth/*in*/);
  52. /* ret=0 is sucss ret<0 is false*/
  53. int print_data(D_STROE* last_data,int lenth,FILE* fd) ;
  54. /* ret=-1 is no data return >=0 and -65535 is data return */
  55. int64_t findva(const char* ins,D_STROE* last_data,int lenth);
  56. /* no retrun value*/
  57. int freedatap(MDATA* *datap,uint64_t row_count);

  59. static freecouti=0;

  61. void test(void)
  62. {
  63.         ;
  64. }


  67. int mprintf(FILE* outfile,const char *format,...)
  68. {
  69.     va_list args;
  70.     va_start(args,format);
  71.     if( vfprintf(outfile,format,args) <0 )
  72.         {
  73.                 GET_LOG(LogLevel[4],ERROR,"ERROR:mprintf() error:%d\n",ERROR);
  74.                         printf("MYMON: mprintf() error:%d\n",ERROR);
  75.                         exit(-1);
  76.         }
  77.     va_end(args);
  78.         return 0;
  79. }



  83. int xfree(void* p)
  84. {
  85.         if(p==NULL)
  86.         {
  87.                 freecouti++;
  88.                 if(debug == 3)
  89.                 {
  90.                         GET_LOG(LogLevel[1],DEBUG,"DEBUG:xfree(NULL) debug:%d\n",freecouti);
  91.                 }
  92.                 return 0;
  93.         }
  94.         free(p);
  95.         p=NULL;
  96.         return 0;
  97. }

  99. int conn(char (*par)[500]/*in*/,int t,int n,FILE* fd,unsigned int myport)
  100. {
  101.         MYSQL conn_ptr;
  102.         MYSQL_RES *query_res =NULL;
  103.         MYSQL_ROW sqlrow_data;
  104.         int ret = 0;
  105.         uint64_t row_count = 0;
  106.         unsigned int row_field = 0;
  107.         MDATA* *datap =NULL;
  108.         int i=0;//used to check frist time no old data


  111.         /*
  112.          *MYSQL *mysql_init(MYSQL *mysql)
  113.          *An initialized MYSQL*handle. NULLif there was insufficient memory to allocate a new object.
  114.          */
  115.         if(mysql_init(&conn_ptr) == NULL)
  116.         {
  117.                 ret = -1;
  118.                 GET_LOG(LogLevel[4],ERROR,"ERROR:mysql_init() error:%d\n",ERROR);
  119.                 printf("MYMON: mysql_init() error\n");
  120.                 return ret;
  121.         }
  122.         /*
  123.          *MYSQL *mysql_real_connect(MYSQL *mysql, const char *host, const char *user,
  124.          *const char *passwd, const char *db, unsigned int port, const char *unix_socket,
  125.          *unsigned long client_flag)
  126.          *A MYSQL*connection handle if the connection was successful, NULLif the connection was unsuccessful.
  127.          *For a successful connection, the return value is the same as the value of the first parameter
  128.          */
  129.         if(mysql_real_connect(&conn_ptr,*(par+4),*par,*(par+1),NULL,myport,*(par+2),0)==NULL)
  130.         {
  131.                 ret = -2;
  132.                 GET_LOG(LogLevel[4],ERROR,"ERROR:mysql_real_connect() error:%d\n",ERROR);
  133.                 printf("MYMON: mysql_real_connect() error\n");
  134.                 if(mysql_errno(&conn_ptr))
  135.                 {
  136.                         GET_LOG(LogLevel[4],ERROR,"ERROR:mysql_real_connect() error:%s\n",mysql_error(&conn_ptr));
  137.                         printf("MYMON: mysql_real_connect() error:%s\n",mysql_error(&conn_ptr));
  138.                 }
  139.                 return ret;
  140.         }

  142.         while(n--)
  143.         {
  144.                 /*
  145.                  *int mysql_query(MYSQL *mysql, const char *stmt_str)
  146.                  *Zero for success. Nonzero if an error occurred.
  147.                  */
  148.                 if((mysql_query(&conn_ptr,"show global status")) != 0)
  149.                 {
  150.                         ret = -3;
  151.                         GET_LOG(LogLevel[4],ERROR,"ERROR:mysql_query() error:%s\n",mysql_error(&conn_ptr));
  152.                         printf("MYMON: mysql_query() error:%s\n",mysql_error(&conn_ptr));
  153.                         return ret;
  154.                 }
  155.                 /*
  156.                  * MYSQL give memory out
  157.                  * MYSQL_RES *mysql_store_result(MYSQL *mysql)
  158.                  * A MYSQL_RESresult structure with the results. NULL(0) if an error occurred
  159.                  */

  161.                 if((query_res=mysql_store_result(&conn_ptr)) == NULL)
  162.                 {
  163.                         ret = -4;
  164.                         GET_LOG(LogLevel[4],ERROR,"ERROR:mysql_store_result() error:%s\n",mysql_error(&conn_ptr));
  165.                         printf("MYMON: mysql_store_result() error:%s\n",mysql_error(&conn_ptr));
  166.                         return ret;
  167.                 }
  168.                 /*
  169.                  * my_ulonglong mysql_num_rows(MYSQL_RES *result)
  170.                  * The number of rows in the result set.
  171.                  * unsigned int mysql_num_fields(MYSQL_RES *result)
  172.                  * An unsigned integer representing the number of columns in a result set
  173.                  */
  174.                 row_count = mysql_num_rows(query_res);
  175.                 row_field = mysql_field_count(&conn_ptr);
  176.                 if(debug == 1)
  177.                 {
  178.                         GET_LOG(LogLevel[2],INFO,"INFO:mysql_num_rows() rows is %llu\n",row_count);
  179.                         GET_LOG(LogLevel[2],INFO,"INFO:mysql_field_count() fileds is %ld\n",row_field);
  180.                         printf("MYMON: mysql_num_rows() rows is %llu\n",row_count);
  181.                         printf("MYMON: mysql_field_count() fileds is %ld\n",row_field);
  182.                 }
  183.                 if(i == 0)
  184.                 {
  185.                         if((memaloc(&datap,row_count)) !=0)
  186.                         {
  187.                                 ret = -6;
  188.                                 GET_LOG(LogLevel[4],ERROR,"ERROR:memaloc() error:%s\n","ERROR");
  189.                                 printf("MYMON: memaloc() error:%s\n","ERROR");
  190.                                 return ret;
  191.                         }
  192.                 }
  193.                 if(handle_data(query_res,row_count,row_field,fd,datap,i)!=0)
  194.                 {
  195.                         ret = -5;
  196.                         GET_LOG(LogLevel[4],ERROR,"ERROR:handle_data() error:%s\n","ERROR");
  197.                         printf("MYMON: handle_data() error:%s\n","ERROR");
  198.                         return ret;
  199.                 }

  201.                 /*
  202.                  * void mysql_free_result(MYSQL_RES *result)
  203.                  * no result
  204.                  */
  205.                 mysql_free_result(query_res);
  206.                 sleep(t);
  207.                 i++;
  208.         }
  209.         /*
  210.          * void mysql_close(MYSQL *mysql)
  211.          * no result
  212.          */

  214.         /*hear free datap*/
  215.                 {
  216.                         freedatap(datap,row_count);
  217.                 }
  218.         mysql_close(&conn_ptr);
  219.         return ret;
  220. }


  223. int freedatap(MDATA* *datap,uint64_t row_count)
  224. {
  225.         int ret = 0;
  226.         uint64_t i = 0;
  227.         if(datap == NULL)
  228.                 {
  229.                         return ret;
  230.                 }
  231.         GET_LOG(LogLevel[3],INFO,"INFO:freedatap() check previous line is error?:%d\n",ret);
  232.         for(i=0;i<row_count;i++)
  233.                 {
  234.                         xfree ((*(datap+i))->statname);
  235.                         xfree((*(datap+i))->newdata);
  236.                         xfree((*(datap+i))->olddata);
  237.                         xfree(*(datap+i));
  238.                 }
  239.         xfree(datap);
  240.         return ret;
  241. }
  242. int memaloc(MDATA** *datap,uint64_t row_count)
  243. {
  244.         int ret=0;
  245.         MDATA* *mp=NULL;
  246.         uint64_t i=0;

  248.         if(datap == NULL)
  249.         {
  250.                 ret = -5;
  251.                 GET_LOG(LogLevel[4],ERROR,"ERROR:memaloc() datap=NULL?:%d\n",ret);
  252.                 printf("MYMON: memaloc() datap=NULL?:%d\n",ret);
  253.                 return ret;
  254.         }
  255.         if((mp = (MDATA**)calloc(1,row_count*sizeof(MDATA*))) == NULL)
  256.         {
  257.                 ret = -3;
  258.                 GET_LOG(LogLevel[4],ERROR,"ERROR:memaloc() memory malloc **p error:%d\n",ret);
  259.                 printf("MYMON: memaloc() memory malloc **p error:%d\n",ret);
  260.                 return ret;
  261.         }
  262.         for(i=0;i<row_count;i++)
  263.         {
  264.                 if((*(mp+i)=(MDATA*)calloc(1,sizeof(MDATA))) == NULL)
  265.                 {
  266.                         ret=-4;
  267.                         GET_LOG(LogLevel[4],ERROR,"ERROR:handle_data() memory malloc *p error:%d\n",ret);
  268.                         printf("MYMON: MYMON:handle_data() memory malloc *p error:%d\n",ret);
  269.                         freedatap(mp,row_count);
  270.                         return ret;
  271.                 }
  272.         }
  273.         *datap = mp;
  274.         return ret;

  276. }


  279. int handle_data(MYSQL_RES *result,uint64_t row_count,unsigned int row_field,FILE* fd,MDATA* *datap,int seq)
  280. {
  281.         uint64_t i = 0;
  282.         MYSQL_ROW sqlrow_data;
  283.         int ret = 0;
  284.         D_STROE* last_data=NULL;//used last data store
  285.         int lenth=0;//last data lenth

  287.         //tmp
  288.         int tmp = 0;
  289.     D_STROE* tmp_last_data = NULL;

  291.         if(result == NULL||datap == NULL)
  292.         {
  293.                 ret = -2;
  294.                 GET_LOG(LogLevel[4],ERROR,"ERROR:handle_data() result == NULL datap == NULL :%s\n","ERROR");
  295.                 printf("MYMON:handle_data() result == NULL datap == NULL :%s\n","ERROR");
  296.                 return ret;
  297.         }

  299.         for(i=0;i<row_count;i++)//control true result return
  300.         {
  301.                 /*
  302.                  * MYSQL_ROW mysql_fetch_row(MYSQL_RES *result)
  303.                  * A MYSQL_ROW structure for the next row. NULL if there are no more rows to retrieve or if an error occurred
  304.                  */
  305.                 if((sqlrow_data=mysql_fetch_row(result)) == NULL) //control mysql_fetch_row error
  306.                 {
  307.                         ret = -1;
  308.                         GET_LOG(LogLevel[4],ERROR,"ERROR:mysql_fetch_row() error:%s\n","ERROR");
  309.                         printf("MYMON: mysql_fetch_row() error:%s\n","ERROR");
  310.                         return ret;
  311.                 }
  312.                 {
  313.                         unsigned long *lengths;
  314.                         lengths = mysql_fetch_lengths(result);
  315.                         xfree((*(datap+i))->statname);
  316.                         if(((*(datap+i))->statname = (char*)calloc(1,lengths[0]+10)) == NULL)
  317.                         {
  318.                                 ret = -4;
  319.                                 GET_LOG(LogLevel[4],ERROR,"ERROR:handle_data() statname loop mem alloc error:%s\n","ERROR");
  320.                                 printf("MYMON: handle_data() statname loop mem alloc error:%s\n","ERROR");
  321.                                 return ret;

  323.                         }
  324.                         strcpy((*(datap+i))->statname,sqlrow_data[0] ? sqlrow_data[0] : "NULL");
  325.                         xfree((*(datap+i))->olddata);
  326.                         (*(datap+i))->olddata = (*(datap+i))->newdata;
  327.                         //no free newdata pointer
  328.                         if(((*(datap+i))->newdata = (char*)calloc(1,lengths[1]+10)) == NULL)
  329.                         {
  330.                                 ret = -5;
  331.                                 GET_LOG(LogLevel[4],ERROR,"ERROR:handle_data() newdata loop mem alloc error:%s\n","ERROR");
  332.                                 printf("MYMON: handle_data() newdata loop mem alloc error:%s\n","ERROR");
  333.                                 return ret;
  334.                         }
  335.                         strcpy((*(datap+i))->newdata,sqlrow_data[1] ? sqlrow_data[1] : "NULL");
  336.                         if(debug == 1)
  337.                                 {
  338.                                if((!strcmp((*(datap+i))->statname,"NULL")) || (!strcmp((*(datap+i))->newdata,"NULL")) )
  339.                                 {
  340.                                         GET_LOG(LogLevel[1],DEBUG,"DEBUG:handle_data() statname or data IS NULL:[%s]\n",(*(datap+i))->statname);
  341.                                                 GET_LOG(LogLevel[1],DEBUG,"DEBUG:handle_data() statname or data IS NULL:[%s]\n",(*(datap+i))->newdata);
  342.                                 }
  343.                                 }
  344.                 }

  346.         }
  347.         if(seq == 0)//olddata have no data
  348.                 {
  349.                         if(debug == 1)
  350.                                 {
  351.                         GET_LOG(LogLevel[1],DEBUG,"DEBUG:handle_data() first time is info %s\n","no old data");
  352.                         printf("MYMON: handle_data() first time is info %s\n","no old data");
  353.                                 }
  354.                 }
  355.         if(seq != 0 ) //newdata and olddata have data
  356.                 {
  357.                         if(sub_store_data(datap,&last_data,row_count,&lenth) != 0 ) //store data to array
  358.                                 {
  359.                                         ret = -6;
  360.                                         GET_LOG(LogLevel[4],ERROR,"ERROR:handle_data() sub_store_data() error:%s\n","ERROR");
  361.                                         printf("MYMON: handle_data() sub_store_data() error %s\n","ERROR");
  362.                                         return ret;
  363.                                 }
  364.                 if(debug == 1)
  365.                         {
  366.                         tmp_last_data = last_data;
  367.                         for(tmp =0;tmp<lenth;tmp++)
  368.                                 {
  369.                                         GET_LOG(LogLevel[1],DEBUG,"DEBUG:handle_data() find data is [%s]",(tmp_last_data)->statname);
  370.                                         GET_LOG(LogLevel[1],DEBUG,"[%lld] \n",(tmp_last_data)->data);
  371.                                         tmp_last_data++;
  372.                                 }
  373.                         }



  377.                         if(print_data(last_data,lenth,fd) != 0) //store data from array
  378.                                 {
  379.                                         ret = -7;
  380.                                         GET_LOG(LogLevel[4],ERROR,"ERROR:handle_data() print_data() error:%s\n","ERROR");
  381.                                         printf("MYMON: handle_data() print_data() error %s\n","ERROR");
  382.                                         return ret;
  383.                                 }

  385.                 }
  386.         //used end free last data array
  387.         xfree(last_data);
  388.         return ret;
  389. }


  392. int sub_store_data(MDATA* *datap,D_STROE* *last_data,uint64_t row_count,int* lenth)
  393. {
  394.         D_STROE* tmp_p = NULL;
  395.         int ret = 0;
  396.         uint64_t i = 0;

  398.         char* *dyd_d = NULL;
  399.         char* *std_d = NULL;
  400.         int64_t a = 0;
  401.         int64_t b = 0;

  403.         if(datap == NULL || last_data == NULL )
  404.                 {
  405.                     ret = -1;
  406.                         GET_LOG(LogLevel[4],ERROR,"ERROR:sub_store_data() datap == NULL || fail_data == NULL %s\n","ERROR");
  407.                         printf("MYMON: sub_store_data() datap == NULL || fail_data == NULL %s\n","ERROR");
  408.                         return ret;
  409.                 }

  411.         if((tmp_p = (D_STROE*)calloc(1,(sizeof(stdata)+sizeof(dydata))*sizeof(D_STROE))) == NULL)
  412.                 {
  413.                         ret = -2;
  414.                         GET_LOG(LogLevel[4],ERROR,"ERROR:sub_store_data() mem alloc error:%s\n","ERROR");
  415.                         printf("MYMON: sub_store_data() mem alloc error:%s\n","ERROR");
  416.                         return ret;
  417.                 }
  418.         *last_data = tmp_p;

  420.         for(i=0;i<row_count;i++)
  421.                 {
  422.                         dyd_d = dydata; //re pointer to dydata
  423.                 std_d = stdata; //re pointer to dydata
  424.                         if(strlen((*(datap+i))->statname)>MAXSTATNAME)
  425.                                 {
  426.                                         ret = -3;
  427.                                         GET_LOG(LogLevel[4],ERROR,"ERROR:sub_store_data() statname>MAXSTATNAME:%s\n","ERROR");
  428.                                         printf("MYMON: sub_store_data() statname>MAXSTATNAME:%s\n","ERROR");
  429.                                         goto er;
  430.                                 }
  431.                         while(*dyd_d)
  432.                                 {
  433.                                         if(debug == 3)
  434.                                                 {
  435.                                                         printf("dyd [%s] [%s] [%d] [%d]\n",*dyd_d,(*(datap+i))->statname,strlen(*dyd_d),strlen((*(datap+i))->statname));
  436.                                                 }
  437.                                         if(!strcmp(*dyd_d,(*(datap+i))->statname))
  438.                                                 {

  440.                                                         if(debug == 1)
  441.                                                                 {
  442.                                                                         GET_LOG(LogLevel[1],DEBUG,"DEBUG:sub_store_data() find data is %s \n",*dyd_d);
  443.                                                                 }
  444.                                                         strcpy(tmp_p->statname,*dyd_d);
  445.                                                         if( !strcmp((*(datap+i))->olddata,"NULL") || !strcmp((*(datap+i))->newdata,"NULL")) //check "NULL" DATA ?
  446.                                                                 {
  447.                                                                         GET_LOG(LogLevel[2],INFO,"INFO:sub_store_data() data %s is [NULL] \n",*dyd_d);
  448.                                                                         tmp_p->data = ERRORDATA;
  449.                                                                 }
  450.                                                         if(sscanf((*(datap+i))->olddata,"%lld",&a) == EOF || sscanf((*(datap+i))->newdata,"%lld",&b) == EOF)
  451.                                                                 {
  452.                                                                         ret = -4;
  453.                                                                         GET_LOG(LogLevel[4],ERROR,"ERROR:sub_store_data() sscanf() error %s\n","ERROR");
  454.                                                                         printf("MYMON: sub_store_data() sscanf() error:%s\n","ERROR");
  455.                                                                         goto er;
  456.                                                                 }
  457.                                                         tmp_p->data = b-a; //new - old
  458.                                                         tmp_p++;
  459.                                                         (*lenth)++;
  460.                                                         break;
  461.                                                 }
  462.                                         dyd_d++;
  463.                                 }
  464.                         while(*std_d)
  465.                                 {
  466.                                         if(debug == 3)
  467.                                                 {
  468.                                                         printf("std [%s] [%s] [%d] [%d]\n",*std_d,(*(datap+i))->statname,strlen(*std_d),strlen((*(datap+i))->statname));
  469.                                                 }
  470.                                         if(!strcmp(*std_d,(*(datap+i))->statname))
  471.                                                 {

  473.                                                      if(debug == 1)
  474.                                                                 {
  475.                                                                         GET_LOG(LogLevel[1],DEBUG,"DEBUG:sub_store_data() find data is %s \n",*std_d);
  476.                                                                 }
  477.                                                         strcpy(tmp_p->statname,*std_d);
  478.                                                         if(!strcmp((*(datap+i))->newdata,"NULL")) //check "NULL" DATA ?
  479.                                                                 {
  480.                                                                         GET_LOG(LogLevel[2],INFO,"INFO:sub_store_data() data %s is [NULL] \n",*std_d);
  481.                                                                         tmp_p->data = ERRORDATA;
  482.                                                                 }
  483.                                                         if(sscanf((*(datap+i))->olddata,"%lld",&tmp_p->data) == EOF)
  484.                                                                 {
  485.                                                                         ret = -4;
  486.                                                                         GET_LOG(LogLevel[4],ERROR,"ERROR:sub_store_data() sscanf() error %s\n","ERROR");
  487.                                                                         printf("MYMON: sub_store_data() sscanf() error:%s\n","ERROR");
  488.                                                                         goto er;
  489.                                                                 }
  490.                                                         tmp_p++;
  491.                                                         (*lenth)++;
  492.                                                         break;
  493.                                                 }
  494.                                 std_d++;
  495.                                 }
  496.                 }
  497.         return ret;

  499.         er:
  500.                 xfree(tmp_p);
  501.                 *last_data= NULL;
  502.                 return ret;
  503. }

  505. int print_data(D_STROE* last_data,int lenth,FILE* fd)
  506. {
  507.         time_t rawtime;
  508.         struct tm * timeinfo = NULL;
  509.         int ret = 0;
  510.         FILE* outfile = NULL;
  511.         if(write_file == 1)
  512.                 {
  513.                         outfile=fd;
  514.                 }
  515.         else
  516.                 {
  517.                         outfile=stdout;
  518.                 }

  520.         if(time (&rawtime) == -1)
  521.                 {
  522.                         ret = -2;
  523.                         GET_LOG(LogLevel[4],ERROR,"ERROR:print_data() time() error %s\n","ERROR");
  524.             printf("MYMON: ERROR:print_data() time() error:%s\n","ERROR");
  525.                         return ret;
  526.                 }
  527.         timeinfo = localtime ( &rawtime );
  528.         if (timeinfo == NULL )
  529.                 {
  530.                         ret = -1;
  531.                         GET_LOG(LogLevel[4],ERROR,"ERROR:print_data() localtime () error %s\n","ERROR");
  532.                         printf("MYMON: ERROR:print_data() localtime () error:%s\n","ERROR");
  533.                         return ret;
  534.                 }
  535.         mprintf(outfile,"------------------------------------------MYMON--------------------------------------------\n");
  536.         mprintf(outfile,"SysTime: %s",asctime (timeinfo));
  537.         mprintf(outfile,
  538.                     "%s%-11ld%s%-8ld%s%-8ld%s%-8ld\n",
  539.                         "Uptime:",findva("Uptime",last_data,lenth),
  540.                         "Connections:",findva("Connections",last_data,lenth) ,
  541.                         "Aborted_clients:",findva("Aborted_clients",last_data,lenth),
  542.                         "Max_used_connections:",findva("Max_used_connections",last_data,lenth));
  543.         mprintf(outfile,"--------------------------------------MYSQLINFO-------------------------------------------\n");
  544.         mprintf(outfile,"[###Threads info and qc info:]\n");
  545.         mprintf(outfile,
  546.                     "%s%-12ld%s%-14ld%s%-13ld\n",
  547.                    "Threads_connected:",findva("Threads_connected",last_data,lenth),
  548.            "Threads_running:",findva("Threads_running",last_data,lenth),
  549.            "Qcache_free_memory:",findva("Qcache_free_memory",last_data,lenth)
  550.                         );
  551.         mprintf(outfile,
  552.                     "%s%-18ld%s%-12ld%s%-17ld\n",
  553.                    "Qcache_hits:",findva("Qcache_hits",last_data,lenth),
  554.                    "Qcache_not_cached:",findva("Qcache_not_cached",last_data,lenth),
  555.                    "Qcache_inserts:",findva("Qcache_inserts",last_data,lenth)
  556.                   );
  557.         mprintf(outfile,"[###Table read info:]\n");
  558.         mprintf(outfile,
  559.                     "%s%-11ld%s%-13ld%s%-14ld\n",
  560.                         "Handler_read_first:",findva("Handler_read_first",last_data,lenth),
  561.                         "Handler_read_key:",findva("Handler_read_key",last_data,lenth),
  562.                         "Handler_read_next:",findva("Handler_read_next",last_data,lenth)
  563.                         );

  565.         mprintf(outfile,
  566.                     "%s%-12ld%s%-13ld%s%ld\n",
  567.                         "Handler_read_last:",findva("Handler_read_last",last_data,lenth),
  568.                         "Handler_read_rnd:",findva("Handler_read_rnd",last_data,lenth),
  569.                         "Handler_read_rnd_next:",findva("Handler_read_rnd_next",last_data,lenth)
  570.                         );
  571.         mprintf(outfile,"[###Sorts and temp tables info:]\n");
  572.         mprintf(outfile,
  573.                     "%s%-20ld%s%ld\n",
  574.                     "Sort_rows:",findva("Sort_rows",last_data,lenth),
  575.                         "Sort_merge_passes:",findva("Sort_merge_passes",last_data,lenth)
  576.                         );
  577.         mprintf(outfile,
  578.                     "%s%-11ld%s%ld\n",
  579.                         "Created_tmp_tables:",findva("Created_tmp_tables",last_data,lenth),
  580.                         "Created_tmp_disk_tables:",findva("Created_tmp_disk_tables",last_data,lenth)
  581.                         );
  582.         mprintf(outfile,"[###Table join info:]\n");
  583.     mprintf(outfile,
  584.                     "%s%-13ld%s%ld\n",
  585.                         "Select_full_join:",findva("Select_full_join",last_data,lenth),
  586.                         "Select_scan:",findva("Select_scan",last_data,lenth)
  587.                         );
  588.          
  589.           mprintf(outfile,"[###Open table cache and binlog cache info:]\n");
  590.           mprintf(outfile,
  591.                     "%s%-8ld%s%ld\n",
  592.                         "Table_open_cache_hits:",findva("Table_open_cache_hits",last_data,lenth),
  593.                         "Table_open_cache_misses:",findva("Table_open_cache_misses",last_data,lenth)
  594.                         );
  595.           mprintf(outfile,
  596.                     "%s%-13ld%s%ld\n",
  597.                         "Binlog_cache_use:",findva("Binlog_cache_use",last_data,lenth),
  598.                         "Binlog_cache_disk_use:",findva("Binlog_cache_disk_use",last_data,lenth)
  599.                         );
  600.          mprintf(outfile,"[###Hanler_xxx and Com_xxx info:]\n");

  602.          mprintf(outfile,
  603.                     "%s%-15ld%s%-15ld%s%ld\n",
  604.                         "Handler_delete:",findva("Handler_delete",last_data,lenth),
  605.                         "Handler_update:",findva("Handler_update",last_data,lenth),
  606.                         "Handler_write:",findva("Handler_write",last_data,lenth)
  607.                         );
  608.          mprintf(outfile,
  609.                     "%s%-15ld%s%-ld\n",
  610.                         "Handler_commit:",findva("Handler_commit",last_data,lenth),
  611.                         "Handler_rollback:",findva("Handler_rollback",last_data,lenth)
  612.                         );
  613.           mprintf(outfile,
  614.                          "%s%-19ld%s%ld\n",
  615.                          "Com_commit:",findva("Com_commit",last_data,lenth),
  616.                          "Com_rollback:",findva("Com_rollback",last_data,lenth)
  617.                          );
  618.         mprintf(outfile,
  619.                     "%s%-8ld%s%-8ld%s%-8ld%s%-8ld\n",
  620.                         "U(counts):",findva("Com_update",last_data,lenth),
  621.                         "D(counts):",findva("Com_delete",last_data,lenth),
  622.                         "I(counts):",findva("Com_insert",last_data,lenth),
  623.                         "S(counts):",findva("Com_select",last_data,lenth)
  624.                         );
  625.     mprintf(outfile,
  626.                    "--------------------------------------INNODBINFO------------------------------------------\n");
  627.     mprintf(outfile,"[###Innodb_lock info:]\n");
  628.         mprintf(outfile,
  629.                     "%s%-17ld%s%ld\n",
  630.                         "Innodb_row_lock_time:",findva("Innodb_row_lock_time",last_data,lenth),
  631.                         "Innodb_row_lock_waits:",findva("Innodb_row_lock_waits",last_data,lenth)
  632.                         );
  633.         mprintf(outfile,
  634.                     "%s%ld\n",
  635.                         "Innodb_row_lock_current_waits:",findva("Innodb_row_lock_current_waits",last_data,lenth)
  636.                         );
  637.     mprintf(outfile,"[###Innodb_buffer_pool info:]\n");

  639.         mprintf(outfile,"%s%-10ld%s%ld\n","Innodb_buf_pool_pages_total:",findva("Innodb_buffer_pool_pages_total",last_data,lenth)
  640.                     ,"Innodb_buf_pool_pages_dirty:",findva("Innodb_buffer_pool_pages_dirty",last_data,lenth));

  642.         mprintf(outfile,"%s%-16ld%s%ld\n","Innodb_buf_pages_data:",findva("Innodb_buffer_pool_pages_data",last_data,lenth)
  643.                     ,"Innodb_buf_pages_free:",findva("Innodb_buffer_pool_pages_free",last_data,lenth));

  645.         mprintf(outfile,
  646.                     "%s%-9ld%s%ld\n",
  647.                         "Innodb_buffer_pool_wait_free:",findva("Innodb_buffer_pool_wait_free",last_data,lenth),
  648.                         "Innodb_buffer_pool_pages_misc:",findva("Innodb_buffer_pool_pages_misc",last_data,lenth)
  649.                         );
  650.         mprintf(outfile,
  651.                     "%s%-11ld%s%ld\n",
  652.                         "Innodb_dblwr_pages_written:",findva("Innodb_dblwr_pages_written",last_data,lenth),
  653.                         "Innodb_dblwr_writes:",findva("Innodb_dblwr_writes",last_data,lenth)
  654.                         );

  656.         mprintf(outfile,
  657.                     "%s%ld\n",
  658.                         "Innodb_buffer_pool_pages_flushed:",findva("Innodb_buffer_pool_pages_flushed",last_data,lenth)
  659.                         );
  660.         mprintf(outfile,
  661.                      "%s%-10ld %s%-10ld %s%-10ld\n",
  662.                      "read_ahead:",findva("Innodb_buffer_pool_read_ahead",last_data,lenth),
  663.                      "ahead_evict:",findva("Innodb_buffer_pool_read_ahead_evicted",last_data,lenth),
  664.                      "ahead_rnd:",findva("Innodb_buffer_pool_read_ahead_rnd",last_data,lenth));
  665.         mprintf(outfile,"[###Innodb_log info:]\n");
  666.         mprintf(outfile,
  667.                      "%s%-20ld%s%ld\n",
  668.                         "Innodb_log_writes:",findva("Innodb_log_writes",last_data,lenth),
  669.                         "Innodb_log_waits:",findva("Innodb_log_waits",last_data,lenth)
  670.                         );
  671.         mprintf(outfile,
  672.                     "%s%-9ld%s%ld\n",
  673.                         "Innodb_os_log_pending_fsyncs:",findva("Innodb_os_log_pending_fsyncs",last_data,lenth),
  674.                         "Innodb_os_log_pending_writes:",findva("Innodb_os_log_pending_writes",last_data,lenth)
  675.                         );
  676.         mprintf(outfile,
  677.                     "%s%ld\n",
  678.                         "Innodb_os_log_written:",findva("Innodb_os_log_written",last_data,lenth)
  679.                    );
  680.         mprintf(outfile,"[###Innodb_data read/writes info:]\n");
  681.     mprintf(outfile,
  682.                     "%s%-20ld%s%ld\n",
  683.                         "Innodb_data_reads:",findva("Innodb_data_reads",last_data,lenth),
  684.                         "Innodb_data_read:",findva("Innodb_data_read",last_data,lenth)
  685.                         );
  686.     mprintf(outfile,
  687.                     "%s%-19ld%s%ld\n",
  688.                         "Innodb_data_writes:",findva("Innodb_data_writes",last_data,lenth),
  689.                         "Innodb_data_written:",findva("Innodb_data_written",last_data,lenth)
  690.                         );
  691.         mprintf(outfile,
  692.                     "%s%-19ld%s%ld\n",
  693.                     "Innodb_data_fsyncs:",findva("Innodb_data_fsyncs",last_data,lenth),
  694.                     "Innodb_data_pending_fsyncs:",findva("Innodb_data_pending_fsyncs",last_data,lenth)
  695.                     );
  696.         mprintf(outfile,
  697.                     "%s%ld\n",
  698.                         "Innodb_buffer_pool_reads(physics reads):",findva("Innodb_buffer_pool_reads",last_data,lenth)
  699.                    );
  700.         mprintf(outfile,
  701.                     "%s%ld\n",
  702.                         "Innodb_buffer_pool_read_requests(logic reads):",findva("Innodb_buffer_pool_read_requests",last_data,lenth)
  703.                    );

  705.         mprintf(outfile,"[###Innodb_data rows info:]\n");
  706.         mprintf(outfile,
  707.                     "%s%-8ld%s%-8ld%s%-8ld%s%-8ld\n",
  708.                         "U(rows):",findva("Innodb_rows_updated",last_data,lenth),
  709.                         "D(rows):",findva("Innodb_rows_deleted",last_data,lenth),
  710.                         "I(rows):",findva("Innodb_rows_inserted",last_data,lenth),
  711.                         "S(rows):",findva("Innodb_rows_read",last_data,lenth)
  712.                         );

  714.         mprintf(outfile,"---------------------------------------TOTALINFO------------------------------------------\n");
  715.         mprintf(outfile,
  716.                     "%s%-15ld%s%ld\n",
  717.                         "Bytes_received:",findva("Bytes_received",last_data,lenth),
  718.                         "Bytes_sent:",findva("Bytes_sent",last_data,lenth)
  719.                         );
  720.         return ret;
  721. }

  723. int64_t findva(const char* ins,D_STROE* last_data,int lenth)
  724. {
  725.         int i=0;
  726.         for(i=0;i<lenth;i++)
  727.                 {
  728.                         if(!strcmp(last_data->statname,ins))
  729.                                 {
  730.                                         return last_data->data;
  731.                                         break;
  732.                                 }
  733.                         last_data++;
  734.                 }
  735.         return (int64_t)(-1);
  736. }


作者微信：

               







文章标签：
云数据库 RDS MySQL 版
关系型数据库
索引
MySQL
监控
数据库管理
关键词：
云数据库 RDS MySQL 版工具
云数据库 RDS MySQL 版开发
监控云数据库 RDS MySQL 版
云数据库 RDS MySQL 版运行
工具云数据库 RDS MySQL 版
相关实践学习
如何在云端创建MySQL数据库
开始实验后，系统会自动创建一台自建MySQL的 源数据库 ECS 实例和一台 目标数据库 RDS。
全面了解阿里云能为你做什么
阿里云在全球各地部署高效节能的绿色数据中心，利用清洁计算为万物互联的新世界提供源源不断的能源动力，目前开服的区域包括中国（华北、华东、华南、香港）、新加坡、美国（美东、美西）、欧洲、中东、澳大利亚、日本。目前阿里云的产品涵盖弹性计算、数据库、存储与CDN、分析与搜索、云通信、网络、管理与监控、应用服务、互联网中间件、移动服务、视频服务等。通过本课程，来了解阿里云能够为你的业务带来哪些帮助 &nbsp; &nbsp; 相关的阿里云产品：云服务器ECS 云服务器 ECS（Elastic Compute Service）是一种弹性可伸缩的计算服务，助您降低 IT 成本，提升运维效率，使您更专注于核心业务创新。产品详情: https://www.aliyun.com/product/ecs
重庆八怪
目录
相关文章
大数据文摘
|
22小时前
|
SQL 关系型数据库 MySQL
MySQL 窗口函数详解：分析性查询的强大工具
MySQL 窗口函数从 8.0 版本开始支持，提供了一种灵活的方式处理 SQL 查询中的数据。无需分组即可对行集进行分析，常用于计算排名、累计和、移动平均值等。基本语法包括 `function_name([arguments]) OVER ([PARTITION BY columns] [ORDER BY columns] [frame_clause])`，常见函数有 `ROW_NUMBER()`, `RANK()`, `DENSE_RANK()`, `SUM()`, `AVG()` 等。窗口框架定义了计算聚合值时应包含的行。适用于复杂数据操作和分析报告。
大数据文摘
25 11
高端源码库
|
12天前
|
JavaScript 安全 Java
java版药品不良反应智能监测系统源码，采用SpringBoot、Vue、MySQL技术开发
基于B/S架构，采用Java、SpringBoot、Vue、MySQL等技术自主研发的ADR智能监测系统，适用于三甲医院，支持二次开发。该系统能自动监测全院患者药物不良反应，通过移动端和PC端实时反馈，提升用药安全。系统涵盖规则管理、监测报告、系统管理三大模块，确保精准、高效地处理ADR事件。
高端源码库
25 1
1554023534442740
|
28天前
|
监控 前端开发 Java
【技术开发】接口管理平台要用什么技术栈？推荐：Java+Vue3+Docker+MySQL
该文档介绍了基于Java后端和Vue3前端构建的管理系统的技术栈及功能模块，涵盖管理后台的访问、登录、首页概览、API接口管理、接口权限设置、接口监控、计费管理、账号管理、应用管理、数据库配置、站点配置及管理员个人设置等内容，并提供了访问地址及操作指南。
1554023534442740
35 3
mao29955
|
1月前
|
缓存 监控 关系型数据库
如何根据监控结果调整 MySQL 数据库的参数以提高性能？
【10月更文挑战第28天】根据MySQL数据库的监控结果来调整参数以提高性能，需要综合考虑多个方面的因素
mao29955
78 1
mao29955
|
1月前
|
监控 关系型数据库 MySQL
如何监控和诊断 MySQL 数据库的性能问题？
【10月更文挑战第28天】监控和诊断MySQL数据库的性能问题是确保数据库高效稳定运行的关键
mao29955
116 1
快乐就是哈哈哈
|
2月前
|
SQL JavaScript 关系型数据库
node博客小项目：接口开发、连接mysql数据库
【10月更文挑战第14天】node博客小项目：接口开发、连接mysql数据库
快乐就是哈哈哈
36 2
小Tomkk
|
2月前
|
存储 自然语言处理 关系型数据库
mysql 8.0 日期维度表生成（可运行）
mysql 8.0 日期维度表生成（可运行）
小Tomkk
57 2
游客5fdji2pvmf8888
|
2月前
|
SQL 关系型数据库 MySQL
PHP与MySQL协同工作的艺术：开发高效动态网站
在这个后端技术迅速迭代的时代，PHP和MySQL的组合仍然是创建动态网站和应用的主流选择之一。本文将带领读者深入理解PHP后端逻辑与MySQL数据库之间的协同工作方式，包括数据的检索、插入、更新和删除操作。文章将通过一系列实用的示例和最佳实践，揭示如何充分利用这两种技术的优势，构建高效、安全且易于维护的动态网站。
游客5fdji2pvmf8888
48 1
小Tomkk
|
2月前
|
存储 关系型数据库 MySQL
mysql 8.0 时间维度表生成（可运行）
mysql 8.0 时间维度表生成（可运行）
小Tomkk
49 0
AIweker
|
8天前
|
关系型数据库 MySQL 数据库
Python处理数据库：MySQL与SQLite详解 | python小知识
本文详细介绍了如何使用Python操作MySQL和SQLite数据库，包括安装必要的库、连接数据库、执行增删改查等基本操作，适合初学者快速上手。
AIweker
71 15

热门文章

最新文章

  • 1
    RDS入门——Excel文件转存到RDS数据库实践
  • 2
    PostgreSQL SQL HINT的使用
  • 3
    mysql安装过程
  • 4
    Mysql数据库初始化后更改数据存储目录
  • 5
    MySQL学习笔记_2_MySQL创建数据表（上）
  • 6
    MySQL服务器 IO 100%的案例分析
  • 7
    MySQL和Oracle的添加字段的处理差别
  • 8
    [MySQL]命令行工具和基本操作
  • 9
    PostgreSQL:系统表pg_attribute膨胀解决方案
  • 10
    mysql中的时间函数---运维常用
  • 1
    Java医院绩效考核系统源码B/S+avue+MySQL助力医院实现精细化管理
    76
  • 2
    Linux对MySQL语法校验
    89
  • 3
    【MySQL系列笔记】分库分表
    206
  • 4
    mysql 设置环境变量与未设置环境变量连接数据库的区别
    161
  • 5
    服务器Linux系统配置mysql数据库主从自动备份
    214
  • 6
    mysqlTools 一分钟部署安装本mysql多个版本，解锁繁琐部署过程
    419
  • 7
    golang使用gorm操作mysql3，数据查询
    97
  • 8
    golang使用gorm操作mysql2
    61
  • 9
    golang使用gorm操作mysql1
    112
  • 10
    Hbase与MySQL对比，区别是什么？
    303

    • 相关课程

    更多
  • MySQL企业常见架构与调优经验分享
  • 云数据库MySQL版快速上手教程
  • 阿里云云原生数据仓库AnalyticDB MySQL版 使用教程
  • MySQL实战进阶
  • 数据库及SQL/MySQL基础
  • 云数据库MySQL快速入门

    • 相关电子书

    更多
  • 搭建电商项目架构连接MySQL
  • 搭建4层电商项目架构，实战连接MySQL
  • PolarDB MySQL引擎重磅功能及产品能力盛大发布

    • 相关实验场景

    更多
  • MySQL基础-学生管理系统数据库设计
  • 如何快速连接云数据库RDS MySQL
  • MySQL数据库快速部署实践
  • MySQL引擎及架构优化
  • 基于EBS部署高性能的MySQL服务
  • 使用CloudLens采集RDS日志并进行审计分析

    • 推荐镜像

    更多
  • mysql
  • mariadb
  • postgresql
    • 下一篇
    fs.oss.accessKeyId和fs.oss.accessKeySecret。