太阳城申博注册-什么是切断医院传播的主要途径

首页

AD联系:507867812

太阳城申博注册

时间:2019-11-21 12:17:06 作者:太阳城申博官方下载 浏览量:44133

太阳城申博注册MySQL查询缓存

一、查询缓存说明

MySQL Query Cache是用来缓存我们所执行的SELECT语句以及该语句的结果集,MySql在实现Query Cache的具体技术细节上类似典型的KV存储,就是将SELECT语句和该查询语句的结果集做了一个HASH映射并保存在一定的内存区域中。当客户端发起SQL查询时,Query Cache的查找逻辑是,先对SQL进行相应的权限验证,接着就通过Query Cache来查找结果(注意必须是完全相同,即使多一个空格或者大小写不 同都认为不同,即使完全相同的SQL,如果使用不同的字符集、不同的协议等也会被认为是不同的查询而分别进行缓存)。它不需要经过Optimizer模块进行执行计划的分析优化,更不需要发生同任何存储引擎的交互,减少了大量的磁盘IO和CPU运 算,所以有时候效率非常高。

二、查询缓存命中

判断一个缓存是否被命中,通过查询语句的HASH值来判断,HASH值因素包括查询语句、查询数据库、客户端版本协议等,如查询语句任何字符的不同,都会导致HASH结果的不同,都可能导致缓存无法命中。有些查询不能被缓存,如查询中包含UDF、存储函数、用户自定义变量、临时表、mysql库中系统表、或者包含列级权限的表、有着不确定值的函数(Now()); 查询缓存是完全存储在内存中的,对整个内存空间分配回收等,会额外产生系统资源消耗,这会导致内存碎片的产生。

三、查看查询缓存的参数

MariaDB[(none)]>showglobalvariableslike'%query%'; +------------------------------+--------------------+ |Variable_name |Value | +------------------------------+--------------------+ |expensive_subquery_limit |100 | |ft_query_expansion_limit |20 | |have_query_cache |YES | |long_query_time |10.000000 | |query_alloc_block_size |16384 | |query_cache_limit |1048576 | |query_cache_min_res_unit |4096 | |query_cache_size |16777216 | |query_cache_strip_comments |OFF | |query_cache_type |ON | |query_cache_wlock_invalidate|OFF | |query_prealloc_size |24576 | |slow_query_log |OFF | |slow_query_log_file |localhost-slow.log| +------------------------------+--------------------+ 14rowsinset(0.01sec)

查询缓存相关变量说明

query_cache_min_res_unit: 查询缓存中内存块的最小分配单位;较小值会减少浪费,但会导致更频繁的内存分配操作;较大值会带来浪费,会导致碎片过多;

query_cache_limit:能够缓存的最大查询结果;对于有着较大结果的查询语句,建议在SELECT中使用SQL_NO_CACHE

query_cache_size:查询缓存总共可用的内存空间;单位是字节,必须是1024的整数倍;

query_cache_type: ON, OFF, DEMAND

a、0(OFF):关闭 Query Cache 功能,任何情况下都不会使用 Query Cache;

b、1(ON):开启 Query Cache 功能,但是当SELECT语句中使用SQL_NO_CACHE提示后,将不使用Query Cache;

c、2(DEMAND):开启Query Cache 功能,但是只有当SELECT语句中使用了SQL_CACHE 提示后,才使用Query Cache。

query_cache_wlock_invalidate:如果某表被其它的连接锁定,是否仍然可以从查询缓存中返回结果;默认值为OFF,表示可以在表被其它连接锁定的场景中继续从缓存返回数据;ON则表示不允许;

MariaDB[(none)]>showglobalstatuslike'Qcache%'; +-------------------------+----------+ |Variable_name |Value | +-------------------------+----------+ |Qcache_free_blocks |1 | |Qcache_free_memory |16759656| |Qcache_hits |0 | |Qcache_inserts |0 | |Qcache_lowmem_prunes |0 | |Qcache_not_cached |7 | |Qcache_queries_in_cache|0 | |Qcache_total_blocks |1 | +-------------------------+----------+ 8rowsinset(0.00sec)

查看缓存变量参数说明:

Qcache_free_blocks: 缓存池中空闲块的个数,空闲的内存块。

Qcache_free_memory: 缓存中空闲内存空间

Qcache_hits: 缓存命中次数

Qcache_inserts: 可缓存查询语句的结果被放入缓存的次数

Qcache_lowmen_prunes: 有多少次是因为查询缓存内存空间太少而使用LRU算法清理缓存的次数

Qcache_not_cached: 可缓存却未能缓存的结果,例如查询结果超出缓存块大小,查询中包含可变函数等

Qcache_queries_in_cache: 当前缓存中缓存的SQL数量

Qcache_total_blocks: 整个查询缓存有多少内存块

缓存命中率:Qcache_hits/(Qcache_hits+Com_select)

四、分析和配置查询缓存流程及提高缓存命中率

①.开始,如果查询缓存命中率是否可以接受?如果可以的话,就结束。

②.不能接受目前的缓存命中率,查看大部分查询不是可缓存?是的话,就是大部分查询都不能缓存,query_cache_limit足够大吗?如果是,就结束,说明查询不能缓存,有可能是用户自定义变量、存储函数等,这种情况,建议关闭查询缓存。如果不是足够大,则需要增加此值。

③.1.大部分查询缓存都是可以缓存,但是却没有被缓存。是否发生很多严重工作?

是的话,查看缓存是不是被碎片化。需要降低query_cache_min_res_unit的值或是否flush query cache命令来整理缓存,减少碎片。

③.2.如果缓存不是因为碎片太多导致没有被缓存,内存过低发生的修正工作?

④.1.如果是内存过低,则增加query_cache_size。

④.2.如果不是内存过低,是否有很多的更新语句?频繁的更新表导致的缓存不能被命中,是有很多频繁更新的语句,负载不适合缓存,建议关闭缓存。不是有很多频繁更新的语句,则有其他配置的问题。

⑤.如果不是发生了很多验证工作,缓存启动了?是,没有见过此查询。否的话,启动缓存。

linux

一、查询缓存说明

MySQL Query Cache是用来缓存我们所执行的SELECT语句以及该语句的结果集,MySql在实现Query Cache的具体技术细节上类似典型的KV存储,就是将SELECT语句和该查询语句的结果集做了一个HASH映射并保存在一定的内存区域中。当客户端发起SQL查询时,Query Cache的查找逻辑是,先对SQL进行相应的权限验证,接着就通过Query Cache来查找结果(注意必须是完全相同,即使多一个空格或者大小写不 同都认为不同,即使完全相同的SQL,如果使用不同的字符集、不同的协议等也会被认为是不同的查询而分别进行缓存)。它不需要经过Optimizer模块进行执行计划的分析优化,更不需要发生同任何存储引擎的交互,减少了大量的磁盘IO和CPU运 算,所以有时候效率非常高。

二、查询缓存命中

判断一个缓存是否被命中,通过查询语句的HASH值来判断,HASH值因素包括查询语句、查询数据库、客户端版本协议等,如查询语句任何字符的不同,都会导致HASH结果的不同,都可能导致缓存无法命中。有些查询不能被缓存,如查询中包含UDF、存储函数、用户自定义变量、临时表、mysql库中系统表、或者包含列级权限的表、有着不确定值的函数(Now()); 查询缓存是完全存储在内存中的,对整个内存空间分配回收等,会额外产生系统资源消耗,这会导致内存碎片的产生。

三、查看查询缓存的参数

MariaDB[(none)]>showglobalvariableslike'%query%'; +------------------------------+--------------------+ |Variable_name |Value | +------------------------------+--------------------+ |expensive_subquery_limit |100 | |ft_query_expansion_limit |20 | |have_query_cache |YES | |long_query_time |10.000000 | |query_alloc_block_size |16384 | |query_cache_limit |1048576 | |query_cache_min_res_unit |4096 | |query_cache_size |16777216 | |query_cache_strip_comments |OFF | |query_cache_type |ON | |query_cache_wlock_invalidate|OFF | |query_prealloc_size |24576 | |slow_query_log |OFF | |slow_query_log_file |localhost-slow.log| +------------------------------+--------------------+ 14rowsinset(0.01sec)

查询缓存相关变量说明

query_cache_min_res_unit: 查询缓存中内存块的最小分配单位;较小值会减少浪费,但会导致更频繁的内存分配操作;较大值会带来浪费,会导致碎片过多;

query_cache_limit:能够缓存的最大查询结果;对于有着较大结果的查询语句,建议在SELECT中使用SQL_NO_CACHE

query_cache_size:查询缓存总共可用的内存空间;单位是字节,必须是1024的整数倍;

query_cache_type: ON, OFF, DEMAND

a、0(OFF):关闭 Query Cache 功能,任何情况下都不会使用 Query Cache;

b、1(ON):开启 Query Cache 功能,但是当SELECT语句中使用SQL_NO_CACHE提示后,将不使用Query Cache;

c、2(DEMAND):开启Query Cache 功能,但是只有当SELECT语句中使用了SQL_CACHE 提示后,才使用Query Cache。

query_cache_wlock_invalidate:如果某表被其它的连接锁定,是否仍然可以从查询缓存中返回结果;默认值为OFF,表示可以在表被其它连接锁定的场景中继续从缓存返回数据;ON则表示不允许;

MariaDB[(none)]>showglobalstatuslike'Qcache%'; +-------------------------+----------+ |Variable_name |Value | +-------------------------+----------+ |Qcache_free_blocks |1 | |Qcache_free_memory |16759656| |Qcache_hits |0 | |Qcache_inserts |0 | |Qcache_lowmem_prunes |0 | |Qcache_not_cached |7 | |Qcache_queries_in_cache|0 | |Qcache_total_blocks |1 | +-------------------------+----------+ 8rowsinset(0.00sec)

查看缓存变量参数说明:

Qcache_free_blocks: 缓存池中空闲块的个数,空闲的内存块。

Qcache_free_memory: 缓存中空闲内存空间

Qcache_hits: 缓存命中次数

Qcache_inserts: 可缓存查询语句的结果被放入缓存的次数

Qcache_lowmen_prunes: 有多少次是因为查询缓存内存空间太少而使用LRU算法清理缓存的次数

Qcache_not_cached: 可缓存却未能缓存的结果,例如查询结果超出缓存块大小,查询中包含可变函数等

Qcache_queries_in_cache: 当前缓存中缓存的SQL数量

Qcache_total_blocks: 整个查询缓存有多少内存块

缓存命中率:Qcache_hits/(Qcache_hits+Com_select)

四、分析和配置查询缓存流程及提高缓存命中率

①.开始,如果查询缓存命中率是否可以接受?如果可以的话,就结束。

②.不能接受目前的缓存命中率,查看大部分查询不是可缓存?是的话,就是大部分查询都不能缓存,query_cache_limit足够大吗?如果是,就结束,说明查询不能缓存,有可能是用户自定义变量、存储函数等,这种情况,建议关闭查询缓存。如果不是足够大,则需要增加此值。

③.1.大部分查询缓存都是可以缓存,但是却没有被缓存。是否发生很多严重工作?

是的话,查看缓存是不是被碎片化。需要降低query_cache_min_res_unit的值或是否flush query cache命令来整理缓存,减少碎片。

③.2.如果缓存不是因为碎片太多导致没有被缓存,内存过低发生的修正工作?

④.1.如果是内存过低,则增加query_cache_size。

④.2.如果不是内存过低,是否有很多的更新语句?频繁的更新表导致的缓存不能被命中,是有很多频繁更新的语句,负载不适合缓存,建议关闭缓存。不是有很多频繁更新的语句,则有其他配置的问题。

⑤.如果不是发生了很多验证工作,缓存启动了?是,没有见过此查询。否的话,启动缓存。

linuxMySQL查询缓存MySQL查询缓存MySQL查询缓存

一、查询缓存说明

MySQL Query Cache是用来缓存我们所执行的SELECT语句以及该语句的结果集,MySql在实现Query Cache的具体技术细节上类似典型的KV存储,就是将SELECT语句和该查询语句的结果集做了一个HASH映射并保存在一定的内存区域中。当客户端发起SQL查询时,Query Cache的查找逻辑是,先对SQL进行相应的权限验证,接着就通过Query Cache来查找结果(注意必须是完全相同,即使多一个空格或者大小写不 同都认为不同,即使完全相同的SQL,如果使用不同的字符集、不同的协议等也会被认为是不同的查询而分别进行缓存)。它不需要经过Optimizer模块进行执行计划的分析优化,更不需要发生同任何存储引擎的交互,减少了大量的磁盘IO和CPU运 算,所以有时候效率非常高。

二、查询缓存命中

判断一个缓存是否被命中,通过查询语句的HASH值来判断,HASH值因素包括查询语句、查询数据库、客户端版本协议等,如查询语句任何字符的不同,都会导致HASH结果的不同,都可能导致缓存无法命中。有些查询不能被缓存,如查询中包含UDF、存储函数、用户自定义变量、临时表、mysql库中系统表、或者包含列级权限的表、有着不确定值的函数(Now()); 查询缓存是完全存储在内存中的,对整个内存空间分配回收等,会额外产生系统资源消耗,这会导致内存碎片的产生。

三、查看查询缓存的参数

MariaDB[(none)]>showglobalvariableslike'%query%'; +------------------------------+--------------------+ |Variable_name |Value | +------------------------------+--------------------+ |expensive_subquery_limit |100 | |ft_query_expansion_limit |20 | |have_query_cache |YES | |long_query_time |10.000000 | |query_alloc_block_size |16384 | |query_cache_limit |1048576 | |query_cache_min_res_unit |4096 | |query_cache_size |16777216 | |query_cache_strip_comments |OFF | |query_cache_type |ON | |query_cache_wlock_invalidate|OFF | |query_prealloc_size |24576 | |slow_query_log |OFF | |slow_query_log_file |localhost-slow.log| +------------------------------+--------------------+ 14rowsinset(0.01sec)

查询缓存相关变量说明

query_cache_min_res_unit: 查询缓存中内存块的最小分配单位;较小值会减少浪费,但会导致更频繁的内存分配操作;较大值会带来浪费,会导致碎片过多;

query_cache_limit:能够缓存的最大查询结果;对于有着较大结果的查询语句,建议在SELECT中使用SQL_NO_CACHE

query_cache_size:查询缓存总共可用的内存空间;单位是字节,必须是1024的整数倍;

query_cache_type: ON, OFF, DEMAND

a、0(OFF):关闭 Query Cache 功能,任何情况下都不会使用 Query Cache;

b、1(ON):开启 Query Cache 功能,但是当SELECT语句中使用SQL_NO_CACHE提示后,将不使用Query Cache;

c、2(DEMAND):开启Query Cache 功能,但是只有当SELECT语句中使用了SQL_CACHE 提示后,才使用Query Cache。

query_cache_wlock_invalidate:如果某表被其它的连接锁定,是否仍然可以从查询缓存中返回结果;默认值为OFF,表示可以在表被其它连接锁定的场景中继续从缓存返回数据;ON则表示不允许;

MariaDB[(none)]>showglobalstatuslike'Qcache%'; +-------------------------+----------+ |Variable_name |Value | +-------------------------+----------+ |Qcache_free_blocks |1 | |Qcache_free_memory |16759656| |Qcache_hits |0 | |Qcache_inserts |0 | |Qcache_lowmem_prunes |0 | |Qcache_not_cached |7 | |Qcache_queries_in_cache|0 | |Qcache_total_blocks |1 | +-------------------------+----------+ 8rowsinset(0.00sec)

查看缓存变量参数说明:

Qcache_free_blocks: 缓存池中空闲块的个数,空闲的内存块。

Qcache_free_memory: 缓存中空闲内存空间

Qcache_hits: 缓存命中次数

Qcache_inserts: 可缓存查询语句的结果被放入缓存的次数

Qcache_lowmen_prunes: 有多少次是因为查询缓存内存空间太少而使用LRU算法清理缓存的次数

Qcache_not_cached: 可缓存却未能缓存的结果,例如查询结果超出缓存块大小,查询中包含可变函数等

Qcache_queries_in_cache: 当前缓存中缓存的SQL数量

Qcache_total_blocks: 整个查询缓存有多少内存块

缓存命中率:Qcache_hits/(Qcache_hits+Com_select)

四、分析和配置查询缓存流程及提高缓存命中率

①.开始,如果查询缓存命中率是否可以接受?如果可以的话,就结束。

②.不能接受目前的缓存命中率,查看大部分查询不是可缓存?是的话,就是大部分查询都不能缓存,query_cache_limit足够大吗?如果是,就结束,说明查询不能缓存,有可能是用户自定义变量、存储函数等,这种情况,建议关闭查询缓存。如果不是足够大,则需要增加此值。

③.1.大部分查询缓存都是可以缓存,但是却没有被缓存。是否发生很多严重工作?

是的话,查看缓存是不是被碎片化。需要降低query_cache_min_res_unit的值或是否flush query cache命令来整理缓存,减少碎片。

③.2.如果缓存不是因为碎片太多导致没有被缓存,内存过低发生的修正工作?

④.1.如果是内存过低,则增加query_cache_size。

④.2.如果不是内存过低,是否有很多的更新语句?频繁的更新表导致的缓存不能被命中,是有很多频繁更新的语句,负载不适合缓存,建议关闭缓存。不是有很多频繁更新的语句,则有其他配置的问题。

⑤.如果不是发生了很多验证工作,缓存启动了?是,没有见过此查询。否的话,启动缓存。

linux,见下图

一、查询缓存说明

MySQL Query Cache是用来缓存我们所执行的SELECT语句以及该语句的结果集,MySql在实现Query Cache的具体技术细节上类似典型的KV存储,就是将SELECT语句和该查询语句的结果集做了一个HASH映射并保存在一定的内存区域中。当客户端发起SQL查询时,Query Cache的查找逻辑是,先对SQL进行相应的权限验证,接着就通过Query Cache来查找结果(注意必须是完全相同,即使多一个空格或者大小写不 同都认为不同,即使完全相同的SQL,如果使用不同的字符集、不同的协议等也会被认为是不同的查询而分别进行缓存)。它不需要经过Optimizer模块进行执行计划的分析优化,更不需要发生同任何存储引擎的交互,减少了大量的磁盘IO和CPU运 算,所以有时候效率非常高。

二、查询缓存命中

判断一个缓存是否被命中,通过查询语句的HASH值来判断,HASH值因素包括查询语句、查询数据库、客户端版本协议等,如查询语句任何字符的不同,都会导致HASH结果的不同,都可能导致缓存无法命中。有些查询不能被缓存,如查询中包含UDF、存储函数、用户自定义变量、临时表、mysql库中系统表、或者包含列级权限的表、有着不确定值的函数(Now()); 查询缓存是完全存储在内存中的,对整个内存空间分配回收等,会额外产生系统资源消耗,这会导致内存碎片的产生。

三、查看查询缓存的参数

MariaDB[(none)]>showglobalvariableslike'%query%'; +------------------------------+--------------------+ |Variable_name |Value | +------------------------------+--------------------+ |expensive_subquery_limit |100 | |ft_query_expansion_limit |20 | |have_query_cache |YES | |long_query_time |10.000000 | |query_alloc_block_size |16384 | |query_cache_limit |1048576 | |query_cache_min_res_unit |4096 | |query_cache_size |16777216 | |query_cache_strip_comments |OFF | |query_cache_type |ON | |query_cache_wlock_invalidate|OFF | |query_prealloc_size |24576 | |slow_query_log |OFF | |slow_query_log_file |localhost-slow.log| +------------------------------+--------------------+ 14rowsinset(0.01sec)

查询缓存相关变量说明

query_cache_min_res_unit: 查询缓存中内存块的最小分配单位;较小值会减少浪费,但会导致更频繁的内存分配操作;较大值会带来浪费,会导致碎片过多;

query_cache_limit:能够缓存的最大查询结果;对于有着较大结果的查询语句,建议在SELECT中使用SQL_NO_CACHE

query_cache_size:查询缓存总共可用的内存空间;单位是字节,必须是1024的整数倍;

query_cache_type: ON, OFF, DEMAND

a、0(OFF):关闭 Query Cache 功能,任何情况下都不会使用 Query Cache;

b、1(ON):开启 Query Cache 功能,但是当SELECT语句中使用SQL_NO_CACHE提示后,将不使用Query Cache;

c、2(DEMAND):开启Query Cache 功能,但是只有当SELECT语句中使用了SQL_CACHE 提示后,才使用Query Cache。

query_cache_wlock_invalidate:如果某表被其它的连接锁定,是否仍然可以从查询缓存中返回结果;默认值为OFF,表示可以在表被其它连接锁定的场景中继续从缓存返回数据;ON则表示不允许;

MariaDB[(none)]>showglobalstatuslike'Qcache%'; +-------------------------+----------+ |Variable_name |Value | +-------------------------+----------+ |Qcache_free_blocks |1 | |Qcache_free_memory |16759656| |Qcache_hits |0 | |Qcache_inserts |0 | |Qcache_lowmem_prunes |0 | |Qcache_not_cached |7 | |Qcache_queries_in_cache|0 | |Qcache_total_blocks |1 | +-------------------------+----------+ 8rowsinset(0.00sec)

查看缓存变量参数说明:

Qcache_free_blocks: 缓存池中空闲块的个数,空闲的内存块。

Qcache_free_memory: 缓存中空闲内存空间

Qcache_hits: 缓存命中次数

Qcache_inserts: 可缓存查询语句的结果被放入缓存的次数

Qcache_lowmen_prunes: 有多少次是因为查询缓存内存空间太少而使用LRU算法清理缓存的次数

Qcache_not_cached: 可缓存却未能缓存的结果,例如查询结果超出缓存块大小,查询中包含可变函数等

Qcache_queries_in_cache: 当前缓存中缓存的SQL数量

Qcache_total_blocks: 整个查询缓存有多少内存块

缓存命中率:Qcache_hits/(Qcache_hits+Com_select)

四、分析和配置查询缓存流程及提高缓存命中率

①.开始,如果查询缓存命中率是否可以接受?如果可以的话,就结束。

②.不能接受目前的缓存命中率,查看大部分查询不是可缓存?是的话,就是大部分查询都不能缓存,query_cache_limit足够大吗?如果是,就结束,说明查询不能缓存,有可能是用户自定义变量、存储函数等,这种情况,建议关闭查询缓存。如果不是足够大,则需要增加此值。

③.1.大部分查询缓存都是可以缓存,但是却没有被缓存。是否发生很多严重工作?

是的话,查看缓存是不是被碎片化。需要降低query_cache_min_res_unit的值或是否flush query cache命令来整理缓存,减少碎片。

③.2.如果缓存不是因为碎片太多导致没有被缓存,内存过低发生的修正工作?

④.1.如果是内存过低,则增加query_cache_size。

④.2.如果不是内存过低,是否有很多的更新语句?频繁的更新表导致的缓存不能被命中,是有很多频繁更新的语句,负载不适合缓存,建议关闭缓存。不是有很多频繁更新的语句,则有其他配置的问题。

⑤.如果不是发生了很多验证工作,缓存启动了?是,没有见过此查询。否的话,启动缓存。

linux

MySQL查询缓存

一、查询缓存说明

MySQL Query Cache是用来缓存我们所执行的SELECT语句以及该语句的结果集,MySql在实现Query Cache的具体技术细节上类似典型的KV存储,就是将SELECT语句和该查询语句的结果集做了一个HASH映射并保存在一定的内存区域中。当客户端发起SQL查询时,Query Cache的查找逻辑是,先对SQL进行相应的权限验证,接着就通过Query Cache来查找结果(注意必须是完全相同,即使多一个空格或者大小写不 同都认为不同,即使完全相同的SQL,如果使用不同的字符集、不同的协议等也会被认为是不同的查询而分别进行缓存)。它不需要经过Optimizer模块进行执行计划的分析优化,更不需要发生同任何存储引擎的交互,减少了大量的磁盘IO和CPU运 算,所以有时候效率非常高。

二、查询缓存命中

判断一个缓存是否被命中,通过查询语句的HASH值来判断,HASH值因素包括查询语句、查询数据库、客户端版本协议等,如查询语句任何字符的不同,都会导致HASH结果的不同,都可能导致缓存无法命中。有些查询不能被缓存,如查询中包含UDF、存储函数、用户自定义变量、临时表、mysql库中系统表、或者包含列级权限的表、有着不确定值的函数(Now()); 查询缓存是完全存储在内存中的,对整个内存空间分配回收等,会额外产生系统资源消耗,这会导致内存碎片的产生。

三、查看查询缓存的参数

MariaDB[(none)]>showglobalvariableslike'%query%'; +------------------------------+--------------------+ |Variable_name |Value | +------------------------------+--------------------+ |expensive_subquery_limit |100 | |ft_query_expansion_limit |20 | |have_query_cache |YES | |long_query_time |10.000000 | |query_alloc_block_size |16384 | |query_cache_limit |1048576 | |query_cache_min_res_unit |4096 | |query_cache_size |16777216 | |query_cache_strip_comments |OFF | |query_cache_type |ON | |query_cache_wlock_invalidate|OFF | |query_prealloc_size |24576 | |slow_query_log |OFF | |slow_query_log_file |localhost-slow.log| +------------------------------+--------------------+ 14rowsinset(0.01sec)

查询缓存相关变量说明

query_cache_min_res_unit: 查询缓存中内存块的最小分配单位;较小值会减少浪费,但会导致更频繁的内存分配操作;较大值会带来浪费,会导致碎片过多;

query_cache_limit:能够缓存的最大查询结果;对于有着较大结果的查询语句,建议在SELECT中使用SQL_NO_CACHE

query_cache_size:查询缓存总共可用的内存空间;单位是字节,必须是1024的整数倍;

query_cache_type: ON, OFF, DEMAND

a、0(OFF):关闭 Query Cache 功能,任何情况下都不会使用 Query Cache;

b、1(ON):开启 Query Cache 功能,但是当SELECT语句中使用SQL_NO_CACHE提示后,将不使用Query Cache;

c、2(DEMAND):开启Query Cache 功能,但是只有当SELECT语句中使用了SQL_CACHE 提示后,才使用Query Cache。

query_cache_wlock_invalidate:如果某表被其它的连接锁定,是否仍然可以从查询缓存中返回结果;默认值为OFF,表示可以在表被其它连接锁定的场景中继续从缓存返回数据;ON则表示不允许;

MariaDB[(none)]>showglobalstatuslike'Qcache%'; +-------------------------+----------+ |Variable_name |Value | +-------------------------+----------+ |Qcache_free_blocks |1 | |Qcache_free_memory |16759656| |Qcache_hits |0 | |Qcache_inserts |0 | |Qcache_lowmem_prunes |0 | |Qcache_not_cached |7 | |Qcache_queries_in_cache|0 | |Qcache_total_blocks |1 | +-------------------------+----------+ 8rowsinset(0.00sec)

查看缓存变量参数说明:

Qcache_free_blocks: 缓存池中空闲块的个数,空闲的内存块。

Qcache_free_memory: 缓存中空闲内存空间

Qcache_hits: 缓存命中次数

Qcache_inserts: 可缓存查询语句的结果被放入缓存的次数

Qcache_lowmen_prunes: 有多少次是因为查询缓存内存空间太少而使用LRU算法清理缓存的次数

Qcache_not_cached: 可缓存却未能缓存的结果,例如查询结果超出缓存块大小,查询中包含可变函数等

Qcache_queries_in_cache: 当前缓存中缓存的SQL数量

Qcache_total_blocks: 整个查询缓存有多少内存块

缓存命中率:Qcache_hits/(Qcache_hits+Com_select)

四、分析和配置查询缓存流程及提高缓存命中率

①.开始,如果查询缓存命中率是否可以接受?如果可以的话,就结束。

②.不能接受目前的缓存命中率,查看大部分查询不是可缓存?是的话,就是大部分查询都不能缓存,query_cache_limit足够大吗?如果是,就结束,说明查询不能缓存,有可能是用户自定义变量、存储函数等,这种情况,建议关闭查询缓存。如果不是足够大,则需要增加此值。

③.1.大部分查询缓存都是可以缓存,但是却没有被缓存。是否发生很多严重工作?

是的话,查看缓存是不是被碎片化。需要降低query_cache_min_res_unit的值或是否flush query cache命令来整理缓存,减少碎片。

③.2.如果缓存不是因为碎片太多导致没有被缓存,内存过低发生的修正工作?

④.1.如果是内存过低,则增加query_cache_size。

④.2.如果不是内存过低,是否有很多的更新语句?频繁的更新表导致的缓存不能被命中,是有很多频繁更新的语句,负载不适合缓存,建议关闭缓存。不是有很多频繁更新的语句,则有其他配置的问题。

⑤.如果不是发生了很多验证工作,缓存启动了?是,没有见过此查询。否的话,启动缓存。

linux,见下图

MySQL查询缓存MySQL查询缓存

一、查询缓存说明

MySQL Query Cache是用来缓存我们所执行的SELECT语句以及该语句的结果集,MySql在实现Query Cache的具体技术细节上类似典型的KV存储,就是将SELECT语句和该查询语句的结果集做了一个HASH映射并保存在一定的内存区域中。当客户端发起SQL查询时,Query Cache的查找逻辑是,先对SQL进行相应的权限验证,接着就通过Query Cache来查找结果(注意必须是完全相同,即使多一个空格或者大小写不 同都认为不同,即使完全相同的SQL,如果使用不同的字符集、不同的协议等也会被认为是不同的查询而分别进行缓存)。它不需要经过Optimizer模块进行执行计划的分析优化,更不需要发生同任何存储引擎的交互,减少了大量的磁盘IO和CPU运 算,所以有时候效率非常高。

二、查询缓存命中

判断一个缓存是否被命中,通过查询语句的HASH值来判断,HASH值因素包括查询语句、查询数据库、客户端版本协议等,如查询语句任何字符的不同,都会导致HASH结果的不同,都可能导致缓存无法命中。有些查询不能被缓存,如查询中包含UDF、存储函数、用户自定义变量、临时表、mysql库中系统表、或者包含列级权限的表、有着不确定值的函数(Now()); 查询缓存是完全存储在内存中的,对整个内存空间分配回收等,会额外产生系统资源消耗,这会导致内存碎片的产生。

三、查看查询缓存的参数

MariaDB[(none)]>showglobalvariableslike'%query%'; +------------------------------+--------------------+ |Variable_name |Value | +------------------------------+--------------------+ |expensive_subquery_limit |100 | |ft_query_expansion_limit |20 | |have_query_cache |YES | |long_query_time |10.000000 | |query_alloc_block_size |16384 | |query_cache_limit |1048576 | |query_cache_min_res_unit |4096 | |query_cache_size |16777216 | |query_cache_strip_comments |OFF | |query_cache_type |ON | |query_cache_wlock_invalidate|OFF | |query_prealloc_size |24576 | |slow_query_log |OFF | |slow_query_log_file |localhost-slow.log| +------------------------------+--------------------+ 14rowsinset(0.01sec)

查询缓存相关变量说明

query_cache_min_res_unit: 查询缓存中内存块的最小分配单位;较小值会减少浪费,但会导致更频繁的内存分配操作;较大值会带来浪费,会导致碎片过多;

query_cache_limit:能够缓存的最大查询结果;对于有着较大结果的查询语句,建议在SELECT中使用SQL_NO_CACHE

query_cache_size:查询缓存总共可用的内存空间;单位是字节,必须是1024的整数倍;

query_cache_type: ON, OFF, DEMAND

a、0(OFF):关闭 Query Cache 功能,任何情况下都不会使用 Query Cache;

b、1(ON):开启 Query Cache 功能,但是当SELECT语句中使用SQL_NO_CACHE提示后,将不使用Query Cache;

c、2(DEMAND):开启Query Cache 功能,但是只有当SELECT语句中使用了SQL_CACHE 提示后,才使用Query Cache。

query_cache_wlock_invalidate:如果某表被其它的连接锁定,是否仍然可以从查询缓存中返回结果;默认值为OFF,表示可以在表被其它连接锁定的场景中继续从缓存返回数据;ON则表示不允许;

MariaDB[(none)]>showglobalstatuslike'Qcache%'; +-------------------------+----------+ |Variable_name |Value | +-------------------------+----------+ |Qcache_free_blocks |1 | |Qcache_free_memory |16759656| |Qcache_hits |0 | |Qcache_inserts |0 | |Qcache_lowmem_prunes |0 | |Qcache_not_cached |7 | |Qcache_queries_in_cache|0 | |Qcache_total_blocks |1 | +-------------------------+----------+ 8rowsinset(0.00sec)

查看缓存变量参数说明:

Qcache_free_blocks: 缓存池中空闲块的个数,空闲的内存块。

Qcache_free_memory: 缓存中空闲内存空间

Qcache_hits: 缓存命中次数

Qcache_inserts: 可缓存查询语句的结果被放入缓存的次数

Qcache_lowmen_prunes: 有多少次是因为查询缓存内存空间太少而使用LRU算法清理缓存的次数

Qcache_not_cached: 可缓存却未能缓存的结果,例如查询结果超出缓存块大小,查询中包含可变函数等

Qcache_queries_in_cache: 当前缓存中缓存的SQL数量

Qcache_total_blocks: 整个查询缓存有多少内存块

缓存命中率:Qcache_hits/(Qcache_hits+Com_select)

四、分析和配置查询缓存流程及提高缓存命中率

①.开始,如果查询缓存命中率是否可以接受?如果可以的话,就结束。

②.不能接受目前的缓存命中率,查看大部分查询不是可缓存?是的话,就是大部分查询都不能缓存,query_cache_limit足够大吗?如果是,就结束,说明查询不能缓存,有可能是用户自定义变量、存储函数等,这种情况,建议关闭查询缓存。如果不是足够大,则需要增加此值。

③.1.大部分查询缓存都是可以缓存,但是却没有被缓存。是否发生很多严重工作?

是的话,查看缓存是不是被碎片化。需要降低query_cache_min_res_unit的值或是否flush query cache命令来整理缓存,减少碎片。

③.2.如果缓存不是因为碎片太多导致没有被缓存,内存过低发生的修正工作?

④.1.如果是内存过低,则增加query_cache_size。

④.2.如果不是内存过低,是否有很多的更新语句?频繁的更新表导致的缓存不能被命中,是有很多频繁更新的语句,负载不适合缓存,建议关闭缓存。不是有很多频繁更新的语句,则有其他配置的问题。

⑤.如果不是发生了很多验证工作,缓存启动了?是,没有见过此查询。否的话,启动缓存。

linuxMySQL查询缓存,如下图

一、查询缓存说明

MySQL Query Cache是用来缓存我们所执行的SELECT语句以及该语句的结果集,MySql在实现Query Cache的具体技术细节上类似典型的KV存储,就是将SELECT语句和该查询语句的结果集做了一个HASH映射并保存在一定的内存区域中。当客户端发起SQL查询时,Query Cache的查找逻辑是,先对SQL进行相应的权限验证,接着就通过Query Cache来查找结果(注意必须是完全相同,即使多一个空格或者大小写不 同都认为不同,即使完全相同的SQL,如果使用不同的字符集、不同的协议等也会被认为是不同的查询而分别进行缓存)。它不需要经过Optimizer模块进行执行计划的分析优化,更不需要发生同任何存储引擎的交互,减少了大量的磁盘IO和CPU运 算,所以有时候效率非常高。

二、查询缓存命中

判断一个缓存是否被命中,通过查询语句的HASH值来判断,HASH值因素包括查询语句、查询数据库、客户端版本协议等,如查询语句任何字符的不同,都会导致HASH结果的不同,都可能导致缓存无法命中。有些查询不能被缓存,如查询中包含UDF、存储函数、用户自定义变量、临时表、mysql库中系统表、或者包含列级权限的表、有着不确定值的函数(Now()); 查询缓存是完全存储在内存中的,对整个内存空间分配回收等,会额外产生系统资源消耗,这会导致内存碎片的产生。

