MySQL存储引擎的选择

转自：http://www.cnblogs.com/zhangjing0502/archive/2012/08/03.html

 

存储引擎的选择：
1.事务
如果应用需要事务处理操作，InnoDB仍是最稳定的、良好集成的、已经被证明的一种选择。
如果不需要事务处理，并且主要操作是处理一些select或insert查询，MyISAM是很好的选择。

2.并发
如果只是需要并发的插入和读操作，MyISAM都是正确的选择。
如果需要混合性的并发操作，并且操作之间要互不干扰，那么支持行级锁的引擎是更好的选择。

3.备份
如果服务器可以周期性地停机，来进行备份，各种引擎都能很容易务份。
但如果需要某种联机备份，选择就复杂了。

4. 崩溃后恢复
如果有大量的数据，应慎重考虑，系统崩溃后需要花多长时间才能恢复。
如MyISAM表比InnoDB表更容易出错，恢复时间也更长。事实上，很多人并不需要事务处理，
也选择了InnoDB引擎，就是基于这个重要原因。

5.特有特性
只有某些引擎提供特殊性或优化手段。
例如，很多应用都依赖于聚集索引优化。这种情况下，只有InnoDB和solidDB可以选择。
别一方面，在MySQL中，也只有MyISAM支持全文检索。
如果某个存储引擎可以满足应用的一个或若干重要需求，但又不支持别的需求时，就要做折
衷考虑了，或寻找一种更灵巧的设计方案。
通常的情况是，某种存储引擎可以满足所有的需要，虽然从表面上看似乎不支持全部需求。

posted @ 2012-08-03 14:08 很多不懂呀。。 阅读(6) 评论(0) 编辑

mysql 压力测试工具

MySQL5.1地的确提供了好多有力的工具来帮助我们DBA进行数据库管理。
现在看一下这个压力测试工具mysqlslap.
关于他的选项手册上以及--help介绍的很详细。
我解释一下一些常用的选项。
这里要注意的几个选项：
--concurrency代表并发数量，多个可以用逗号隔开，当然你也可以用自己的分隔符隔开，这个时候要用到--delimiter开关。
--engines代表要测试的引擎，可以有多个，用分隔符隔开。
--iterations代表要运行这些测试多少次。
--auto-generate-sql 代表用系统自己生成的SQL脚本来测试。
--auto-generate-sql-load-type 代表要测试的是读还是写还是两者混合的（read,write,update,mixed）
--number-of-queries 代表总共要运行多少次查询。每个客户运行的查询数量可以用查询总数/并发数来计算。比如倒数第二个结果2=200/100。
--debug-info 代表要额外输出CPU以及内存的相关信息。
--number-int-cols 代表示例表中的INTEGER类型的属性有几个。
--number-char-cols 意思同上。
--create-schema 代表自己定义的模式（在MySQL中也就是库）。
--query 代表自己的SQL脚本。
--only-print 如果只想打印看看SQL语句是什么，可以用这个选项。

现在来看一些我测试的例子。

1、用自带的SQL脚本来测试。
MySQL版本为5.1.23
[root@localhost ~]# mysqlslap --defaults-file=/usr/local/mysql-maria/my.cnf --concurrency=50,100,200 --iterations=1 --number-int-cols=4 --number-char-cols=35 --auto-generate-sql --auto-generate-sql-add-autoincrement --auto-generate-sql-load-type=mixed --engine=myisam,innodb --number-of-queries=200 --debug-info -uroot -p1 -S/tmp/mysql_3310.sock

Benchmark
        Running for engine myisam
        Average number of seconds to run all queries: 0.063 seconds
        Minimum number of seconds to run all queries: 0.063 seconds
        Maximum number of seconds to run all queries: 0.063 seconds
        Number of clients running queries: 50
        Average number of queries per client: 4

Benchmark
        Running for engine myisam
        Average number of seconds to run all queries: 0.070 seconds
        Minimum number of seconds to run all queries: 0.070 seconds
        Maximum number of seconds to run all queries: 0.070 seconds
        Number of clients running queries: 100
        Average number of queries per client: 2