三、查看查询缓存的参数

MariaDB[(none)]>showglobalvariableslike'%query%'; +------------------------------+--------------------+ |Variable_name |Value | +------------------------------+--------------------+ |expensive_subquery_limit |100 | |ft_query_expansion_limit |20 | |have_query_cache |YES | |long_query_time |10.000000 | |query_alloc_block_size |16384 | |query_cache_limit |1048576 | |query_cache_min_res_unit |4096 | |query_cache_size |16777216 | |query_cache_strip_comments |OFF | |query_cache_type |ON | |query_cache_wlock_invalidate|OFF | |query_prealloc_size |24576 | |slow_query_log |OFF | |slow_query_log_file |localhost-slow.log| +------------------------------+--------------------+ 14rowsinset(0.01sec)

查询缓存相关变量说明

query_cache_min_res_unit: 查询缓存中内存块的最小分配单位;较小值会减少浪费,但会导致更频繁的内存分配操作;较大值会带来浪费,会导致碎片过多;

query_cache_limit:能够缓存的最大查询结果;对于有着较大结果的查询语句,建议在SELECT中使用SQL_NO_CACHE

query_cache_size:查询缓存总共可用的内存空间;单位是字节,必须是1024的整数倍;

query_cache_type: ON, OFF, DEMAND

a、0(OFF):关闭 Query Cache 功能,任何情况下都不会使用 Query Cache;

b、1(ON):开启 Query Cache 功能,但是当SELECT语句中使用SQL_NO_CACHE提示后,将不使用Query Cache;

c、2(DEMAND):开启Query Cache 功能,但是只有当SELECT语句中使用了SQL_CACHE 提示后,才使用Query Cache。

query_cache_wlock_invalidate:如果某表被其它的连接锁定,是否仍然可以从查询缓存中返回结果;默认值为OFF,表示可以在表被其它连接锁定的场景中继续从缓存返回数据;ON则表示不允许;

MariaDB[(none)]>showglobalstatuslike'Qcache%'; +-------------------------+----------+ |Variable_name |Value | +-------------------------+----------+ |Qcache_free_blocks |1 | |Qcache_free_memory |16759656| |Qcache_hits |0 | |Qcache_inserts |0 | |Qcache_lowmem_prunes |0 | |Qcache_not_cached |7 | |Qcache_queries_in_cache|0 | |Qcache_total_blocks |1 | +-------------------------+----------+ 8rowsinset(0.00sec)

查看缓存变量参数说明:

Qcache_free_blocks: 缓存池中空闲块的个数,空闲的内存块。

Qcache_free_memory: 缓存中空闲内存空间

Qcache_hits: 缓存命中次数

Qcache_inserts: 可缓存查询语句的结果被放入缓存的次数

Qcache_lowmen_prunes: 有多少次是因为查询缓存内存空间太少而使用LRU算法清理缓存的次数

Qcache_not_cached: 可缓存却未能缓存的结果,例如查询结果超出缓存块大小,查询中包含可变函数等

Qcache_queries_in_cache: 当前缓存中缓存的SQL数量

Qcache_total_blocks: 整个查询缓存有多少内存块

缓存命中率:Qcache_hits/(Qcache_hits+Com_select)

四、分析和配置查询缓存流程及提高缓存命中率

①.开始,如果查询缓存命中率是否可以接受?如果可以的话,就结束。

②.不能接受目前的缓存命中率,查看大部分查询不是可缓存?是的话,就是大部分查询都不能缓存,query_cache_limit足够大吗?如果是,就结束,说明查询不能缓存,有可能是用户自定义变量、存储函数等,这种情况,建议关闭查询缓存。如果不是足够大,则需要增加此值。

③.1.大部分查询缓存都是可以缓存,但是却没有被缓存。是否发生很多严重工作?

是的话,查看缓存是不是被碎片化。需要降低query_cache_min_res_unit的值或是否flush query cache命令来整理缓存,减少碎片。

③.2.如果缓存不是因为碎片太多导致没有被缓存,内存过低发生的修正工作?

④.1.如果是内存过低,则增加query_cache_size。

④.2.如果不是内存过低,是否有很多的更新语句?频繁的更新表导致的缓存不能被命中,是有很多频繁更新的语句,负载不适合缓存,建议关闭缓存。不是有很多频繁更新的语句,则有其他配置的问题。

⑤.如果不是发生了很多验证工作,缓存启动了?是,没有见过此查询。否的话,启动缓存。

linuxMySQL查询缓存

MySQL查询缓存

如下图

MySQL查询缓存,如下图

MySQL查询缓存

一、查询缓存说明

MySQL Query Cache是用来缓存我们所执行的SELECT语句以及该语句的结果集,MySql在实现Query Cache的具体技术细节上类似典型的KV存储,就是将SELECT语句和该查询语句的结果集做了一个HASH映射并保存在一定的内存区域中。当客户端发起SQL查询时,Query Cache的查找逻辑是,先对SQL进行相应的权限验证,接着就通过Query Cache来查找结果(注意必须是完全相同,即使多一个空格或者大小写不 同都认为不同,即使完全相同的SQL,如果使用不同的字符集、不同的协议等也会被认为是不同的查询而分别进行缓存)。它不需要经过Optimizer模块进行执行计划的分析优化,更不需要发生同任何存储引擎的交互,减少了大量的磁盘IO和CPU运 算,所以有时候效率非常高。

二、查询缓存命中

判断一个缓存是否被命中,通过查询语句的HASH值来判断,HASH值因素包括查询语句、查询数据库、客户端版本协议等,如查询语句任何字符的不同,都会导致HASH结果的不同,都可能导致缓存无法命中。有些查询不能被缓存,如查询中包含UDF、存储函数、用户自定义变量、临时表、mysql库中系统表、或者包含列级权限的表、有着不确定值的函数(Now()); 查询缓存是完全存储在内存中的,对整个内存空间分配回收等,会额外产生系统资源消耗,这会导致内存碎片的产生。

三、查看查询缓存的参数

MariaDB[(none)]>showglobalvariableslike'%query%'; +------------------------------+--------------------+ |Variable_name |Value | +------------------------------+--------------------+ |expensive_subquery_limit |100 | |ft_query_expansion_limit |20 | |have_query_cache |YES | |long_query_time |10.000000 | |query_alloc_block_size |16384 | |query_cache_limit |1048576 | |query_cache_min_res_unit |4096 | |query_cache_size |16777216 | |query_cache_strip_comments |OFF | |query_cache_type |ON | |query_cache_wlock_invalidate|OFF | |query_prealloc_size |24576 | |slow_query_log |OFF | |slow_query_log_file |localhost-slow.log| +------------------------------+--------------------+ 14rowsinset(0.01sec)

查询缓存相关变量说明

query_cache_min_res_unit: 查询缓存中内存块的最小分配单位;较小值会减少浪费,但会导致更频繁的内存分配操作;较大值会带来浪费,会导致碎片过多;

query_cache_limit:能够缓存的最大查询结果;对于有着较大结果的查询语句,建议在SELECT中使用SQL_NO_CACHE

query_cache_size:查询缓存总共可用的内存空间;单位是字节,必须是1024的整数倍;

query_cache_type: ON, OFF, DEMAND

a、0(OFF):关闭 Query Cache 功能,任何情况下都不会使用 Query Cache;

b、1(ON):开启 Query Cache 功能,但是当SELECT语句中使用SQL_NO_CACHE提示后,将不使用Query Cache;

c、2(DEMAND):开启Query Cache 功能,但是只有当SELECT语句中使用了SQL_CACHE 提示后,才使用Query Cache。

query_cache_wlock_invalidate:如果某表被其它的连接锁定,是否仍然可以从查询缓存中返回结果;默认值为OFF,表示可以在表被其它连接锁定的场景中继续从缓存返回数据;ON则表示不允许;

MariaDB[(none)]>showglobalstatuslike'Qcache%'; +-------------------------+----------+ |Variable_name |Value | +-------------------------+----------+ |Qcache_free_blocks |1 | |Qcache_free_memory |16759656| |Qcache_hits |0 | |Qcache_inserts |0 | |Qcache_lowmem_prunes |0 | |Qcache_not_cached |7 | |Qcache_queries_in_cache|0 | |Qcache_total_blocks |1 | +-------------------------+----------+ 8rowsinset(0.00sec)

查看缓存变量参数说明:

Qcache_free_blocks: 缓存池中空闲块的个数,空闲的内存块。

Qcache_free_memory: 缓存中空闲内存空间

Qcache_hits: 缓存命中次数

Qcache_inserts: 可缓存查询语句的结果被放入缓存的次数

Qcache_lowmen_prunes: 有多少次是因为查询缓存内存空间太少而使用LRU算法清理缓存的次数

Qcache_not_cached: 可缓存却未能缓存的结果,例如查询结果超出缓存块大小,查询中包含可变函数等

Qcache_queries_in_cache: 当前缓存中缓存的SQL数量

Qcache_total_blocks: 整个查询缓存有多少内存块

缓存命中率:Qcache_hits/(Qcache_hits+Com_select)

四、分析和配置查询缓存流程及提高缓存命中率

①.开始,如果查询缓存命中率是否可以接受?如果可以的话,就结束。

②.不能接受目前的缓存命中率,查看大部分查询不是可缓存?是的话,就是大部分查询都不能缓存,query_cache_limit足够大吗?如果是,就结束,说明查询不能缓存,有可能是用户自定义变量、存储函数等,这种情况,建议关闭查询缓存。如果不是足够大,则需要增加此值。

③.1.大部分查询缓存都是可以缓存,但是却没有被缓存。是否发生很多严重工作?

是的话,查看缓存是不是被碎片化。需要降低query_cache_min_res_unit的值或是否flush query cache命令来整理缓存,减少碎片。

③.2.如果缓存不是因为碎片太多导致没有被缓存,内存过低发生的修正工作?

④.1.如果是内存过低,则增加query_cache_size。

④.2.如果不是内存过低,是否有很多的更新语句?频繁的更新表导致的缓存不能被命中,是有很多频繁更新的语句,负载不适合缓存,建议关闭缓存。不是有很多频繁更新的语句,则有其他配置的问题。

⑤.如果不是发生了很多验证工作,缓存启动了?是,没有见过此查询。否的话,启动缓存。

linux,见图

太阳城申博注册MySQL查询缓存

一、查询缓存说明

MySQL Query Cache是用来缓存我们所执行的SELECT语句以及该语句的结果集,MySql在实现Query Cache的具体技术细节上类似典型的KV存储,就是将SELECT语句和该查询语句的结果集做了一个HASH映射并保存在一定的内存区域中。当客户端发起SQL查询时,Query Cache的查找逻辑是,先对SQL进行相应的权限验证,接着就通过Query Cache来查找结果(注意必须是完全相同,即使多一个空格或者大小写不 同都认为不同,即使完全相同的SQL,如果使用不同的字符集、不同的协议等也会被认为是不同的查询而分别进行缓存)。它不需要经过Optimizer模块进行执行计划的分析优化,更不需要发生同任何存储引擎的交互,减少了大量的磁盘IO和CPU运 算,所以有时候效率非常高。

二、查询缓存命中

判断一个缓存是否被命中,通过查询语句的HASH值来判断,HASH值因素包括查询语句、查询数据库、客户端版本协议等,如查询语句任何字符的不同,都会导致HASH结果的不同,都可能导致缓存无法命中。有些查询不能被缓存,如查询中包含UDF、存储函数、用户自定义变量、临时表、mysql库中系统表、或者包含列级权限的表、有着不确定值的函数(Now()); 查询缓存是完全存储在内存中的,对整个内存空间分配回收等,会额外产生系统资源消耗,这会导致内存碎片的产生。

三、查看查询缓存的参数

MariaDB[(none)]>showglobalvariableslike'%query%'; +------------------------------+--------------------+ |Variable_name |Value | +------------------------------+--------------------+ |expensive_subquery_limit |100 | |ft_query_expansion_limit |20 | |have_query_cache |YES | |long_query_time |10.000000 | |query_alloc_block_size |16384 | |query_cache_limit |1048576 | |query_cache_min_res_unit |4096 | |query_cache_size |16777216 | |query_cache_strip_comments |OFF | |query_cache_type |ON | |query_cache_wlock_invalidate|OFF | |query_prealloc_size |24576 | |slow_query_log |OFF | |slow_query_log_file |localhost-slow.log| +------------------------------+--------------------+ 14rowsinset(0.01sec)

查询缓存相关变量说明

query_cache_min_res_unit: 查询缓存中内存块的最小分配单位;较小值会减少浪费,但会导致更频繁的内存分配操作;较大值会带来浪费,会导致碎片过多;

query_cache_limit:能够缓存的最大查询结果;对于有着较大结果的查询语句,建议在SELECT中使用SQL_NO_CACHE

query_cache_size:查询缓存总共可用的内存空间;单位是字节,必须是1024的整数倍;

query_cache_type: ON, OFF, DEMAND

a、0(OFF):关闭 Query Cache 功能,任何情况下都不会使用 Query Cache;

b、1(ON):开启 Query Cache 功能,但是当SELECT语句中使用SQL_NO_CACHE提示后,将不使用Query Cache;

c、2(DEMAND):开启Query Cache 功能,但是只有当SELECT语句中使用了SQL_CACHE 提示后,才使用Query Cache。

query_cache_wlock_invalidate:如果某表被其它的连接锁定,是否仍然可以从查询缓存中返回结果;默认值为OFF,表示可以在表被其它连接锁定的场景中继续从缓存返回数据;ON则表示不允许;

MariaDB[(none)]>showglobalstatuslike'Qcache%'; +-------------------------+----------+ |Variable_name |Value | +-------------------------+----------+ |Qcache_free_blocks |1 | |Qcache_free_memory |16759656| |Qcache_hits |0 | |Qcache_inserts |0 | |Qcache_lowmem_prunes |0 | |Qcache_not_cached |7 | |Qcache_queries_in_cache|0 | |Qcache_total_blocks |1 | +-------------------------+----------+ 8rowsinset(0.00sec)

查看缓存变量参数说明:

Qcache_free_blocks: 缓存池中空闲块的个数,空闲的内存块。

Qcache_free_memory: 缓存中空闲内存空间

Qcache_hits: 缓存命中次数

Qcache_inserts: 可缓存查询语句的结果被放入缓存的次数

Qcache_lowmen_prunes: 有多少次是因为查询缓存内存空间太少而使用LRU算法清理缓存的次数

Qcache_not_cached: 可缓存却未能缓存的结果,例如查询结果超出缓存块大小,查询中包含可变函数等

Qcache_queries_in_cache: 当前缓存中缓存的SQL数量

Qcache_total_blocks: 整个查询缓存有多少内存块

缓存命中率:Qcache_hits/(Qcache_hits+Com_select)

四、分析和配置查询缓存流程及提高缓存命中率

①.开始,如果查询缓存命中率是否可以接受?如果可以的话,就结束。

②.不能接受目前的缓存命中率,查看大部分查询不是可缓存?是的话,就是大部分查询都不能缓存,query_cache_limit足够大吗?如果是,就结束,说明查询不能缓存,有可能是用户自定义变量、存储函数等,这种情况,建议关闭查询缓存。如果不是足够大,则需要增加此值。

③.1.大部分查询缓存都是可以缓存,但是却没有被缓存。是否发生很多严重工作?

是的话,查看缓存是不是被碎片化。需要降低query_cache_min_res_unit的值或是否flush query cache命令来整理缓存,减少碎片。

③.2.如果缓存不是因为碎片太多导致没有被缓存,内存过低发生的修正工作?

④.1.如果是内存过低,则增加query_cache_size。

④.2.如果不是内存过低,是否有很多的更新语句?频繁的更新表导致的缓存不能被命中,是有很多频繁更新的语句,负载不适合缓存,建议关闭缓存。不是有很多频繁更新的语句,则有其他配置的问题。

⑤.如果不是发生了很多验证工作,缓存启动了?是,没有见过此查询。否的话,启动缓存。

linuxMySQL查询缓存

MySQL查询缓存

MySQL查询缓存

一、查询缓存说明

MySQL Query Cache是用来缓存我们所执行的SELECT语句以及该语句的结果集,MySql在实现Query Cache的具体技术细节上类似典型的KV存储,就是将SELECT语句和该查询语句的结果集做了一个HASH映射并保存在一定的内存区域中。当客户端发起SQL查询时,Query Cache的查找逻辑是,先对SQL进行相应的权限验证,接着就通过Query Cache来查找结果(注意必须是完全相同,即使多一个空格或者大小写不 同都认为不同,即使完全相同的SQL,如果使用不同的字符集、不同的协议等也会被认为是不同的查询而分别进行缓存)。它不需要经过Optimizer模块进行执行计划的分析优化,更不需要发生同任何存储引擎的交互,减少了大量的磁盘IO和CPU运 算,所以有时候效率非常高。

二、查询缓存命中

判断一个缓存是否被命中,通过查询语句的HASH值来判断,HASH值因素包括查询语句、查询数据库、客户端版本协议等,如查询语句任何字符的不同,都会导致HASH结果的不同,都可能导致缓存无法命中。有些查询不能被缓存,如查询中包含UDF、存储函数、用户自定义变量、临时表、mysql库中系统表、或者包含列级权限的表、有着不确定值的函数(Now()); 查询缓存是完全存储在内存中的,对整个内存空间分配回收等,会额外产生系统资源消耗,这会导致内存碎片的产生。

三、查看查询缓存的参数

MariaDB[(none)]>showglobalvariableslike'%query%'; +------------------------------+--------------------+ |Variable_name |Value | +------------------------------+--------------------+ |expensive_subquery_limit |100 | |ft_query_expansion_limit |20 | |have_query_cache |YES | |long_query_time |10.000000 | |query_alloc_block_size |16384 | |query_cache_limit |1048576 | |query_cache_min_res_unit |4096 | |query_cache_size |16777216 | |query_cache_strip_comments |OFF | |query_cache_type |ON | |query_cache_wlock_invalidate|OFF | |query_prealloc_size |24576 | |slow_query_log |OFF | |slow_query_log_file |localhost-slow.log| +------------------------------+--------------------+ 14rowsinset(0.01sec)

查询缓存相关变量说明

query_cache_min_res_unit: 查询缓存中内存块的最小分配单位;较小值会减少浪费,但会导致更频繁的内存分配操作;较大值会带来浪费,会导致碎片过多;

query_cache_limit:能够缓存的最大查询结果;对于有着较大结果的查询语句,建议在SELECT中使用SQL_NO_CACHE

query_cache_size:查询缓存总共可用的内存空间;单位是字节,必须是1024的整数倍;

query_cache_type: ON, OFF, DEMAND

a、0(OFF):关闭 Query Cache 功能,任何情况下都不会使用 Query Cache;

b、1(ON):开启 Query Cache 功能,但是当SELECT语句中使用SQL_NO_CACHE提示后,将不使用Query Cache;

c、2(DEMAND):开启Query Cache 功能,但是只有当SELECT语句中使用了SQL_CACHE 提示后,才使用Query Cache。

query_cache_wlock_invalidate:如果某表被其它的连接锁定,是否仍然可以从查询缓存中返回结果;默认值为OFF,表示可以在表被其它连接锁定的场景中继续从缓存返回数据;ON则表示不允许;

MariaDB[(none)]>showglobalstatuslike'Qcache%'; +-------------------------+----------+ |Variable_name |Value | +-------------------------+----------+ |Qcache_free_blocks |1 | |Qcache_free_memory |16759656| |Qcache_hits |0 | |Qcache_inserts |0 | |Qcache_lowmem_prunes |0 | |Qcache_not_cached |7 | |Qcache_queries_in_cache|0 | |Qcache_total_blocks |1 | +-------------------------+----------+ 8rowsinset(0.00sec)

查看缓存变量参数说明:

Qcache_free_blocks: 缓存池中空闲块的个数,空闲的内存块。

Qcache_free_memory: 缓存中空闲内存空间

Qcache_hits: 缓存命中次数

Qcache_inserts: 可缓存查询语句的结果被放入缓存的次数

Qcache_lowmen_prunes: 有多少次是因为查询缓存内存空间太少而使用LRU算法清理缓存的次数

Qcache_not_cached: 可缓存却未能缓存的结果,例如查询结果超出缓存块大小,查询中包含可变函数等

Qcache_queries_in_cache: 当前缓存中缓存的SQL数量

Qcache_total_blocks: 整个查询缓存有多少内存块

缓存命中率:Qcache_hits/(Qcache_hits+Com_select)

四、分析和配置查询缓存流程及提高缓存命中率

①.开始,如果查询缓存命中率是否可以接受?如果可以的话,就结束。

②.不能接受目前的缓存命中率,查看大部分查询不是可缓存?是的话,就是大部分查询都不能缓存,query_cache_limit足够大吗?如果是,就结束,说明查询不能缓存,有可能是用户自定义变量、存储函数等,这种情况,建议关闭查询缓存。如果不是足够大,则需要增加此值。

③.1.大部分查询缓存都是可以缓存,但是却没有被缓存。是否发生很多严重工作?

是的话,查看缓存是不是被碎片化。需要降低query_cache_min_res_unit的值或是否flush query cache命令来整理缓存,减少碎片。

③.2.如果缓存不是因为碎片太多导致没有被缓存,内存过低发生的修正工作?

④.1.如果是内存过低,则增加query_cache_size。

④.2.如果不是内存过低,是否有很多的更新语句?频繁的更新表导致的缓存不能被命中,是有很多频繁更新的语句,负载不适合缓存,建议关闭缓存。不是有很多频繁更新的语句,则有其他配置的问题。

⑤.如果不是发生了很多验证工作,缓存启动了?是,没有见过此查询。否的话,启动缓存。

linux

一、查询缓存说明

MySQL Query Cache是用来缓存我们所执行的SELECT语句以及该语句的结果集,MySql在实现Query Cache的具体技术细节上类似典型的KV存储,就是将SELECT语句和该查询语句的结果集做了一个HASH映射并保存在一定的内存区域中。当客户端发起SQL查询时,Query Cache的查找逻辑是,先对SQL进行相应的权限验证,接着就通过Query Cache来查找结果(注意必须是完全相同,即使多一个空格或者大小写不 同都认为不同,即使完全相同的SQL,如果使用不同的字符集、不同的协议等也会被认为是不同的查询而分别进行缓存)。它不需要经过Optimizer模块进行执行计划的分析优化,更不需要发生同任何存储引擎的交互,减少了大量的磁盘IO和CPU运 算,所以有时候效率非常高。

二、查询缓存命中

判断一个缓存是否被命中,通过查询语句的HASH值来判断,HASH值因素包括查询语句、查询数据库、客户端版本协议等,如查询语句任何字符的不同,都会导致HASH结果的不同,都可能导致缓存无法命中。有些查询不能被缓存,如查询中包含UDF、存储函数、用户自定义变量、临时表、mysql库中系统表、或者包含列级权限的表、有着不确定值的函数(Now()); 查询缓存是完全存储在内存中的,对整个内存空间分配回收等,会额外产生系统资源消耗,这会导致内存碎片的产生。

三、查看查询缓存的参数

MariaDB[(none)]>showglobalvariableslike'%query%'; +------------------------------+--------------------+ |Variable_name |Value | +------------------------------+--------------------+ |expensive_subquery_limit |100 | |ft_query_expansion_limit |20 | |have_query_cache |YES | |long_query_time |10.000000 | |query_alloc_block_size |16384 | |query_cache_limit |1048576 | |query_cache_min_res_unit |4096 | |query_cache_size |16777216 | |query_cache_strip_comments |OFF | |query_cache_type |ON | |query_cache_wlock_invalidate|OFF | |query_prealloc_size |24576 | |slow_query_log |OFF | |slow_query_log_file |localhost-slow.log| +------------------------------+--------------------+ 14rowsinset(0.01sec)

查询缓存相关变量说明

query_cache_min_res_unit: 查询缓存中内存块的最小分配单位;较小值会减少浪费,但会导致更频繁的内存分配操作;较大值会带来浪费,会导致碎片过多;

query_cache_limit:能够缓存的最大查询结果;对于有着较大结果的查询语句,建议在SELECT中使用SQL_NO_CACHE

query_cache_size:查询缓存总共可用的内存空间;单位是字节,必须是1024的整数倍;

query_cache_type: ON, OFF, DEMAND

a、0(OFF):关闭 Query Cache 功能,任何情况下都不会使用 Query Cache;

b、1(ON):开启 Query Cache 功能,但是当SELECT语句中使用SQL_NO_CACHE提示后,将不使用Query Cache;

c、2(DEMAND):开启Query Cache 功能,但是只有当SELECT语句中使用了SQL_CACHE 提示后,才使用Query Cache。

query_cache_wlock_invalidate:如果某表被其它的连接锁定,是否仍然可以从查询缓存中返回结果;默认值为OFF,表示可以在表被其它连接锁定的场景中继续从缓存返回数据;ON则表示不允许;

MariaDB[(none)]>showglobalstatuslike'Qcache%'; +-------------------------+----------+ |Variable_name |Value | +-------------------------+----------+ |Qcache_free_blocks |1 | |Qcache_free_memory |16759656| |Qcache_hits |0 | |Qcache_inserts |0 | |Qcache_lowmem_prunes |0 | |Qcache_not_cached |7 | |Qcache_queries_in_cache|0 | |Qcache_total_blocks |1 | +-------------------------+----------+ 8rowsinset(0.00sec)

查看缓存变量参数说明:

Qcache_free_blocks: 缓存池中空闲块的个数,空闲的内存块。

Qcache_free_memory: 缓存中空闲内存空间

Qcache_hits: 缓存命中次数

Qcache_inserts: 可缓存查询语句的结果被放入缓存的次数

Qcache_lowmen_prunes: 有多少次是因为查询缓存内存空间太少而使用LRU算法清理缓存的次数

Qcache_not_cached: 可缓存却未能缓存的结果,例如查询结果超出缓存块大小,查询中包含可变函数等

Qcache_queries_in_cache: 当前缓存中缓存的SQL数量

Qcache_total_blocks: 整个查询缓存有多少内存块

缓存命中率:Qcache_hits/(Qcache_hits+Com_select)

四、分析和配置查询缓存流程及提高缓存命中率

①.开始,如果查询缓存命中率是否可以接受?如果可以的话,就结束。

②.不能接受目前的缓存命中率,查看大部分查询不是可缓存?是的话,就是大部分查询都不能缓存,query_cache_limit足够大吗?如果是,就结束,说明查询不能缓存,有可能是用户自定义变量、存储函数等,这种情况,建议关闭查询缓存。如果不是足够大,则需要增加此值。

③.1.大部分查询缓存都是可以缓存,但是却没有被缓存。是否发生很多严重工作?

是的话,查看缓存是不是被碎片化。需要降低query_cache_min_res_unit的值或是否flush query cache命令来整理缓存,减少碎片。

③.2.如果缓存不是因为碎片太多导致没有被缓存,内存过低发生的修正工作?

④.1.如果是内存过低,则增加query_cache_size。

④.2.如果不是内存过低,是否有很多的更新语句?频繁的更新表导致的缓存不能被命中,是有很多频繁更新的语句,负载不适合缓存,建议关闭缓存。不是有很多频繁更新的语句,则有其他配置的问题。

⑤.如果不是发生了很多验证工作,缓存启动了?是,没有见过此查询。否的话,启动缓存。

linuxMySQL查询缓存

一、查询缓存说明

MySQL Query Cache是用来缓存我们所执行的SELECT语句以及该语句的结果集,MySql在实现Query Cache的具体技术细节上类似典型的KV存储,就是将SELECT语句和该查询语句的结果集做了一个HASH映射并保存在一定的内存区域中。当客户端发起SQL查询时,Query Cache的查找逻辑是,先对SQL进行相应的权限验证,接着就通过Query Cache来查找结果(注意必须是完全相同,即使多一个空格或者大小写不 同都认为不同,即使完全相同的SQL,如果使用不同的字符集、不同的协议等也会被认为是不同的查询而分别进行缓存)。它不需要经过Optimizer模块进行执行计划的分析优化,更不需要发生同任何存储引擎的交互,减少了大量的磁盘IO和CPU运 算,所以有时候效率非常高。

二、查询缓存命中

判断一个缓存是否被命中,通过查询语句的HASH值来判断,HASH值因素包括查询语句、查询数据库、客户端版本协议等,如查询语句任何字符的不同,都会导致HASH结果的不同,都可能导致缓存无法命中。有些查询不能被缓存,如查询中包含UDF、存储函数、用户自定义变量、临时表、mysql库中系统表、或者包含列级权限的表、有着不确定值的函数(Now()); 查询缓存是完全存储在内存中的,对整个内存空间分配回收等,会额外产生系统资源消耗,这会导致内存碎片的产生。

三、查看查询缓存的参数

MariaDB[(none)]>showglobalvariableslike'%query%'; +------------------------------+--------------------+ |Variable_name |Value | +------------------------------+--------------------+ |expensive_subquery_limit |100 | |ft_query_expansion_limit |20 | |have_query_cache |YES | |long_query_time |10.000000 | |query_alloc_block_size |16384 | |query_cache_limit |1048576 | |query_cache_min_res_unit |4096 | |query_cache_size |16777216 | |query_cache_strip_comments |OFF | |query_cache_type |ON | |query_cache_wlock_invalidate|OFF | |query_prealloc_size |24576 | |slow_query_log |OFF | |slow_query_log_file |localhost-slow.log| +------------------------------+--------------------+ 14rowsinset(0.01sec)

查询缓存相关变量说明

query_cache_min_res_unit: 查询缓存中内存块的最小分配单位;较小值会减少浪费,但会导致更频繁的内存分配操作;较大值会带来浪费,会导致碎片过多;

query_cache_limit:能够缓存的最大查询结果;对于有着较大结果的查询语句,建议在SELECT中使用SQL_NO_CACHE

query_cache_size:查询缓存总共可用的内存空间;单位是字节,必须是1024的整数倍;

query_cache_type: ON, OFF, DEMAND

a、0(OFF):关闭 Query Cache 功能,任何情况下都不会使用 Query Cache;

b、1(ON):开启 Query Cache 功能,但是当SELECT语句中使用SQL_NO_CACHE提示后,将不使用Query Cache;

c、2(DEMAND):开启Query Cache 功能,但是只有当SELECT语句中使用了SQL_CACHE 提示后,才使用Query Cache。

query_cache_wlock_invalidate:如果某表被其它的连接锁定,是否仍然可以从查询缓存中返回结果;默认值为OFF,表示可以在表被其它连接锁定的场景中继续从缓存返回数据;ON则表示不允许;

MariaDB[(none)]>showglobalstatuslike'Qcache%'; +-------------------------+----------+ |Variable_name |Value | +-------------------------+----------+ |Qcache_free_blocks |1 | |Qcache_free_memory |16759656| |Qcache_hits |0 | |Qcache_inserts |0 | |Qcache_lowmem_prunes |0 | |Qcache_not_cached |7 | |Qcache_queries_in_cache|0 | |Qcache_total_blocks |1 | +-------------------------+----------+ 8rowsinset(0.00sec)

查看缓存变量参数说明:

Qcache_free_blocks: 缓存池中空闲块的个数,空闲的内存块。

Qcache_free_memory: 缓存中空闲内存空间

Qcache_hits: 缓存命中次数

Qcache_inserts: 可缓存查询语句的结果被放入缓存的次数

Qcache_lowmen_prunes: 有多少次是因为查询缓存内存空间太少而使用LRU算法清理缓存的次数

Qcache_not_cached: 可缓存却未能缓存的结果,例如查询结果超出缓存块大小,查询中包含可变函数等

Qcache_queries_in_cache: 当前缓存中缓存的SQL数量

Qcache_total_blocks: 整个查询缓存有多少内存块

缓存命中率:Qcache_hits/(Qcache_hits+Com_select)

四、分析和配置查询缓存流程及提高缓存命中率

①.开始,如果查询缓存命中率是否可以接受?如果可以的话,就结束。

②.不能接受目前的缓存命中率,查看大部分查询不是可缓存?是的话,就是大部分查询都不能缓存,query_cache_limit足够大吗?如果是,就结束,说明查询不能缓存,有可能是用户自定义变量、存储函数等,这种情况,建议关闭查询缓存。如果不是足够大,则需要增加此值。

③.1.大部分查询缓存都是可以缓存,但是却没有被缓存。是否发生很多严重工作?

是的话,查看缓存是不是被碎片化。需要降低query_cache_min_res_unit的值或是否flush query cache命令来整理缓存,减少碎片。

③.2.如果缓存不是因为碎片太多导致没有被缓存,内存过低发生的修正工作?

④.1.如果是内存过低,则增加query_cache_size。

④.2.如果不是内存过低,是否有很多的更新语句?频繁的更新表导致的缓存不能被命中,是有很多频繁更新的语句,负载不适合缓存,建议关闭缓存。不是有很多频繁更新的语句,则有其他配置的问题。

⑤.如果不是发生了很多验证工作,缓存启动了?是,没有见过此查询。否的话,启动缓存。

linuxMySQL查询缓存

MySQL查询缓存

一、查询缓存说明

MySQL Query Cache是用来缓存我们所执行的SELECT语句以及该语句的结果集,MySql在实现Query Cache的具体技术细节上类似典型的KV存储,就是将SELECT语句和该查询语句的结果集做了一个HASH映射并保存在一定的内存区域中。当客户端发起SQL查询时,Query Cache的查找逻辑是,先对SQL进行相应的权限验证,接着就通过Query Cache来查找结果(注意必须是完全相同,即使多一个空格或者大小写不 同都认为不同,即使完全相同的SQL,如果使用不同的字符集、不同的协议等也会被认为是不同的查询而分别进行缓存)。它不需要经过Optimizer模块进行执行计划的分析优化,更不需要发生同任何存储引擎的交互,减少了大量的磁盘IO和CPU运 算,所以有时候效率非常高。

二、查询缓存命中

判断一个缓存是否被命中,通过查询语句的HASH值来判断,HASH值因素包括查询语句、查询数据库、客户端版本协议等,如查询语句任何字符的不同,都会导致HASH结果的不同,都可能导致缓存无法命中。有些查询不能被缓存,如查询中包含UDF、存储函数、用户自定义变量、临时表、mysql库中系统表、或者包含列级权限的表、有着不确定值的函数(Now()); 查询缓存是完全存储在内存中的,对整个内存空间分配回收等,会额外产生系统资源消耗,这会导致内存碎片的产生。

三、查看查询缓存的参数

MariaDB[(none)]>showglobalvariableslike'%query%'; +------------------------------+--------------------+ |Variable_name |Value | +------------------------------+--------------------+ |expensive_subquery_limit |100 | |ft_query_expansion_limit |20 | |have_query_cache |YES | |long_query_time |10.000000 | |query_alloc_block_size |16384 | |query_cache_limit |1048576 | |query_cache_min_res_unit |4096 | |query_cache_size |16777216 | |query_cache_strip_comments |OFF | |query_cache_type |ON | |query_cache_wlock_invalidate|OFF | |query_prealloc_size |24576 | |slow_query_log |OFF | |slow_query_log_file |localhost-slow.log| +------------------------------+--------------------+ 14rowsinset(0.01sec)

查询缓存相关变量说明

query_cache_min_res_unit: 查询缓存中内存块的最小分配单位;较小值会减少浪费,但会导致更频繁的内存分配操作;较大值会带来浪费,会导致碎片过多;

query_cache_limit:能够缓存的最大查询结果;对于有着较大结果的查询语句,建议在SELECT中使用SQL_NO_CACHE

query_cache_size:查询缓存总共可用的内存空间;单位是字节,必须是1024的整数倍;

query_cache_type: ON, OFF, DEMAND

a、0(OFF):关闭 Query Cache 功能,任何情况下都不会使用 Query Cache;

b、1(ON):开启 Query Cache 功能,但是当SELECT语句中使用SQL_NO_CACHE提示后,将不使用Query Cache;

c、2(DEMAND):开启Query Cache 功能,但是只有当SELECT语句中使用了SQL_CACHE 提示后,才使用Query Cache。

query_cache_wlock_invalidate:如果某表被其它的连接锁定,是否仍然可以从查询缓存中返回结果;默认值为OFF,表示可以在表被其它连接锁定的场景中继续从缓存返回数据;ON则表示不允许;

MariaDB[(none)]>showglobalstatuslike'Qcache%'; +-------------------------+----------+ |Variable_name |Value | +-------------------------+----------+ |Qcache_free_blocks |1 | |Qcache_free_memory |16759656| |Qcache_hits |0 | |Qcache_inserts |0 | |Qcache_lowmem_prunes |0 | |Qcache_not_cached |7 | |Qcache_queries_in_cache|0 | |Qcache_total_blocks |1 | +-------------------------+----------+ 8rowsinset(0.00sec)

查看缓存变量参数说明:

Qcache_free_blocks: 缓存池中空闲块的个数,空闲的内存块。

Qcache_free_memory: 缓存中空闲内存空间

Qcache_hits: 缓存命中次数

Qcache_inserts: 可缓存查询语句的结果被放入缓存的次数

Qcache_lowmen_prunes: 有多少次是因为查询缓存内存空间太少而使用LRU算法清理缓存的次数

Qcache_not_cached: 可缓存却未能缓存的结果,例如查询结果超出缓存块大小,查询中包含可变函数等

Qcache_queries_in_cache: 当前缓存中缓存的SQL数量

Qcache_total_blocks: 整个查询缓存有多少内存块

缓存命中率:Qcache_hits/(Qcache_hits+Com_select)

四、分析和配置查询缓存流程及提高缓存命中率

①.开始,如果查询缓存命中率是否可以接受?如果可以的话,就结束。

②.不能接受目前的缓存命中率,查看大部分查询不是可缓存?是的话,就是大部分查询都不能缓存,query_cache_limit足够大吗?如果是,就结束,说明查询不能缓存,有可能是用户自定义变量、存储函数等,这种情况,建议关闭查询缓存。如果不是足够大,则需要增加此值。

③.1.大部分查询缓存都是可以缓存,但是却没有被缓存。是否发生很多严重工作?

是的话,查看缓存是不是被碎片化。需要降低query_cache_min_res_unit的值或是否flush query cache命令来整理缓存,减少碎片。

③.2.如果缓存不是因为碎片太多导致没有被缓存,内存过低发生的修正工作?

④.1.如果是内存过低,则增加query_cache_size。

④.2.如果不是内存过低,是否有很多的更新语句?频繁的更新表导致的缓存不能被命中,是有很多频繁更新的语句,负载不适合缓存,建议关闭缓存。不是有很多频繁更新的语句,则有其他配置的问题。

⑤.如果不是发生了很多验证工作,缓存启动了?是,没有见过此查询。否的话,启动缓存。

linux

MySQL查询缓存MySQL查询缓存MySQL查询缓存MySQL查询缓存

一、查询缓存说明

MySQL Query Cache是用来缓存我们所执行的SELECT语句以及该语句的结果集,MySql在实现Query Cache的具体技术细节上类似典型的KV存储,就是将SELECT语句和该查询语句的结果集做了一个HASH映射并保存在一定的内存区域中。当客户端发起SQL查询时,Query Cache的查找逻辑是,先对SQL进行相应的权限验证,接着就通过Query Cache来查找结果(注意必须是完全相同,即使多一个空格或者大小写不 同都认为不同,即使完全相同的SQL,如果使用不同的字符集、不同的协议等也会被认为是不同的查询而分别进行缓存)。它不需要经过Optimizer模块进行执行计划的分析优化,更不需要发生同任何存储引擎的交互,减少了大量的磁盘IO和CPU运 算,所以有时候效率非常高。

二、查询缓存命中

判断一个缓存是否被命中,通过查询语句的HASH值来判断,HASH值因素包括查询语句、查询数据库、客户端版本协议等,如查询语句任何字符的不同,都会导致HASH结果的不同,都可能导致缓存无法命中。有些查询不能被缓存,如查询中包含UDF、存储函数、用户自定义变量、临时表、mysql库中系统表、或者包含列级权限的表、有着不确定值的函数(Now()); 查询缓存是完全存储在内存中的,对整个内存空间分配回收等,会额外产生系统资源消耗,这会导致内存碎片的产生。

三、查看查询缓存的参数

MariaDB[(none)]>showglobalvariableslike'%query%'; +------------------------------+--------------------+ |Variable_name |Value | +------------------------------+--------------------+ |expensive_subquery_limit |100 | |ft_query_expansion_limit |20 | |have_query_cache |YES | |long_query_time |10.000000 | |query_alloc_block_size |16384 | |query_cache_limit |1048576 | |query_cache_min_res_unit |4096 | |query_cache_size |16777216 | |query_cache_strip_comments |OFF | |query_cache_type |ON | |query_cache_wlock_invalidate|OFF | |query_prealloc_size |24576 | |slow_query_log |OFF | |slow_query_log_file |localhost-slow.log| +------------------------------+--------------------+ 14rowsinset(0.01sec)

查询缓存相关变量说明

query_cache_min_res_unit: 查询缓存中内存块的最小分配单位;较小值会减少浪费,但会导致更频繁的内存分配操作;较大值会带来浪费,会导致碎片过多;

query_cache_limit:能够缓存的最大查询结果;对于有着较大结果的查询语句,建议在SELECT中使用SQL_NO_CACHE

query_cache_size:查询缓存总共可用的内存空间;单位是字节,必须是1024的整数倍;

query_cache_type: ON, OFF, DEMAND

a、0(OFF):关闭 Query Cache 功能,任何情况下都不会使用 Query Cache;

b、1(ON):开启 Query Cache 功能,但是当SELECT语句中使用SQL_NO_CACHE提示后,将不使用Query Cache;

c、2(DEMAND):开启Query Cache 功能,但是只有当SELECT语句中使用了SQL_CACHE 提示后,才使用Query Cache。

query_cache_wlock_invalidate:如果某表被其它的连接锁定,是否仍然可以从查询缓存中返回结果;默认值为OFF,表示可以在表被其它连接锁定的场景中继续从缓存返回数据;ON则表示不允许;

MariaDB[(none)]>showglobalstatuslike'Qcache%'; +-------------------------+----------+ |Variable_name |Value | +-------------------------+----------+ |Qcache_free_blocks |1 | |Qcache_free_memory |16759656| |Qcache_hits |0 | |Qcache_inserts |0 | |Qcache_lowmem_prunes |0 | |Qcache_not_cached |7 | |Qcache_queries_in_cache|0 | |Qcache_total_blocks |1 | +-------------------------+----------+ 8rowsinset(0.00sec)

查看缓存变量参数说明:

Qcache_free_blocks: 缓存池中空闲块的个数,空闲的内存块。

Qcache_free_memory: 缓存中空闲内存空间

Qcache_hits: 缓存命中次数

Qcache_inserts: 可缓存查询语句的结果被放入缓存的次数

Qcache_lowmen_prunes: 有多少次是因为查询缓存内存空间太少而使用LRU算法清理缓存的次数

Qcache_not_cached: 可缓存却未能缓存的结果,例如查询结果超出缓存块大小,查询中包含可变函数等

Qcache_queries_in_cache: 当前缓存中缓存的SQL数量

Qcache_total_blocks: 整个查询缓存有多少内存块

缓存命中率:Qcache_hits/(Qcache_hits+Com_select)

四、分析和配置查询缓存流程及提高缓存命中率

①.开始,如果查询缓存命中率是否可以接受?如果可以的话,就结束。

②.不能接受目前的缓存命中率,查看大部分查询不是可缓存?是的话,就是大部分查询都不能缓存,query_cache_limit足够大吗?如果是,就结束,说明查询不能缓存,有可能是用户自定义变量、存储函数等,这种情况,建议关闭查询缓存。如果不是足够大,则需要增加此值。

③.1.大部分查询缓存都是可以缓存,但是却没有被缓存。是否发生很多严重工作?

是的话,查看缓存是不是被碎片化。需要降低query_cache_min_res_unit的值或是否flush query cache命令来整理缓存,减少碎片。

③.2.如果缓存不是因为碎片太多导致没有被缓存,内存过低发生的修正工作?

④.1.如果是内存过低,则增加query_cache_size。

④.2.如果不是内存过低,是否有很多的更新语句?频繁的更新表导致的缓存不能被命中,是有很多频繁更新的语句,负载不适合缓存,建议关闭缓存。不是有很多频繁更新的语句,则有其他配置的问题。

⑤.如果不是发生了很多验证工作,缓存启动了?是,没有见过此查询。否的话,启动缓存。

linuxMySQL查询缓存

一、查询缓存说明

MySQL Query Cache是用来缓存我们所执行的SELECT语句以及该语句的结果集,MySql在实现Query Cache的具体技术细节上类似典型的KV存储,就是将SELECT语句和该查询语句的结果集做了一个HASH映射并保存在一定的内存区域中。当客户端发起SQL查询时,Query Cache的查找逻辑是,先对SQL进行相应的权限验证,接着就通过Query Cache来查找结果(注意必须是完全相同,即使多一个空格或者大小写不 同都认为不同,即使完全相同的SQL,如果使用不同的字符集、不同的协议等也会被认为是不同的查询而分别进行缓存)。它不需要经过Optimizer模块进行执行计划的分析优化,更不需要发生同任何存储引擎的交互,减少了大量的磁盘IO和CPU运 算,所以有时候效率非常高。

二、查询缓存命中

判断一个缓存是否被命中,通过查询语句的HASH值来判断,HASH值因素包括查询语句、查询数据库、客户端版本协议等,如查询语句任何字符的不同,都会导致HASH结果的不同,都可能导致缓存无法命中。有些查询不能被缓存,如查询中包含UDF、存储函数、用户自定义变量、临时表、mysql库中系统表、或者包含列级权限的表、有着不确定值的函数(Now()); 查询缓存是完全存储在内存中的,对整个内存空间分配回收等,会额外产生系统资源消耗,这会导致内存碎片的产生。

三、查看查询缓存的参数

MariaDB[(none)]>showglobalvariableslike'%query%'; +------------------------------+--------------------+ |Variable_name |Value | +------------------------------+--------------------+ |expensive_subquery_limit |100 | |ft_query_expansion_limit |20 | |have_query_cache |YES | |long_query_time |10.000000 | |query_alloc_block_size |16384 | |query_cache_limit |1048576 | |query_cache_min_res_unit |4096 | |query_cache_size |16777216 | |query_cache_strip_comments |OFF | |query_cache_type |ON | |query_cache_wlock_invalidate|OFF | |query_prealloc_size |24576 | |slow_query_log |OFF | |slow_query_log_file |localhost-slow.log| +------------------------------+--------------------+ 14rowsinset(0.01sec)

查询缓存相关变量说明

query_cache_min_res_unit: 查询缓存中内存块的最小分配单位;较小值会减少浪费,但会导致更频繁的内存分配操作;较大值会带来浪费,会导致碎片过多;

query_cache_limit:能够缓存的最大查询结果;对于有着较大结果的查询语句,建议在SELECT中使用SQL_NO_CACHE

query_cache_size:查询缓存总共可用的内存空间;单位是字节,必须是1024的整数倍;

query_cache_type: ON, OFF, DEMAND

a、0(OFF):关闭 Query Cache 功能,任何情况下都不会使用 Query Cache;

b、1(ON):开启 Query Cache 功能,但是当SELECT语句中使用SQL_NO_CACHE提示后,将不使用Query Cache;

c、2(DEMAND):开启Query Cache 功能,但是只有当SELECT语句中使用了SQL_CACHE 提示后,才使用Query Cache。

query_cache_wlock_invalidate:如果某表被其它的连接锁定,是否仍然可以从查询缓存中返回结果;默认值为OFF,表示可以在表被其它连接锁定的场景中继续从缓存返回数据;ON则表示不允许;

MariaDB[(none)]>showglobalstatuslike'Qcache%'; +-------------------------+----------+ |Variable_name |Value | +-------------------------+----------+ |Qcache_free_blocks |1 | |Qcache_free_memory |16759656| |Qcache_hits |0 | |Qcache_inserts |0 | |Qcache_lowmem_prunes |0 | |Qcache_not_cached |7 | |Qcache_queries_in_cache|0 | |Qcache_total_blocks |1 | +-------------------------+----------+ 8rowsinset(0.00sec)

查看缓存变量参数说明:

Qcache_free_blocks: 缓存池中空闲块的个数,空闲的内存块。

Qcache_free_memory: 缓存中空闲内存空间

Qcache_hits: 缓存命中次数

Qcache_inserts: 可缓存查询语句的结果被放入缓存的次数

Qcache_lowmen_prunes: 有多少次是因为查询缓存内存空间太少而使用LRU算法清理缓存的次数

Qcache_not_cached: 可缓存却未能缓存的结果,例如查询结果超出缓存块大小,查询中包含可变函数等

Qcache_queries_in_cache: 当前缓存中缓存的SQL数量

Qcache_total_blocks: 整个查询缓存有多少内存块

缓存命中率:Qcache_hits/(Qcache_hits+Com_select)

四、分析和配置查询缓存流程及提高缓存命中率

①.开始,如果查询缓存命中率是否可以接受?如果可以的话,就结束。

②.不能接受目前的缓存命中率,查看大部分查询不是可缓存?是的话,就是大部分查询都不能缓存,query_cache_limit足够大吗?如果是,就结束,说明查询不能缓存,有可能是用户自定义变量、存储函数等,这种情况,建议关闭查询缓存。如果不是足够大,则需要增加此值。

③.1.大部分查询缓存都是可以缓存,但是却没有被缓存。是否发生很多严重工作?

是的话,查看缓存是不是被碎片化。需要降低query_cache_min_res_unit的值或是否flush query cache命令来整理缓存,减少碎片。

③.2.如果缓存不是因为碎片太多导致没有被缓存,内存过低发生的修正工作?

④.1.如果是内存过低,则增加query_cache_size。

④.2.如果不是内存过低,是否有很多的更新语句?频繁的更新表导致的缓存不能被命中,是有很多频繁更新的语句,负载不适合缓存,建议关闭缓存。不是有很多频繁更新的语句,则有其他配置的问题。

⑤.如果不是发生了很多验证工作,缓存启动了?是,没有见过此查询。否的话,启动缓存。

linux

一、查询缓存说明

MySQL Query Cache是用来缓存我们所执行的SELECT语句以及该语句的结果集,MySql在实现Query Cache的具体技术细节上类似典型的KV存储,就是将SELECT语句和该查询语句的结果集做了一个HASH映射并保存在一定的内存区域中。当客户端发起SQL查询时,Query Cache的查找逻辑是,先对SQL进行相应的权限验证,接着就通过Query Cache来查找结果(注意必须是完全相同,即使多一个空格或者大小写不 同都认为不同,即使完全相同的SQL,如果使用不同的字符集、不同的协议等也会被认为是不同的查询而分别进行缓存)。它不需要经过Optimizer模块进行执行计划的分析优化,更不需要发生同任何存储引擎的交互,减少了大量的磁盘IO和CPU运 算,所以有时候效率非常高。

二、查询缓存命中

判断一个缓存是否被命中,通过查询语句的HASH值来判断,HASH值因素包括查询语句、查询数据库、客户端版本协议等,如查询语句任何字符的不同,都会导致HASH结果的不同,都可能导致缓存无法命中。有些查询不能被缓存,如查询中包含UDF、存储函数、用户自定义变量、临时表、mysql库中系统表、或者包含列级权限的表、有着不确定值的函数(Now()); 查询缓存是完全存储在内存中的,对整个内存空间分配回收等,会额外产生系统资源消耗,这会导致内存碎片的产生。

三、查看查询缓存的参数

MariaDB[(none)]>showglobalvariableslike'%query%'; +------------------------------+--------------------+ |Variable_name |Value | +------------------------------+--------------------+ |expensive_subquery_limit |100 | |ft_query_expansion_limit |20 | |have_query_cache |YES | |long_query_time |10.000000 | |query_alloc_block_size |16384 | |query_cache_limit |1048576 | |query_cache_min_res_unit |4096 | |query_cache_size |16777216 | |query_cache_strip_comments |OFF | |query_cache_type |ON | |query_cache_wlock_invalidate|OFF | |query_prealloc_size |24576 | |slow_query_log |OFF | |slow_query_log_file |localhost-slow.log| +------------------------------+--------------------+ 14rowsinset(0.01sec)

查询缓存相关变量说明

query_cache_min_res_unit: 查询缓存中内存块的最小分配单位;较小值会减少浪费,但会导致更频繁的内存分配操作;较大值会带来浪费,会导致碎片过多;

query_cache_limit:能够缓存的最大查询结果;对于有着较大结果的查询语句,建议在SELECT中使用SQL_NO_CACHE

query_cache_size:查询缓存总共可用的内存空间;单位是字节,必须是1024的整数倍;

query_cache_type: ON, OFF, DEMAND

a、0(OFF):关闭 Query Cache 功能,任何情况下都不会使用 Query Cache;

b、1(ON):开启 Query Cache 功能,但是当SELECT语句中使用SQL_NO_CACHE提示后,将不使用Query Cache;

c、2(DEMAND):开启Query Cache 功能,但是只有当SELECT语句中使用了SQL_CACHE 提示后,才使用Query Cache。

query_cache_wlock_invalidate:如果某表被其它的连接锁定,是否仍然可以从查询缓存中返回结果;默认值为OFF,表示可以在表被其它连接锁定的场景中继续从缓存返回数据;ON则表示不允许;

MariaDB[(none)]>showglobalstatuslike'Qcache%'; +-------------------------+----------+ |Variable_name |Value | +-------------------------+----------+ |Qcache_free_blocks |1 | |Qcache_free_memory |16759656| |Qcache_hits |0 | |Qcache_inserts |0 | |Qcache_lowmem_prunes |0 | |Qcache_not_cached |7 | |Qcache_queries_in_cache|0 | |Qcache_total_blocks |1 | +-------------------------+----------+ 8rowsinset(0.00sec)

查看缓存变量参数说明:

Qcache_free_blocks: 缓存池中空闲块的个数,空闲的内存块。

Qcache_free_memory: 缓存中空闲内存空间

Qcache_hits: 缓存命中次数

Qcache_inserts: 可缓存查询语句的结果被放入缓存的次数

Qcache_lowmen_prunes: 有多少次是因为查询缓存内存空间太少而使用LRU算法清理缓存的次数

Qcache_not_cached: 可缓存却未能缓存的结果,例如查询结果超出缓存块大小,查询中包含可变函数等

Qcache_queries_in_cache: 当前缓存中缓存的SQL数量

Qcache_total_blocks: 整个查询缓存有多少内存块

缓存命中率:Qcache_hits/(Qcache_hits+Com_select)

四、分析和配置查询缓存流程及提高缓存命中率

①.开始,如果查询缓存命中率是否可以接受?如果可以的话,就结束。

②.不能接受目前的缓存命中率,查看大部分查询不是可缓存?是的话,就是大部分查询都不能缓存,query_cache_limit足够大吗?如果是,就结束,说明查询不能缓存,有可能是用户自定义变量、存储函数等,这种情况,建议关闭查询缓存。如果不是足够大,则需要增加此值。

③.1.大部分查询缓存都是可以缓存,但是却没有被缓存。是否发生很多严重工作?

是的话,查看缓存是不是被碎片化。需要降低query_cache_min_res_unit的值或是否flush query cache命令来整理缓存,减少碎片。

③.2.如果缓存不是因为碎片太多导致没有被缓存,内存过低发生的修正工作?

④.1.如果是内存过低,则增加query_cache_size。

④.2.如果不是内存过低,是否有很多的更新语句?频繁的更新表导致的缓存不能被命中,是有很多频繁更新的语句,负载不适合缓存,建议关闭缓存。不是有很多频繁更新的语句,则有其他配置的问题。

⑤.如果不是发生了很多验证工作,缓存启动了?是,没有见过此查询。否的话,启动缓存。

linux

一、查询缓存说明

MySQL Query Cache是用来缓存我们所执行的SELECT语句以及该语句的结果集,MySql在实现Query Cache的具体技术细节上类似典型的KV存储,就是将SELECT语句和该查询语句的结果集做了一个HASH映射并保存在一定的内存区域中。当客户端发起SQL查询时,Query Cache的查找逻辑是,先对SQL进行相应的权限验证,接着就通过Query Cache来查找结果(注意必须是完全相同,即使多一个空格或者大小写不 同都认为不同,即使完全相同的SQL,如果使用不同的字符集、不同的协议等也会被认为是不同的查询而分别进行缓存)。它不需要经过Optimizer模块进行执行计划的分析优化,更不需要发生同任何存储引擎的交互,减少了大量的磁盘IO和CPU运 算,所以有时候效率非常高。

二、查询缓存命中

判断一个缓存是否被命中,通过查询语句的HASH值来判断,HASH值因素包括查询语句、查询数据库、客户端版本协议等,如查询语句任何字符的不同,都会导致HASH结果的不同,都可能导致缓存无法命中。有些查询不能被缓存,如查询中包含UDF、存储函数、用户自定义变量、临时表、mysql库中系统表、或者包含列级权限的表、有着不确定值的函数(Now()); 查询缓存是完全存储在内存中的,对整个内存空间分配回收等,会额外产生系统资源消耗,这会导致内存碎片的产生。

三、查看查询缓存的参数

MariaDB[(none)]>showglobalvariableslike'%query%'; +------------------------------+--------------------+ |Variable_name |Value | +------------------------------+--------------------+ |expensive_subquery_limit |100 | |ft_query_expansion_limit |20 | |have_query_cache |YES | |long_query_time |10.000000 | |query_alloc_block_size |16384 | |query_cache_limit |1048576 | |query_cache_min_res_unit |4096 | |query_cache_size |16777216 | |query_cache_strip_comments |OFF | |query_cache_type |ON | |query_cache_wlock_invalidate|OFF | |query_prealloc_size |24576 | |slow_query_log |OFF | |slow_query_log_file |localhost-slow.log| +------------------------------+--------------------+ 14rowsinset(0.01sec)

查询缓存相关变量说明

query_cache_min_res_unit: 查询缓存中内存块的最小分配单位;较小值会减少浪费,但会导致更频繁的内存分配操作;较大值会带来浪费,会导致碎片过多;

query_cache_limit:能够缓存的最大查询结果;对于有着较大结果的查询语句,建议在SELECT中使用SQL_NO_CACHE

query_cache_size:查询缓存总共可用的内存空间;单位是字节,必须是1024的整数倍;

query_cache_type: ON, OFF, DEMAND

a、0(OFF):关闭 Query Cache 功能,任何情况下都不会使用 Query Cache;

b、1(ON):开启 Query Cache 功能,但是当SELECT语句中使用SQL_NO_CACHE提示后,将不使用Query Cache;

c、2(DEMAND):开启Query Cache 功能,但是只有当SELECT语句中使用了SQL_CACHE 提示后,才使用Query Cache。

query_cache_wlock_invalidate:如果某表被其它的连接锁定,是否仍然可以从查询缓存中返回结果;默认值为OFF,表示可以在表被其它连接锁定的场景中继续从缓存返回数据;ON则表示不允许;

MariaDB[(none)]>showglobalstatuslike'Qcache%'; +-------------------------+----------+ |Variable_name |Value | +-------------------------+----------+ |Qcache_free_blocks |1 | |Qcache_free_memory |16759656| |Qcache_hits |0 | |Qcache_inserts |0 | |Qcache_lowmem_prunes |0 | |Qcache_not_cached |7 | |Qcache_queries_in_cache|0 | |Qcache_total_blocks |1 | +-------------------------+----------+ 8rowsinset(0.00sec)

查看缓存变量参数说明:

Qcache_free_blocks: 缓存池中空闲块的个数,空闲的内存块。

Qcache_free_memory: 缓存中空闲内存空间

Qcache_hits: 缓存命中次数

Qcache_inserts: 可缓存查询语句的结果被放入缓存的次数

Qcache_lowmen_prunes: 有多少次是因为查询缓存内存空间太少而使用LRU算法清理缓存的次数

Qcache_not_cached: 可缓存却未能缓存的结果,例如查询结果超出缓存块大小,查询中包含可变函数等

Qcache_queries_in_cache: 当前缓存中缓存的SQL数量

Qcache_total_blocks: 整个查询缓存有多少内存块

缓存命中率:Qcache_hits/(Qcache_hits+Com_select)

四、分析和配置查询缓存流程及提高缓存命中率

①.开始,如果查询缓存命中率是否可以接受?如果可以的话,就结束。

②.不能接受目前的缓存命中率,查看大部分查询不是可缓存?是的话,就是大部分查询都不能缓存,query_cache_limit足够大吗?如果是,就结束,说明查询不能缓存,有可能是用户自定义变量、存储函数等,这种情况,建议关闭查询缓存。如果不是足够大,则需要增加此值。

③.1.大部分查询缓存都是可以缓存,但是却没有被缓存。是否发生很多严重工作?

是的话,查看缓存是不是被碎片化。需要降低query_cache_min_res_unit的值或是否flush query cache命令来整理缓存,减少碎片。

③.2.如果缓存不是因为碎片太多导致没有被缓存,内存过低发生的修正工作?

④.1.如果是内存过低,则增加query_cache_size。

④.2.如果不是内存过低,是否有很多的更新语句?频繁的更新表导致的缓存不能被命中,是有很多频繁更新的语句,负载不适合缓存,建议关闭缓存。不是有很多频繁更新的语句,则有其他配置的问题。

⑤.如果不是发生了很多验证工作,缓存启动了?是,没有见过此查询。否的话,启动缓存。

linuxMySQL查询缓存MySQL查询缓存MySQL查询缓存

一、查询缓存说明

MySQL Query Cache是用来缓存我们所执行的SELECT语句以及该语句的结果集,MySql在实现Query Cache的具体技术细节上类似典型的KV存储,就是将SELECT语句和该查询语句的结果集做了一个HASH映射并保存在一定的内存区域中。当客户端发起SQL查询时,Query Cache的查找逻辑是,先对SQL进行相应的权限验证,接着就通过Query Cache来查找结果(注意必须是完全相同,即使多一个空格或者大小写不 同都认为不同,即使完全相同的SQL,如果使用不同的字符集、不同的协议等也会被认为是不同的查询而分别进行缓存)。它不需要经过Optimizer模块进行执行计划的分析优化,更不需要发生同任何存储引擎的交互,减少了大量的磁盘IO和CPU运 算,所以有时候效率非常高。

二、查询缓存命中

判断一个缓存是否被命中,通过查询语句的HASH值来判断,HASH值因素包括查询语句、查询数据库、客户端版本协议等,如查询语句任何字符的不同,都会导致HASH结果的不同,都可能导致缓存无法命中。有些查询不能被缓存,如查询中包含UDF、存储函数、用户自定义变量、临时表、mysql库中系统表、或者包含列级权限的表、有着不确定值的函数(Now()); 查询缓存是完全存储在内存中的,对整个内存空间分配回收等,会额外产生系统资源消耗,这会导致内存碎片的产生。

三、查看查询缓存的参数

MariaDB[(none)]>showglobalvariableslike'%query%'; +------------------------------+--------------------+ |Variable_name |Value | +------------------------------+--------------------+ |expensive_subquery_limit |100 | |ft_query_expansion_limit |20 | |have_query_cache |YES | |long_query_time |10.000000 | |query_alloc_block_size |16384 | |query_cache_limit |1048576 | |query_cache_min_res_unit |4096 | |query_cache_size |16777216 | |query_cache_strip_comments |OFF | |query_cache_type |ON | |query_cache_wlock_invalidate|OFF | |query_prealloc_size |24576 | |slow_query_log |OFF | |slow_query_log_file |localhost-slow.log| +------------------------------+--------------------+ 14rowsinset(0.01sec)

查询缓存相关变量说明

query_cache_min_res_unit: 查询缓存中内存块的最小分配单位;较小值会减少浪费,但会导致更频繁的内存分配操作;较大值会带来浪费,会导致碎片过多;

query_cache_limit:能够缓存的最大查询结果;对于有着较大结果的查询语句,建议在SELECT中使用SQL_NO_CACHE

query_cache_size:查询缓存总共可用的内存空间;单位是字节,必须是1024的整数倍;

query_cache_type: ON, OFF, DEMAND

a、0(OFF):关闭 Query Cache 功能,任何情况下都不会使用 Query Cache;

b、1(ON):开启 Query Cache 功能,但是当SELECT语句中使用SQL_NO_CACHE提示后,将不使用Query Cache;

c、2(DEMAND):开启Query Cache 功能,但是只有当SELECT语句中使用了SQL_CACHE 提示后,才使用Query Cache。

query_cache_wlock_invalidate:如果某表被其它的连接锁定,是否仍然可以从查询缓存中返回结果;默认值为OFF,表示可以在表被其它连接锁定的场景中继续从缓存返回数据;ON则表示不允许;

MariaDB[(none)]>showglobalstatuslike'Qcache%'; +-------------------------+----------+ |Variable_name |Value | +-------------------------+----------+ |Qcache_free_blocks |1 | |Qcache_free_memory |16759656| |Qcache_hits |0 | |Qcache_inserts |0 | |Qcache_lowmem_prunes |0 | |Qcache_not_cached |7 | |Qcache_queries_in_cache|0 | |Qcache_total_blocks |1 | +-------------------------+----------+ 8rowsinset(0.00sec)

查看缓存变量参数说明:

Qcache_free_blocks: 缓存池中空闲块的个数,空闲的内存块。

Qcache_free_memory: 缓存中空闲内存空间

Qcache_hits: 缓存命中次数

Qcache_inserts: 可缓存查询语句的结果被放入缓存的次数

Qcache_lowmen_prunes: 有多少次是因为查询缓存内存空间太少而使用LRU算法清理缓存的次数

Qcache_not_cached: 可缓存却未能缓存的结果,例如查询结果超出缓存块大小,查询中包含可变函数等

Qcache_queries_in_cache: 当前缓存中缓存的SQL数量

Qcache_total_blocks: 整个查询缓存有多少内存块

缓存命中率:Qcache_hits/(Qcache_hits+Com_select)

四、分析和配置查询缓存流程及提高缓存命中率

①.开始,如果查询缓存命中率是否可以接受?如果可以的话,就结束。

②.不能接受目前的缓存命中率,查看大部分查询不是可缓存?是的话,就是大部分查询都不能缓存,query_cache_limit足够大吗?如果是,就结束,说明查询不能缓存,有可能是用户自定义变量、存储函数等,这种情况,建议关闭查询缓存。如果不是足够大,则需要增加此值。

③.1.大部分查询缓存都是可以缓存,但是却没有被缓存。是否发生很多严重工作?

是的话,查看缓存是不是被碎片化。需要降低query_cache_min_res_unit的值或是否flush query cache命令来整理缓存,减少碎片。

③.2.如果缓存不是因为碎片太多导致没有被缓存,内存过低发生的修正工作?

④.1.如果是内存过低,则增加query_cache_size。

④.2.如果不是内存过低,是否有很多的更新语句?频繁的更新表导致的缓存不能被命中,是有很多频繁更新的语句,负载不适合缓存,建议关闭缓存。不是有很多频繁更新的语句,则有其他配置的问题。

⑤.如果不是发生了很多验证工作,缓存启动了?是,没有见过此查询。否的话,启动缓存。

linux

MySQL查询缓存

太阳城申博注册

一、查询缓存说明

MySQL Query Cache是用来缓存我们所执行的SELECT语句以及该语句的结果集,MySql在实现Query Cache的具体技术细节上类似典型的KV存储,就是将SELECT语句和该查询语句的结果集做了一个HASH映射并保存在一定的内存区域中。当客户端发起SQL查询时,Query Cache的查找逻辑是,先对SQL进行相应的权限验证,接着就通过Query Cache来查找结果(注意必须是完全相同,即使多一个空格或者大小写不 同都认为不同,即使完全相同的SQL,如果使用不同的字符集、不同的协议等也会被认为是不同的查询而分别进行缓存)。它不需要经过Optimizer模块进行执行计划的分析优化,更不需要发生同任何存储引擎的交互,减少了大量的磁盘IO和CPU运 算,所以有时候效率非常高。

二、查询缓存命中

判断一个缓存是否被命中,通过查询语句的HASH值来判断,HASH值因素包括查询语句、查询数据库、客户端版本协议等,如查询语句任何字符的不同,都会导致HASH结果的不同,都可能导致缓存无法命中。有些查询不能被缓存,如查询中包含UDF、存储函数、用户自定义变量、临时表、mysql库中系统表、或者包含列级权限的表、有着不确定值的函数(Now()); 查询缓存是完全存储在内存中的,对整个内存空间分配回收等,会额外产生系统资源消耗,这会导致内存碎片的产生。

三、查看查询缓存的参数

MariaDB[(none)]>showglobalvariableslike'%query%'; +------------------------------+--------------------+ |Variable_name |Value | +------------------------------+--------------------+ |expensive_subquery_limit |100 | |ft_query_expansion_limit |20 | |have_query_cache |YES | |long_query_time |10.000000 | |query_alloc_block_size |16384 | |query_cache_limit |1048576 | |query_cache_min_res_unit |4096 | |query_cache_size |16777216 | |query_cache_strip_comments |OFF | |query_cache_type |ON | |query_cache_wlock_invalidate|OFF | |query_prealloc_size |24576 | |slow_query_log |OFF | |slow_query_log_file |localhost-slow.log| +------------------------------+--------------------+ 14rowsinset(0.01sec)

查询缓存相关变量说明

query_cache_min_res_unit: 查询缓存中内存块的最小分配单位;较小值会减少浪费,但会导致更频繁的内存分配操作;较大值会带来浪费,会导致碎片过多;

query_cache_limit:能够缓存的最大查询结果;对于有着较大结果的查询语句,建议在SELECT中使用SQL_NO_CACHE

query_cache_size:查询缓存总共可用的内存空间;单位是字节,必须是1024的整数倍;

query_cache_type: ON, OFF, DEMAND

a、0(OFF):关闭 Query Cache 功能,任何情况下都不会使用 Query Cache;

b、1(ON):开启 Query Cache 功能,但是当SELECT语句中使用SQL_NO_CACHE提示后,将不使用Query Cache;

c、2(DEMAND):开启Query Cache 功能,但是只有当SELECT语句中使用了SQL_CACHE 提示后,才使用Query Cache。

query_cache_wlock_invalidate:如果某表被其它的连接锁定,是否仍然可以从查询缓存中返回结果;默认值为OFF,表示可以在表被其它连接锁定的场景中继续从缓存返回数据;ON则表示不允许;

MariaDB[(none)]>showglobalstatuslike'Qcache%'; +-------------------------+----------+ |Variable_name |Value | +-------------------------+----------+ |Qcache_free_blocks |1 | |Qcache_free_memory |16759656| |Qcache_hits |0 | |Qcache_inserts |0 | |Qcache_lowmem_prunes |0 | |Qcache_not_cached |7 | |Qcache_queries_in_cache|0 | |Qcache_total_blocks |1 | +-------------------------+----------+ 8rowsinset(0.00sec)

查看缓存变量参数说明:

Qcache_free_blocks: 缓存池中空闲块的个数,空闲的内存块。

Qcache_free_memory: 缓存中空闲内存空间

Qcache_hits: 缓存命中次数

Qcache_inserts: 可缓存查询语句的结果被放入缓存的次数