Benchmark
        Running for engine myisam
        Average number of seconds to run all queries: 0.092 seconds
        Minimum number of seconds to run all queries: 0.092 seconds
        Maximum number of seconds to run all queries: 0.092 seconds
        Number of clients running queries: 200
        Average number of queries per client: 1

Benchmark
        Running for engine innodb
        Average number of seconds to run all queries: 0.115 seconds
        Minimum number of seconds to run all queries: 0.115 seconds
        Maximum number of seconds to run all queries: 0.115 seconds
        Number of clients running queries: 50
        Average number of queries per client: 4

Benchmark
        Running for engine innodb
        Average number of seconds to run all queries: 0.134 seconds
        Minimum number of seconds to run all queries: 0.134 seconds
        Maximum number of seconds to run all queries: 0.134 seconds
        Number of clients running queries: 100
        Average number of queries per client: 2

Benchmark
        Running for engine innodb
        Average number of seconds to run all queries: 0.192 seconds
        Minimum number of seconds to run all queries: 0.192 seconds
        Maximum number of seconds to run all queries: 0.192 seconds
        Number of clients running queries: 200
        Average number of queries per client: 1


User time 0.06, System time 0.15
Maximum resident set size 0, Integral resident set size 0
Non-physical pagefaults 5803, Physical pagefaults 0, Swaps 0
Blocks in 0 out 0, Messages in 0 out 0, Signals 0
Voluntary context switches 8173, Involuntary context switches 528


我来解释一下结果的含义。
拿每个引擎最后一个Benchmark示例。
对于INNODB引擎，200个客户端同时运行这些SQL语句平均要花0.192秒。相应的MYISAM为0.092秒。

2、用我们自己定义的SQL 脚本来测试。
这些数据在另外一个MySQL实例上。版本为5.0.45
先看一下这两个表的相关数据。
1）、总记录数。
mysql> select table_rows as rows from information_schema.tables where table_schema='t_girl' and table_name='article';
+--------+
| rows   |
+--------+
| 296693 |
+--------+
1 row in set (0.01 sec)

mysql> select table_rows as rows from information_schema.tables where table_schema='t_girl' and table_name='category';
+------+
| rows |
+------+
| 113  |
+------+
1 row in set (0.00 sec)

2）、总列数。
mysql> select count(*) as column_total from information_schema.columns where table_schema = 't_girl' and table_name = 'article';
+--------------+
| column_total |
+--------------+
| 32           |
+--------------+
1 row in set (0.01 sec)

mysql> select count(*) as column_total from information_schema.columns where table_schema = 't_girl' and table_name = 'category';
+--------------+
| column_total |
+--------------+
| 9            |
+--------------+
1 row in set (0.01 sec)


3）、调用的存储过程
DELIMITER $$

DROP PROCEDURE IF EXISTS `t_girl`.`sp_get_article`$$

CREATE DEFINER=`root`@`%` PROCEDURE `sp_get_article`(IN f_category_id int,
 IN f_page_size int, IN f_page_no int
)
BEGIN
  set @stmt = 'select a.* from article as a inner join ';
  set @stmt = concat(@stmt,'(select a.aid from article as a ');
  if f_category_id != 0 then
    set @stmt = concat(@stmt,' inner join (select cid from category where cid = ',f_category_id,' or parent_id = ',f_category_id,') as b on a.category_id = b.cid');
  end if;
  if f_page_size >0 && f_page_no > 0 then
    set @stmt = concat(@stmt,' limit ',(f_page_no-1)*f_page_size,',',f_page_size);
  end if;
 
  set @stmt = concat(@stmt,') as b on (a.aid = b.aid)');
  prepare s1 from @stmt;
  execute s1;
  deallocate prepare s1;
  set @stmt = NULL;
END$$