Qcache_lowmen_prunes: 有多少次是因为查询缓存内存空间太少而使用LRU算法清理缓存的次数

Qcache_not_cached: 可缓存却未能缓存的结果,例如查询结果超出缓存块大小,查询中包含可变函数等

Qcache_queries_in_cache: 当前缓存中缓存的SQL数量

Qcache_total_blocks: 整个查询缓存有多少内存块

缓存命中率:Qcache_hits/(Qcache_hits+Com_select)

四、分析和配置查询缓存流程及提高缓存命中率

①.开始,如果查询缓存命中率是否可以接受?如果可以的话,就结束。

②.不能接受目前的缓存命中率,查看大部分查询不是可缓存?是的话,就是大部分查询都不能缓存,query_cache_limit足够大吗?如果是,就结束,说明查询不能缓存,有可能是用户自定义变量、存储函数等,这种情况,建议关闭查询缓存。如果不是足够大,则需要增加此值。

③.1.大部分查询缓存都是可以缓存,但是却没有被缓存。是否发生很多严重工作?

是的话,查看缓存是不是被碎片化。需要降低query_cache_min_res_unit的值或是否flush query cache命令来整理缓存,减少碎片。

③.2.如果缓存不是因为碎片太多导致没有被缓存,内存过低发生的修正工作?

④.1.如果是内存过低,则增加query_cache_size。

④.2.如果不是内存过低,是否有很多的更新语句?频繁的更新表导致的缓存不能被命中,是有很多频繁更新的语句,负载不适合缓存,建议关闭缓存。不是有很多频繁更新的语句,则有其他配置的问题。

⑤.如果不是发生了很多验证工作,缓存启动了?是,没有见过此查询。否的话,启动缓存。

linux

一、查询缓存说明

MySQL Query Cache是用来缓存我们所执行的SELECT语句以及该语句的结果集,MySql在实现Query Cache的具体技术细节上类似典型的KV存储,就是将SELECT语句和该查询语句的结果集做了一个HASH映射并保存在一定的内存区域中。当客户端发起SQL查询时,Query Cache的查找逻辑是,先对SQL进行相应的权限验证,接着就通过Query Cache来查找结果(注意必须是完全相同,即使多一个空格或者大小写不 同都认为不同,即使完全相同的SQL,如果使用不同的字符集、不同的协议等也会被认为是不同的查询而分别进行缓存)。它不需要经过Optimizer模块进行执行计划的分析优化,更不需要发生同任何存储引擎的交互,减少了大量的磁盘IO和CPU运 算,所以有时候效率非常高。

二、查询缓存命中

判断一个缓存是否被命中,通过查询语句的HASH值来判断,HASH值因素包括查询语句、查询数据库、客户端版本协议等,如查询语句任何字符的不同,都会导致HASH结果的不同,都可能导致缓存无法命中。有些查询不能被缓存,如查询中包含UDF、存储函数、用户自定义变量、临时表、mysql库中系统表、或者包含列级权限的表、有着不确定值的函数(Now()); 查询缓存是完全存储在内存中的,对整个内存空间分配回收等,会额外产生系统资源消耗,这会导致内存碎片的产生。

三、查看查询缓存的参数

MariaDB[(none)]>showglobalvariableslike'%query%'; +------------------------------+--------------------+ |Variable_name |Value | +------------------------------+--------------------+ |expensive_subquery_limit |100 | |ft_query_expansion_limit |20 | |have_query_cache |YES | |long_query_time |10.000000 | |query_alloc_block_size |16384 | |query_cache_limit |1048576 | |query_cache_min_res_unit |4096 | |query_cache_size |16777216 | |query_cache_strip_comments |OFF | |query_cache_type |ON | |query_cache_wlock_invalidate|OFF | |query_prealloc_size |24576 | |slow_query_log |OFF | |slow_query_log_file |localhost-slow.log| +------------------------------+--------------------+ 14rowsinset(0.01sec)

查询缓存相关变量说明

query_cache_min_res_unit: 查询缓存中内存块的最小分配单位;较小值会减少浪费,但会导致更频繁的内存分配操作;较大值会带来浪费,会导致碎片过多;

query_cache_limit:能够缓存的最大查询结果;对于有着较大结果的查询语句,建议在SELECT中使用SQL_NO_CACHE

query_cache_size:查询缓存总共可用的内存空间;单位是字节,必须是1024的整数倍;

query_cache_type: ON, OFF, DEMAND

a、0(OFF):关闭 Query Cache 功能,任何情况下都不会使用 Query Cache;

b、1(ON):开启 Query Cache 功能,但是当SELECT语句中使用SQL_NO_CACHE提示后,将不使用Query Cache;

c、2(DEMAND):开启Query Cache 功能,但是只有当SELECT语句中使用了SQL_CACHE 提示后,才使用Query Cache。

query_cache_wlock_invalidate:如果某表被其它的连接锁定,是否仍然可以从查询缓存中返回结果;默认值为OFF,表示可以在表被其它连接锁定的场景中继续从缓存返回数据;ON则表示不允许;

MariaDB[(none)]>showglobalstatuslike'Qcache%'; +-------------------------+----------+ |Variable_name |Value | +-------------------------+----------+ |Qcache_free_blocks |1 | |Qcache_free_memory |16759656| |Qcache_hits |0 | |Qcache_inserts |0 | |Qcache_lowmem_prunes |0 | |Qcache_not_cached |7 | |Qcache_queries_in_cache|0 | |Qcache_total_blocks |1 | +-------------------------+----------+ 8rowsinset(0.00sec)

查看缓存变量参数说明:

Qcache_free_blocks: 缓存池中空闲块的个数,空闲的内存块。

Qcache_free_memory: 缓存中空闲内存空间

Qcache_hits: 缓存命中次数

Qcache_inserts: 可缓存查询语句的结果被放入缓存的次数

Qcache_lowmen_prunes: 有多少次是因为查询缓存内存空间太少而使用LRU算法清理缓存的次数

Qcache_not_cached: 可缓存却未能缓存的结果,例如查询结果超出缓存块大小,查询中包含可变函数等

Qcache_queries_in_cache: 当前缓存中缓存的SQL数量

Qcache_total_blocks: 整个查询缓存有多少内存块

缓存命中率:Qcache_hits/(Qcache_hits+Com_select)

四、分析和配置查询缓存流程及提高缓存命中率

①.开始,如果查询缓存命中率是否可以接受?如果可以的话,就结束。

②.不能接受目前的缓存命中率,查看大部分查询不是可缓存?是的话,就是大部分查询都不能缓存,query_cache_limit足够大吗?如果是,就结束,说明查询不能缓存,有可能是用户自定义变量、存储函数等,这种情况,建议关闭查询缓存。如果不是足够大,则需要增加此值。

③.1.大部分查询缓存都是可以缓存,但是却没有被缓存。是否发生很多严重工作?

是的话,查看缓存是不是被碎片化。需要降低query_cache_min_res_unit的值或是否flush query cache命令来整理缓存,减少碎片。

③.2.如果缓存不是因为碎片太多导致没有被缓存,内存过低发生的修正工作?

④.1.如果是内存过低,则增加query_cache_size。

④.2.如果不是内存过低,是否有很多的更新语句?频繁的更新表导致的缓存不能被命中,是有很多频繁更新的语句,负载不适合缓存,建议关闭缓存。不是有很多频繁更新的语句,则有其他配置的问题。

⑤.如果不是发生了很多验证工作,缓存启动了?是,没有见过此查询。否的话,启动缓存。

linux

一、查询缓存说明

MySQL Query Cache是用来缓存我们所执行的SELECT语句以及该语句的结果集,MySql在实现Query Cache的具体技术细节上类似典型的KV存储,就是将SELECT语句和该查询语句的结果集做了一个HASH映射并保存在一定的内存区域中。当客户端发起SQL查询时,Query Cache的查找逻辑是,先对SQL进行相应的权限验证,接着就通过Query Cache来查找结果(注意必须是完全相同,即使多一个空格或者大小写不 同都认为不同,即使完全相同的SQL,如果使用不同的字符集、不同的协议等也会被认为是不同的查询而分别进行缓存)。它不需要经过Optimizer模块进行执行计划的分析优化,更不需要发生同任何存储引擎的交互,减少了大量的磁盘IO和CPU运 算,所以有时候效率非常高。

二、查询缓存命中

判断一个缓存是否被命中,通过查询语句的HASH值来判断,HASH值因素包括查询语句、查询数据库、客户端版本协议等,如查询语句任何字符的不同,都会导致HASH结果的不同,都可能导致缓存无法命中。有些查询不能被缓存,如查询中包含UDF、存储函数、用户自定义变量、临时表、mysql库中系统表、或者包含列级权限的表、有着不确定值的函数(Now()); 查询缓存是完全存储在内存中的,对整个内存空间分配回收等,会额外产生系统资源消耗,这会导致内存碎片的产生。

三、查看查询缓存的参数

MariaDB[(none)]>showglobalvariableslike'%query%'; +------------------------------+--------------------+ |Variable_name |Value | +------------------------------+--------------------+ |expensive_subquery_limit |100 | |ft_query_expansion_limit |20 | |have_query_cache |YES | |long_query_time |10.000000 | |query_alloc_block_size |16384 | |query_cache_limit |1048576 | |query_cache_min_res_unit |4096 | |query_cache_size |16777216 | |query_cache_strip_comments |OFF | |query_cache_type |ON | |query_cache_wlock_invalidate|OFF | |query_prealloc_size |24576 | |slow_query_log |OFF | |slow_query_log_file |localhost-slow.log| +------------------------------+--------------------+ 14rowsinset(0.01sec)

查询缓存相关变量说明

query_cache_min_res_unit: 查询缓存中内存块的最小分配单位;较小值会减少浪费,但会导致更频繁的内存分配操作;较大值会带来浪费,会导致碎片过多;

query_cache_limit:能够缓存的最大查询结果;对于有着较大结果的查询语句,建议在SELECT中使用SQL_NO_CACHE

query_cache_size:查询缓存总共可用的内存空间;单位是字节,必须是1024的整数倍;

query_cache_type: ON, OFF, DEMAND

a、0(OFF):关闭 Query Cache 功能,任何情况下都不会使用 Query Cache;

b、1(ON):开启 Query Cache 功能,但是当SELECT语句中使用SQL_NO_CACHE提示后,将不使用Query Cache;

c、2(DEMAND):开启Query Cache 功能,但是只有当SELECT语句中使用了SQL_CACHE 提示后,才使用Query Cache。

query_cache_wlock_invalidate:如果某表被其它的连接锁定,是否仍然可以从查询缓存中返回结果;默认值为OFF,表示可以在表被其它连接锁定的场景中继续从缓存返回数据;ON则表示不允许;

MariaDB[(none)]>showglobalstatuslike'Qcache%'; +-------------------------+----------+ |Variable_name |Value | +-------------------------+----------+ |Qcache_free_blocks |1 | |Qcache_free_memory |16759656| |Qcache_hits |0 | |Qcache_inserts |0 | |Qcache_lowmem_prunes |0 | |Qcache_not_cached |7 | |Qcache_queries_in_cache|0 | |Qcache_total_blocks |1 | +-------------------------+----------+ 8rowsinset(0.00sec)

查看缓存变量参数说明:

Qcache_free_blocks: 缓存池中空闲块的个数,空闲的内存块。

Qcache_free_memory: 缓存中空闲内存空间

Qcache_hits: 缓存命中次数

Qcache_inserts: 可缓存查询语句的结果被放入缓存的次数

Qcache_lowmen_prunes: 有多少次是因为查询缓存内存空间太少而使用LRU算法清理缓存的次数

Qcache_not_cached: 可缓存却未能缓存的结果,例如查询结果超出缓存块大小,查询中包含可变函数等

Qcache_queries_in_cache: 当前缓存中缓存的SQL数量

Qcache_total_blocks: 整个查询缓存有多少内存块

缓存命中率:Qcache_hits/(Qcache_hits+Com_select)

四、分析和配置查询缓存流程及提高缓存命中率

①.开始,如果查询缓存命中率是否可以接受?如果可以的话,就结束。

②.不能接受目前的缓存命中率,查看大部分查询不是可缓存?是的话,就是大部分查询都不能缓存,query_cache_limit足够大吗?如果是,就结束,说明查询不能缓存,有可能是用户自定义变量、存储函数等,这种情况,建议关闭查询缓存。如果不是足够大,则需要增加此值。

③.1.大部分查询缓存都是可以缓存,但是却没有被缓存。是否发生很多严重工作?

是的话,查看缓存是不是被碎片化。需要降低query_cache_min_res_unit的值或是否flush query cache命令来整理缓存,减少碎片。

③.2.如果缓存不是因为碎片太多导致没有被缓存,内存过低发生的修正工作?

④.1.如果是内存过低,则增加query_cache_size。

④.2.如果不是内存过低,是否有很多的更新语句?频繁的更新表导致的缓存不能被命中,是有很多频繁更新的语句,负载不适合缓存,建议关闭缓存。不是有很多频繁更新的语句,则有其他配置的问题。

⑤.如果不是发生了很多验证工作,缓存启动了?是,没有见过此查询。否的话,启动缓存。

linuxMySQL查询缓存

一、查询缓存说明

MySQL Query Cache是用来缓存我们所执行的SELECT语句以及该语句的结果集,MySql在实现Query Cache的具体技术细节上类似典型的KV存储,就是将SELECT语句和该查询语句的结果集做了一个HASH映射并保存在一定的内存区域中。当客户端发起SQL查询时,Query Cache的查找逻辑是,先对SQL进行相应的权限验证,接着就通过Query Cache来查找结果(注意必须是完全相同,即使多一个空格或者大小写不 同都认为不同,即使完全相同的SQL,如果使用不同的字符集、不同的协议等也会被认为是不同的查询而分别进行缓存)。它不需要经过Optimizer模块进行执行计划的分析优化,更不需要发生同任何存储引擎的交互,减少了大量的磁盘IO和CPU运 算,所以有时候效率非常高。

二、查询缓存命中

判断一个缓存是否被命中,通过查询语句的HASH值来判断,HASH值因素包括查询语句、查询数据库、客户端版本协议等,如查询语句任何字符的不同,都会导致HASH结果的不同,都可能导致缓存无法命中。有些查询不能被缓存,如查询中包含UDF、存储函数、用户自定义变量、临时表、mysql库中系统表、或者包含列级权限的表、有着不确定值的函数(Now()); 查询缓存是完全存储在内存中的,对整个内存空间分配回收等,会额外产生系统资源消耗,这会导致内存碎片的产生。

三、查看查询缓存的参数

MariaDB[(none)]>showglobalvariableslike'%query%'; +------------------------------+--------------------+ |Variable_name |Value | +------------------------------+--------------------+ |expensive_subquery_limit |100 | |ft_query_expansion_limit |20 | |have_query_cache |YES | |long_query_time |10.000000 | |query_alloc_block_size |16384 | |query_cache_limit |1048576 | |query_cache_min_res_unit |4096 | |query_cache_size |16777216 | |query_cache_strip_comments |OFF | |query_cache_type |ON | |query_cache_wlock_invalidate|OFF | |query_prealloc_size |24576 | |slow_query_log |OFF | |slow_query_log_file |localhost-slow.log| +------------------------------+--------------------+ 14rowsinset(0.01sec)

查询缓存相关变量说明

query_cache_min_res_unit: 查询缓存中内存块的最小分配单位;较小值会减少浪费,但会导致更频繁的内存分配操作;较大值会带来浪费,会导致碎片过多;

query_cache_limit:能够缓存的最大查询结果;对于有着较大结果的查询语句,建议在SELECT中使用SQL_NO_CACHE

query_cache_size:查询缓存总共可用的内存空间;单位是字节,必须是1024的整数倍;

query_cache_type: ON, OFF, DEMAND

a、0(OFF):关闭 Query Cache 功能,任何情况下都不会使用 Query Cache;

b、1(ON):开启 Query Cache 功能,但是当SELECT语句中使用SQL_NO_CACHE提示后,将不使用Query Cache;

c、2(DEMAND):开启Query Cache 功能,但是只有当SELECT语句中使用了SQL_CACHE 提示后,才使用Query Cache。

query_cache_wlock_invalidate:如果某表被其它的连接锁定,是否仍然可以从查询缓存中返回结果;默认值为OFF,表示可以在表被其它连接锁定的场景中继续从缓存返回数据;ON则表示不允许;

MariaDB[(none)]>showglobalstatuslike'Qcache%'; +-------------------------+----------+ |Variable_name |Value | +-------------------------+----------+ |Qcache_free_blocks |1 | |Qcache_free_memory |16759656| |Qcache_hits |0 | |Qcache_inserts |0 | |Qcache_lowmem_prunes |0 | |Qcache_not_cached |7 | |Qcache_queries_in_cache|0 | |Qcache_total_blocks |1 | +-------------------------+----------+ 8rowsinset(0.00sec)

查看缓存变量参数说明:

Qcache_free_blocks: 缓存池中空闲块的个数,空闲的内存块。

Qcache_free_memory: 缓存中空闲内存空间

Qcache_hits: 缓存命中次数

Qcache_inserts: 可缓存查询语句的结果被放入缓存的次数

Qcache_lowmen_prunes: 有多少次是因为查询缓存内存空间太少而使用LRU算法清理缓存的次数

Qcache_not_cached: 可缓存却未能缓存的结果,例如查询结果超出缓存块大小,查询中包含可变函数等

Qcache_queries_in_cache: 当前缓存中缓存的SQL数量

Qcache_total_blocks: 整个查询缓存有多少内存块

缓存命中率:Qcache_hits/(Qcache_hits+Com_select)

四、分析和配置查询缓存流程及提高缓存命中率

①.开始,如果查询缓存命中率是否可以接受?如果可以的话,就结束。

②.不能接受目前的缓存命中率,查看大部分查询不是可缓存?是的话,就是大部分查询都不能缓存,query_cache_limit足够大吗?如果是,就结束,说明查询不能缓存,有可能是用户自定义变量、存储函数等,这种情况,建议关闭查询缓存。如果不是足够大,则需要增加此值。

③.1.大部分查询缓存都是可以缓存,但是却没有被缓存。是否发生很多严重工作?

是的话,查看缓存是不是被碎片化。需要降低query_cache_min_res_unit的值或是否flush query cache命令来整理缓存,减少碎片。

③.2.如果缓存不是因为碎片太多导致没有被缓存,内存过低发生的修正工作?

④.1.如果是内存过低,则增加query_cache_size。

④.2.如果不是内存过低,是否有很多的更新语句?频繁的更新表导致的缓存不能被命中,是有很多频繁更新的语句,负载不适合缓存,建议关闭缓存。不是有很多频繁更新的语句,则有其他配置的问题。

⑤.如果不是发生了很多验证工作,缓存启动了?是,没有见过此查询。否的话,启动缓存。

linuxMySQL查询缓存MySQL查询缓存MySQL查询缓存MySQL查询缓存MySQL查询缓存。

MySQL查询缓存

1.MySQL查询缓存

MySQL查询缓存MySQL查询缓存

一、查询缓存说明

MySQL Query Cache是用来缓存我们所执行的SELECT语句以及该语句的结果集,MySql在实现Query Cache的具体技术细节上类似典型的KV存储,就是将SELECT语句和该查询语句的结果集做了一个HASH映射并保存在一定的内存区域中。当客户端发起SQL查询时,Query Cache的查找逻辑是,先对SQL进行相应的权限验证,接着就通过Query Cache来查找结果(注意必须是完全相同,即使多一个空格或者大小写不 同都认为不同,即使完全相同的SQL,如果使用不同的字符集、不同的协议等也会被认为是不同的查询而分别进行缓存)。它不需要经过Optimizer模块进行执行计划的分析优化,更不需要发生同任何存储引擎的交互,减少了大量的磁盘IO和CPU运 算,所以有时候效率非常高。

二、查询缓存命中

判断一个缓存是否被命中,通过查询语句的HASH值来判断,HASH值因素包括查询语句、查询数据库、客户端版本协议等,如查询语句任何字符的不同,都会导致HASH结果的不同,都可能导致缓存无法命中。有些查询不能被缓存,如查询中包含UDF、存储函数、用户自定义变量、临时表、mysql库中系统表、或者包含列级权限的表、有着不确定值的函数(Now()); 查询缓存是完全存储在内存中的,对整个内存空间分配回收等,会额外产生系统资源消耗,这会导致内存碎片的产生。

三、查看查询缓存的参数

MariaDB[(none)]>showglobalvariableslike'%query%'; +------------------------------+--------------------+ |Variable_name |Value | +------------------------------+--------------------+ |expensive_subquery_limit |100 | |ft_query_expansion_limit |20 | |have_query_cache |YES | |long_query_time |10.000000 | |query_alloc_block_size |16384 | |query_cache_limit |1048576 | |query_cache_min_res_unit |4096 | |query_cache_size |16777216 | |query_cache_strip_comments |OFF | |query_cache_type |ON | |query_cache_wlock_invalidate|OFF | |query_prealloc_size |24576 | |slow_query_log |OFF | |slow_query_log_file |localhost-slow.log| +------------------------------+--------------------+ 14rowsinset(0.01sec)

查询缓存相关变量说明

query_cache_min_res_unit: 查询缓存中内存块的最小分配单位;较小值会减少浪费,但会导致更频繁的内存分配操作;较大值会带来浪费,会导致碎片过多;

query_cache_limit:能够缓存的最大查询结果;对于有着较大结果的查询语句,建议在SELECT中使用SQL_NO_CACHE

query_cache_size:查询缓存总共可用的内存空间;单位是字节,必须是1024的整数倍;

query_cache_type: ON, OFF, DEMAND

a、0(OFF):关闭 Query Cache 功能,任何情况下都不会使用 Query Cache;

b、1(ON):开启 Query Cache 功能,但是当SELECT语句中使用SQL_NO_CACHE提示后,将不使用Query Cache;

c、2(DEMAND):开启Query Cache 功能,但是只有当SELECT语句中使用了SQL_CACHE 提示后,才使用Query Cache。

query_cache_wlock_invalidate:如果某表被其它的连接锁定,是否仍然可以从查询缓存中返回结果;默认值为OFF,表示可以在表被其它连接锁定的场景中继续从缓存返回数据;ON则表示不允许;

MariaDB[(none)]>showglobalstatuslike'Qcache%'; +-------------------------+----------+ |Variable_name |Value | +-------------------------+----------+ |Qcache_free_blocks |1 | |Qcache_free_memory |16759656| |Qcache_hits |0 | |Qcache_inserts |0 | |Qcache_lowmem_prunes |0 | |Qcache_not_cached |7 | |Qcache_queries_in_cache|0 | |Qcache_total_blocks |1 | +-------------------------+----------+ 8rowsinset(0.00sec)

查看缓存变量参数说明:

Qcache_free_blocks: 缓存池中空闲块的个数,空闲的内存块。

Qcache_free_memory: 缓存中空闲内存空间

Qcache_hits: 缓存命中次数

Qcache_inserts: 可缓存查询语句的结果被放入缓存的次数

Qcache_lowmen_prunes: 有多少次是因为查询缓存内存空间太少而使用LRU算法清理缓存的次数

Qcache_not_cached: 可缓存却未能缓存的结果,例如查询结果超出缓存块大小,查询中包含可变函数等

Qcache_queries_in_cache: 当前缓存中缓存的SQL数量

Qcache_total_blocks: 整个查询缓存有多少内存块

缓存命中率:Qcache_hits/(Qcache_hits+Com_select)

四、分析和配置查询缓存流程及提高缓存命中率

①.开始,如果查询缓存命中率是否可以接受?如果可以的话,就结束。

②.不能接受目前的缓存命中率,查看大部分查询不是可缓存?是的话,就是大部分查询都不能缓存,query_cache_limit足够大吗?如果是,就结束,说明查询不能缓存,有可能是用户自定义变量、存储函数等,这种情况,建议关闭查询缓存。如果不是足够大,则需要增加此值。

③.1.大部分查询缓存都是可以缓存,但是却没有被缓存。是否发生很多严重工作?

是的话,查看缓存是不是被碎片化。需要降低query_cache_min_res_unit的值或是否flush query cache命令来整理缓存,减少碎片。

③.2.如果缓存不是因为碎片太多导致没有被缓存,内存过低发生的修正工作?

④.1.如果是内存过低,则增加query_cache_size。

④.2.如果不是内存过低,是否有很多的更新语句?频繁的更新表导致的缓存不能被命中,是有很多频繁更新的语句,负载不适合缓存,建议关闭缓存。不是有很多频繁更新的语句,则有其他配置的问题。

⑤.如果不是发生了很多验证工作,缓存启动了?是,没有见过此查询。否的话,启动缓存。

linuxMySQL查询缓存

一、查询缓存说明

MySQL Query Cache是用来缓存我们所执行的SELECT语句以及该语句的结果集,MySql在实现Query Cache的具体技术细节上类似典型的KV存储,就是将SELECT语句和该查询语句的结果集做了一个HASH映射并保存在一定的内存区域中。当客户端发起SQL查询时,Query Cache的查找逻辑是,先对SQL进行相应的权限验证,接着就通过Query Cache来查找结果(注意必须是完全相同,即使多一个空格或者大小写不 同都认为不同,即使完全相同的SQL,如果使用不同的字符集、不同的协议等也会被认为是不同的查询而分别进行缓存)。它不需要经过Optimizer模块进行执行计划的分析优化,更不需要发生同任何存储引擎的交互,减少了大量的磁盘IO和CPU运 算,所以有时候效率非常高。

二、查询缓存命中

判断一个缓存是否被命中,通过查询语句的HASH值来判断,HASH值因素包括查询语句、查询数据库、客户端版本协议等,如查询语句任何字符的不同,都会导致HASH结果的不同,都可能导致缓存无法命中。有些查询不能被缓存,如查询中包含UDF、存储函数、用户自定义变量、临时表、mysql库中系统表、或者包含列级权限的表、有着不确定值的函数(Now()); 查询缓存是完全存储在内存中的,对整个内存空间分配回收等,会额外产生系统资源消耗,这会导致内存碎片的产生。

三、查看查询缓存的参数

MariaDB[(none)]>showglobalvariableslike'%query%'; +------------------------------+--------------------+ |Variable_name |Value | +------------------------------+--------------------+ |expensive_subquery_limit |100 | |ft_query_expansion_limit |20 | |have_query_cache |YES | |long_query_time |10.000000 | |query_alloc_block_size |16384 | |query_cache_limit |1048576 | |query_cache_min_res_unit |4096 | |query_cache_size |16777216 | |query_cache_strip_comments |OFF | |query_cache_type |ON | |query_cache_wlock_invalidate|OFF | |query_prealloc_size |24576 | |slow_query_log |OFF | |slow_query_log_file |localhost-slow.log| +------------------------------+--------------------+ 14rowsinset(0.01sec)

查询缓存相关变量说明

query_cache_min_res_unit: 查询缓存中内存块的最小分配单位;较小值会减少浪费,但会导致更频繁的内存分配操作;较大值会带来浪费,会导致碎片过多;

query_cache_limit:能够缓存的最大查询结果;对于有着较大结果的查询语句,建议在SELECT中使用SQL_NO_CACHE

query_cache_size:查询缓存总共可用的内存空间;单位是字节,必须是1024的整数倍;

query_cache_type: ON, OFF, DEMAND

a、0(OFF):关闭 Query Cache 功能,任何情况下都不会使用 Query Cache;

b、1(ON):开启 Query Cache 功能,但是当SELECT语句中使用SQL_NO_CACHE提示后,将不使用Query Cache;

c、2(DEMAND):开启Query Cache 功能,但是只有当SELECT语句中使用了SQL_CACHE 提示后,才使用Query Cache。

query_cache_wlock_invalidate:如果某表被其它的连接锁定,是否仍然可以从查询缓存中返回结果;默认值为OFF,表示可以在表被其它连接锁定的场景中继续从缓存返回数据;ON则表示不允许;

MariaDB[(none)]>showglobalstatuslike'Qcache%'; +-------------------------+----------+ |Variable_name |Value | +-------------------------+----------+ |Qcache_free_blocks |1 | |Qcache_free_memory |16759656| |Qcache_hits |0 | |Qcache_inserts |0 | |Qcache_lowmem_prunes |0 | |Qcache_not_cached |7 | |Qcache_queries_in_cache|0 | |Qcache_total_blocks |1 | +-------------------------+----------+ 8rowsinset(0.00sec)

查看缓存变量参数说明:

Qcache_free_blocks: 缓存池中空闲块的个数,空闲的内存块。

Qcache_free_memory: 缓存中空闲内存空间

Qcache_hits: 缓存命中次数

Qcache_inserts: 可缓存查询语句的结果被放入缓存的次数

Qcache_lowmen_prunes: 有多少次是因为查询缓存内存空间太少而使用LRU算法清理缓存的次数

Qcache_not_cached: 可缓存却未能缓存的结果,例如查询结果超出缓存块大小,查询中包含可变函数等

Qcache_queries_in_cache: 当前缓存中缓存的SQL数量

Qcache_total_blocks: 整个查询缓存有多少内存块

缓存命中率:Qcache_hits/(Qcache_hits+Com_select)

四、分析和配置查询缓存流程及提高缓存命中率

①.开始,如果查询缓存命中率是否可以接受?如果可以的话,就结束。

②.不能接受目前的缓存命中率,查看大部分查询不是可缓存?是的话,就是大部分查询都不能缓存,query_cache_limit足够大吗?如果是,就结束,说明查询不能缓存,有可能是用户自定义变量、存储函数等,这种情况,建议关闭查询缓存。如果不是足够大,则需要增加此值。

③.1.大部分查询缓存都是可以缓存,但是却没有被缓存。是否发生很多严重工作?

是的话,查看缓存是不是被碎片化。需要降低query_cache_min_res_unit的值或是否flush query cache命令来整理缓存,减少碎片。

③.2.如果缓存不是因为碎片太多导致没有被缓存,内存过低发生的修正工作?

④.1.如果是内存过低,则增加query_cache_size。

④.2.如果不是内存过低,是否有很多的更新语句?频繁的更新表导致的缓存不能被命中,是有很多频繁更新的语句,负载不适合缓存,建议关闭缓存。不是有很多频繁更新的语句,则有其他配置的问题。

⑤.如果不是发生了很多验证工作,缓存启动了?是,没有见过此查询。否的话,启动缓存。

linux

一、查询缓存说明

MySQL Query Cache是用来缓存我们所执行的SELECT语句以及该语句的结果集,MySql在实现Query Cache的具体技术细节上类似典型的KV存储,就是将SELECT语句和该查询语句的结果集做了一个HASH映射并保存在一定的内存区域中。当客户端发起SQL查询时,Query Cache的查找逻辑是,先对SQL进行相应的权限验证,接着就通过Query Cache来查找结果(注意必须是完全相同,即使多一个空格或者大小写不 同都认为不同,即使完全相同的SQL,如果使用不同的字符集、不同的协议等也会被认为是不同的查询而分别进行缓存)。它不需要经过Optimizer模块进行执行计划的分析优化,更不需要发生同任何存储引擎的交互,减少了大量的磁盘IO和CPU运 算,所以有时候效率非常高。

二、查询缓存命中

判断一个缓存是否被命中,通过查询语句的HASH值来判断,HASH值因素包括查询语句、查询数据库、客户端版本协议等,如查询语句任何字符的不同,都会导致HASH结果的不同,都可能导致缓存无法命中。有些查询不能被缓存,如查询中包含UDF、存储函数、用户自定义变量、临时表、mysql库中系统表、或者包含列级权限的表、有着不确定值的函数(Now()); 查询缓存是完全存储在内存中的,对整个内存空间分配回收等,会额外产生系统资源消耗,这会导致内存碎片的产生。

三、查看查询缓存的参数

MariaDB[(none)]>showglobalvariableslike'%query%'; +------------------------------+--------------------+ |Variable_name |Value | +------------------------------+--------------------+ |expensive_subquery_limit |100 | |ft_query_expansion_limit |20 | |have_query_cache |YES | |long_query_time |10.000000 | |query_alloc_block_size |16384 | |query_cache_limit |1048576 | |query_cache_min_res_unit |4096 | |query_cache_size |16777216 | |query_cache_strip_comments |OFF | |query_cache_type |ON | |query_cache_wlock_invalidate|OFF | |query_prealloc_size |24576 | |slow_query_log |OFF | |slow_query_log_file |localhost-slow.log| +------------------------------+--------------------+ 14rowsinset(0.01sec)

查询缓存相关变量说明

query_cache_min_res_unit: 查询缓存中内存块的最小分配单位;较小值会减少浪费,但会导致更频繁的内存分配操作;较大值会带来浪费,会导致碎片过多;

query_cache_limit:能够缓存的最大查询结果;对于有着较大结果的查询语句,建议在SELECT中使用SQL_NO_CACHE

query_cache_size:查询缓存总共可用的内存空间;单位是字节,必须是1024的整数倍;

query_cache_type: ON, OFF, DEMAND

a、0(OFF):关闭 Query Cache 功能,任何情况下都不会使用 Query Cache;

b、1(ON):开启 Query Cache 功能,但是当SELECT语句中使用SQL_NO_CACHE提示后,将不使用Query Cache;

c、2(DEMAND):开启Query Cache 功能,但是只有当SELECT语句中使用了SQL_CACHE 提示后,才使用Query Cache。

query_cache_wlock_invalidate:如果某表被其它的连接锁定,是否仍然可以从查询缓存中返回结果;默认值为OFF,表示可以在表被其它连接锁定的场景中继续从缓存返回数据;ON则表示不允许;

MariaDB[(none)]>showglobalstatuslike'Qcache%'; +-------------------------+----------+ |Variable_name |Value | +-------------------------+----------+ |Qcache_free_blocks |1 | |Qcache_free_memory |16759656| |Qcache_hits |0 | |Qcache_inserts |0 | |Qcache_lowmem_prunes |0 | |Qcache_not_cached |7 | |Qcache_queries_in_cache|0 | |Qcache_total_blocks |1 | +-------------------------+----------+ 8rowsinset(0.00sec)

查看缓存变量参数说明:

Qcache_free_blocks: 缓存池中空闲块的个数,空闲的内存块。

Qcache_free_memory: 缓存中空闲内存空间

Qcache_hits: 缓存命中次数

Qcache_inserts: 可缓存查询语句的结果被放入缓存的次数

Qcache_lowmen_prunes: 有多少次是因为查询缓存内存空间太少而使用LRU算法清理缓存的次数

Qcache_not_cached: 可缓存却未能缓存的结果,例如查询结果超出缓存块大小,查询中包含可变函数等

Qcache_queries_in_cache: 当前缓存中缓存的SQL数量

Qcache_total_blocks: 整个查询缓存有多少内存块

缓存命中率:Qcache_hits/(Qcache_hits+Com_select)

四、分析和配置查询缓存流程及提高缓存命中率

①.开始,如果查询缓存命中率是否可以接受?如果可以的话,就结束。

②.不能接受目前的缓存命中率,查看大部分查询不是可缓存?是的话,就是大部分查询都不能缓存,query_cache_limit足够大吗?如果是,就结束,说明查询不能缓存,有可能是用户自定义变量、存储函数等,这种情况,建议关闭查询缓存。如果不是足够大,则需要增加此值。

③.1.大部分查询缓存都是可以缓存,但是却没有被缓存。是否发生很多严重工作?

是的话,查看缓存是不是被碎片化。需要降低query_cache_min_res_unit的值或是否flush query cache命令来整理缓存,减少碎片。

③.2.如果缓存不是因为碎片太多导致没有被缓存,内存过低发生的修正工作?

④.1.如果是内存过低,则增加query_cache_size。

④.2.如果不是内存过低,是否有很多的更新语句?频繁的更新表导致的缓存不能被命中,是有很多频繁更新的语句,负载不适合缓存,建议关闭缓存。不是有很多频繁更新的语句,则有其他配置的问题。

⑤.如果不是发生了很多验证工作,缓存启动了?是,没有见过此查询。否的话,启动缓存。

linuxMySQL查询缓存MySQL查询缓存MySQL查询缓存

一、查询缓存说明

MySQL Query Cache是用来缓存我们所执行的SELECT语句以及该语句的结果集,MySql在实现Query Cache的具体技术细节上类似典型的KV存储,就是将SELECT语句和该查询语句的结果集做了一个HASH映射并保存在一定的内存区域中。当客户端发起SQL查询时,Query Cache的查找逻辑是,先对SQL进行相应的权限验证,接着就通过Query Cache来查找结果(注意必须是完全相同,即使多一个空格或者大小写不 同都认为不同,即使完全相同的SQL,如果使用不同的字符集、不同的协议等也会被认为是不同的查询而分别进行缓存)。它不需要经过Optimizer模块进行执行计划的分析优化,更不需要发生同任何存储引擎的交互,减少了大量的磁盘IO和CPU运 算,所以有时候效率非常高。

二、查询缓存命中

判断一个缓存是否被命中,通过查询语句的HASH值来判断,HASH值因素包括查询语句、查询数据库、客户端版本协议等,如查询语句任何字符的不同,都会导致HASH结果的不同,都可能导致缓存无法命中。有些查询不能被缓存,如查询中包含UDF、存储函数、用户自定义变量、临时表、mysql库中系统表、或者包含列级权限的表、有着不确定值的函数(Now()); 查询缓存是完全存储在内存中的,对整个内存空间分配回收等,会额外产生系统资源消耗,这会导致内存碎片的产生。

三、查看查询缓存的参数

MariaDB[(none)]>showglobalvariableslike'%query%'; +------------------------------+--------------------+ |Variable_name |Value | +------------------------------+--------------------+ |expensive_subquery_limit |100 | |ft_query_expansion_limit |20 | |have_query_cache |YES | |long_query_time |10.000000 | |query_alloc_block_size |16384 | |query_cache_limit |1048576 | |query_cache_min_res_unit |4096 | |query_cache_size |16777216 | |query_cache_strip_comments |OFF | |query_cache_type |ON | |query_cache_wlock_invalidate|OFF | |query_prealloc_size |24576 | |slow_query_log |OFF | |slow_query_log_file |localhost-slow.log| +------------------------------+--------------------+ 14rowsinset(0.01sec)

查询缓存相关变量说明

query_cache_min_res_unit: 查询缓存中内存块的最小分配单位;较小值会减少浪费,但会导致更频繁的内存分配操作;较大值会带来浪费,会导致碎片过多;

query_cache_limit:能够缓存的最大查询结果;对于有着较大结果的查询语句,建议在SELECT中使用SQL_NO_CACHE

query_cache_size:查询缓存总共可用的内存空间;单位是字节,必须是1024的整数倍;

query_cache_type: ON, OFF, DEMAND

a、0(OFF):关闭 Query Cache 功能,任何情况下都不会使用 Query Cache;

b、1(ON):开启 Query Cache 功能,但是当SELECT语句中使用SQL_NO_CACHE提示后,将不使用Query Cache;

c、2(DEMAND):开启Query Cache 功能,但是只有当SELECT语句中使用了SQL_CACHE 提示后,才使用Query Cache。

query_cache_wlock_invalidate:如果某表被其它的连接锁定,是否仍然可以从查询缓存中返回结果;默认值为OFF,表示可以在表被其它连接锁定的场景中继续从缓存返回数据;ON则表示不允许;

MariaDB[(none)]>showglobalstatuslike'Qcache%'; +-------------------------+----------+ |Variable_name |Value | +-------------------------+----------+ |Qcache_free_blocks |1 | |Qcache_free_memory |16759656| |Qcache_hits |0 | |Qcache_inserts |0 | |Qcache_lowmem_prunes |0 | |Qcache_not_cached |7 | |Qcache_queries_in_cache|0 | |Qcache_total_blocks |1 | +-------------------------+----------+ 8rowsinset(0.00sec)

查看缓存变量参数说明:

Qcache_free_blocks: 缓存池中空闲块的个数,空闲的内存块。

Qcache_free_memory: 缓存中空闲内存空间

Qcache_hits: 缓存命中次数

Qcache_inserts: 可缓存查询语句的结果被放入缓存的次数

Qcache_lowmen_prunes: 有多少次是因为查询缓存内存空间太少而使用LRU算法清理缓存的次数

Qcache_not_cached: 可缓存却未能缓存的结果,例如查询结果超出缓存块大小,查询中包含可变函数等

Qcache_queries_in_cache: 当前缓存中缓存的SQL数量

Qcache_total_blocks: 整个查询缓存有多少内存块

缓存命中率:Qcache_hits/(Qcache_hits+Com_select)

四、分析和配置查询缓存流程及提高缓存命中率

①.开始,如果查询缓存命中率是否可以接受?如果可以的话,就结束。

②.不能接受目前的缓存命中率,查看大部分查询不是可缓存?是的话,就是大部分查询都不能缓存,query_cache_limit足够大吗?如果是,就结束,说明查询不能缓存,有可能是用户自定义变量、存储函数等,这种情况,建议关闭查询缓存。如果不是足够大,则需要增加此值。

③.1.大部分查询缓存都是可以缓存,但是却没有被缓存。是否发生很多严重工作?

是的话,查看缓存是不是被碎片化。需要降低query_cache_min_res_unit的值或是否flush query cache命令来整理缓存,减少碎片。

③.2.如果缓存不是因为碎片太多导致没有被缓存,内存过低发生的修正工作?

④.1.如果是内存过低,则增加query_cache_size。

④.2.如果不是内存过低,是否有很多的更新语句?频繁的更新表导致的缓存不能被命中,是有很多频繁更新的语句,负载不适合缓存,建议关闭缓存。不是有很多频繁更新的语句,则有其他配置的问题。

⑤.如果不是发生了很多验证工作,缓存启动了?是,没有见过此查询。否的话,启动缓存。

linuxMySQL查询缓存MySQL查询缓存

一、查询缓存说明

MySQL Query Cache是用来缓存我们所执行的SELECT语句以及该语句的结果集,MySql在实现Query Cache的具体技术细节上类似典型的KV存储,就是将SELECT语句和该查询语句的结果集做了一个HASH映射并保存在一定的内存区域中。当客户端发起SQL查询时,Query Cache的查找逻辑是,先对SQL进行相应的权限验证,接着就通过Query Cache来查找结果(注意必须是完全相同,即使多一个空格或者大小写不 同都认为不同,即使完全相同的SQL,如果使用不同的字符集、不同的协议等也会被认为是不同的查询而分别进行缓存)。它不需要经过Optimizer模块进行执行计划的分析优化,更不需要发生同任何存储引擎的交互,减少了大量的磁盘IO和CPU运 算,所以有时候效率非常高。

二、查询缓存命中

判断一个缓存是否被命中,通过查询语句的HASH值来判断,HASH值因素包括查询语句、查询数据库、客户端版本协议等,如查询语句任何字符的不同,都会导致HASH结果的不同,都可能导致缓存无法命中。有些查询不能被缓存,如查询中包含UDF、存储函数、用户自定义变量、临时表、mysql库中系统表、或者包含列级权限的表、有着不确定值的函数(Now()); 查询缓存是完全存储在内存中的,对整个内存空间分配回收等,会额外产生系统资源消耗,这会导致内存碎片的产生。

三、查看查询缓存的参数

MariaDB[(none)]>showglobalvariableslike'%query%'; +------------------------------+--------------------+ |Variable_name |Value | +------------------------------+--------------------+ |expensive_subquery_limit |100 | |ft_query_expansion_limit |20 | |have_query_cache |YES | |long_query_time |10.000000 | |query_alloc_block_size |16384 | |query_cache_limit |1048576 | |query_cache_min_res_unit |4096 | |query_cache_size |16777216 | |query_cache_strip_comments |OFF | |query_cache_type |ON | |query_cache_wlock_invalidate|OFF | |query_prealloc_size |24576 | |slow_query_log |OFF | |slow_query_log_file |localhost-slow.log| +------------------------------+--------------------+ 14rowsinset(0.01sec)

查询缓存相关变量说明

query_cache_min_res_unit: 查询缓存中内存块的最小分配单位;较小值会减少浪费,但会导致更频繁的内存分配操作;较大值会带来浪费,会导致碎片过多;

query_cache_limit:能够缓存的最大查询结果;对于有着较大结果的查询语句,建议在SELECT中使用SQL_NO_CACHE

query_cache_size:查询缓存总共可用的内存空间;单位是字节,必须是1024的整数倍;

query_cache_type: ON, OFF, DEMAND

a、0(OFF):关闭 Query Cache 功能,任何情况下都不会使用 Query Cache;

b、1(ON):开启 Query Cache 功能,但是当SELECT语句中使用SQL_NO_CACHE提示后,将不使用Query Cache;

c、2(DEMAND):开启Query Cache 功能,但是只有当SELECT语句中使用了SQL_CACHE 提示后,才使用Query Cache。

query_cache_wlock_invalidate:如果某表被其它的连接锁定,是否仍然可以从查询缓存中返回结果;默认值为OFF,表示可以在表被其它连接锁定的场景中继续从缓存返回数据;ON则表示不允许;

MariaDB[(none)]>showglobalstatuslike'Qcache%'; +-------------------------+----------+ |Variable_name |Value | +-------------------------+----------+ |Qcache_free_blocks |1 | |Qcache_free_memory |16759656| |Qcache_hits |0 | |Qcache_inserts |0 | |Qcache_lowmem_prunes |0 | |Qcache_not_cached |7 | |Qcache_queries_in_cache|0 | |Qcache_total_blocks |1 | +-------------------------+----------+ 8rowsinset(0.00sec)

查看缓存变量参数说明:

Qcache_free_blocks: 缓存池中空闲块的个数,空闲的内存块。

Qcache_free_memory: 缓存中空闲内存空间

Qcache_hits: 缓存命中次数

Qcache_inserts: 可缓存查询语句的结果被放入缓存的次数

Qcache_lowmen_prunes: 有多少次是因为查询缓存内存空间太少而使用LRU算法清理缓存的次数

Qcache_not_cached: 可缓存却未能缓存的结果,例如查询结果超出缓存块大小,查询中包含可变函数等

Qcache_queries_in_cache: 当前缓存中缓存的SQL数量

Qcache_total_blocks: 整个查询缓存有多少内存块

缓存命中率:Qcache_hits/(Qcache_hits+Com_select)

四、分析和配置查询缓存流程及提高缓存命中率

①.开始,如果查询缓存命中率是否可以接受?如果可以的话,就结束。

②.不能接受目前的缓存命中率,查看大部分查询不是可缓存?是的话,就是大部分查询都不能缓存,query_cache_limit足够大吗?如果是,就结束,说明查询不能缓存,有可能是用户自定义变量、存储函数等,这种情况,建议关闭查询缓存。如果不是足够大,则需要增加此值。

③.1.大部分查询缓存都是可以缓存,但是却没有被缓存。是否发生很多严重工作?

是的话,查看缓存是不是被碎片化。需要降低query_cache_min_res_unit的值或是否flush query cache命令来整理缓存,减少碎片。

③.2.如果缓存不是因为碎片太多导致没有被缓存,内存过低发生的修正工作?

④.1.如果是内存过低,则增加query_cache_size。

④.2.如果不是内存过低,是否有很多的更新语句?频繁的更新表导致的缓存不能被命中,是有很多频繁更新的语句,负载不适合缓存,建议关闭缓存。不是有很多频繁更新的语句,则有其他配置的问题。

⑤.如果不是发生了很多验证工作,缓存启动了?是,没有见过此查询。否的话,启动缓存。

linux

一、查询缓存说明

MySQL Query Cache是用来缓存我们所执行的SELECT语句以及该语句的结果集,MySql在实现Query Cache的具体技术细节上类似典型的KV存储,就是将SELECT语句和该查询语句的结果集做了一个HASH映射并保存在一定的内存区域中。当客户端发起SQL查询时,Query Cache的查找逻辑是,先对SQL进行相应的权限验证,接着就通过Query Cache来查找结果(注意必须是完全相同,即使多一个空格或者大小写不 同都认为不同,即使完全相同的SQL,如果使用不同的字符集、不同的协议等也会被认为是不同的查询而分别进行缓存)。它不需要经过Optimizer模块进行执行计划的分析优化,更不需要发生同任何存储引擎的交互,减少了大量的磁盘IO和CPU运 算,所以有时候效率非常高。

二、查询缓存命中

判断一个缓存是否被命中,通过查询语句的HASH值来判断,HASH值因素包括查询语句、查询数据库、客户端版本协议等,如查询语句任何字符的不同,都会导致HASH结果的不同,都可能导致缓存无法命中。有些查询不能被缓存,如查询中包含UDF、存储函数、用户自定义变量、临时表、mysql库中系统表、或者包含列级权限的表、有着不确定值的函数(Now()); 查询缓存是完全存储在内存中的,对整个内存空间分配回收等,会额外产生系统资源消耗,这会导致内存碎片的产生。

三、查看查询缓存的参数

MariaDB[(none)]>showglobalvariableslike'%query%'; +------------------------------+--------------------+ |Variable_name |Value | +------------------------------+--------------------+ |expensive_subquery_limit |100 | |ft_query_expansion_limit |20 | |have_query_cache |YES | |long_query_time |10.000000 | |query_alloc_block_size |16384 | |query_cache_limit |1048576 | |query_cache_min_res_unit |4096 | |query_cache_size |16777216 | |query_cache_strip_comments |OFF | |query_cache_type |ON | |query_cache_wlock_invalidate|OFF | |query_prealloc_size |24576 | |slow_query_log |OFF | |slow_query_log_file |localhost-slow.log| +------------------------------+--------------------+ 14rowsinset(0.01sec)

查询缓存相关变量说明

query_cache_min_res_unit: 查询缓存中内存块的最小分配单位;较小值会减少浪费,但会导致更频繁的内存分配操作;较大值会带来浪费,会导致碎片过多;

query_cache_limit:能够缓存的最大查询结果;对于有着较大结果的查询语句,建议在SELECT中使用SQL_NO_CACHE

query_cache_size:查询缓存总共可用的内存空间;单位是字节,必须是1024的整数倍;

query_cache_type: ON, OFF, DEMAND

a、0(OFF):关闭 Query Cache 功能,任何情况下都不会使用 Query Cache;

b、1(ON):开启 Query Cache 功能,但是当SELECT语句中使用SQL_NO_CACHE提示后,将不使用Query Cache;

c、2(DEMAND):开启Query Cache 功能,但是只有当SELECT语句中使用了SQL_CACHE 提示后,才使用Query Cache。

query_cache_wlock_invalidate:如果某表被其它的连接锁定,是否仍然可以从查询缓存中返回结果;默认值为OFF,表示可以在表被其它连接锁定的场景中继续从缓存返回数据;ON则表示不允许;

MariaDB[(none)]>showglobalstatuslike'Qcache%'; +-------------------------+----------+ |Variable_name |Value | +-------------------------+----------+ |Qcache_free_blocks |1 | |Qcache_free_memory |16759656| |Qcache_hits |0 | |Qcache_inserts |0 | |Qcache_lowmem_prunes |0 | |Qcache_not_cached |7 | |Qcache_queries_in_cache|0 | |Qcache_total_blocks |1 | +-------------------------+----------+ 8rowsinset(0.00sec)

查看缓存变量参数说明:

Qcache_free_blocks: 缓存池中空闲块的个数,空闲的内存块。

Qcache_free_memory: 缓存中空闲内存空间

Qcache_hits: 缓存命中次数

Qcache_inserts: 可缓存查询语句的结果被放入缓存的次数

Qcache_lowmen_prunes: 有多少次是因为查询缓存内存空间太少而使用LRU算法清理缓存的次数

Qcache_not_cached: 可缓存却未能缓存的结果,例如查询结果超出缓存块大小,查询中包含可变函数等

Qcache_queries_in_cache: 当前缓存中缓存的SQL数量

Qcache_total_blocks: 整个查询缓存有多少内存块

缓存命中率:Qcache_hits/(Qcache_hits+Com_select)

四、分析和配置查询缓存流程及提高缓存命中率

①.开始,如果查询缓存命中率是否可以接受?如果可以的话,就结束。

②.不能接受目前的缓存命中率,查看大部分查询不是可缓存?是的话,就是大部分查询都不能缓存,query_cache_limit足够大吗?如果是,就结束,说明查询不能缓存,有可能是用户自定义变量、存储函数等,这种情况,建议关闭查询缓存。如果不是足够大,则需要增加此值。

③.1.大部分查询缓存都是可以缓存,但是却没有被缓存。是否发生很多严重工作?

是的话,查看缓存是不是被碎片化。需要降低query_cache_min_res_unit的值或是否flush query cache命令来整理缓存,减少碎片。

③.2.如果缓存不是因为碎片太多导致没有被缓存,内存过低发生的修正工作?

④.1.如果是内存过低,则增加query_cache_size。

④.2.如果不是内存过低,是否有很多的更新语句?频繁的更新表导致的缓存不能被命中,是有很多频繁更新的语句,负载不适合缓存,建议关闭缓存。不是有很多频繁更新的语句,则有其他配置的问题。

⑤.如果不是发生了很多验证工作,缓存启动了?是,没有见过此查询。否的话,启动缓存。

linux

一、查询缓存说明

MySQL Query Cache是用来缓存我们所执行的SELECT语句以及该语句的结果集,MySql在实现Query Cache的具体技术细节上类似典型的KV存储,就是将SELECT语句和该查询语句的结果集做了一个HASH映射并保存在一定的内存区域中。当客户端发起SQL查询时,Query Cache的查找逻辑是,先对SQL进行相应的权限验证,接着就通过Query Cache来查找结果(注意必须是完全相同,即使多一个空格或者大小写不 同都认为不同,即使完全相同的SQL,如果使用不同的字符集、不同的协议等也会被认为是不同的查询而分别进行缓存)。它不需要经过Optimizer模块进行执行计划的分析优化,更不需要发生同任何存储引擎的交互,减少了大量的磁盘IO和CPU运 算,所以有时候效率非常高。

二、查询缓存命中

判断一个缓存是否被命中,通过查询语句的HASH值来判断,HASH值因素包括查询语句、查询数据库、客户端版本协议等,如查询语句任何字符的不同,都会导致HASH结果的不同,都可能导致缓存无法命中。有些查询不能被缓存,如查询中包含UDF、存储函数、用户自定义变量、临时表、mysql库中系统表、或者包含列级权限的表、有着不确定值的函数(Now()); 查询缓存是完全存储在内存中的,对整个内存空间分配回收等,会额外产生系统资源消耗,这会导致内存碎片的产生。

三、查看查询缓存的参数

MariaDB[(none)]>showglobalvariableslike'%query%'; +------------------------------+--------------------+ |Variable_name |Value | +------------------------------+--------------------+ |expensive_subquery_limit |100 | |ft_query_expansion_limit |20 | |have_query_cache |YES | |long_query_time |10.000000 | |query_alloc_block_size |16384 | |query_cache_limit |1048576 | |query_cache_min_res_unit |4096 | |query_cache_size |16777216 | |query_cache_strip_comments |OFF | |query_cache_type |ON | |query_cache_wlock_invalidate|OFF | |query_prealloc_size |24576 | |slow_query_log |OFF | |slow_query_log_file |localhost-slow.log| +------------------------------+--------------------+ 14rowsinset(0.01sec)

查询缓存相关变量说明

query_cache_min_res_unit: 查询缓存中内存块的最小分配单位;较小值会减少浪费,但会导致更频繁的内存分配操作;较大值会带来浪费,会导致碎片过多;

query_cache_limit:能够缓存的最大查询结果;对于有着较大结果的查询语句,建议在SELECT中使用SQL_NO_CACHE

query_cache_size:查询缓存总共可用的内存空间;单位是字节,必须是1024的整数倍;

query_cache_type: ON, OFF, DEMAND

a、0(OFF):关闭 Query Cache 功能,任何情况下都不会使用 Query Cache;

b、1(ON):开启 Query Cache 功能,但是当SELECT语句中使用SQL_NO_CACHE提示后,将不使用Query Cache;

c、2(DEMAND):开启Query Cache 功能,但是只有当SELECT语句中使用了SQL_CACHE 提示后,才使用Query Cache。

query_cache_wlock_invalidate:如果某表被其它的连接锁定,是否仍然可以从查询缓存中返回结果;默认值为OFF,表示可以在表被其它连接锁定的场景中继续从缓存返回数据;ON则表示不允许;

MariaDB[(none)]>showglobalstatuslike'Qcache%'; +-------------------------+----------+ |Variable_name |Value | +-------------------------+----------+ |Qcache_free_blocks |1 | |Qcache_free_memory |16759656| |Qcache_hits |0 | |Qcache_inserts |0 | |Qcache_lowmem_prunes |0 | |Qcache_not_cached |7 | |Qcache_queries_in_cache|0 | |Qcache_total_blocks |1 | +-------------------------+----------+ 8rowsinset(0.00sec)

查看缓存变量参数说明:

Qcache_free_blocks: 缓存池中空闲块的个数,空闲的内存块。

Qcache_free_memory: 缓存中空闲内存空间

Qcache_hits: 缓存命中次数

Qcache_inserts: 可缓存查询语句的结果被放入缓存的次数

Qcache_lowmen_prunes: 有多少次是因为查询缓存内存空间太少而使用LRU算法清理缓存的次数

Qcache_not_cached: 可缓存却未能缓存的结果,例如查询结果超出缓存块大小,查询中包含可变函数等

Qcache_queries_in_cache: 当前缓存中缓存的SQL数量

Qcache_total_blocks: 整个查询缓存有多少内存块

缓存命中率:Qcache_hits/(Qcache_hits+Com_select)

四、分析和配置查询缓存流程及提高缓存命中率

①.开始,如果查询缓存命中率是否可以接受?如果可以的话,就结束。

②.不能接受目前的缓存命中率,查看大部分查询不是可缓存?是的话,就是大部分查询都不能缓存,query_cache_limit足够大吗?如果是,就结束,说明查询不能缓存,有可能是用户自定义变量、存储函数等,这种情况,建议关闭查询缓存。如果不是足够大,则需要增加此值。

③.1.大部分查询缓存都是可以缓存,但是却没有被缓存。是否发生很多严重工作?

是的话,查看缓存是不是被碎片化。需要降低query_cache_min_res_unit的值或是否flush query cache命令来整理缓存,减少碎片。

③.2.如果缓存不是因为碎片太多导致没有被缓存,内存过低发生的修正工作?

④.1.如果是内存过低,则增加query_cache_size。

④.2.如果不是内存过低,是否有很多的更新语句?频繁的更新表导致的缓存不能被命中,是有很多频繁更新的语句,负载不适合缓存,建议关闭缓存。不是有很多频繁更新的语句,则有其他配置的问题。

⑤.如果不是发生了很多验证工作,缓存启动了?是,没有见过此查询。否的话,启动缓存。

linux

2.

一、查询缓存说明

MySQL Query Cache是用来缓存我们所执行的SELECT语句以及该语句的结果集,MySql在实现Query Cache的具体技术细节上类似典型的KV存储,就是将SELECT语句和该查询语句的结果集做了一个HASH映射并保存在一定的内存区域中。当客户端发起SQL查询时,Query Cache的查找逻辑是,先对SQL进行相应的权限验证,接着就通过Query Cache来查找结果(注意必须是完全相同,即使多一个空格或者大小写不 同都认为不同,即使完全相同的SQL,如果使用不同的字符集、不同的协议等也会被认为是不同的查询而分别进行缓存)。它不需要经过Optimizer模块进行执行计划的分析优化,更不需要发生同任何存储引擎的交互,减少了大量的磁盘IO和CPU运 算,所以有时候效率非常高。

二、查询缓存命中

判断一个缓存是否被命中,通过查询语句的HASH值来判断,HASH值因素包括查询语句、查询数据库、客户端版本协议等,如查询语句任何字符的不同,都会导致HASH结果的不同,都可能导致缓存无法命中。有些查询不能被缓存,如查询中包含UDF、存储函数、用户自定义变量、临时表、mysql库中系统表、或者包含列级权限的表、有着不确定值的函数(Now()); 查询缓存是完全存储在内存中的,对整个内存空间分配回收等,会额外产生系统资源消耗,这会导致内存碎片的产生。

三、查看查询缓存的参数

MariaDB[(none)]>showglobalvariableslike'%query%'; +------------------------------+--------------------+ |Variable_name |Value | +------------------------------+--------------------+ |expensive_subquery_limit |100 | |ft_query_expansion_limit |20 | |have_query_cache |YES | |long_query_time |10.000000 | |query_alloc_block_size |16384 | |query_cache_limit |1048576 | |query_cache_min_res_unit |4096 | |query_cache_size |16777216 | |query_cache_strip_comments |OFF | |query_cache_type |ON | |query_cache_wlock_invalidate|OFF | |query_prealloc_size |24576 | |slow_query_log |OFF | |slow_query_log_file |localhost-slow.log| +------------------------------+--------------------+ 14rowsinset(0.01sec)

查询缓存相关变量说明

query_cache_min_res_unit: 查询缓存中内存块的最小分配单位;较小值会减少浪费,但会导致更频繁的内存分配操作;较大值会带来浪费,会导致碎片过多;

query_cache_limit:能够缓存的最大查询结果;对于有着较大结果的查询语句,建议在SELECT中使用SQL_NO_CACHE

query_cache_size:查询缓存总共可用的内存空间;单位是字节,必须是1024的整数倍;

query_cache_type: ON, OFF, DEMAND

a、0(OFF):关闭 Query Cache 功能,任何情况下都不会使用 Query Cache;

b、1(ON):开启 Query Cache 功能,但是当SELECT语句中使用SQL_NO_CACHE提示后,将不使用Query Cache;

c、2(DEMAND):开启Query Cache 功能,但是只有当SELECT语句中使用了SQL_CACHE 提示后,才使用Query Cache。

query_cache_wlock_invalidate:如果某表被其它的连接锁定,是否仍然可以从查询缓存中返回结果;默认值为OFF,表示可以在表被其它连接锁定的场景中继续从缓存返回数据;ON则表示不允许;

MariaDB[(none)]>showglobalstatuslike'Qcache%'; +-------------------------+----------+ |Variable_name |Value | +-------------------------+----------+ |Qcache_free_blocks |1 | |Qcache_free_memory |16759656| |Qcache_hits |0 | |Qcache_inserts |0 | |Qcache_lowmem_prunes |0 | |Qcache_not_cached |7 | |Qcache_queries_in_cache|0 | |Qcache_total_blocks |1 | +-------------------------+----------+ 8rowsinset(0.00sec)

查看缓存变量参数说明:

Qcache_free_blocks: 缓存池中空闲块的个数,空闲的内存块。

Qcache_free_memory: 缓存中空闲内存空间

Qcache_hits: 缓存命中次数

Qcache_inserts: 可缓存查询语句的结果被放入缓存的次数

Qcache_lowmen_prunes: 有多少次是因为查询缓存内存空间太少而使用LRU算法清理缓存的次数

Qcache_not_cached: 可缓存却未能缓存的结果,例如查询结果超出缓存块大小,查询中包含可变函数等

Qcache_queries_in_cache: 当前缓存中缓存的SQL数量

Qcache_total_blocks: 整个查询缓存有多少内存块

缓存命中率:Qcache_hits/(Qcache_hits+Com_select)

四、分析和配置查询缓存流程及提高缓存命中率

①.开始,如果查询缓存命中率是否可以接受?如果可以的话,就结束。

②.不能接受目前的缓存命中率,查看大部分查询不是可缓存?是的话,就是大部分查询都不能缓存,query_cache_limit足够大吗?如果是,就结束,说明查询不能缓存,有可能是用户自定义变量、存储函数等,这种情况,建议关闭查询缓存。如果不是足够大,则需要增加此值。

③.1.大部分查询缓存都是可以缓存,但是却没有被缓存。是否发生很多严重工作?

是的话,查看缓存是不是被碎片化。需要降低query_cache_min_res_unit的值或是否flush query cache命令来整理缓存,减少碎片。

③.2.如果缓存不是因为碎片太多导致没有被缓存,内存过低发生的修正工作?

④.1.如果是内存过低,则增加query_cache_size。

④.2.如果不是内存过低,是否有很多的更新语句?频繁的更新表导致的缓存不能被命中,是有很多频繁更新的语句,负载不适合缓存,建议关闭缓存。不是有很多频繁更新的语句,则有其他配置的问题。

⑤.如果不是发生了很多验证工作,缓存启动了?是,没有见过此查询。否的话,启动缓存。

linux

MySQL查询缓存

一、查询缓存说明

MySQL Query Cache是用来缓存我们所执行的SELECT语句以及该语句的结果集,MySql在实现Query Cache的具体技术细节上类似典型的KV存储,就是将SELECT语句和该查询语句的结果集做了一个HASH映射并保存在一定的内存区域中。当客户端发起SQL查询时,Query Cache的查找逻辑是,先对SQL进行相应的权限验证,接着就通过Query Cache来查找结果(注意必须是完全相同,即使多一个空格或者大小写不 同都认为不同,即使完全相同的SQL,如果使用不同的字符集、不同的协议等也会被认为是不同的查询而分别进行缓存)。它不需要经过Optimizer模块进行执行计划的分析优化,更不需要发生同任何存储引擎的交互,减少了大量的磁盘IO和CPU运 算,所以有时候效率非常高。

二、查询缓存命中

判断一个缓存是否被命中,通过查询语句的HASH值来判断,HASH值因素包括查询语句、查询数据库、客户端版本协议等,如查询语句任何字符的不同,都会导致HASH结果的不同,都可能导致缓存无法命中。有些查询不能被缓存,如查询中包含UDF、存储函数、用户自定义变量、临时表、mysql库中系统表、或者包含列级权限的表、有着不确定值的函数(Now()); 查询缓存是完全存储在内存中的,对整个内存空间分配回收等,会额外产生系统资源消耗,这会导致内存碎片的产生。

三、查看查询缓存的参数

MariaDB[(none)]>showglobalvariableslike'%query%'; +------------------------------+--------------------+ |Variable_name |Value | +------------------------------+--------------------+ |expensive_subquery_limit |100 | |ft_query_expansion_limit |20 | |have_query_cache |YES | |long_query_time |10.000000 | |query_alloc_block_size |16384 | |query_cache_limit |1048576 | |query_cache_min_res_unit |4096 | |query_cache_size |16777216 | |query_cache_strip_comments |OFF | |query_cache_type |ON | |query_cache_wlock_invalidate|OFF | |query_prealloc_size |24576 | |slow_query_log |OFF | |slow_query_log_file |localhost-slow.log| +------------------------------+--------------------+ 14rowsinset(0.01sec)

查询缓存相关变量说明

query_cache_min_res_unit: 查询缓存中内存块的最小分配单位;较小值会减少浪费,但会导致更频繁的内存分配操作;较大值会带来浪费,会导致碎片过多;

query_cache_limit:能够缓存的最大查询结果;对于有着较大结果的查询语句,建议在SELECT中使用SQL_NO_CACHE

query_cache_size:查询缓存总共可用的内存空间;单位是字节,必须是1024的整数倍;

query_cache_type: ON, OFF, DEMAND

a、0(OFF):关闭 Query Cache 功能,任何情况下都不会使用 Query Cache;

b、1(ON):开启 Query Cache 功能,但是当SELECT语句中使用SQL_NO_CACHE提示后,将不使用Query Cache;

c、2(DEMAND):开启Query Cache 功能,但是只有当SELECT语句中使用了SQL_CACHE 提示后,才使用Query Cache。

query_cache_wlock_invalidate:如果某表被其它的连接锁定,是否仍然可以从查询缓存中返回结果;默认值为OFF,表示可以在表被其它连接锁定的场景中继续从缓存返回数据;ON则表示不允许;

MariaDB[(none)]>showglobalstatuslike'Qcache%'; +-------------------------+----------+ |Variable_name |Value | +-------------------------+----------+ |Qcache_free_blocks |1 | |Qcache_free_memory |16759656| |Qcache_hits |0 | |Qcache_inserts |0 | |Qcache_lowmem_prunes |0 | |Qcache_not_cached |7 | |Qcache_queries_in_cache|0 | |Qcache_total_blocks |1 | +-------------------------+----------+ 8rowsinset(0.00sec)

查看缓存变量参数说明:

Qcache_free_blocks: 缓存池中空闲块的个数,空闲的内存块。

Qcache_free_memory: 缓存中空闲内存空间

Qcache_hits: 缓存命中次数

Qcache_inserts: 可缓存查询语句的结果被放入缓存的次数

Qcache_lowmen_prunes: 有多少次是因为查询缓存内存空间太少而使用LRU算法清理缓存的次数

Qcache_not_cached: 可缓存却未能缓存的结果,例如查询结果超出缓存块大小,查询中包含可变函数等

Qcache_queries_in_cache: 当前缓存中缓存的SQL数量

Qcache_total_blocks: 整个查询缓存有多少内存块

缓存命中率:Qcache_hits/(Qcache_hits+Com_select)

四、分析和配置查询缓存流程及提高缓存命中率

①.开始,如果查询缓存命中率是否可以接受?如果可以的话,就结束。

②.不能接受目前的缓存命中率,查看大部分查询不是可缓存?是的话,就是大部分查询都不能缓存,query_cache_limit足够大吗?如果是,就结束,说明查询不能缓存,有可能是用户自定义变量、存储函数等,这种情况,建议关闭查询缓存。如果不是足够大,则需要增加此值。

③.1.大部分查询缓存都是可以缓存,但是却没有被缓存。是否发生很多严重工作?

是的话,查看缓存是不是被碎片化。需要降低query_cache_min_res_unit的值或是否flush query cache命令来整理缓存,减少碎片。

③.2.如果缓存不是因为碎片太多导致没有被缓存,内存过低发生的修正工作?

④.1.如果是内存过低,则增加query_cache_size。

④.2.如果不是内存过低,是否有很多的更新语句?频繁的更新表导致的缓存不能被命中,是有很多频繁更新的语句,负载不适合缓存,建议关闭缓存。不是有很多频繁更新的语句,则有其他配置的问题。

⑤.如果不是发生了很多验证工作,缓存启动了?是,没有见过此查询。否的话,启动缓存。

linuxMySQL查询缓存MySQL查询缓存

3.

一、查询缓存说明

MySQL Query Cache是用来缓存我们所执行的SELECT语句以及该语句的结果集,MySql在实现Query Cache的具体技术细节上类似典型的KV存储,就是将SELECT语句和该查询语句的结果集做了一个HASH映射并保存在一定的内存区域中。当客户端发起SQL查询时,Query Cache的查找逻辑是,先对SQL进行相应的权限验证,接着就通过Query Cache来查找结果(注意必须是完全相同,即使多一个空格或者大小写不 同都认为不同,即使完全相同的SQL,如果使用不同的字符集、不同的协议等也会被认为是不同的查询而分别进行缓存)。它不需要经过Optimizer模块进行执行计划的分析优化,更不需要发生同任何存储引擎的交互,减少了大量的磁盘IO和CPU运 算,所以有时候效率非常高。

二、查询缓存命中

判断一个缓存是否被命中,通过查询语句的HASH值来判断,HASH值因素包括查询语句、查询数据库、客户端版本协议等,如查询语句任何字符的不同,都会导致HASH结果的不同,都可能导致缓存无法命中。有些查询不能被缓存,如查询中包含UDF、存储函数、用户自定义变量、临时表、mysql库中系统表、或者包含列级权限的表、有着不确定值的函数(Now()); 查询缓存是完全存储在内存中的,对整个内存空间分配回收等,会额外产生系统资源消耗,这会导致内存碎片的产生。