DELIMITER ;
4）、我们用mysqlslap来测试
以下得这个例子代表用mysqlslap来测试并发数为25,50,100的调用存储过程，并且总共调用5000次。
[root@localhost ~]# mysqlslap --defaults-file=/usr/local/mysql-maria/my.cnf --concurrency=25,50,100 --iterations=1 --query='call t_girl.sp_get_article(2,10,1);' --number-of-queries=5000 --debug-info -uroot -p -S/tmp/mysql50.sock
Enter password:
Benchmark
        Average number of seconds to run all queries: 3.507 seconds
        Minimum number of seconds to run all queries: 3.507 seconds
        Maximum number of seconds to run all queries: 3.507 seconds
        Number of clients running queries: 25
        Average number of queries per client: 200
平均每个并发运行200个查询用了3.507秒。
Benchmark
        Average number of seconds to run all queries: 3.742 seconds
        Minimum number of seconds to run all queries: 3.742 seconds
        Maximum number of seconds to run all queries: 3.742 seconds
        Number of clients running queries: 50
        Average number of queries per client: 100

Benchmark
        Average number of seconds to run all queries: 3.697 seconds
        Minimum number of seconds to run all queries: 3.697 seconds
        Maximum number of seconds to run all queries: 3.697 seconds
        Number of clients running queries: 100
        Average number of queries per client: 50


User time 0.87, System time 0.33
Maximum resident set size 0, Integral resident set size 0
Non-physical pagefaults 1877, Physical pagefaults 0, Swaps 0
Blocks in 0 out 0, Messages in 0 out 0, Signals 0
Voluntary context switches 27218, Involuntary context switches 3100