三、查看查询缓存的参数

MariaDB[(none)]>showglobalvariableslike'%query%'; +------------------------------+--------------------+ |Variable_name |Value | +------------------------------+--------------------+ |expensive_subquery_limit |100 | |ft_query_expansion_limit |20 | |have_query_cache |YES | |long_query_time |10.000000 | |query_alloc_block_size |16384 | |query_cache_limit |1048576 | |query_cache_min_res_unit |4096 | |query_cache_size |16777216 | |query_cache_strip_comments |OFF | |query_cache_type |ON | |query_cache_wlock_invalidate|OFF | |query_prealloc_size |24576 | |slow_query_log |OFF | |slow_query_log_file |localhost-slow.log| +------------------------------+--------------------+ 14rowsinset(0.01sec)

查询缓存相关变量说明

query_cache_min_res_unit: 查询缓存中内存块的最小分配单位;较小值会减少浪费,但会导致更频繁的内存分配操作;较大值会带来浪费,会导致碎片过多;

query_cache_limit:能够缓存的最大查询结果;对于有着较大结果的查询语句,建议在SELECT中使用SQL_NO_CACHE

query_cache_size:查询缓存总共可用的内存空间;单位是字节,必须是1024的整数倍;

query_cache_type: ON, OFF, DEMAND

a、0(OFF):关闭 Query Cache 功能,任何情况下都不会使用 Query Cache;

b、1(ON):开启 Query Cache 功能,但是当SELECT语句中使用SQL_NO_CACHE提示后,将不使用Query Cache;

c、2(DEMAND):开启Query Cache 功能,但是只有当SELECT语句中使用了SQL_CACHE 提示后,才使用Query Cache。

query_cache_wlock_invalidate:如果某表被其它的连接锁定,是否仍然可以从查询缓存中返回结果;默认值为OFF,表示可以在表被其它连接锁定的场景中继续从缓存返回数据;ON则表示不允许;

MariaDB[(none)]>showglobalstatuslike'Qcache%'; +-------------------------+----------+ |Variable_name |Value | +-------------------------+----------+ |Qcache_free_blocks |1 | |Qcache_free_memory |16759656| |Qcache_hits |0 | |Qcache_inserts |0 | |Qcache_lowmem_prunes |0 | |Qcache_not_cached |7 | |Qcache_queries_in_cache|0 | |Qcache_total_blocks |1 | +-------------------------+----------+ 8rowsinset(0.00sec)

查看缓存变量参数说明:

Qcache_free_blocks: 缓存池中空闲块的个数,空闲的内存块。

Qcache_free_memory: 缓存中空闲内存空间

Qcache_hits: 缓存命中次数

Qcache_inserts: 可缓存查询语句的结果被放入缓存的次数

Qcache_lowmen_prunes: 有多少次是因为查询缓存内存空间太少而使用LRU算法清理缓存的次数

Qcache_not_cached: 可缓存却未能缓存的结果,例如查询结果超出缓存块大小,查询中包含可变函数等

Qcache_queries_in_cache: 当前缓存中缓存的SQL数量

Qcache_total_blocks: 整个查询缓存有多少内存块

缓存命中率:Qcache_hits/(Qcache_hits+Com_select)

四、分析和配置查询缓存流程及提高缓存命中率

①.开始,如果查询缓存命中率是否可以接受?如果可以的话,就结束。

②.不能接受目前的缓存命中率,查看大部分查询不是可缓存?是的话,就是大部分查询都不能缓存,query_cache_limit足够大吗?如果是,就结束,说明查询不能缓存,有可能是用户自定义变量、存储函数等,这种情况,建议关闭查询缓存。如果不是足够大,则需要增加此值。

③.1.大部分查询缓存都是可以缓存,但是却没有被缓存。是否发生很多严重工作?

是的话,查看缓存是不是被碎片化。需要降低query_cache_min_res_unit的值或是否flush query cache命令来整理缓存,减少碎片。

③.2.如果缓存不是因为碎片太多导致没有被缓存,内存过低发生的修正工作?

④.1.如果是内存过低,则增加query_cache_size。

④.2.如果不是内存过低,是否有很多的更新语句?频繁的更新表导致的缓存不能被命中,是有很多频繁更新的语句,负载不适合缓存,建议关闭缓存。不是有很多频繁更新的语句,则有其他配置的问题。

⑤.如果不是发生了很多验证工作,缓存启动了?是,没有见过此查询。否的话,启动缓存。

linux

MySQL查询缓存

一、查询缓存说明

MySQL Query Cache是用来缓存我们所执行的SELECT语句以及该语句的结果集,MySql在实现Query Cache的具体技术细节上类似典型的KV存储,就是将SELECT语句和该查询语句的结果集做了一个HASH映射并保存在一定的内存区域中。当客户端发起SQL查询时,Query Cache的查找逻辑是,先对SQL进行相应的权限验证,接着就通过Query Cache来查找结果(注意必须是完全相同,即使多一个空格或者大小写不 同都认为不同,即使完全相同的SQL,如果使用不同的字符集、不同的协议等也会被认为是不同的查询而分别进行缓存)。它不需要经过Optimizer模块进行执行计划的分析优化,更不需要发生同任何存储引擎的交互,减少了大量的磁盘IO和CPU运 算,所以有时候效率非常高。

二、查询缓存命中

判断一个缓存是否被命中,通过查询语句的HASH值来判断,HASH值因素包括查询语句、查询数据库、客户端版本协议等,如查询语句任何字符的不同,都会导致HASH结果的不同,都可能导致缓存无法命中。有些查询不能被缓存,如查询中包含UDF、存储函数、用户自定义变量、临时表、mysql库中系统表、或者包含列级权限的表、有着不确定值的函数(Now()); 查询缓存是完全存储在内存中的,对整个内存空间分配回收等,会额外产生系统资源消耗,这会导致内存碎片的产生。

三、查看查询缓存的参数

MariaDB[(none)]>showglobalvariableslike'%query%'; +------------------------------+--------------------+ |Variable_name |Value | +------------------------------+--------------------+ |expensive_subquery_limit |100 | |ft_query_expansion_limit |20 | |have_query_cache |YES | |long_query_time |10.000000 | |query_alloc_block_size |16384 | |query_cache_limit |1048576 | |query_cache_min_res_unit |4096 | |query_cache_size |16777216 | |query_cache_strip_comments |OFF | |query_cache_type |ON | |query_cache_wlock_invalidate|OFF | |query_prealloc_size |24576 | |slow_query_log |OFF | |slow_query_log_file |localhost-slow.log| +------------------------------+--------------------+ 14rowsinset(0.01sec)

查询缓存相关变量说明

query_cache_min_res_unit: 查询缓存中内存块的最小分配单位;较小值会减少浪费,但会导致更频繁的内存分配操作;较大值会带来浪费,会导致碎片过多;

query_cache_limit:能够缓存的最大查询结果;对于有着较大结果的查询语句,建议在SELECT中使用SQL_NO_CACHE

query_cache_size:查询缓存总共可用的内存空间;单位是字节,必须是1024的整数倍;

query_cache_type: ON, OFF, DEMAND

a、0(OFF):关闭 Query Cache 功能,任何情况下都不会使用 Query Cache;

b、1(ON):开启 Query Cache 功能,但是当SELECT语句中使用SQL_NO_CACHE提示后,将不使用Query Cache;

c、2(DEMAND):开启Query Cache 功能,但是只有当SELECT语句中使用了SQL_CACHE 提示后,才使用Query Cache。

query_cache_wlock_invalidate:如果某表被其它的连接锁定,是否仍然可以从查询缓存中返回结果;默认值为OFF,表示可以在表被其它连接锁定的场景中继续从缓存返回数据;ON则表示不允许;

MariaDB[(none)]>showglobalstatuslike'Qcache%'; +-------------------------+----------+ |Variable_name |Value | +-------------------------+----------+ |Qcache_free_blocks |1 | |Qcache_free_memory |16759656| |Qcache_hits |0 | |Qcache_inserts |0 | |Qcache_lowmem_prunes |0 | |Qcache_not_cached |7 | |Qcache_queries_in_cache|0 | |Qcache_total_blocks |1 | +-------------------------+----------+ 8rowsinset(0.00sec)

查看缓存变量参数说明:

Qcache_free_blocks: 缓存池中空闲块的个数,空闲的内存块。

Qcache_free_memory: 缓存中空闲内存空间

Qcache_hits: 缓存命中次数

Qcache_inserts: 可缓存查询语句的结果被放入缓存的次数

Qcache_lowmen_prunes: 有多少次是因为查询缓存内存空间太少而使用LRU算法清理缓存的次数

Qcache_not_cached: 可缓存却未能缓存的结果,例如查询结果超出缓存块大小,查询中包含可变函数等

Qcache_queries_in_cache: 当前缓存中缓存的SQL数量

Qcache_total_blocks: 整个查询缓存有多少内存块

缓存命中率:Qcache_hits/(Qcache_hits+Com_select)

四、分析和配置查询缓存流程及提高缓存命中率

①.开始,如果查询缓存命中率是否可以接受?如果可以的话,就结束。

②.不能接受目前的缓存命中率,查看大部分查询不是可缓存?是的话,就是大部分查询都不能缓存,query_cache_limit足够大吗?如果是,就结束,说明查询不能缓存,有可能是用户自定义变量、存储函数等,这种情况,建议关闭查询缓存。如果不是足够大,则需要增加此值。

③.1.大部分查询缓存都是可以缓存,但是却没有被缓存。是否发生很多严重工作?

是的话,查看缓存是不是被碎片化。需要降低query_cache_min_res_unit的值或是否flush query cache命令来整理缓存,减少碎片。

③.2.如果缓存不是因为碎片太多导致没有被缓存,内存过低发生的修正工作?

④.1.如果是内存过低,则增加query_cache_size。

④.2.如果不是内存过低,是否有很多的更新语句?频繁的更新表导致的缓存不能被命中,是有很多频繁更新的语句,负载不适合缓存,建议关闭缓存。不是有很多频繁更新的语句,则有其他配置的问题。

⑤.如果不是发生了很多验证工作,缓存启动了?是,没有见过此查询。否的话,启动缓存。

linux

一、查询缓存说明

MySQL Query Cache是用来缓存我们所执行的SELECT语句以及该语句的结果集,MySql在实现Query Cache的具体技术细节上类似典型的KV存储,就是将SELECT语句和该查询语句的结果集做了一个HASH映射并保存在一定的内存区域中。当客户端发起SQL查询时,Query Cache的查找逻辑是,先对SQL进行相应的权限验证,接着就通过Query Cache来查找结果(注意必须是完全相同,即使多一个空格或者大小写不 同都认为不同,即使完全相同的SQL,如果使用不同的字符集、不同的协议等也会被认为是不同的查询而分别进行缓存)。它不需要经过Optimizer模块进行执行计划的分析优化,更不需要发生同任何存储引擎的交互,减少了大量的磁盘IO和CPU运 算,所以有时候效率非常高。

二、查询缓存命中

判断一个缓存是否被命中,通过查询语句的HASH值来判断,HASH值因素包括查询语句、查询数据库、客户端版本协议等,如查询语句任何字符的不同,都会导致HASH结果的不同,都可能导致缓存无法命中。有些查询不能被缓存,如查询中包含UDF、存储函数、用户自定义变量、临时表、mysql库中系统表、或者包含列级权限的表、有着不确定值的函数(Now()); 查询缓存是完全存储在内存中的,对整个内存空间分配回收等,会额外产生系统资源消耗,这会导致内存碎片的产生。

三、查看查询缓存的参数

MariaDB[(none)]>showglobalvariableslike'%query%'; +------------------------------+--------------------+ |Variable_name |Value | +------------------------------+--------------------+ |expensive_subquery_limit |100 | |ft_query_expansion_limit |20 | |have_query_cache |YES | |long_query_time |10.000000 | |query_alloc_block_size |16384 | |query_cache_limit |1048576 | |query_cache_min_res_unit |4096 | |query_cache_size |16777216 | |query_cache_strip_comments |OFF | |query_cache_type |ON | |query_cache_wlock_invalidate|OFF | |query_prealloc_size |24576 | |slow_query_log |OFF | |slow_query_log_file |localhost-slow.log| +------------------------------+--------------------+ 14rowsinset(0.01sec)

查询缓存相关变量说明

query_cache_min_res_unit: 查询缓存中内存块的最小分配单位;较小值会减少浪费,但会导致更频繁的内存分配操作;较大值会带来浪费,会导致碎片过多;

query_cache_limit:能够缓存的最大查询结果;对于有着较大结果的查询语句,建议在SELECT中使用SQL_NO_CACHE

query_cache_size:查询缓存总共可用的内存空间;单位是字节,必须是1024的整数倍;

query_cache_type: ON, OFF, DEMAND

a、0(OFF):关闭 Query Cache 功能,任何情况下都不会使用 Query Cache;

b、1(ON):开启 Query Cache 功能,但是当SELECT语句中使用SQL_NO_CACHE提示后,将不使用Query Cache;

c、2(DEMAND):开启Query Cache 功能,但是只有当SELECT语句中使用了SQL_CACHE 提示后,才使用Query Cache。

query_cache_wlock_invalidate:如果某表被其它的连接锁定,是否仍然可以从查询缓存中返回结果;默认值为OFF,表示可以在表被其它连接锁定的场景中继续从缓存返回数据;ON则表示不允许;

MariaDB[(none)]>showglobalstatuslike'Qcache%'; +-------------------------+----------+ |Variable_name |Value | +-------------------------+----------+ |Qcache_free_blocks |1 | |Qcache_free_memory |16759656| |Qcache_hits |0 | |Qcache_inserts |0 | |Qcache_lowmem_prunes |0 | |Qcache_not_cached |7 | |Qcache_queries_in_cache|0 | |Qcache_total_blocks |1 | +-------------------------+----------+ 8rowsinset(0.00sec)

查看缓存变量参数说明:

Qcache_free_blocks: 缓存池中空闲块的个数,空闲的内存块。

Qcache_free_memory: 缓存中空闲内存空间

Qcache_hits: 缓存命中次数

Qcache_inserts: 可缓存查询语句的结果被放入缓存的次数

Qcache_lowmen_prunes: 有多少次是因为查询缓存内存空间太少而使用LRU算法清理缓存的次数

Qcache_not_cached: 可缓存却未能缓存的结果,例如查询结果超出缓存块大小,查询中包含可变函数等

Qcache_queries_in_cache: 当前缓存中缓存的SQL数量

Qcache_total_blocks: 整个查询缓存有多少内存块

缓存命中率:Qcache_hits/(Qcache_hits+Com_select)

四、分析和配置查询缓存流程及提高缓存命中率

①.开始,如果查询缓存命中率是否可以接受?如果可以的话,就结束。

②.不能接受目前的缓存命中率,查看大部分查询不是可缓存?是的话,就是大部分查询都不能缓存,query_cache_limit足够大吗?如果是,就结束,说明查询不能缓存,有可能是用户自定义变量、存储函数等,这种情况,建议关闭查询缓存。如果不是足够大,则需要增加此值。

③.1.大部分查询缓存都是可以缓存,但是却没有被缓存。是否发生很多严重工作?

是的话,查看缓存是不是被碎片化。需要降低query_cache_min_res_unit的值或是否flush query cache命令来整理缓存,减少碎片。

③.2.如果缓存不是因为碎片太多导致没有被缓存,内存过低发生的修正工作?

④.1.如果是内存过低,则增加query_cache_size。

④.2.如果不是内存过低,是否有很多的更新语句?频繁的更新表导致的缓存不能被命中,是有很多频繁更新的语句,负载不适合缓存,建议关闭缓存。不是有很多频繁更新的语句,则有其他配置的问题。

⑤.如果不是发生了很多验证工作,缓存启动了?是,没有见过此查询。否的话,启动缓存。

linuxMySQL查询缓存MySQL查询缓存

一、查询缓存说明

MySQL Query Cache是用来缓存我们所执行的SELECT语句以及该语句的结果集,MySql在实现Query Cache的具体技术细节上类似典型的KV存储,就是将SELECT语句和该查询语句的结果集做了一个HASH映射并保存在一定的内存区域中。当客户端发起SQL查询时,Query Cache的查找逻辑是,先对SQL进行相应的权限验证,接着就通过Query Cache来查找结果(注意必须是完全相同,即使多一个空格或者大小写不 同都认为不同,即使完全相同的SQL,如果使用不同的字符集、不同的协议等也会被认为是不同的查询而分别进行缓存)。它不需要经过Optimizer模块进行执行计划的分析优化,更不需要发生同任何存储引擎的交互,减少了大量的磁盘IO和CPU运 算,所以有时候效率非常高。

二、查询缓存命中

判断一个缓存是否被命中,通过查询语句的HASH值来判断,HASH值因素包括查询语句、查询数据库、客户端版本协议等,如查询语句任何字符的不同,都会导致HASH结果的不同,都可能导致缓存无法命中。有些查询不能被缓存,如查询中包含UDF、存储函数、用户自定义变量、临时表、mysql库中系统表、或者包含列级权限的表、有着不确定值的函数(Now()); 查询缓存是完全存储在内存中的,对整个内存空间分配回收等,会额外产生系统资源消耗,这会导致内存碎片的产生。

三、查看查询缓存的参数

MariaDB[(none)]>showglobalvariableslike'%query%'; +------------------------------+--------------------+ |Variable_name |Value | +------------------------------+--------------------+ |expensive_subquery_limit |100 | |ft_query_expansion_limit |20 | |have_query_cache |YES | |long_query_time |10.000000 | |query_alloc_block_size |16384 | |query_cache_limit |1048576 | |query_cache_min_res_unit |4096 | |query_cache_size |16777216 | |query_cache_strip_comments |OFF | |query_cache_type |ON | |query_cache_wlock_invalidate|OFF | |query_prealloc_size |24576 | |slow_query_log |OFF | |slow_query_log_file |localhost-slow.log| +------------------------------+--------------------+ 14rowsinset(0.01sec)

查询缓存相关变量说明

query_cache_min_res_unit: 查询缓存中内存块的最小分配单位;较小值会减少浪费,但会导致更频繁的内存分配操作;较大值会带来浪费,会导致碎片过多;

query_cache_limit:能够缓存的最大查询结果;对于有着较大结果的查询语句,建议在SELECT中使用SQL_NO_CACHE

query_cache_size:查询缓存总共可用的内存空间;单位是字节,必须是1024的整数倍;

query_cache_type: ON, OFF, DEMAND

a、0(OFF):关闭 Query Cache 功能,任何情况下都不会使用 Query Cache;

b、1(ON):开启 Query Cache 功能,但是当SELECT语句中使用SQL_NO_CACHE提示后,将不使用Query Cache;

c、2(DEMAND):开启Query Cache 功能,但是只有当SELECT语句中使用了SQL_CACHE 提示后,才使用Query Cache。

query_cache_wlock_invalidate:如果某表被其它的连接锁定,是否仍然可以从查询缓存中返回结果;默认值为OFF,表示可以在表被其它连接锁定的场景中继续从缓存返回数据;ON则表示不允许;

MariaDB[(none)]>showglobalstatuslike'Qcache%'; +-------------------------+----------+ |Variable_name |Value | +-------------------------+----------+ |Qcache_free_blocks |1 | |Qcache_free_memory |16759656| |Qcache_hits |0 | |Qcache_inserts |0 | |Qcache_lowmem_prunes |0 | |Qcache_not_cached |7 | |Qcache_queries_in_cache|0 | |Qcache_total_blocks |1 | +-------------------------+----------+ 8rowsinset(0.00sec)

查看缓存变量参数说明:

Qcache_free_blocks: 缓存池中空闲块的个数,空闲的内存块。

Qcache_free_memory: 缓存中空闲内存空间

Qcache_hits: 缓存命中次数

Qcache_inserts: 可缓存查询语句的结果被放入缓存的次数

Qcache_lowmen_prunes: 有多少次是因为查询缓存内存空间太少而使用LRU算法清理缓存的次数

Qcache_not_cached: 可缓存却未能缓存的结果,例如查询结果超出缓存块大小,查询中包含可变函数等

Qcache_queries_in_cache: 当前缓存中缓存的SQL数量

Qcache_total_blocks: 整个查询缓存有多少内存块

缓存命中率:Qcache_hits/(Qcache_hits+Com_select)

四、分析和配置查询缓存流程及提高缓存命中率

①.开始,如果查询缓存命中率是否可以接受?如果可以的话,就结束。

②.不能接受目前的缓存命中率,查看大部分查询不是可缓存?是的话,就是大部分查询都不能缓存,query_cache_limit足够大吗?如果是,就结束,说明查询不能缓存,有可能是用户自定义变量、存储函数等,这种情况,建议关闭查询缓存。如果不是足够大,则需要增加此值。

③.1.大部分查询缓存都是可以缓存,但是却没有被缓存。是否发生很多严重工作?

是的话,查看缓存是不是被碎片化。需要降低query_cache_min_res_unit的值或是否flush query cache命令来整理缓存,减少碎片。

③.2.如果缓存不是因为碎片太多导致没有被缓存,内存过低发生的修正工作?

④.1.如果是内存过低,则增加query_cache_size。

④.2.如果不是内存过低,是否有很多的更新语句?频繁的更新表导致的缓存不能被命中,是有很多频繁更新的语句,负载不适合缓存,建议关闭缓存。不是有很多频繁更新的语句,则有其他配置的问题。

⑤.如果不是发生了很多验证工作,缓存启动了?是,没有见过此查询。否的话,启动缓存。

linuxMySQL查询缓存

4.

一、查询缓存说明

MySQL Query Cache是用来缓存我们所执行的SELECT语句以及该语句的结果集,MySql在实现Query Cache的具体技术细节上类似典型的KV存储,就是将SELECT语句和该查询语句的结果集做了一个HASH映射并保存在一定的内存区域中。当客户端发起SQL查询时,Query Cache的查找逻辑是,先对SQL进行相应的权限验证,接着就通过Query Cache来查找结果(注意必须是完全相同,即使多一个空格或者大小写不 同都认为不同,即使完全相同的SQL,如果使用不同的字符集、不同的协议等也会被认为是不同的查询而分别进行缓存)。它不需要经过Optimizer模块进行执行计划的分析优化,更不需要发生同任何存储引擎的交互,减少了大量的磁盘IO和CPU运 算,所以有时候效率非常高。

二、查询缓存命中

判断一个缓存是否被命中,通过查询语句的HASH值来判断,HASH值因素包括查询语句、查询数据库、客户端版本协议等,如查询语句任何字符的不同,都会导致HASH结果的不同,都可能导致缓存无法命中。有些查询不能被缓存,如查询中包含UDF、存储函数、用户自定义变量、临时表、mysql库中系统表、或者包含列级权限的表、有着不确定值的函数(Now()); 查询缓存是完全存储在内存中的,对整个内存空间分配回收等,会额外产生系统资源消耗,这会导致内存碎片的产生。

三、查看查询缓存的参数

MariaDB[(none)]>showglobalvariableslike'%query%'; +------------------------------+--------------------+ |Variable_name |Value | +------------------------------+--------------------+ |expensive_subquery_limit |100 | |ft_query_expansion_limit |20 | |have_query_cache |YES | |long_query_time |10.000000 | |query_alloc_block_size |16384 | |query_cache_limit |1048576 | |query_cache_min_res_unit |4096 | |query_cache_size |16777216 | |query_cache_strip_comments |OFF | |query_cache_type |ON | |query_cache_wlock_invalidate|OFF | |query_prealloc_size |24576 | |slow_query_log |OFF | |slow_query_log_file |localhost-slow.log| +------------------------------+--------------------+ 14rowsinset(0.01sec)

查询缓存相关变量说明

query_cache_min_res_unit: 查询缓存中内存块的最小分配单位;较小值会减少浪费,但会导致更频繁的内存分配操作;较大值会带来浪费,会导致碎片过多;

query_cache_limit:能够缓存的最大查询结果;对于有着较大结果的查询语句,建议在SELECT中使用SQL_NO_CACHE

query_cache_size:查询缓存总共可用的内存空间;单位是字节,必须是1024的整数倍;

query_cache_type: ON, OFF, DEMAND

a、0(OFF):关闭 Query Cache 功能,任何情况下都不会使用 Query Cache;

b、1(ON):开启 Query Cache 功能,但是当SELECT语句中使用SQL_NO_CACHE提示后,将不使用Query Cache;

c、2(DEMAND):开启Query Cache 功能,但是只有当SELECT语句中使用了SQL_CACHE 提示后,才使用Query Cache。

query_cache_wlock_invalidate:如果某表被其它的连接锁定,是否仍然可以从查询缓存中返回结果;默认值为OFF,表示可以在表被其它连接锁定的场景中继续从缓存返回数据;ON则表示不允许;

MariaDB[(none)]>showglobalstatuslike'Qcache%'; +-------------------------+----------+ |Variable_name |Value | +-------------------------+----------+ |Qcache_free_blocks |1 | |Qcache_free_memory |16759656| |Qcache_hits |0 | |Qcache_inserts |0 | |Qcache_lowmem_prunes |0 | |Qcache_not_cached |7 | |Qcache_queries_in_cache|0 | |Qcache_total_blocks |1 | +-------------------------+----------+ 8rowsinset(0.00sec)

查看缓存变量参数说明:

Qcache_free_blocks: 缓存池中空闲块的个数,空闲的内存块。

Qcache_free_memory: 缓存中空闲内存空间

Qcache_hits: 缓存命中次数

Qcache_inserts: 可缓存查询语句的结果被放入缓存的次数

Qcache_lowmen_prunes: 有多少次是因为查询缓存内存空间太少而使用LRU算法清理缓存的次数

Qcache_not_cached: 可缓存却未能缓存的结果,例如查询结果超出缓存块大小,查询中包含可变函数等

Qcache_queries_in_cache: 当前缓存中缓存的SQL数量

Qcache_total_blocks: 整个查询缓存有多少内存块

缓存命中率:Qcache_hits/(Qcache_hits+Com_select)

四、分析和配置查询缓存流程及提高缓存命中率

①.开始,如果查询缓存命中率是否可以接受?如果可以的话,就结束。

②.不能接受目前的缓存命中率,查看大部分查询不是可缓存?是的话,就是大部分查询都不能缓存,query_cache_limit足够大吗?如果是,就结束,说明查询不能缓存,有可能是用户自定义变量、存储函数等,这种情况,建议关闭查询缓存。如果不是足够大,则需要增加此值。

③.1.大部分查询缓存都是可以缓存,但是却没有被缓存。是否发生很多严重工作?

是的话,查看缓存是不是被碎片化。需要降低query_cache_min_res_unit的值或是否flush query cache命令来整理缓存,减少碎片。

③.2.如果缓存不是因为碎片太多导致没有被缓存,内存过低发生的修正工作?

④.1.如果是内存过低,则增加query_cache_size。

④.2.如果不是内存过低,是否有很多的更新语句?频繁的更新表导致的缓存不能被命中,是有很多频繁更新的语句,负载不适合缓存,建议关闭缓存。不是有很多频繁更新的语句,则有其他配置的问题。

⑤.如果不是发生了很多验证工作,缓存启动了?是,没有见过此查询。否的话,启动缓存。

linux

一、查询缓存说明

MySQL Query Cache是用来缓存我们所执行的SELECT语句以及该语句的结果集,MySql在实现Query Cache的具体技术细节上类似典型的KV存储,就是将SELECT语句和该查询语句的结果集做了一个HASH映射并保存在一定的内存区域中。当客户端发起SQL查询时,Query Cache的查找逻辑是,先对SQL进行相应的权限验证,接着就通过Query Cache来查找结果(注意必须是完全相同,即使多一个空格或者大小写不 同都认为不同,即使完全相同的SQL,如果使用不同的字符集、不同的协议等也会被认为是不同的查询而分别进行缓存)。它不需要经过Optimizer模块进行执行计划的分析优化,更不需要发生同任何存储引擎的交互,减少了大量的磁盘IO和CPU运 算,所以有时候效率非常高。

二、查询缓存命中

判断一个缓存是否被命中,通过查询语句的HASH值来判断,HASH值因素包括查询语句、查询数据库、客户端版本协议等,如查询语句任何字符的不同,都会导致HASH结果的不同,都可能导致缓存无法命中。有些查询不能被缓存,如查询中包含UDF、存储函数、用户自定义变量、临时表、mysql库中系统表、或者包含列级权限的表、有着不确定值的函数(Now()); 查询缓存是完全存储在内存中的,对整个内存空间分配回收等,会额外产生系统资源消耗,这会导致内存碎片的产生。

三、查看查询缓存的参数

MariaDB[(none)]>showglobalvariableslike'%query%'; +------------------------------+--------------------+ |Variable_name |Value | +------------------------------+--------------------+ |expensive_subquery_limit |100 | |ft_query_expansion_limit |20 | |have_query_cache |YES | |long_query_time |10.000000 | |query_alloc_block_size |16384 | |query_cache_limit |1048576 | |query_cache_min_res_unit |4096 | |query_cache_size |16777216 | |query_cache_strip_comments |OFF | |query_cache_type |ON | |query_cache_wlock_invalidate|OFF | |query_prealloc_size |24576 | |slow_query_log |OFF | |slow_query_log_file |localhost-slow.log| +------------------------------+--------------------+ 14rowsinset(0.01sec)

查询缓存相关变量说明

query_cache_min_res_unit: 查询缓存中内存块的最小分配单位;较小值会减少浪费,但会导致更频繁的内存分配操作;较大值会带来浪费,会导致碎片过多;

query_cache_limit:能够缓存的最大查询结果;对于有着较大结果的查询语句,建议在SELECT中使用SQL_NO_CACHE

query_cache_size:查询缓存总共可用的内存空间;单位是字节,必须是1024的整数倍;

query_cache_type: ON, OFF, DEMAND

a、0(OFF):关闭 Query Cache 功能,任何情况下都不会使用 Query Cache;

b、1(ON):开启 Query Cache 功能,但是当SELECT语句中使用SQL_NO_CACHE提示后,将不使用Query Cache;

c、2(DEMAND):开启Query Cache 功能,但是只有当SELECT语句中使用了SQL_CACHE 提示后,才使用Query Cache。

query_cache_wlock_invalidate:如果某表被其它的连接锁定,是否仍然可以从查询缓存中返回结果;默认值为OFF,表示可以在表被其它连接锁定的场景中继续从缓存返回数据;ON则表示不允许;

MariaDB[(none)]>showglobalstatuslike'Qcache%'; +-------------------------+----------+ |Variable_name |Value | +-------------------------+----------+ |Qcache_free_blocks |1 | |Qcache_free_memory |16759656| |Qcache_hits |0 | |Qcache_inserts |0 | |Qcache_lowmem_prunes |0 | |Qcache_not_cached |7 | |Qcache_queries_in_cache|0 | |Qcache_total_blocks |1 | +-------------------------+----------+ 8rowsinset(0.00sec)

查看缓存变量参数说明:

Qcache_free_blocks: 缓存池中空闲块的个数,空闲的内存块。

Qcache_free_memory: 缓存中空闲内存空间

Qcache_hits: 缓存命中次数

Qcache_inserts: 可缓存查询语句的结果被放入缓存的次数

Qcache_lowmen_prunes: 有多少次是因为查询缓存内存空间太少而使用LRU算法清理缓存的次数

Qcache_not_cached: 可缓存却未能缓存的结果,例如查询结果超出缓存块大小,查询中包含可变函数等

Qcache_queries_in_cache: 当前缓存中缓存的SQL数量

Qcache_total_blocks: 整个查询缓存有多少内存块

缓存命中率:Qcache_hits/(Qcache_hits+Com_select)

四、分析和配置查询缓存流程及提高缓存命中率

①.开始,如果查询缓存命中率是否可以接受?如果可以的话,就结束。

②.不能接受目前的缓存命中率,查看大部分查询不是可缓存?是的话,就是大部分查询都不能缓存,query_cache_limit足够大吗?如果是,就结束,说明查询不能缓存,有可能是用户自定义变量、存储函数等,这种情况,建议关闭查询缓存。如果不是足够大,则需要增加此值。

③.1.大部分查询缓存都是可以缓存,但是却没有被缓存。是否发生很多严重工作?

是的话,查看缓存是不是被碎片化。需要降低query_cache_min_res_unit的值或是否flush query cache命令来整理缓存,减少碎片。

③.2.如果缓存不是因为碎片太多导致没有被缓存,内存过低发生的修正工作?

④.1.如果是内存过低,则增加query_cache_size。

④.2.如果不是内存过低,是否有很多的更新语句?频繁的更新表导致的缓存不能被命中,是有很多频繁更新的语句,负载不适合缓存,建议关闭缓存。不是有很多频繁更新的语句,则有其他配置的问题。

⑤.如果不是发生了很多验证工作,缓存启动了?是,没有见过此查询。否的话,启动缓存。

linuxMySQL查询缓存MySQL查询缓存

一、查询缓存说明

MySQL Query Cache是用来缓存我们所执行的SELECT语句以及该语句的结果集,MySql在实现Query Cache的具体技术细节上类似典型的KV存储,就是将SELECT语句和该查询语句的结果集做了一个HASH映射并保存在一定的内存区域中。当客户端发起SQL查询时,Query Cache的查找逻辑是,先对SQL进行相应的权限验证,接着就通过Query Cache来查找结果(注意必须是完全相同,即使多一个空格或者大小写不 同都认为不同,即使完全相同的SQL,如果使用不同的字符集、不同的协议等也会被认为是不同的查询而分别进行缓存)。它不需要经过Optimizer模块进行执行计划的分析优化,更不需要发生同任何存储引擎的交互,减少了大量的磁盘IO和CPU运 算,所以有时候效率非常高。

二、查询缓存命中

判断一个缓存是否被命中,通过查询语句的HASH值来判断,HASH值因素包括查询语句、查询数据库、客户端版本协议等,如查询语句任何字符的不同,都会导致HASH结果的不同,都可能导致缓存无法命中。有些查询不能被缓存,如查询中包含UDF、存储函数、用户自定义变量、临时表、mysql库中系统表、或者包含列级权限的表、有着不确定值的函数(Now()); 查询缓存是完全存储在内存中的,对整个内存空间分配回收等,会额外产生系统资源消耗,这会导致内存碎片的产生。

三、查看查询缓存的参数

MariaDB[(none)]>showglobalvariableslike'%query%'; +------------------------------+--------------------+ |Variable_name |Value | +------------------------------+--------------------+ |expensive_subquery_limit |100 | |ft_query_expansion_limit |20 | |have_query_cache |YES | |long_query_time |10.000000 | |query_alloc_block_size |16384 | |query_cache_limit |1048576 | |query_cache_min_res_unit |4096 | |query_cache_size |16777216 | |query_cache_strip_comments |OFF | |query_cache_type |ON | |query_cache_wlock_invalidate|OFF | |query_prealloc_size |24576 | |slow_query_log |OFF | |slow_query_log_file |localhost-slow.log| +------------------------------+--------------------+ 14rowsinset(0.01sec)

查询缓存相关变量说明

query_cache_min_res_unit: 查询缓存中内存块的最小分配单位;较小值会减少浪费,但会导致更频繁的内存分配操作;较大值会带来浪费,会导致碎片过多;

query_cache_limit:能够缓存的最大查询结果;对于有着较大结果的查询语句,建议在SELECT中使用SQL_NO_CACHE

query_cache_size:查询缓存总共可用的内存空间;单位是字节,必须是1024的整数倍;

query_cache_type: ON, OFF, DEMAND

a、0(OFF):关闭 Query Cache 功能,任何情况下都不会使用 Query Cache;