看一下SHOW PROCESSLIST 结果
mysql> show processlist;
+------+------+--------------------+--------------------+---------+-------+--------------------+------------------------------------------------------------------------------------------------------+
| Id   | User | Host               | db                 | Command | Time  | State              | Info                                                                                                 |
+------+------+--------------------+--------------------+---------+-------+--------------------+------------------------------------------------------------------------------------------------------+
…………
| 3177 | root | %                  | t_girl             | Query   |     0 | NULL               | select a.* from article as a inner join (select a.aid from article as a  inner join (select cid from |
| 3178 | root | %                  | t_girl             | Query   |     0 | NULL               | select a.* from article as a inner join (select a.aid from article as a  inner join (select cid from |
| 3179 | root | %                  | t_girl             | Query   |     0 | NULL               | select a.* from article as a inner join (select a.aid from article as a  inner join (select cid from |
| 3181 | root | %                  | t_girl             | Query   |     0 | NULL               | select a.* from article as a inner join (select a.aid from article as a  inner join (select cid from |
| 3180 | root | %                  | t_girl             | Query   |     0 | NULL               | select a.* from article as a inner join (select a.aid from article as a  inner join (select cid from |
| 3182 | root | %                  | t_girl             | Query   |     0 | NULL               | select a.* from article as a inner join (select a.aid from article as a  inner join (select cid from |
| 3183 | root | %                  | t_girl             | Query   |     0 | NULL               | select a.* from article as a inner join (select a.aid from article as a  inner join (select cid from |
| 3187 | root | %                  | t_girl             | Query   |     0 | removing tmp table | select a.* from article as a inner join (select a.aid from article as a  inner join (select cid from |
| 3186 | root | %                  | t_girl             | Query   |     0 | NULL               | select a.* from article as a inner join (select a.aid from article as a  inner join (select cid from |
| 3194 | root | %                  | t_girl             | Query   |     0 | NULL               | select a.* from article as a inner join (select a.aid from article as a  inner join (select cid from |
| 3203 | root | %                  | t_girl             | Query   |     0 | NULL               | deallocate prepare s1                                                                                |
…………
| 3221 | root | %                  | t_girl             | Query   |     0 | NULL               | select a.* from article as a inner join (select a.aid from article as a  inner join (select cid from |
| 3222 | root | %                  | t_girl             | Query   |     0 | NULL               | select a.* from article as a inner join (select a.aid from article as a  inner join (select cid from |
| 3223 | root | %                  | t_girl             | Query   |     0 | NULL               | select a.* from article as a inner join (select a.aid from article as a  inner join (select cid from |
| 3224 | root | %                  | t_girl             | Query   |     0 | removing tmp table | select a.* from article as a inner join (select a.aid from article as a  inner join (select cid from |
| 3225 | root | %                  | t_girl             | Query   |     0 | NULL               | select a.* from article as a inner join (select a.aid from article as a  inner join (select cid from |
| 3226 | root | %                  | t_girl             | Query   |     0 | NULL               | select a.* from article as a inner join (select a.aid from article as a  inner join (select cid from |
+------+------+--------------------+--------------------+---------+-------+--------------------+------------------------------------------------------------------------------------------------------+
55 rows in set (0.00 sec)

上面的测试语句其实也可以这样写

[root@localhost ~]# mysqlslap --defaults-file=/usr/local/mysql-maria/my.cnf --concurrency=25,50,100 --iterations=1 --create-schema='t_girl' --query='call sp_get_article(2,10,1);' --number-of-queries=5000 --debug-info -uroot -p -S/tmp/mysql50.sock

 

 

另：

 

mysqlslap是一个mysql官方提供的压力测试工具。以下是比较重要的参数：
–defaults-file，配置文件存放位置
–concurrency，并发数
–engines，引擎
–iterations，迭代的实验次数
–socket，socket文件位置

自动测试：
–auto-generate-sql，自动产生测试SQL
–auto-generate-sql-load-type，测试SQL的类型。类型有mixed，update，write，key，read。
–number-of-queries，执行的SQL总数量
–number-int-cols，表内int列的数量
–number-char-cols，表内char列的数量

例如：
shell>mysqlslap –defaults-file=/u01/mysql1/mysql/my.cnf –concurrency=50,100 –iterations=1 –number-int-cols=4 –auto-generate-sql –auto-generate-sql-load-type=write –engine=myisam –number-of-queries=200 -S/tmp/mysql1.sock
Benchmark
Running for engine myisam
Average number of seconds to run all queries: 0.016 seconds
Minimum number of seconds to run all queries: 0.016 seconds
Maximum number of seconds to run all queries: 0.016 seconds
Number of clients running queries: 50
Average number of queries per client: 4

Benchmark
Running for engine myisam
Average number of seconds to run all queries: 0.265 seconds
Minimum number of seconds to run all queries: 0.265 seconds
Maximum number of seconds to run all queries: 0.265 seconds
Number of clients running queries: 100
Average number of queries per client: 2

指定数据库的测试：
–create-schema，指定数据库名称
–query，指定SQL语句，可以定位到某个包含SQL的文件

例如：
shell>mysqlslap –defaults-file=/u01/mysql1/mysql/my.cnf –concurrency=25,50 –iterations=1 –create-schema=test –query=/u01/test.sql -S/tmp/mysql1.sock
Benchmark
Average number of seconds to run all queries: 0.018 seconds
Minimum number of seconds to run all queries: 0.018 seconds
Maximum number of seconds to run all queries: 0.018 seconds
Number of clients running queries: 25
Average number of queries per client: 1

Benchmark
Average number of seconds to run all queries: 0.011 seconds
Minimum number of seconds to run all queries: 0.011 seconds
Maximum number of seconds to run all queries: 0.011 seconds
Number of clients running queries: 50
Average number of queries per client: 1

 

 

另：

Mysqlslap是从5.1.4版开始的一个MySQL官方提供的压力测试工具。通过模拟多个并发客户端访问MySQL来执行压力测试，同时详细的提供了“高负荷攻击MySQL”的数据性能报告。并且能很好的对比多个存储引擎在相同环境下的并发压力性能差别。

它的使用语法如下：
shell>/usr/local/mysql/bin/mysqlslap [options]

常用参数【options】详细介绍：
--concurrency代表并发数量，多个可以用逗号隔开。例如：--concurrency=50,200,500
--engines代表要测试的引擎，可以有多个，用分隔符隔开。例如：--engines=myisam,innodb,memory
--iterations代表要在不同并发环境下，各自运行测试多少次。
--auto-generate-sql 代表用mysqlslap工具自己生成的SQL脚本来测试并发压力。
--auto-generate-sql-add-auto-increment 代表对生成的表自动添加auto_increment列，从5.1.18版本开始，
--auto-generate-sql-load-type 代表要测试的环境是读操作还是写操作还是两者混合的（read,write,update,mixed）
--number-of-queries 代表总共要运行多少条查询。
--debug-info 代表要额外输出CPU以及内存的相关信息。
--number-int-cols 代表示例表中的INTEGER类型的属性有几个。
--number-char-cols代表示例表中的vachar类型的属性有几个。
--create-schema 代表自定义的测试库名称。
--query 代表自定义的测试SQL脚本。 

说明：

测试的过程需要生成测试表，插入测试数据，这个mysqlslap可以自动生成，默认生成一个mysqlslap的schema，如果已经存在则先删除。可以用-only-print来打印实际的测试过程，整个测试完成后不会在数据库中留下痕迹。


实验步骤：

练习一：
单线程测试。测试做了什么。
>./bin/mysqlslap -a -uroot -p111111 
多线程测试。使用--concurrency来模拟并发连接。
> ./bin/mysqlslap -a  -c 100 -uroot -p111111 
迭代测试。用于需要多次执行测试得到平均值。
> ./bin/mysqlslap  -a -i 10 -uroot -p111111

练习二：
> ./bin/mysqlslap -auto-generate-sql-add-autoincrement -a -uroot -p111111
> ./bin/mysqlslap -a -auto-generate-sql-load-type=read -uroot -p111111
> ./bin/mysqlslap -a -auto-generate-secondary-indexes=3 -uroot -p111111
> ./bin/mysqlslap -a -auto-generate-sql-write-number=1000 -uroot -p111111

> ./bin/mysqlslap --create-schema world -q "select count(*) from City" -uroot -p111111
> ./bin/mysqlslap -a -e innodb -uroot -p111111
> ./bin/mysqlslap -a --number-of-queries=10 -uroot -p111111


练习三：
执行一次测试，分别50和100个并发，执行1000次总查询：
> ./bin/mysqlslap -a --concurrency=50,100 --number-of-queries 1000 --debug-info -uroot -p111111

50和100个并发分别得到一次测试结果(Benchmark)，并发数越多，执行完所有查询的时间越长。为了准确起见，可以多迭代测试几次:
> ./bin/mysqlslap -a --concurrency=50,100 --number-of-queries 1000 --iterations=5 --debug-info -uroot -p111111

测试同时不同的存储引擎的性能进行对比：
>./bin/mysqlslap -a --concurrency=50,100 --number-of-queries 1000 --iterations=5 --engine=myisam,innodb --debug-info -uroot -p111111 

 

posted @ 2012-08-03 13:50 很多不懂呀。。 阅读(13) 评论(0) 编辑

mysql 相关2

1、查看当前所有连接的详细资料:
mysqladmin -uroot -proot processlist
D:\MySQL\bin>mysqladmin -uroot -proot processlist
+-----+------+----------------+---------+---------+------+-------+------------------+
| Id | User | Host | db | Command | Time | State | Info |
+-----+------+----------------+---------+---------+------+-------+------------------+
| 591 | root | localhost:3544 | bbs | Sleep | 25 | | |
| 701 | root | localhost:3761 | | uery | 0 | | show processlist |
+-----+------+----------------+---------+---------+------+-------+------------------+

2、只查看当前连接数(Threads就是连接数.):
mysqladmin -uroot -proot status
D:\MySQL\bin>mysqladmin -uroot -proot status
Uptime: 2102 Threads: 3 Questions: 15531 Slow queries: 0 Opens: 0 Flush tables: 1 Open tables: 61 Queries per second avg: 7.389

3、修改mysql最大连接数：
打开my.ini，修改max_connections=100(默认为100)。
命令： show processlist;
如果是root帐号，你能看到所有用户的当前连接。如果是其它普通帐号，只能看到自己占用的连接。
show processlist;只列出前100条，如果想全列出请使用show full processlist;

 

 

缓存机制简单的说就是缓存sql文本及查询结果，如果运行相同的sql，服务器直接从缓存中取到结果，而不需要再去解析和执行sql。如果表更改了，那么使用这个表的所有缓冲查询将不再有效，查询缓存值的相关条目被清空。更改指的是表中任何数据或是结构的改变，包括INSERT、UPDATE、DELETE、TRUNCATE、ALTER TABLE、DROP TABLE或DROP DATABASE等，也包括那些映射到改变了的表的使用MERGE表的查询。显然，这对于频繁更新的表，查询缓存是不适合的，而对于一些不常改变数据且有大量相同sql查询的表，查询缓存会节约很大的性能。

　　查询必须是完全相同的(逐字节相同)才能够被认为是相同的。另外，同样的查询字符串由于其它原因可能认为是不同的。使用不同的数据库、不同的协议版本或者不同 默认字符集的查询被认为是不同的查询并且分别进行缓存。

　　下面sql查询缓存认为是不同的：

　　SELECT * FROM tbl_name

　　Select * from tbl_name

　　查询缓存相关参数

mysql> SHOW VARIABLES LIKE ’%query_cache%’;
+------------------------------+---------+
| Variable_name                | Value   |
+------------------------------+---------+
| have_query_cache             | YES     | --查询缓存是否可用
| query_cache_limit            | 1048576 | --可缓存具体查询结果的最大值
| query_cache_min_res_unit     | 4096    |  
| query_cache_size             | 599040  | --查询缓存的大小
| query_cache_type             | ON      | --阻止或是支持查询缓存
| query_cache_wlock_invalidate | OFF     |  
+------------------------------+---------+  


　　下面是一个简单的例子：

[mysql@csdba1850 ~]$ mysql -u root -p
Enter password:  
Welcome to the MySQL monitor.  Commands end with ; or \\g.
Your MySQL connection id is 3
Server version: 5.0.45-community MySQL Community Edition (GPL)

Type ’help;’ or ’\\h’ for help. Type ’\\c’ to clear the buffer.

mysql> set global query_cache_size = 600000; --设置缓存内存
Query OK, 0 rows affected (0.00 sec)

mysql> set session query_cache_type = ON; --开启查询缓存
Query OK, 0 rows affected (0.00 sec)  

Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A

Database changed
mysql> show tables;
+----------------+
| Tables_in_test |
+----------------+
| animals        |  
| person         |  
+----------------+
5 rows in set (0.00 sec)

mysql> select count(*) from animals;
+----------+
| count(*) |
+----------+
|        6 |  
+----------+
1 row in set (0.00 sec)

--Qcache_hits表示sql查询在缓存中命中的累计次数，是累加值。
mysql> SHOW STATUS LIKE ’Qcache_hits’;
+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| Qcache_hits   | 0     |  --0次 [Page]
+---------------+-------+
8 rows in set (0.00 sec)

mysql>  select count(*) from animals;
+----------+
| count(*) |
+----------+
|        6 |  
+----------+
1 row in set (0.00 sec)

mysql>  SHOW STATUS LIKE ’Qcache%’;
+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| Qcache_hits   | 1     | --表示sql在缓存中直接得到结果，不需要再去解析
+---------------+-------+
8 rows in set (0.00 sec)

mysql> select count(*) from animals;
+----------+ | count(*) |
+----------+
|        6 |  
+----------+
1 row in set (0.00 sec)

mysql> select count(*) from animals;
+----------+
| count(*) |
+----------+
|        6 |  
+----------+
1 row in set (0.00 sec)

mysql> SHOW STATUS LIKE ’Qcache_hits’;
+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| Qcache_hits   | 3     |    --上面的sql也是是从缓存中直接取到结果

1rowinset(0.00sec) mysqlinsertintoanimalsselect9,testsds;--插入数据后，跟这个表所有相关的sql缓存就会被清空掉 QueryOK,1rowaffected(0.00sec) Records:1Duplicates:0Warnings:0 mysqlselectcount(*)fromanima
-

1 row in set (0.00 sec)

mysql> insert into animals select 9,’testsds’ ; --插入数据后，跟这个表所有相关的sql缓存就会被清空掉
Query OK, 1 row affected (0.00 sec)
Records: 1  Duplicates: 0  Warnings: 0

mysql> select count(*) from animals;
+----------+
| count(*) |
+----------+
|        7 |  
+----------+
1 row in set (0.00 sec)

mysql> SHOW STATUS LIKE ’Qcache_hits’;
+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| Qcache_hits   | 3    |  --还是等于3，说明上一条sql是没有直接从缓存中直接得到的
+---------------+-------+
1 row in set (0.00 sec)

mysql> select count(*) from animals;
+----------+
| count(*) |
+----------+
|        7 |  
+----------+
1 row in set (0.00 sec)

mysql> SHOW STATUS LIKE ’Qcache_hits’;  
+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| Qcache_hits   | 4     |  
+---------------+-------+
1 row in set (0.00 sec)  


http://tech.16c.cn/mysql/200904024265_3.html

当查询接收到一个和之前同样的查询，

服务器将会从查询缓存种检索结果，而不是再次分析和执行上次的查询。

这样就大大提高了性能，节省时间，非常有用。

打开查询缓存，是通过几个步骤来设置的，例如：虽然你设置Mysql允许查询缓存，但

是如果你设置的查询缓存大小为了0，这和没有允许没什么区别。

所以必须是几个步骤的设置才能真正打开查询缓存这个功能。

下面我用 mysql6.0 最为演示最常用的设置查询缓存

第一： query_cache_type 使用查询缓存的方式

一般，我们会把 query_cache_type 设置为 ON,默认情况下应该是ON

mysql> select @@query_cache_type;
+--------------------+
| @@query_cache_type |
+--------------------+
| ON |
+--------------------+
这样 当我们执行 select id,name from tableName; 这样就会用到查询缓存。

在 query_cache_type 打开的情况下，如果你不想使用缓存，需要指明
select sql_no_cache id,name from tableName;

当然也可以禁用查询缓存： mysql> set session query_cache_type=off;
这里我们不讨论这个，我们演示常用的设置。

第二： 系统变量 have_query_cache 设置查询缓存是否可用

mysql> show variables like 'have_query_cache';

+------------------+-------+
| Variable_name | Value |
+------------------+-------+
| have_query_cache | YES |
+------------------+-------+
上面的显示，表示设置查询缓存是可用的。

第三： 系统变量 query_cache_size

表示查询缓存大小，也就是分配内存大小给查询缓存，如果你分配大小为0，

那么 第一步 和 第二步 起不到作用，还是没有任何效果。

mysql> select @@global.query_cache_size;

+---------------------------+
| @@global.query_cache_size |
+---------------------------+
| 16777216 |
+---------------------------+
上面是 mysql6.0设置默认的，之前的版本好像默认是0的，那么就要自己设置下。

设置 set @@global.query_cache_size=1000000; 这里是设置1M左右，900多K。

再次查看下 select @@global.query_cache_size;

+---------------------------+
| @@global.query_cache_size |
+---------------------------+
| 999424 |
+---------------------------+
显示我们设置新的大小，表示设置成功。

第四： query_cache_limit 控制缓存查询结果的最大值

例如： 如果查询结果很大， 也缓存？？？？这个明显是不可能的。

MySql 可以设置一个最大的缓存值，当你查询缓存数结果数据超过这个值就不会
进行缓存。缺省为1M，也就是超过了1M查询结果就不会缓存。

mysql> select @@global.query_cache_limit;

+----------------------------+
| @@global.query_cache_limit |
+----------------------------+
| 1048576 |
+----------------------------+

这个是默认的数值，如果需要修改，就像设置缓存大小一样设置，使用set
重新指定大小。

MySQL查询缓存
注意：查询缓存绝不返回过期数据。
如果一个表发生的改变（insert,update,delect,truncate,alter或drop table|database）,那么所有这张表使用的缓冲的查询将被得失效，并从缓存中移除。
如果一个查询包括下面的函数，它将不能被缓存。
user-defined functions   connection_id   found_rows   get_lock   release_lock
load_file   master_pos_wait   now   sysdate   current_timestamp    curdate
current_date   curtime   current_time   database   encrypt  last_insert_id
rand   unix_timestamp   user   benchmark
查询缓存选项 select @@query_cache_type;
select sql_cache[选项on/off]
select sql_no_cache id,name from customer;
系统变量have_query_cache表示查询缓存是否可用。


show variables like ‘have_query_cache’;
系统查询query_cache_size表示查询缓存的大小。如果设置它为0，查询缓存将被禁止（缺省值为0）。


select @@global.query_cache_size;
若启用查询缓存，则系统变量query_cache_type表示查询缓存工作方式，他可以设置成如下值：
0（off,不缓存结果）
1（on,缓存所有的结果，除了select sql_no_cache… 查询）
2（demand,仅缓存select sql_cache… 查询）


用户可以禁止查询缓存；
set session query_cache_type=off;


若查询结果很大，缓存吗？
系统变量query_cache_limit控制可以缓存的查询结果的最大值，不缓存大于这个值的结果（缺省为1M）。


碎片整理
使用flush query cache命令，你可以整理查询缓存，以更好的利用它的内存。这个命令不会从缓存中移除任何查询。


清除cache
seset query cache命令从查询缓存中移除所有的查询结果。
flush tables也会清除查询缓存。
我们可以使用show status来监视查询缓存性能。
show status like ‘qcache%’;
变量                           含义
Qcache_queries_in_cache        搜索缓存中结果集的查询数目
Qcache_inserts                 被加入到缓存中的查询数目
Qcache_hits                    缓存命令数目
Qcache_lowmem_prunes           因为缺少内存而被从缓存中删除的查询数目
Qcache_not_cached              没有被缓存的查询结果数目（不能被缓存的，或由于
Query_cache_type）
Qcache_free_memory             查询缓存的空闲内存总数
Qcache_free_blocks             查询缓存的空闲内存块的数目
Qcache_total_blocks            查询缓存中的块的总数目

--------------------------------------------


MySQL 数据库管理
MySQL数据库管理
MySQL启动/停止/测试


添加用户
增加一个用户test_user密码为123，让他可以在任何主机上登陆，并对所有数据库有查询、插入、修改、删除的权限。
grant select,insert,update,delete on *.* to ‘test_user’@ ‘%’ identified by
‘123’;
增加一个用户test_user2密码123，让他只可以在localhost上登陆，并可以对数据库test进行查询、插入、修改、删除的操作（localhost指本地主机，即MySQL数据库所在的那台主机），这样用户即使知道test_user2的密码，他也无法从Internet上直接访问数据库，只能通过MySQL主机上的web页来访问了。
grant select,insert,update,delete on test.* to ‘test_user2’@ ‘localhost’ identfied by ‘123’;


创建一个本地的完全的超级用户admin，口令 ‘123’
grant all privileges on *.* to admin@localhost identified by ‘123’ with grant option ;


删除用户
revoke all on *.* from ‘test_user’@localhost;
delete from user where user= ‘test_user’;
flush privileges;


删除匿名用户
mysql mysql
delete from user where host= ‘localhost’ and user= ‘’;
flush privileges;#刷新内存授权表


修改密码
mysqladmin –u用户名 –p旧密码password新密码
给root加个密码123,再修改密码为456
mysqladmin –uroot password 123
mysqladmin –uroot –p123 password 456
或
mysql –u root –p
set password for root =password(“456”);
或
update user set password =password(‘456’) where user= ‘root’;
flush privileges;


清除密码
mysqladmin –uroot –p456 password ‘’;


优化
optimize table 表1，表2…
对含有varchar,blob或text列的表（记录行长度可变）有用。
MySQL数据库备份与优化


导入
load data infile ‘/tmp/teacher.txt’into table teacher;
或 mysqlimport school /tmp/teacher.txt;


逻辑备份
将数据库school中的表全部备份到school_2004_9.sql文本文件
mysqldump –-opt school > school_2004_9.sql
仅备份数据库school中的一部分表teacher和student
mysqldump –-opt school teacher student >school_teacher_student_2004_9.sql


备份多个数据库
mysqldump –-databases school tset >school_test_2004_9.sql


恢复
将数据库school不慎破坏，从school_2004_9.sql备份文件中恢复数据
creat database school;
use school;
source school_2004_9.sql#恢复


恢复表teacher和student
use school;
soure school_teacher_student_2004_9.sql


恢复多个数据库
souce school_test_2004_9.sql