b、1(ON):开启 Query Cache 功能,但是当SELECT语句中使用SQL_NO_CACHE提示后,将不使用Query Cache;

c、2(DEMAND):开启Query Cache 功能,但是只有当SELECT语句中使用了SQL_CACHE 提示后,才使用Query Cache。

query_cache_wlock_invalidate:如果某表被其它的连接锁定,是否仍然可以从查询缓存中返回结果;默认值为OFF,表示可以在表被其它连接锁定的场景中继续从缓存返回数据;ON则表示不允许;

MariaDB[(none)]>showglobalstatuslike'Qcache%'; +-------------------------+----------+ |Variable_name |Value | +-------------------------+----------+ |Qcache_free_blocks |1 | |Qcache_free_memory |16759656| |Qcache_hits |0 | |Qcache_inserts |0 | |Qcache_lowmem_prunes |0 | |Qcache_not_cached |7 | |Qcache_queries_in_cache|0 | |Qcache_total_blocks |1 | +-------------------------+----------+ 8rowsinset(0.00sec)

查看缓存变量参数说明:

Qcache_free_blocks: 缓存池中空闲块的个数,空闲的内存块。

Qcache_free_memory: 缓存中空闲内存空间

Qcache_hits: 缓存命中次数

Qcache_inserts: 可缓存查询语句的结果被放入缓存的次数

Qcache_lowmen_prunes: 有多少次是因为查询缓存内存空间太少而使用LRU算法清理缓存的次数

Qcache_not_cached: 可缓存却未能缓存的结果,例如查询结果超出缓存块大小,查询中包含可变函数等

Qcache_queries_in_cache: 当前缓存中缓存的SQL数量

Qcache_total_blocks: 整个查询缓存有多少内存块

缓存命中率:Qcache_hits/(Qcache_hits+Com_select)

四、分析和配置查询缓存流程及提高缓存命中率

①.开始,如果查询缓存命中率是否可以接受?如果可以的话,就结束。

②.不能接受目前的缓存命中率,查看大部分查询不是可缓存?是的话,就是大部分查询都不能缓存,query_cache_limit足够大吗?如果是,就结束,说明查询不能缓存,有可能是用户自定义变量、存储函数等,这种情况,建议关闭查询缓存。如果不是足够大,则需要增加此值。

③.1.大部分查询缓存都是可以缓存,但是却没有被缓存。是否发生很多严重工作?

是的话,查看缓存是不是被碎片化。需要降低query_cache_min_res_unit的值或是否flush query cache命令来整理缓存,减少碎片。

③.2.如果缓存不是因为碎片太多导致没有被缓存,内存过低发生的修正工作?

④.1.如果是内存过低,则增加query_cache_size。

④.2.如果不是内存过低,是否有很多的更新语句?频繁的更新表导致的缓存不能被命中,是有很多频繁更新的语句,负载不适合缓存,建议关闭缓存。不是有很多频繁更新的语句,则有其他配置的问题。

⑤.如果不是发生了很多验证工作,缓存启动了?是,没有见过此查询。否的话,启动缓存。

linuxMySQL查询缓存

一、查询缓存说明

MySQL Query Cache是用来缓存我们所执行的SELECT语句以及该语句的结果集,MySql在实现Query Cache的具体技术细节上类似典型的KV存储,就是将SELECT语句和该查询语句的结果集做了一个HASH映射并保存在一定的内存区域中。当客户端发起SQL查询时,Query Cache的查找逻辑是,先对SQL进行相应的权限验证,接着就通过Query Cache来查找结果(注意必须是完全相同,即使多一个空格或者大小写不 同都认为不同,即使完全相同的SQL,如果使用不同的字符集、不同的协议等也会被认为是不同的查询而分别进行缓存)。它不需要经过Optimizer模块进行执行计划的分析优化,更不需要发生同任何存储引擎的交互,减少了大量的磁盘IO和CPU运 算,所以有时候效率非常高。

二、查询缓存命中

判断一个缓存是否被命中,通过查询语句的HASH值来判断,HASH值因素包括查询语句、查询数据库、客户端版本协议等,如查询语句任何字符的不同,都会导致HASH结果的不同,都可能导致缓存无法命中。有些查询不能被缓存,如查询中包含UDF、存储函数、用户自定义变量、临时表、mysql库中系统表、或者包含列级权限的表、有着不确定值的函数(Now()); 查询缓存是完全存储在内存中的,对整个内存空间分配回收等,会额外产生系统资源消耗,这会导致内存碎片的产生。

三、查看查询缓存的参数

MariaDB[(none)]>showglobalvariableslike'%query%'; +------------------------------+--------------------+ |Variable_name |Value | +------------------------------+--------------------+ |expensive_subquery_limit |100 | |ft_query_expansion_limit |20 | |have_query_cache |YES | |long_query_time |10.000000 | |query_alloc_block_size |16384 | |query_cache_limit |1048576 | |query_cache_min_res_unit |4096 | |query_cache_size |16777216 | |query_cache_strip_comments |OFF | |query_cache_type |ON | |query_cache_wlock_invalidate|OFF | |query_prealloc_size |24576 | |slow_query_log |OFF | |slow_query_log_file |localhost-slow.log| +------------------------------+--------------------+ 14rowsinset(0.01sec)

查询缓存相关变量说明

query_cache_min_res_unit: 查询缓存中内存块的最小分配单位;较小值会减少浪费,但会导致更频繁的内存分配操作;较大值会带来浪费,会导致碎片过多;

query_cache_limit:能够缓存的最大查询结果;对于有着较大结果的查询语句,建议在SELECT中使用SQL_NO_CACHE

query_cache_size:查询缓存总共可用的内存空间;单位是字节,必须是1024的整数倍;

query_cache_type: ON, OFF, DEMAND

a、0(OFF):关闭 Query Cache 功能,任何情况下都不会使用 Query Cache;

b、1(ON):开启 Query Cache 功能,但是当SELECT语句中使用SQL_NO_CACHE提示后,将不使用Query Cache;

c、2(DEMAND):开启Query Cache 功能,但是只有当SELECT语句中使用了SQL_CACHE 提示后,才使用Query Cache。

query_cache_wlock_invalidate:如果某表被其它的连接锁定,是否仍然可以从查询缓存中返回结果;默认值为OFF,表示可以在表被其它连接锁定的场景中继续从缓存返回数据;ON则表示不允许;

MariaDB[(none)]>showglobalstatuslike'Qcache%'; +-------------------------+----------+ |Variable_name |Value | +-------------------------+----------+ |Qcache_free_blocks |1 | |Qcache_free_memory |16759656| |Qcache_hits |0 | |Qcache_inserts |0 | |Qcache_lowmem_prunes |0 | |Qcache_not_cached |7 | |Qcache_queries_in_cache|0 | |Qcache_total_blocks |1 | +-------------------------+----------+ 8rowsinset(0.00sec)

查看缓存变量参数说明:

Qcache_free_blocks: 缓存池中空闲块的个数,空闲的内存块。

Qcache_free_memory: 缓存中空闲内存空间

Qcache_hits: 缓存命中次数

Qcache_inserts: 可缓存查询语句的结果被放入缓存的次数

Qcache_lowmen_prunes: 有多少次是因为查询缓存内存空间太少而使用LRU算法清理缓存的次数

Qcache_not_cached: 可缓存却未能缓存的结果,例如查询结果超出缓存块大小,查询中包含可变函数等

Qcache_queries_in_cache: 当前缓存中缓存的SQL数量

Qcache_total_blocks: 整个查询缓存有多少内存块

缓存命中率:Qcache_hits/(Qcache_hits+Com_select)

四、分析和配置查询缓存流程及提高缓存命中率

①.开始,如果查询缓存命中率是否可以接受?如果可以的话,就结束。

②.不能接受目前的缓存命中率,查看大部分查询不是可缓存?是的话,就是大部分查询都不能缓存,query_cache_limit足够大吗?如果是,就结束,说明查询不能缓存,有可能是用户自定义变量、存储函数等,这种情况,建议关闭查询缓存。如果不是足够大,则需要增加此值。

③.1.大部分查询缓存都是可以缓存,但是却没有被缓存。是否发生很多严重工作?

是的话,查看缓存是不是被碎片化。需要降低query_cache_min_res_unit的值或是否flush query cache命令来整理缓存,减少碎片。

③.2.如果缓存不是因为碎片太多导致没有被缓存,内存过低发生的修正工作?

④.1.如果是内存过低,则增加query_cache_size。

④.2.如果不是内存过低,是否有很多的更新语句?频繁的更新表导致的缓存不能被命中,是有很多频繁更新的语句,负载不适合缓存,建议关闭缓存。不是有很多频繁更新的语句,则有其他配置的问题。

⑤.如果不是发生了很多验证工作,缓存启动了?是,没有见过此查询。否的话,启动缓存。

linux

一、查询缓存说明

MySQL Query Cache是用来缓存我们所执行的SELECT语句以及该语句的结果集,MySql在实现Query Cache的具体技术细节上类似典型的KV存储,就是将SELECT语句和该查询语句的结果集做了一个HASH映射并保存在一定的内存区域中。当客户端发起SQL查询时,Query Cache的查找逻辑是,先对SQL进行相应的权限验证,接着就通过Query Cache来查找结果(注意必须是完全相同,即使多一个空格或者大小写不 同都认为不同,即使完全相同的SQL,如果使用不同的字符集、不同的协议等也会被认为是不同的查询而分别进行缓存)。它不需要经过Optimizer模块进行执行计划的分析优化,更不需要发生同任何存储引擎的交互,减少了大量的磁盘IO和CPU运 算,所以有时候效率非常高。

二、查询缓存命中

判断一个缓存是否被命中,通过查询语句的HASH值来判断,HASH值因素包括查询语句、查询数据库、客户端版本协议等,如查询语句任何字符的不同,都会导致HASH结果的不同,都可能导致缓存无法命中。有些查询不能被缓存,如查询中包含UDF、存储函数、用户自定义变量、临时表、mysql库中系统表、或者包含列级权限的表、有着不确定值的函数(Now()); 查询缓存是完全存储在内存中的,对整个内存空间分配回收等,会额外产生系统资源消耗,这会导致内存碎片的产生。

三、查看查询缓存的参数

MariaDB[(none)]>showglobalvariableslike'%query%'; +------------------------------+--------------------+ |Variable_name |Value | +------------------------------+--------------------+ |expensive_subquery_limit |100 | |ft_query_expansion_limit |20 | |have_query_cache |YES | |long_query_time |10.000000 | |query_alloc_block_size |16384 | |query_cache_limit |1048576 | |query_cache_min_res_unit |4096 | |query_cache_size |16777216 | |query_cache_strip_comments |OFF | |query_cache_type |ON | |query_cache_wlock_invalidate|OFF | |query_prealloc_size |24576 | |slow_query_log |OFF | |slow_query_log_file |localhost-slow.log| +------------------------------+--------------------+ 14rowsinset(0.01sec)

查询缓存相关变量说明

query_cache_min_res_unit: 查询缓存中内存块的最小分配单位;较小值会减少浪费,但会导致更频繁的内存分配操作;较大值会带来浪费,会导致碎片过多;

query_cache_limit:能够缓存的最大查询结果;对于有着较大结果的查询语句,建议在SELECT中使用SQL_NO_CACHE

query_cache_size:查询缓存总共可用的内存空间;单位是字节,必须是1024的整数倍;

query_cache_type: ON, OFF, DEMAND

a、0(OFF):关闭 Query Cache 功能,任何情况下都不会使用 Query Cache;

b、1(ON):开启 Query Cache 功能,但是当SELECT语句中使用SQL_NO_CACHE提示后,将不使用Query Cache;

c、2(DEMAND):开启Query Cache 功能,但是只有当SELECT语句中使用了SQL_CACHE 提示后,才使用Query Cache。

query_cache_wlock_invalidate:如果某表被其它的连接锁定,是否仍然可以从查询缓存中返回结果;默认值为OFF,表示可以在表被其它连接锁定的场景中继续从缓存返回数据;ON则表示不允许;

MariaDB[(none)]>showglobalstatuslike'Qcache%'; +-------------------------+----------+ |Variable_name |Value | +-------------------------+----------+ |Qcache_free_blocks |1 | |Qcache_free_memory |16759656| |Qcache_hits |0 | |Qcache_inserts |0 | |Qcache_lowmem_prunes |0 | |Qcache_not_cached |7 | |Qcache_queries_in_cache|0 | |Qcache_total_blocks |1 | +-------------------------+----------+ 8rowsinset(0.00sec)

查看缓存变量参数说明:

Qcache_free_blocks: 缓存池中空闲块的个数,空闲的内存块。

Qcache_free_memory: 缓存中空闲内存空间

Qcache_hits: 缓存命中次数

Qcache_inserts: 可缓存查询语句的结果被放入缓存的次数

Qcache_lowmen_prunes: 有多少次是因为查询缓存内存空间太少而使用LRU算法清理缓存的次数

Qcache_not_cached: 可缓存却未能缓存的结果,例如查询结果超出缓存块大小,查询中包含可变函数等

Qcache_queries_in_cache: 当前缓存中缓存的SQL数量

Qcache_total_blocks: 整个查询缓存有多少内存块

缓存命中率:Qcache_hits/(Qcache_hits+Com_select)

四、分析和配置查询缓存流程及提高缓存命中率

①.开始,如果查询缓存命中率是否可以接受?如果可以的话,就结束。

②.不能接受目前的缓存命中率,查看大部分查询不是可缓存?是的话,就是大部分查询都不能缓存,query_cache_limit足够大吗?如果是,就结束,说明查询不能缓存,有可能是用户自定义变量、存储函数等,这种情况,建议关闭查询缓存。如果不是足够大,则需要增加此值。

③.1.大部分查询缓存都是可以缓存,但是却没有被缓存。是否发生很多严重工作?

是的话,查看缓存是不是被碎片化。需要降低query_cache_min_res_unit的值或是否flush query cache命令来整理缓存,减少碎片。

③.2.如果缓存不是因为碎片太多导致没有被缓存,内存过低发生的修正工作?

④.1.如果是内存过低,则增加query_cache_size。

④.2.如果不是内存过低,是否有很多的更新语句?频繁的更新表导致的缓存不能被命中,是有很多频繁更新的语句,负载不适合缓存,建议关闭缓存。不是有很多频繁更新的语句,则有其他配置的问题。

⑤.如果不是发生了很多验证工作,缓存启动了?是,没有见过此查询。否的话,启动缓存。

linux

一、查询缓存说明

MySQL Query Cache是用来缓存我们所执行的SELECT语句以及该语句的结果集,MySql在实现Query Cache的具体技术细节上类似典型的KV存储,就是将SELECT语句和该查询语句的结果集做了一个HASH映射并保存在一定的内存区域中。当客户端发起SQL查询时,Query Cache的查找逻辑是,先对SQL进行相应的权限验证,接着就通过Query Cache来查找结果(注意必须是完全相同,即使多一个空格或者大小写不 同都认为不同,即使完全相同的SQL,如果使用不同的字符集、不同的协议等也会被认为是不同的查询而分别进行缓存)。它不需要经过Optimizer模块进行执行计划的分析优化,更不需要发生同任何存储引擎的交互,减少了大量的磁盘IO和CPU运 算,所以有时候效率非常高。

二、查询缓存命中

判断一个缓存是否被命中,通过查询语句的HASH值来判断,HASH值因素包括查询语句、查询数据库、客户端版本协议等,如查询语句任何字符的不同,都会导致HASH结果的不同,都可能导致缓存无法命中。有些查询不能被缓存,如查询中包含UDF、存储函数、用户自定义变量、临时表、mysql库中系统表、或者包含列级权限的表、有着不确定值的函数(Now()); 查询缓存是完全存储在内存中的,对整个内存空间分配回收等,会额外产生系统资源消耗,这会导致内存碎片的产生。

三、查看查询缓存的参数

MariaDB[(none)]>showglobalvariableslike'%query%'; +------------------------------+--------------------+ |Variable_name |Value | +------------------------------+--------------------+ |expensive_subquery_limit |100 | |ft_query_expansion_limit |20 | |have_query_cache |YES | |long_query_time |10.000000 | |query_alloc_block_size |16384 | |query_cache_limit |1048576 | |query_cache_min_res_unit |4096 | |query_cache_size |16777216 | |query_cache_strip_comments |OFF | |query_cache_type |ON | |query_cache_wlock_invalidate|OFF | |query_prealloc_size |24576 | |slow_query_log |OFF | |slow_query_log_file |localhost-slow.log| +------------------------------+--------------------+ 14rowsinset(0.01sec)

查询缓存相关变量说明

query_cache_min_res_unit: 查询缓存中内存块的最小分配单位;较小值会减少浪费,但会导致更频繁的内存分配操作;较大值会带来浪费,会导致碎片过多;

query_cache_limit:能够缓存的最大查询结果;对于有着较大结果的查询语句,建议在SELECT中使用SQL_NO_CACHE

query_cache_size:查询缓存总共可用的内存空间;单位是字节,必须是1024的整数倍;

query_cache_type: ON, OFF, DEMAND

a、0(OFF):关闭 Query Cache 功能,任何情况下都不会使用 Query Cache;

b、1(ON):开启 Query Cache 功能,但是当SELECT语句中使用SQL_NO_CACHE提示后,将不使用Query Cache;

c、2(DEMAND):开启Query Cache 功能,但是只有当SELECT语句中使用了SQL_CACHE 提示后,才使用Query Cache。

query_cache_wlock_invalidate:如果某表被其它的连接锁定,是否仍然可以从查询缓存中返回结果;默认值为OFF,表示可以在表被其它连接锁定的场景中继续从缓存返回数据;ON则表示不允许;

MariaDB[(none)]>showglobalstatuslike'Qcache%'; +-------------------------+----------+ |Variable_name |Value | +-------------------------+----------+ |Qcache_free_blocks |1 | |Qcache_free_memory |16759656| |Qcache_hits |0 | |Qcache_inserts |0 | |Qcache_lowmem_prunes |0 | |Qcache_not_cached |7 | |Qcache_queries_in_cache|0 | |Qcache_total_blocks |1 | +-------------------------+----------+ 8rowsinset(0.00sec)

查看缓存变量参数说明:

Qcache_free_blocks: 缓存池中空闲块的个数,空闲的内存块。

Qcache_free_memory: 缓存中空闲内存空间

Qcache_hits: 缓存命中次数

Qcache_inserts: 可缓存查询语句的结果被放入缓存的次数

Qcache_lowmen_prunes: 有多少次是因为查询缓存内存空间太少而使用LRU算法清理缓存的次数

Qcache_not_cached: 可缓存却未能缓存的结果,例如查询结果超出缓存块大小,查询中包含可变函数等

Qcache_queries_in_cache: 当前缓存中缓存的SQL数量

Qcache_total_blocks: 整个查询缓存有多少内存块

缓存命中率:Qcache_hits/(Qcache_hits+Com_select)

四、分析和配置查询缓存流程及提高缓存命中率

①.开始,如果查询缓存命中率是否可以接受?如果可以的话,就结束。

②.不能接受目前的缓存命中率,查看大部分查询不是可缓存?是的话,就是大部分查询都不能缓存,query_cache_limit足够大吗?如果是,就结束,说明查询不能缓存,有可能是用户自定义变量、存储函数等,这种情况,建议关闭查询缓存。如果不是足够大,则需要增加此值。

③.1.大部分查询缓存都是可以缓存,但是却没有被缓存。是否发生很多严重工作?

是的话,查看缓存是不是被碎片化。需要降低query_cache_min_res_unit的值或是否flush query cache命令来整理缓存,减少碎片。

③.2.如果缓存不是因为碎片太多导致没有被缓存,内存过低发生的修正工作?

④.1.如果是内存过低,则增加query_cache_size。

④.2.如果不是内存过低,是否有很多的更新语句?频繁的更新表导致的缓存不能被命中,是有很多频繁更新的语句,负载不适合缓存,建议关闭缓存。不是有很多频繁更新的语句,则有其他配置的问题。

⑤.如果不是发生了很多验证工作,缓存启动了?是,没有见过此查询。否的话,启动缓存。

linux

一、查询缓存说明

MySQL Query Cache是用来缓存我们所执行的SELECT语句以及该语句的结果集,MySql在实现Query Cache的具体技术细节上类似典型的KV存储,就是将SELECT语句和该查询语句的结果集做了一个HASH映射并保存在一定的内存区域中。当客户端发起SQL查询时,Query Cache的查找逻辑是,先对SQL进行相应的权限验证,接着就通过Query Cache来查找结果(注意必须是完全相同,即使多一个空格或者大小写不 同都认为不同,即使完全相同的SQL,如果使用不同的字符集、不同的协议等也会被认为是不同的查询而分别进行缓存)。它不需要经过Optimizer模块进行执行计划的分析优化,更不需要发生同任何存储引擎的交互,减少了大量的磁盘IO和CPU运 算,所以有时候效率非常高。

二、查询缓存命中

判断一个缓存是否被命中,通过查询语句的HASH值来判断,HASH值因素包括查询语句、查询数据库、客户端版本协议等,如查询语句任何字符的不同,都会导致HASH结果的不同,都可能导致缓存无法命中。有些查询不能被缓存,如查询中包含UDF、存储函数、用户自定义变量、临时表、mysql库中系统表、或者包含列级权限的表、有着不确定值的函数(Now()); 查询缓存是完全存储在内存中的,对整个内存空间分配回收等,会额外产生系统资源消耗,这会导致内存碎片的产生。

三、查看查询缓存的参数

MariaDB[(none)]>showglobalvariableslike'%query%'; +------------------------------+--------------------+ |Variable_name |Value | +------------------------------+--------------------+ |expensive_subquery_limit |100 | |ft_query_expansion_limit |20 | |have_query_cache |YES | |long_query_time |10.000000 | |query_alloc_block_size |16384 | |query_cache_limit |1048576 | |query_cache_min_res_unit |4096 | |query_cache_size |16777216 | |query_cache_strip_comments |OFF | |query_cache_type |ON | |query_cache_wlock_invalidate|OFF | |query_prealloc_size |24576 | |slow_query_log |OFF | |slow_query_log_file |localhost-slow.log| +------------------------------+--------------------+ 14rowsinset(0.01sec)

查询缓存相关变量说明

query_cache_min_res_unit: 查询缓存中内存块的最小分配单位;较小值会减少浪费,但会导致更频繁的内存分配操作;较大值会带来浪费,会导致碎片过多;

query_cache_limit:能够缓存的最大查询结果;对于有着较大结果的查询语句,建议在SELECT中使用SQL_NO_CACHE

query_cache_size:查询缓存总共可用的内存空间;单位是字节,必须是1024的整数倍;

query_cache_type: ON, OFF, DEMAND

a、0(OFF):关闭 Query Cache 功能,任何情况下都不会使用 Query Cache;

b、1(ON):开启 Query Cache 功能,但是当SELECT语句中使用SQL_NO_CACHE提示后,将不使用Query Cache;

c、2(DEMAND):开启Query Cache 功能,但是只有当SELECT语句中使用了SQL_CACHE 提示后,才使用Query Cache。

query_cache_wlock_invalidate:如果某表被其它的连接锁定,是否仍然可以从查询缓存中返回结果;默认值为OFF,表示可以在表被其它连接锁定的场景中继续从缓存返回数据;ON则表示不允许;

MariaDB[(none)]>showglobalstatuslike'Qcache%'; +-------------------------+----------+ |Variable_name |Value | +-------------------------+----------+ |Qcache_free_blocks |1 | |Qcache_free_memory |16759656| |Qcache_hits |0 | |Qcache_inserts |0 | |Qcache_lowmem_prunes |0 | |Qcache_not_cached |7 | |Qcache_queries_in_cache|0 | |Qcache_total_blocks |1 | +-------------------------+----------+ 8rowsinset(0.00sec)

查看缓存变量参数说明:

Qcache_free_blocks: 缓存池中空闲块的个数,空闲的内存块。

Qcache_free_memory: 缓存中空闲内存空间

Qcache_hits: 缓存命中次数

Qcache_inserts: 可缓存查询语句的结果被放入缓存的次数

Qcache_lowmen_prunes: 有多少次是因为查询缓存内存空间太少而使用LRU算法清理缓存的次数

Qcache_not_cached: 可缓存却未能缓存的结果,例如查询结果超出缓存块大小,查询中包含可变函数等

Qcache_queries_in_cache: 当前缓存中缓存的SQL数量

Qcache_total_blocks: 整个查询缓存有多少内存块

缓存命中率:Qcache_hits/(Qcache_hits+Com_select)

四、分析和配置查询缓存流程及提高缓存命中率

①.开始,如果查询缓存命中率是否可以接受?如果可以的话,就结束。

②.不能接受目前的缓存命中率,查看大部分查询不是可缓存?是的话,就是大部分查询都不能缓存,query_cache_limit足够大吗?如果是,就结束,说明查询不能缓存,有可能是用户自定义变量、存储函数等,这种情况,建议关闭查询缓存。如果不是足够大,则需要增加此值。

③.1.大部分查询缓存都是可以缓存,但是却没有被缓存。是否发生很多严重工作?

是的话,查看缓存是不是被碎片化。需要降低query_cache_min_res_unit的值或是否flush query cache命令来整理缓存,减少碎片。

③.2.如果缓存不是因为碎片太多导致没有被缓存,内存过低发生的修正工作?

④.1.如果是内存过低,则增加query_cache_size。

④.2.如果不是内存过低,是否有很多的更新语句?频繁的更新表导致的缓存不能被命中,是有很多频繁更新的语句,负载不适合缓存,建议关闭缓存。不是有很多频繁更新的语句,则有其他配置的问题。

⑤.如果不是发生了很多验证工作,缓存启动了?是,没有见过此查询。否的话,启动缓存。

linux

一、查询缓存说明

MySQL Query Cache是用来缓存我们所执行的SELECT语句以及该语句的结果集,MySql在实现Query Cache的具体技术细节上类似典型的KV存储,就是将SELECT语句和该查询语句的结果集做了一个HASH映射并保存在一定的内存区域中。当客户端发起SQL查询时,Query Cache的查找逻辑是,先对SQL进行相应的权限验证,接着就通过Query Cache来查找结果(注意必须是完全相同,即使多一个空格或者大小写不 同都认为不同,即使完全相同的SQL,如果使用不同的字符集、不同的协议等也会被认为是不同的查询而分别进行缓存)。它不需要经过Optimizer模块进行执行计划的分析优化,更不需要发生同任何存储引擎的交互,减少了大量的磁盘IO和CPU运 算,所以有时候效率非常高。

二、查询缓存命中

判断一个缓存是否被命中,通过查询语句的HASH值来判断,HASH值因素包括查询语句、查询数据库、客户端版本协议等,如查询语句任何字符的不同,都会导致HASH结果的不同,都可能导致缓存无法命中。有些查询不能被缓存,如查询中包含UDF、存储函数、用户自定义变量、临时表、mysql库中系统表、或者包含列级权限的表、有着不确定值的函数(Now()); 查询缓存是完全存储在内存中的,对整个内存空间分配回收等,会额外产生系统资源消耗,这会导致内存碎片的产生。

三、查看查询缓存的参数

MariaDB[(none)]>showglobalvariableslike'%query%'; +------------------------------+--------------------+ |Variable_name |Value | +------------------------------+--------------------+ |expensive_subquery_limit |100 | |ft_query_expansion_limit |20 | |have_query_cache |YES | |long_query_time |10.000000 | |query_alloc_block_size |16384 | |query_cache_limit |1048576 | |query_cache_min_res_unit |4096 | |query_cache_size |16777216 | |query_cache_strip_comments |OFF | |query_cache_type |ON | |query_cache_wlock_invalidate|OFF | |query_prealloc_size |24576 | |slow_query_log |OFF | |slow_query_log_file |localhost-slow.log| +------------------------------+--------------------+ 14rowsinset(0.01sec)

查询缓存相关变量说明

query_cache_min_res_unit: 查询缓存中内存块的最小分配单位;较小值会减少浪费,但会导致更频繁的内存分配操作;较大值会带来浪费,会导致碎片过多;

query_cache_limit:能够缓存的最大查询结果;对于有着较大结果的查询语句,建议在SELECT中使用SQL_NO_CACHE

query_cache_size:查询缓存总共可用的内存空间;单位是字节,必须是1024的整数倍;

query_cache_type: ON, OFF, DEMAND

a、0(OFF):关闭 Query Cache 功能,任何情况下都不会使用 Query Cache;

b、1(ON):开启 Query Cache 功能,但是当SELECT语句中使用SQL_NO_CACHE提示后,将不使用Query Cache;

c、2(DEMAND):开启Query Cache 功能,但是只有当SELECT语句中使用了SQL_CACHE 提示后,才使用Query Cache。

query_cache_wlock_invalidate:如果某表被其它的连接锁定,是否仍然可以从查询缓存中返回结果;默认值为OFF,表示可以在表被其它连接锁定的场景中继续从缓存返回数据;ON则表示不允许;

MariaDB[(none)]>showglobalstatuslike'Qcache%'; +-------------------------+----------+ |Variable_name |Value | +-------------------------+----------+ |Qcache_free_blocks |1 | |Qcache_free_memory |16759656| |Qcache_hits |0 | |Qcache_inserts |0 | |Qcache_lowmem_prunes |0 | |Qcache_not_cached |7 | |Qcache_queries_in_cache|0 | |Qcache_total_blocks |1 | +-------------------------+----------+ 8rowsinset(0.00sec)

查看缓存变量参数说明:

Qcache_free_blocks: 缓存池中空闲块的个数,空闲的内存块。

Qcache_free_memory: 缓存中空闲内存空间

Qcache_hits: 缓存命中次数

Qcache_inserts: 可缓存查询语句的结果被放入缓存的次数

Qcache_lowmen_prunes: 有多少次是因为查询缓存内存空间太少而使用LRU算法清理缓存的次数

Qcache_not_cached: 可缓存却未能缓存的结果,例如查询结果超出缓存块大小,查询中包含可变函数等

Qcache_queries_in_cache: 当前缓存中缓存的SQL数量

Qcache_total_blocks: 整个查询缓存有多少内存块

缓存命中率:Qcache_hits/(Qcache_hits+Com_select)

四、分析和配置查询缓存流程及提高缓存命中率

①.开始,如果查询缓存命中率是否可以接受?如果可以的话,就结束。

②.不能接受目前的缓存命中率,查看大部分查询不是可缓存?是的话,就是大部分查询都不能缓存,query_cache_limit足够大吗?如果是,就结束,说明查询不能缓存,有可能是用户自定义变量、存储函数等,这种情况,建议关闭查询缓存。如果不是足够大,则需要增加此值。

③.1.大部分查询缓存都是可以缓存,但是却没有被缓存。是否发生很多严重工作?

是的话,查看缓存是不是被碎片化。需要降低query_cache_min_res_unit的值或是否flush query cache命令来整理缓存,减少碎片。

③.2.如果缓存不是因为碎片太多导致没有被缓存,内存过低发生的修正工作?

④.1.如果是内存过低,则增加query_cache_size。

④.2.如果不是内存过低,是否有很多的更新语句?频繁的更新表导致的缓存不能被命中,是有很多频繁更新的语句,负载不适合缓存,建议关闭缓存。不是有很多频繁更新的语句,则有其他配置的问题。

⑤.如果不是发生了很多验证工作,缓存启动了?是,没有见过此查询。否的话,启动缓存。

linux

一、查询缓存说明

MySQL Query Cache是用来缓存我们所执行的SELECT语句以及该语句的结果集,MySql在实现Query Cache的具体技术细节上类似典型的KV存储,就是将SELECT语句和该查询语句的结果集做了一个HASH映射并保存在一定的内存区域中。当客户端发起SQL查询时,Query Cache的查找逻辑是,先对SQL进行相应的权限验证,接着就通过Query Cache来查找结果(注意必须是完全相同,即使多一个空格或者大小写不 同都认为不同,即使完全相同的SQL,如果使用不同的字符集、不同的协议等也会被认为是不同的查询而分别进行缓存)。它不需要经过Optimizer模块进行执行计划的分析优化,更不需要发生同任何存储引擎的交互,减少了大量的磁盘IO和CPU运 算,所以有时候效率非常高。

二、查询缓存命中

判断一个缓存是否被命中,通过查询语句的HASH值来判断,HASH值因素包括查询语句、查询数据库、客户端版本协议等,如查询语句任何字符的不同,都会导致HASH结果的不同,都可能导致缓存无法命中。有些查询不能被缓存,如查询中包含UDF、存储函数、用户自定义变量、临时表、mysql库中系统表、或者包含列级权限的表、有着不确定值的函数(Now()); 查询缓存是完全存储在内存中的,对整个内存空间分配回收等,会额外产生系统资源消耗,这会导致内存碎片的产生。

三、查看查询缓存的参数

MariaDB[(none)]>showglobalvariableslike'%query%'; +------------------------------+--------------------+ |Variable_name |Value | +------------------------------+--------------------+ |expensive_subquery_limit |100 | |ft_query_expansion_limit |20 | |have_query_cache |YES | |long_query_time |10.000000 | |query_alloc_block_size |16384 | |query_cache_limit |1048576 | |query_cache_min_res_unit |4096 | |query_cache_size |16777216 | |query_cache_strip_comments |OFF | |query_cache_type |ON | |query_cache_wlock_invalidate|OFF | |query_prealloc_size |24576 | |slow_query_log |OFF | |slow_query_log_file |localhost-slow.log| +------------------------------+--------------------+ 14rowsinset(0.01sec)

查询缓存相关变量说明

query_cache_min_res_unit: 查询缓存中内存块的最小分配单位;较小值会减少浪费,但会导致更频繁的内存分配操作;较大值会带来浪费,会导致碎片过多;

query_cache_limit:能够缓存的最大查询结果;对于有着较大结果的查询语句,建议在SELECT中使用SQL_NO_CACHE

query_cache_size:查询缓存总共可用的内存空间;单位是字节,必须是1024的整数倍;

query_cache_type: ON, OFF, DEMAND

a、0(OFF):关闭 Query Cache 功能,任何情况下都不会使用 Query Cache;

b、1(ON):开启 Query Cache 功能,但是当SELECT语句中使用SQL_NO_CACHE提示后,将不使用Query Cache;

c、2(DEMAND):开启Query Cache 功能,但是只有当SELECT语句中使用了SQL_CACHE 提示后,才使用Query Cache。

query_cache_wlock_invalidate:如果某表被其它的连接锁定,是否仍然可以从查询缓存中返回结果;默认值为OFF,表示可以在表被其它连接锁定的场景中继续从缓存返回数据;ON则表示不允许;

MariaDB[(none)]>showglobalstatuslike'Qcache%'; +-------------------------+----------+ |Variable_name |Value | +-------------------------+----------+ |Qcache_free_blocks |1 | |Qcache_free_memory |16759656| |Qcache_hits |0 | |Qcache_inserts |0 | |Qcache_lowmem_prunes |0 | |Qcache_not_cached |7 | |Qcache_queries_in_cache|0 | |Qcache_total_blocks |1 | +-------------------------+----------+ 8rowsinset(0.00sec)

查看缓存变量参数说明:

Qcache_free_blocks: 缓存池中空闲块的个数,空闲的内存块。

Qcache_free_memory: 缓存中空闲内存空间

Qcache_hits: 缓存命中次数

Qcache_inserts: 可缓存查询语句的结果被放入缓存的次数

Qcache_lowmen_prunes: 有多少次是因为查询缓存内存空间太少而使用LRU算法清理缓存的次数

Qcache_not_cached: 可缓存却未能缓存的结果,例如查询结果超出缓存块大小,查询中包含可变函数等

Qcache_queries_in_cache: 当前缓存中缓存的SQL数量

Qcache_total_blocks: 整个查询缓存有多少内存块

缓存命中率:Qcache_hits/(Qcache_hits+Com_select)

四、分析和配置查询缓存流程及提高缓存命中率

①.开始,如果查询缓存命中率是否可以接受?如果可以的话,就结束。

②.不能接受目前的缓存命中率,查看大部分查询不是可缓存?是的话,就是大部分查询都不能缓存,query_cache_limit足够大吗?如果是,就结束,说明查询不能缓存,有可能是用户自定义变量、存储函数等,这种情况,建议关闭查询缓存。如果不是足够大,则需要增加此值。

③.1.大部分查询缓存都是可以缓存,但是却没有被缓存。是否发生很多严重工作?

是的话,查看缓存是不是被碎片化。需要降低query_cache_min_res_unit的值或是否flush query cache命令来整理缓存,减少碎片。

③.2.如果缓存不是因为碎片太多导致没有被缓存,内存过低发生的修正工作?

④.1.如果是内存过低,则增加query_cache_size。

④.2.如果不是内存过低,是否有很多的更新语句?频繁的更新表导致的缓存不能被命中,是有很多频繁更新的语句,负载不适合缓存,建议关闭缓存。不是有很多频繁更新的语句,则有其他配置的问题。

⑤.如果不是发生了很多验证工作,缓存启动了?是,没有见过此查询。否的话,启动缓存。

linux。太阳城申博注册

展开全文
相关文章
太阳城官方

MySQL查询缓存

收到太阳城申博的信息

一、查询缓存说明

MySQL Query Cache是用来缓存我们所执行的SELECT语句以及该语句的结果集,MySql在实现Query Cache的具体技术细节上类似典型的KV存储,就是将SELECT语句和该查询语句的结果集做了一个HASH映射并保存在一定的内存区域中。当客户端发起SQL查询时,Query Cache的查找逻辑是,先对SQL进行相应的权限验证,接着就通过Query Cache来查找结果(注意必须是完全相同,即使多一个空格或者大小写不 同都认为不同,即使完全相同的SQL,如果使用不同的字符集、不同的协议等也会被认为是不同的查询而分别进行缓存)。它不需要经过Optimizer模块进行执行计划的分析优化,更不需要发生同任何存储引擎的交互,减少了大量的磁盘IO和CPU运 算,所以有时候效率非常高。

二、查询缓存命中

判断一个缓存是否被命中,通过查询语句的HASH值来判断,HASH值因素包括查询语句、查询数据库、客户端版本协议等,如查询语句任何字符的不同,都会导致HASH结果的不同,都可能导致缓存无法命中。有些查询不能被缓存,如查询中包含UDF、存储函数、用户自定义变量、临时表、mysql库中系统表、或者包含列级权限的表、有着不确定值的函数(Now()); 查询缓存是完全存储在内存中的,对整个内存空间分配回收等,会额外产生系统资源消耗,这会导致内存碎片的产生。

三、查看查询缓存的参数

MariaDB[(none)]>showglobalvariableslike'%query%'; +------------------------------+--------------------+ |Variable_name |Value | +------------------------------+--------------------+ |expensive_subquery_limit |100 | |ft_query_expansion_limit |20 | |have_query_cache |YES | |long_query_time |10.000000 | |query_alloc_block_size |16384 | |query_cache_limit |1048576 | |query_cache_min_res_unit |4096 | |query_cache_size |16777216 | |query_cache_strip_comments |OFF | |query_cache_type |ON | |query_cache_wlock_invalidate|OFF | |query_prealloc_size |24576 | |slow_query_log |OFF | |slow_query_log_file |localhost-slow.log| +------------------------------+--------------------+ 14rowsinset(0.01sec)

查询缓存相关变量说明

query_cache_min_res_unit: 查询缓存中内存块的最小分配单位;较小值会减少浪费,但会导致更频繁的内存分配操作;较大值会带来浪费,会导致碎片过多;

query_cache_limit:能够缓存的最大查询结果;对于有着较大结果的查询语句,建议在SELECT中使用SQL_NO_CACHE

query_cache_size:查询缓存总共可用的内存空间;单位是字节,必须是1024的整数倍;

query_cache_type: ON, OFF, DEMAND

a、0(OFF):关闭 Query Cache 功能,任何情况下都不会使用 Query Cache;

b、1(ON):开启 Query Cache 功能,但是当SELECT语句中使用SQL_NO_CACHE提示后,将不使用Query Cache;

c、2(DEMAND):开启Query Cache 功能,但是只有当SELECT语句中使用了SQL_CACHE 提示后,才使用Query Cache。

query_cache_wlock_invalidate:如果某表被其它的连接锁定,是否仍然可以从查询缓存中返回结果;默认值为OFF,表示可以在表被其它连接锁定的场景中继续从缓存返回数据;ON则表示不允许;

MariaDB[(none)]>showglobalstatuslike'Qcache%'; +-------------------------+----------+ |Variable_name |Value | +-------------------------+----------+ |Qcache_free_blocks |1 | |Qcache_free_memory |16759656| |Qcache_hits |0 | |Qcache_inserts |0 | |Qcache_lowmem_prunes |0 | |Qcache_not_cached |7 | |Qcache_queries_in_cache|0 | |Qcache_total_blocks |1 | +-------------------------+----------+ 8rowsinset(0.00sec)

查看缓存变量参数说明:

Qcache_free_blocks: 缓存池中空闲块的个数,空闲的内存块。

Qcache_free_memory: 缓存中空闲内存空间

Qcache_hits: 缓存命中次数

Qcache_inserts: 可缓存查询语句的结果被放入缓存的次数

Qcache_lowmen_prunes: 有多少次是因为查询缓存内存空间太少而使用LRU算法清理缓存的次数

Qcache_not_cached: 可缓存却未能缓存的结果,例如查询结果超出缓存块大小,查询中包含可变函数等

Qcache_queries_in_cache: 当前缓存中缓存的SQL数量

Qcache_total_blocks: 整个查询缓存有多少内存块

缓存命中率:Qcache_hits/(Qcache_hits+Com_select)

四、分析和配置查询缓存流程及提高缓存命中率

①.开始,如果查询缓存命中率是否可以接受?如果可以的话,就结束。

②.不能接受目前的缓存命中率,查看大部分查询不是可缓存?是的话,就是大部分查询都不能缓存,query_cache_limit足够大吗?如果是,就结束,说明查询不能缓存,有可能是用户自定义变量、存储函数等,这种情况,建议关闭查询缓存。如果不是足够大,则需要增加此值。

③.1.大部分查询缓存都是可以缓存,但是却没有被缓存。是否发生很多严重工作?

是的话,查看缓存是不是被碎片化。需要降低query_cache_min_res_unit的值或是否flush query cache命令来整理缓存,减少碎片。

③.2.如果缓存不是因为碎片太多导致没有被缓存,内存过低发生的修正工作?

④.1.如果是内存过低,则增加query_cache_size。

④.2.如果不是内存过低,是否有很多的更新语句?频繁的更新表导致的缓存不能被命中,是有很多频繁更新的语句,负载不适合缓存,建议关闭缓存。不是有很多频繁更新的语句,则有其他配置的问题。

⑤.如果不是发生了很多验证工作,缓存启动了?是,没有见过此查询。否的话,启动缓存。

linux....

太阳城申博会员登入

一、查询缓存说明

MySQL Query Cache是用来缓存我们所执行的SELECT语句以及该语句的结果集,MySql在实现Query Cache的具体技术细节上类似典型的KV存储,就是将SELECT语句和该查询语句的结果集做了一个HASH映射并保存在一定的内存区域中。当客户端发起SQL查询时,Query Cache的查找逻辑是,先对SQL进行相应的权限验证,接着就通过Query Cache来查找结果(注意必须是完全相同,即使多一个空格或者大小写不 同都认为不同,即使完全相同的SQL,如果使用不同的字符集、不同的协议等也会被认为是不同的查询而分别进行缓存)。它不需要经过Optimizer模块进行执行计划的分析优化,更不需要发生同任何存储引擎的交互,减少了大量的磁盘IO和CPU运 算,所以有时候效率非常高。

二、查询缓存命中

判断一个缓存是否被命中,通过查询语句的HASH值来判断,HASH值因素包括查询语句、查询数据库、客户端版本协议等,如查询语句任何字符的不同,都会导致HASH结果的不同,都可能导致缓存无法命中。有些查询不能被缓存,如查询中包含UDF、存储函数、用户自定义变量、临时表、mysql库中系统表、或者包含列级权限的表、有着不确定值的函数(Now()); 查询缓存是完全存储在内存中的,对整个内存空间分配回收等,会额外产生系统资源消耗,这会导致内存碎片的产生。

三、查看查询缓存的参数

MariaDB[(none)]>showglobalvariableslike'%query%'; +------------------------------+--------------------+ |Variable_name |Value | +------------------------------+--------------------+ |expensive_subquery_limit |100 | |ft_query_expansion_limit |20 | |have_query_cache |YES | |long_query_time |10.000000 | |query_alloc_block_size |16384 | |query_cache_limit |1048576 | |query_cache_min_res_unit |4096 | |query_cache_size |16777216 | |query_cache_strip_comments |OFF | |query_cache_type |ON | |query_cache_wlock_invalidate|OFF | |query_prealloc_size |24576 | |slow_query_log |OFF | |slow_query_log_file |localhost-slow.log| +------------------------------+--------------------+ 14rowsinset(0.01sec)

查询缓存相关变量说明

query_cache_min_res_unit: 查询缓存中内存块的最小分配单位;较小值会减少浪费,但会导致更频繁的内存分配操作;较大值会带来浪费,会导致碎片过多;

query_cache_limit:能够缓存的最大查询结果;对于有着较大结果的查询语句,建议在SELECT中使用SQL_NO_CACHE

query_cache_size:查询缓存总共可用的内存空间;单位是字节,必须是1024的整数倍;

query_cache_type: ON, OFF, DEMAND

a、0(OFF):关闭 Query Cache 功能,任何情况下都不会使用 Query Cache;

b、1(ON):开启 Query Cache 功能,但是当SELECT语句中使用SQL_NO_CACHE提示后,将不使用Query Cache;

c、2(DEMAND):开启Query Cache 功能,但是只有当SELECT语句中使用了SQL_CACHE 提示后,才使用Query Cache。

query_cache_wlock_invalidate:如果某表被其它的连接锁定,是否仍然可以从查询缓存中返回结果;默认值为OFF,表示可以在表被其它连接锁定的场景中继续从缓存返回数据;ON则表示不允许;

MariaDB[(none)]>showglobalstatuslike'Qcache%'; +-------------------------+----------+ |Variable_name |Value | +-------------------------+----------+ |Qcache_free_blocks |1 | |Qcache_free_memory |16759656| |Qcache_hits |0 | |Qcache_inserts |0 | |Qcache_lowmem_prunes |0 | |Qcache_not_cached |7 | |Qcache_queries_in_cache|0 | |Qcache_total_blocks |1 | +-------------------------+----------+ 8rowsinset(0.00sec)

查看缓存变量参数说明:

Qcache_free_blocks: 缓存池中空闲块的个数,空闲的内存块。

Qcache_free_memory: 缓存中空闲内存空间

Qcache_hits: 缓存命中次数

Qcache_inserts: 可缓存查询语句的结果被放入缓存的次数

Qcache_lowmen_prunes: 有多少次是因为查询缓存内存空间太少而使用LRU算法清理缓存的次数

Qcache_not_cached: 可缓存却未能缓存的结果,例如查询结果超出缓存块大小,查询中包含可变函数等

Qcache_queries_in_cache: 当前缓存中缓存的SQL数量

Qcache_total_blocks: 整个查询缓存有多少内存块

缓存命中率:Qcache_hits/(Qcache_hits+Com_select)

四、分析和配置查询缓存流程及提高缓存命中率

①.开始,如果查询缓存命中率是否可以接受?如果可以的话,就结束。

②.不能接受目前的缓存命中率,查看大部分查询不是可缓存?是的话,就是大部分查询都不能缓存,query_cache_limit足够大吗?如果是,就结束,说明查询不能缓存,有可能是用户自定义变量、存储函数等,这种情况,建议关闭查询缓存。如果不是足够大,则需要增加此值。

③.1.大部分查询缓存都是可以缓存,但是却没有被缓存。是否发生很多严重工作?

是的话,查看缓存是不是被碎片化。需要降低query_cache_min_res_unit的值或是否flush query cache命令来整理缓存,减少碎片。

③.2.如果缓存不是因为碎片太多导致没有被缓存,内存过低发生的修正工作?

④.1.如果是内存过低,则增加query_cache_size。

④.2.如果不是内存过低,是否有很多的更新语句?频繁的更新表导致的缓存不能被命中,是有很多频繁更新的语句,负载不适合缓存,建议关闭缓存。不是有很多频繁更新的语句,则有其他配置的问题。

⑤.如果不是发生了很多验证工作,缓存启动了?是,没有见过此查询。否的话,启动缓存。

linux....

太阳城代

一、查询缓存说明

MySQL Query Cache是用来缓存我们所执行的SELECT语句以及该语句的结果集,MySql在实现Query Cache的具体技术细节上类似典型的KV存储,就是将SELECT语句和该查询语句的结果集做了一个HASH映射并保存在一定的内存区域中。当客户端发起SQL查询时,Query Cache的查找逻辑是,先对SQL进行相应的权限验证,接着就通过Query Cache来查找结果(注意必须是完全相同,即使多一个空格或者大小写不 同都认为不同,即使完全相同的SQL,如果使用不同的字符集、不同的协议等也会被认为是不同的查询而分别进行缓存)。它不需要经过Optimizer模块进行执行计划的分析优化,更不需要发生同任何存储引擎的交互,减少了大量的磁盘IO和CPU运 算,所以有时候效率非常高。

二、查询缓存命中

判断一个缓存是否被命中,通过查询语句的HASH值来判断,HASH值因素包括查询语句、查询数据库、客户端版本协议等,如查询语句任何字符的不同,都会导致HASH结果的不同,都可能导致缓存无法命中。有些查询不能被缓存,如查询中包含UDF、存储函数、用户自定义变量、临时表、mysql库中系统表、或者包含列级权限的表、有着不确定值的函数(Now()); 查询缓存是完全存储在内存中的,对整个内存空间分配回收等,会额外产生系统资源消耗,这会导致内存碎片的产生。

三、查看查询缓存的参数

MariaDB[(none)]>showglobalvariableslike'%query%'; +------------------------------+--------------------+ |Variable_name |Value | +------------------------------+--------------------+ |expensive_subquery_limit |100 | |ft_query_expansion_limit |20 | |have_query_cache |YES | |long_query_time |10.000000 | |query_alloc_block_size |16384 | |query_cache_limit |1048576 | |query_cache_min_res_unit |4096 | |query_cache_size |16777216 | |query_cache_strip_comments |OFF | |query_cache_type |ON | |query_cache_wlock_invalidate|OFF | |query_prealloc_size |24576 | |slow_query_log |OFF | |slow_query_log_file |localhost-slow.log| +------------------------------+--------------------+ 14rowsinset(0.01sec)

查询缓存相关变量说明

query_cache_min_res_unit: 查询缓存中内存块的最小分配单位;较小值会减少浪费,但会导致更频繁的内存分配操作;较大值会带来浪费,会导致碎片过多;

query_cache_limit:能够缓存的最大查询结果;对于有着较大结果的查询语句,建议在SELECT中使用SQL_NO_CACHE

query_cache_size:查询缓存总共可用的内存空间;单位是字节,必须是1024的整数倍;

query_cache_type: ON, OFF, DEMAND

a、0(OFF):关闭 Query Cache 功能,任何情况下都不会使用 Query Cache;

b、1(ON):开启 Query Cache 功能,但是当SELECT语句中使用SQL_NO_CACHE提示后,将不使用Query Cache;

c、2(DEMAND):开启Query Cache 功能,但是只有当SELECT语句中使用了SQL_CACHE 提示后,才使用Query Cache。

query_cache_wlock_invalidate:如果某表被其它的连接锁定,是否仍然可以从查询缓存中返回结果;默认值为OFF,表示可以在表被其它连接锁定的场景中继续从缓存返回数据;ON则表示不允许;

MariaDB[(none)]>showglobalstatuslike'Qcache%'; +-------------------------+----------+ |Variable_name |Value | +-------------------------+----------+ |Qcache_free_blocks |1 | |Qcache_free_memory |16759656| |Qcache_hits |0 | |Qcache_inserts |0 | |Qcache_lowmem_prunes |0 | |Qcache_not_cached |7 | |Qcache_queries_in_cache|0 | |Qcache_total_blocks |1 | +-------------------------+----------+ 8rowsinset(0.00sec)

查看缓存变量参数说明:

Qcache_free_blocks: 缓存池中空闲块的个数,空闲的内存块。

Qcache_free_memory: 缓存中空闲内存空间

Qcache_hits: 缓存命中次数

Qcache_inserts: 可缓存查询语句的结果被放入缓存的次数

Qcache_lowmen_prunes: 有多少次是因为查询缓存内存空间太少而使用LRU算法清理缓存的次数

Qcache_not_cached: 可缓存却未能缓存的结果,例如查询结果超出缓存块大小,查询中包含可变函数等

Qcache_queries_in_cache: 当前缓存中缓存的SQL数量

Qcache_total_blocks: 整个查询缓存有多少内存块

缓存命中率:Qcache_hits/(Qcache_hits+Com_select)

四、分析和配置查询缓存流程及提高缓存命中率

①.开始,如果查询缓存命中率是否可以接受?如果可以的话,就结束。

②.不能接受目前的缓存命中率,查看大部分查询不是可缓存?是的话,就是大部分查询都不能缓存,query_cache_limit足够大吗?如果是,就结束,说明查询不能缓存,有可能是用户自定义变量、存储函数等,这种情况,建议关闭查询缓存。如果不是足够大,则需要增加此值。

③.1.大部分查询缓存都是可以缓存,但是却没有被缓存。是否发生很多严重工作?

是的话,查看缓存是不是被碎片化。需要降低query_cache_min_res_unit的值或是否flush query cache命令来整理缓存,减少碎片。

③.2.如果缓存不是因为碎片太多导致没有被缓存,内存过低发生的修正工作?

④.1.如果是内存过低,则增加query_cache_size。

④.2.如果不是内存过低,是否有很多的更新语句?频繁的更新表导致的缓存不能被命中,是有很多频繁更新的语句,负载不适合缓存,建议关闭缓存。不是有很多频繁更新的语句,则有其他配置的问题。

⑤.如果不是发生了很多验证工作,缓存启动了?是,没有见过此查询。否的话,启动缓存。

linux....

ag1万本金

MySQL查询缓存....

相关资讯
ag手机客户端打不开

一、查询缓存说明

MySQL Query Cache是用来缓存我们所执行的SELECT语句以及该语句的结果集,MySql在实现Query Cache的具体技术细节上类似典型的KV存储,就是将SELECT语句和该查询语句的结果集做了一个HASH映射并保存在一定的内存区域中。当客户端发起SQL查询时,Query Cache的查找逻辑是,先对SQL进行相应的权限验证,接着就通过Query Cache来查找结果(注意必须是完全相同,即使多一个空格或者大小写不 同都认为不同,即使完全相同的SQL,如果使用不同的字符集、不同的协议等也会被认为是不同的查询而分别进行缓存)。它不需要经过Optimizer模块进行执行计划的分析优化,更不需要发生同任何存储引擎的交互,减少了大量的磁盘IO和CPU运 算,所以有时候效率非常高。

二、查询缓存命中

判断一个缓存是否被命中,通过查询语句的HASH值来判断,HASH值因素包括查询语句、查询数据库、客户端版本协议等,如查询语句任何字符的不同,都会导致HASH结果的不同,都可能导致缓存无法命中。有些查询不能被缓存,如查询中包含UDF、存储函数、用户自定义变量、临时表、mysql库中系统表、或者包含列级权限的表、有着不确定值的函数(Now()); 查询缓存是完全存储在内存中的,对整个内存空间分配回收等,会额外产生系统资源消耗,这会导致内存碎片的产生。

三、查看查询缓存的参数

MariaDB[(none)]>showglobalvariableslike'%query%'; +------------------------------+--------------------+ |Variable_name |Value | +------------------------------+--------------------+ |expensive_subquery_limit |100 | |ft_query_expansion_limit |20 | |have_query_cache |YES | |long_query_time |10.000000 | |query_alloc_block_size |16384 | |query_cache_limit |1048576 | |query_cache_min_res_unit |4096 | |query_cache_size |16777216 | |query_cache_strip_comments |OFF | |query_cache_type |ON | |query_cache_wlock_invalidate|OFF | |query_prealloc_size |24576 | |slow_query_log |OFF | |slow_query_log_file |localhost-slow.log| +------------------------------+--------------------+ 14rowsinset(0.01sec)

查询缓存相关变量说明

query_cache_min_res_unit: 查询缓存中内存块的最小分配单位;较小值会减少浪费,但会导致更频繁的内存分配操作;较大值会带来浪费,会导致碎片过多;

query_cache_limit:能够缓存的最大查询结果;对于有着较大结果的查询语句,建议在SELECT中使用SQL_NO_CACHE

query_cache_size:查询缓存总共可用的内存空间;单位是字节,必须是1024的整数倍;

query_cache_type: ON, OFF, DEMAND

a、0(OFF):关闭 Query Cache 功能,任何情况下都不会使用 Query Cache;

b、1(ON):开启 Query Cache 功能,但是当SELECT语句中使用SQL_NO_CACHE提示后,将不使用Query Cache;

c、2(DEMAND):开启Query Cache 功能,但是只有当SELECT语句中使用了SQL_CACHE 提示后,才使用Query Cache。

query_cache_wlock_invalidate:如果某表被其它的连接锁定,是否仍然可以从查询缓存中返回结果;默认值为OFF,表示可以在表被其它连接锁定的场景中继续从缓存返回数据;ON则表示不允许;

MariaDB[(none)]>showglobalstatuslike'Qcache%'; +-------------------------+----------+ |Variable_name |Value | +-------------------------+----------+ |Qcache_free_blocks |1 | |Qcache_free_memory |16759656| |Qcache_hits |0 | |Qcache_inserts |0 | |Qcache_lowmem_prunes |0 | |Qcache_not_cached |7 | |Qcache_queries_in_cache|0 | |Qcache_total_blocks |1 | +-------------------------+----------+ 8rowsinset(0.00sec)

查看缓存变量参数说明:

Qcache_free_blocks: 缓存池中空闲块的个数,空闲的内存块。

Qcache_free_memory: 缓存中空闲内存空间

Qcache_hits: 缓存命中次数

Qcache_inserts: 可缓存查询语句的结果被放入缓存的次数

Qcache_lowmen_prunes: 有多少次是因为查询缓存内存空间太少而使用LRU算法清理缓存的次数

Qcache_not_cached: 可缓存却未能缓存的结果,例如查询结果超出缓存块大小,查询中包含可变函数等

Qcache_queries_in_cache: 当前缓存中缓存的SQL数量

Qcache_total_blocks: 整个查询缓存有多少内存块

缓存命中率:Qcache_hits/(Qcache_hits+Com_select)

四、分析和配置查询缓存流程及提高缓存命中率

①.开始,如果查询缓存命中率是否可以接受?如果可以的话,就结束。

②.不能接受目前的缓存命中率,查看大部分查询不是可缓存?是的话,就是大部分查询都不能缓存,query_cache_limit足够大吗?如果是,就结束,说明查询不能缓存,有可能是用户自定义变量、存储函数等,这种情况,建议关闭查询缓存。如果不是足够大,则需要增加此值。

③.1.大部分查询缓存都是可以缓存,但是却没有被缓存。是否发生很多严重工作?

是的话,查看缓存是不是被碎片化。需要降低query_cache_min_res_unit的值或是否flush query cache命令来整理缓存,减少碎片。

③.2.如果缓存不是因为碎片太多导致没有被缓存,内存过低发生的修正工作?

④.1.如果是内存过低,则增加query_cache_size。

④.2.如果不是内存过低,是否有很多的更新语句?频繁的更新表导致的缓存不能被命中,是有很多频繁更新的语句,负载不适合缓存,建议关闭缓存。不是有很多频繁更新的语句,则有其他配置的问题。

⑤.如果不是发生了很多验证工作,缓存启动了?是,没有见过此查询。否的话,启动缓存。

linux....

太阳城网

一、查询缓存说明

MySQL Query Cache是用来缓存我们所执行的SELECT语句以及该语句的结果集,MySql在实现Query Cache的具体技术细节上类似典型的KV存储,就是将SELECT语句和该查询语句的结果集做了一个HASH映射并保存在一定的内存区域中。当客户端发起SQL查询时,Query Cache的查找逻辑是,先对SQL进行相应的权限验证,接着就通过Query Cache来查找结果(注意必须是完全相同,即使多一个空格或者大小写不 同都认为不同,即使完全相同的SQL,如果使用不同的字符集、不同的协议等也会被认为是不同的查询而分别进行缓存)。它不需要经过Optimizer模块进行执行计划的分析优化,更不需要发生同任何存储引擎的交互,减少了大量的磁盘IO和CPU运 算,所以有时候效率非常高。

二、查询缓存命中

判断一个缓存是否被命中,通过查询语句的HASH值来判断,HASH值因素包括查询语句、查询数据库、客户端版本协议等,如查询语句任何字符的不同,都会导致HASH结果的不同,都可能导致缓存无法命中。有些查询不能被缓存,如查询中包含UDF、存储函数、用户自定义变量、临时表、mysql库中系统表、或者包含列级权限的表、有着不确定值的函数(Now()); 查询缓存是完全存储在内存中的,对整个内存空间分配回收等,会额外产生系统资源消耗,这会导致内存碎片的产生。

三、查看查询缓存的参数

MariaDB[(none)]>showglobalvariableslike'%query%'; +------------------------------+--------------------+ |Variable_name |Value | +------------------------------+--------------------+ |expensive_subquery_limit |100 | |ft_query_expansion_limit |20 | |have_query_cache |YES | |long_query_time |10.000000 | |query_alloc_block_size |16384 | |query_cache_limit |1048576 | |query_cache_min_res_unit |4096 | |query_cache_size |16777216 | |query_cache_strip_comments |OFF | |query_cache_type |ON | |query_cache_wlock_invalidate|OFF | |query_prealloc_size |24576 | |slow_query_log |OFF | |slow_query_log_file |localhost-slow.log| +------------------------------+--------------------+ 14rowsinset(0.01sec)

查询缓存相关变量说明

query_cache_min_res_unit: 查询缓存中内存块的最小分配单位;较小值会减少浪费,但会导致更频繁的内存分配操作;较大值会带来浪费,会导致碎片过多;

query_cache_limit:能够缓存的最大查询结果;对于有着较大结果的查询语句,建议在SELECT中使用SQL_NO_CACHE

query_cache_size:查询缓存总共可用的内存空间;单位是字节,必须是1024的整数倍;

query_cache_type: ON, OFF, DEMAND

a、0(OFF):关闭 Query Cache 功能,任何情况下都不会使用 Query Cache;

b、1(ON):开启 Query Cache 功能,但是当SELECT语句中使用SQL_NO_CACHE提示后,将不使用Query Cache;

c、2(DEMAND):开启Query Cache 功能,但是只有当SELECT语句中使用了SQL_CACHE 提示后,才使用Query Cache。

query_cache_wlock_invalidate:如果某表被其它的连接锁定,是否仍然可以从查询缓存中返回结果;默认值为OFF,表示可以在表被其它连接锁定的场景中继续从缓存返回数据;ON则表示不允许;

MariaDB[(none)]>showglobalstatuslike'Qcache%'; +-------------------------+----------+ |Variable_name |Value | +-------------------------+----------+ |Qcache_free_blocks |1 | |Qcache_free_memory |16759656| |Qcache_hits |0 | |Qcache_inserts |0 | |Qcache_lowmem_prunes |0 | |Qcache_not_cached |7 | |Qcache_queries_in_cache|0 | |Qcache_total_blocks |1 | +-------------------------+----------+ 8rowsinset(0.00sec)

查看缓存变量参数说明:

Qcache_free_blocks: 缓存池中空闲块的个数,空闲的内存块。

Qcache_free_memory: 缓存中空闲内存空间

Qcache_hits: 缓存命中次数

Qcache_inserts: 可缓存查询语句的结果被放入缓存的次数

Qcache_lowmen_prunes: 有多少次是因为查询缓存内存空间太少而使用LRU算法清理缓存的次数

Qcache_not_cached: 可缓存却未能缓存的结果,例如查询结果超出缓存块大小,查询中包含可变函数等

Qcache_queries_in_cache: 当前缓存中缓存的SQL数量

Qcache_total_blocks: 整个查询缓存有多少内存块

缓存命中率:Qcache_hits/(Qcache_hits+Com_select)

四、分析和配置查询缓存流程及提高缓存命中率

①.开始,如果查询缓存命中率是否可以接受?如果可以的话,就结束。

②.不能接受目前的缓存命中率,查看大部分查询不是可缓存?是的话,就是大部分查询都不能缓存,query_cache_limit足够大吗?如果是,就结束,说明查询不能缓存,有可能是用户自定义变量、存储函数等,这种情况,建议关闭查询缓存。如果不是足够大,则需要增加此值。

③.1.大部分查询缓存都是可以缓存,但是却没有被缓存。是否发生很多严重工作?

是的话,查看缓存是不是被碎片化。需要降低query_cache_min_res_unit的值或是否flush query cache命令来整理缓存,减少碎片。

③.2.如果缓存不是因为碎片太多导致没有被缓存,内存过低发生的修正工作?

④.1.如果是内存过低,则增加query_cache_size。

④.2.如果不是内存过低,是否有很多的更新语句?频繁的更新表导致的缓存不能被命中,是有很多频繁更新的语句,负载不适合缓存,建议关闭缓存。不是有很多频繁更新的语句,则有其他配置的问题。

⑤.如果不是发生了很多验证工作,缓存启动了?是,没有见过此查询。否的话,启动缓存。

linux....

捕鱼游戏为什么能输钱

一、查询缓存说明

MySQL Query Cache是用来缓存我们所执行的SELECT语句以及该语句的结果集,MySql在实现Query Cache的具体技术细节上类似典型的KV存储,就是将SELECT语句和该查询语句的结果集做了一个HASH映射并保存在一定的内存区域中。当客户端发起SQL查询时,Query Cache的查找逻辑是,先对SQL进行相应的权限验证,接着就通过Query Cache来查找结果(注意必须是完全相同,即使多一个空格或者大小写不 同都认为不同,即使完全相同的SQL,如果使用不同的字符集、不同的协议等也会被认为是不同的查询而分别进行缓存)。它不需要经过Optimizer模块进行执行计划的分析优化,更不需要发生同任何存储引擎的交互,减少了大量的磁盘IO和CPU运 算,所以有时候效率非常高。

二、查询缓存命中

判断一个缓存是否被命中,通过查询语句的HASH值来判断,HASH值因素包括查询语句、查询数据库、客户端版本协议等,如查询语句任何字符的不同,都会导致HASH结果的不同,都可能导致缓存无法命中。有些查询不能被缓存,如查询中包含UDF、存储函数、用户自定义变量、临时表、mysql库中系统表、或者包含列级权限的表、有着不确定值的函数(Now()); 查询缓存是完全存储在内存中的,对整个内存空间分配回收等,会额外产生系统资源消耗,这会导致内存碎片的产生。

三、查看查询缓存的参数

MariaDB[(none)]>showglobalvariableslike'%query%'; +------------------------------+--------------------+ |Variable_name |Value | +------------------------------+--------------------+ |expensive_subquery_limit |100 | |ft_query_expansion_limit |20 | |have_query_cache |YES | |long_query_time |10.000000 | |query_alloc_block_size |16384 | |query_cache_limit |1048576 | |query_cache_min_res_unit |4096 | |query_cache_size |16777216 | |query_cache_strip_comments |OFF | |query_cache_type |ON | |query_cache_wlock_invalidate|OFF | |query_prealloc_size |24576 | |slow_query_log |OFF | |slow_query_log_file |localhost-slow.log| +------------------------------+--------------------+ 14rowsinset(0.01sec)

查询缓存相关变量说明

query_cache_min_res_unit: 查询缓存中内存块的最小分配单位;较小值会减少浪费,但会导致更频繁的内存分配操作;较大值会带来浪费,会导致碎片过多;

query_cache_limit:能够缓存的最大查询结果;对于有着较大结果的查询语句,建议在SELECT中使用SQL_NO_CACHE

query_cache_size:查询缓存总共可用的内存空间;单位是字节,必须是1024的整数倍;

query_cache_type: ON, OFF, DEMAND

a、0(OFF):关闭 Query Cache 功能,任何情况下都不会使用 Query Cache;

b、1(ON):开启 Query Cache 功能,但是当SELECT语句中使用SQL_NO_CACHE提示后,将不使用Query Cache;

c、2(DEMAND):开启Query Cache 功能,但是只有当SELECT语句中使用了SQL_CACHE 提示后,才使用Query Cache。

query_cache_wlock_invalidate:如果某表被其它的连接锁定,是否仍然可以从查询缓存中返回结果;默认值为OFF,表示可以在表被其它连接锁定的场景中继续从缓存返回数据;ON则表示不允许;

MariaDB[(none)]>showglobalstatuslike'Qcache%'; +-------------------------+----------+ |Variable_name |Value | +-------------------------+----------+ |Qcache_free_blocks |1 | |Qcache_free_memory |16759656| |Qcache_hits |0 | |Qcache_inserts |0 | |Qcache_lowmem_prunes |0 | |Qcache_not_cached |7 | |Qcache_queries_in_cache|0 | |Qcache_total_blocks |1 | +-------------------------+----------+ 8rowsinset(0.00sec)

查看缓存变量参数说明:

Qcache_free_blocks: 缓存池中空闲块的个数,空闲的内存块。

Qcache_free_memory: 缓存中空闲内存空间

Qcache_hits: 缓存命中次数

Qcache_inserts: 可缓存查询语句的结果被放入缓存的次数

Qcache_lowmen_prunes: 有多少次是因为查询缓存内存空间太少而使用LRU算法清理缓存的次数

Qcache_not_cached: 可缓存却未能缓存的结果,例如查询结果超出缓存块大小,查询中包含可变函数等

Qcache_queries_in_cache: 当前缓存中缓存的SQL数量

Qcache_total_blocks: 整个查询缓存有多少内存块

缓存命中率:Qcache_hits/(Qcache_hits+Com_select)

四、分析和配置查询缓存流程及提高缓存命中率

①.开始,如果查询缓存命中率是否可以接受?如果可以的话,就结束。

②.不能接受目前的缓存命中率,查看大部分查询不是可缓存?是的话,就是大部分查询都不能缓存,query_cache_limit足够大吗?如果是,就结束,说明查询不能缓存,有可能是用户自定义变量、存储函数等,这种情况,建议关闭查询缓存。如果不是足够大,则需要增加此值。

③.1.大部分查询缓存都是可以缓存,但是却没有被缓存。是否发生很多严重工作?

是的话,查看缓存是不是被碎片化。需要降低query_cache_min_res_unit的值或是否flush query cache命令来整理缓存,减少碎片。

③.2.如果缓存不是因为碎片太多导致没有被缓存,内存过低发生的修正工作?

④.1.如果是内存过低,则增加query_cache_size。

④.2.如果不是内存过低,是否有很多的更新语句?频繁的更新表导致的缓存不能被命中,是有很多频繁更新的语句,负载不适合缓存,建议关闭缓存。不是有很多频繁更新的语句,则有其他配置的问题。

⑤.如果不是发生了很多验证工作,缓存启动了?是,没有见过此查询。否的话,启动缓存。

linux....

热门资讯