Fred Chu » MySQL http://fred.oracle1.com/weblog 一个Web开发者的博客 Tue, 31 Jan 2012 08:00:24 +0000 en hourly 1 http://wordpress.org/?v=3.3.1 MySQL regex_replace Function http://fred.oracle1.com/weblog/2012/01/18/mysql-regex_replace-function/ http://fred.oracle1.com/weblog/2012/01/18/mysql-regex_replace-function/#comments Wed, 18 Jan 2012 04:03:19 +0000 Fred http://fred.oracle1.com/weblog/?p=2222
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
<pre>DELIMITER $$
CREATE FUNCTION  `regex_replace`(pattern VARCHAR(1000),replacement VARCHAR(1000),original VARCHAR(1000))

RETURNS VARCHAR(1000)
DETERMINISTIC
BEGIN
 DECLARE temp VARCHAR(1000);
 DECLARE ch VARCHAR(1);
 DECLARE i INT;
 SET i = 1;
 SET temp = '';
 IF original REGEXP pattern THEN
  loop_label: LOOP
   IF i&gt;CHAR_LENGTH(original) THEN
    LEAVE loop_label;
   END IF;
   SET ch = SUBSTRING(original,i,1);
   IF NOT ch REGEXP pattern THEN
    SET temp = CONCAT(temp,ch);
   ELSE
    SET temp = CONCAT(temp,replacement);
   END IF;
   SET i=i+1;
  END LOOP;
 ELSE
  SET temp = original;
 END IF;
 RETURN temp;
END$$
DELIMITER ;</pre>

Related Posts

]]> http://fred.oracle1.com/weblog/2012/01/18/mysql-regex_replace-function/feed/ 0 MySQL锁表机制分析 http://fred.oracle1.com/weblog/2010/09/13/mysql%e9%94%81%e8%a1%a8%e6%9c%ba%e5%88%b6%e5%88%86%e6%9e%90/ http://fred.oracle1.com/weblog/2010/09/13/mysql%e9%94%81%e8%a1%a8%e6%9c%ba%e5%88%b6%e5%88%86%e6%9e%90/#comments Mon, 13 Sep 2010 06:21:34 +0000 Fred http://fred.oracle1.com/weblog/?p=1948 为了给高并发情况下的mysql进行更好的优化，有必要了解一下mysql查询更新时的锁表机制。
一、概述
MySQL有三种锁的级别：页级、表级、行级。
MyISAM和MEMORY存储引擎采用的是表级锁（table-level locking）；BDB存储引擎采用的是页面锁（page-level
locking），但也支持表级锁；InnoDB存储引擎既支持行级锁（row-level locking），也支持表级锁，但默认情况下是采用行级锁。

MySQL这3种锁的特性可大致归纳如下：

  1. 表级锁：开销小，加锁快；不会出现死锁；锁定粒度大，发生锁冲突的概率最高,并发度最低。
  2. 行级锁：开销大，加锁慢；会出现死锁；锁定粒度最小，发生锁冲突的概率最低,并发度也最高。
  3. 页面锁：开销和加锁时间界于表锁和行锁之间；会出现死锁；锁定粒度界于表锁和行锁之间，并发度一般。

二、MyISAM表锁
MyISAM存储引擎只支持表锁，是现在用得最多的存储引擎。

  1. 查询表级锁争用情况
    可以通过检查table_locks_waited和table_locks_immediate状态变量来分析系统上的表锁定争夺：

    1
    2
    3
    4
    5
    6
    7
    8
    mysql>; show status like ‘table%’;
    +———————–+———-+
    | Variable_name | Value |
    +———————–+———-+
    | Table_locks_immediate | 76939364 |
    | Table_locks_waited | 305089 |
    +———————–+———-+
    2 rows in set (0.00 sec)

    Table_locks_waited的值比较高，说明存在着较严重的表级锁争用情况。

  2. MySQL表级锁的锁模式
    MySQL的表级锁有两种模式：表共享读锁（Table Read Lock）和表独占写锁（Table WriteLock）。MyISAM在执行查询语句（SELECT）前，会自动给涉及的所有表加读锁，在执行更新操作（UPDATE、DELETE、INSERT等）前，会自动给涉及的表加写锁。所以对MyISAM表进行操作，会有以下情况：
    1. a、对MyISAM表的读操作（加读锁），不会阻塞其他进程对同一表的读请求，但会阻塞对同一表的写请求。只有当读锁释放后，才会执行其它进程的写操作。
    2. b、对MyISAM表的写操作（加写锁），会阻塞其他进程对同一表的读和写操作，只有当写锁释放后，才会执行其它进程的读写操作。

    下面通过例子来进行验证以上观点。数据表gz_phone里有二百多万数据，字段id,phone,ua,day。现在同时用多个客户端同时对该表进行操作分析。

    1. a、当我用客户端1进行一个比较长时间的读操作时，分别用客户端2进行读和写操作：

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      client1:
      mysql&gt;select count(*) from gz_phone group by ua;
      75508 rows in set (3 min 15.87 sec) client2:
      select id,phone from gz_phone limit 1000,10;
      +——+——-+
      | id | phone |
      +——+——-+
      | 1001 | 2222 |
      | 1002 | 2222 |
      | 1003 | 2222 |
      | 1004 | 2222 |
      | 1005 | 2222 |
      | 1006 | 2222 |
      | 1007 | 2222 |
      | 1008 | 2222 |
      | 1009 | 2222 |
      | 1010 | 2222 |
      +——+——-+
      10 rows in set (0.01 sec)
      mysql&gt; update gz_phone set phone=’11111111111′ where id=1001;
      Query OK, 0 rows affected (2 min 57.88 sec)
      Rows matched: 1 Changed: 0 Warnings: 0

      说明当数据表有一个读锁时，其它进程的查询操作可以马上执行，但更新操作需等待读锁释放后才会执行。

    2. b、当用客户端1进行一个较长时间的更新操作时，用客户端2,3分别进行读写操作：
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      client1:
      mysql&gt; update gz_phone set phone=’11111111111′;
      Query OK, 1671823 rows affected (3 min 4.03 sec)
      Rows matched: 2212070 Changed: 1671823 Warnings: 0 client2:
      mysql&gt; select id,phone,ua,day from gz_phone limit 10;
      +—-+——-+——————-+————+
      | id | phone | ua | day |
      +—-+——-+——————-+————+
      | 1 | 2222 | SonyEricssonK310c | 2007-12-19 |
      | 2 | 2222 | SonyEricssonK750c | 2007-12-19 |
      | 3 | 2222 | MAUI WAP Browser | 2007-12-19 |
      | 4 | 2222 | Nokia3108 | 2007-12-19 |
      | 5 | 2222 | LENOVO-I750 | 2007-12-19 |
      | 6 | 2222 | BIRD_D636 | 2007-12-19 |
      | 7 | 2222 | SonyEricssonS500c | 2007-12-19 |
      | 8 | 2222 | SAMSUNG-SGH-E258 | 2007-12-19 |
      | 9 | 2222 | NokiaN73-1 | 2007-12-19 |
      | 10 | 2222 | Nokia2610 | 2007-12-19 |
      +—-+——-+——————-+————+
      10 rows in set (2 min 58.56 sec) client3:
      mysql&gt; update gz_phone set phone=’55555′ where id=1;
      Query OK, 1 row affected (3 min 50.16 sec)
      Rows matched: 1 Changed: 1 Warnings: 0

    说明当数据表有一个写锁时，其它进程的读写操作都需等待读锁释放后才会执行。

  3. 并发插入
    原则上数据表有一个读锁时，其它进程无法对此表进行更新操作，但在一定条件下，MyISAM表也支持查询和插入操作的并发进行。
    MyISAM存储引擎有一个系统变量concurrent_insert，专门用以控制其并发插入的行为，其值分别可以为0、1或2。

    1. a、当concurrent_insert设置为0时，不允许并发插入。
    2. b、当concurrent_insert设置为1时，如果MyISAM表中没有空洞（即表的中间没有被删除的行），MyISAM允许在一个进程读表的同时，另一个进程从表尾插入记录。这也是MySQL的默认设置。
    3. c、当concurrent_insert设置为2时，无论MyISAM表中有没有空洞，都允许在表尾并发插入记录。
  4. 4、MyISAM的锁调度
    由于MySQL认为写请求一般比读请求要重要，所以如果有读写请求同时进行的话，MYSQL将会优先执行写操作。这样MyISAM表在进行大量的更新操作时（特别是更新的字段中存在索引的情况下），会造成查询操作很难获得读锁，从而导致查询阻塞。
    我们可以通过一些设置来调节MyISAM的调度行为：
    1. a、通过指定启动参数low-priority-updates，使MyISAM引擎默认给予读请求以优先的权利。
    2. b、通过执行命令SET LOW_PRIORITY_UPDATES=1，使该连接发出的更新请求优先级降低。
    3. c、通过指定INSERT、UPDATE、DELETE语句的LOW_PRIORITY属性，降低该语句的优先级。

    上面3种方法都是要么更新优先，要么查询优先的方法。这里要说明的就是，不要盲目的给mysql设置为读优先，因为一些需要长时间运行的查询操作，也会使写进程“饿死”。只有根据你的实际情况，来决定设置哪种操作优先。这些方法还是没有从根本上同时解决查询和更新的问题。
    在一个有大数据量高并发表的mysql里，我们还可采用另一种策略来进行优化，那就是通过mysql主从（读写）分离来实现负载均衡，这样可避免优先哪一种操作从而可能导致另一种操作的堵塞。下面将用一个篇幅来说明mysql的读写分离技术。

Related Posts

]]> http://fred.oracle1.com/weblog/2010/09/13/mysql%e9%94%81%e8%a1%a8%e6%9c%ba%e5%88%b6%e5%88%86%e6%9e%90/feed/ 0 HOWTO: configure MySQL’s my.cnf file http://fred.oracle1.com/weblog/2010/09/09/howto-configure-mysql%e2%80%99s-my-cnf-file/ http://fred.oracle1.com/weblog/2010/09/09/howto-configure-mysql%e2%80%99s-my-cnf-file/#comments Thu, 09 Sep 2010 02:07:37 +0000 Fred http://fred.oracle1.com/weblog/?p=1919
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
[mysqld]
user=mysql
bind-address=127.0.0.1
datadir=/var/lib/mysql
pid-file=/var/run/mysqld/mysqld.pid
socket=/var/run/mysql/mysql.sock
port=3306
tmpdir=/tmp
language=/usr/share/mysql/english
skip-external-locking
query_cache_limit=64M
query_cache_size=32M
query_cache_type=1
max_connections=15
max_user_connections=300
interactive_timeout=100
wait_timeout=100
connect_timeout=10
thread_stack=128K
thread_cache_size=128
myisam-recover=BACKUP
key_buffer=64M
join_buffer=1M
max_allowed_packet=32M
table_cache=512M
sort_buffer_size=1M
read_buffer_size=1M
read_rnd_buffer_size=768K
max_connect_errors=10
thread_concurrency=4
myisam_sort_buffer_size=32M
skip-locking
skip-bdb
expire_logs_days=10
max_binlog_size=100M
server-id=1
[mysql.server]
user=mysql
basedir=/usr
[safe_mysqld]
bind-address=127.0.0.1
err-log=/var/log/mysqld.log
pid-file=/var/run/mysqld/mysqld.pid
open_files_limit=8192
SAFE_MYSQLD_OPTIONS=”–defaults-file=/etc/my.cnf –log-slow-queries=/var/log/slow-queries.log”
[mysql]
[isamchk]
key_buffer=64M
sort_buffer=64M
read_buffer=16M
write_buffer=16M
[myisamchk]
key_buffer=64M
sort_buffer=64M
read_buffer=16M
write_buffer=16M
[mysqlhotcopy]
interactive-timeout
max_heap_table_size = 64 M
tmp_table_size = 64 M
!includedir /etc/mysql/conf.d/

I’ve gone back and forth over the years configuring MySQL for optimal performance, and while I know I’m not there, I now have a new baseline to build from. From a post called Standard MYSQL my.cnf configuration, you can see all the base information, but also things like:

 key_buffer=256M # 64M for 1GB, 128M for 2GB, 256 for 4GB

Which defines the value (256M) but then spells out ideal base values for you to start with if you have more RAM on your system. This is very helpful, I’m tried to go a step further by combining it withDebian’s default my.cnf that comes on 5.0 (lenny) for MySQL 5. As I’m always open for suggestions for improvements, please comment if you have a different view on these choices, thanks. Here it is:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
[client]
socket=/var/run/mysqld/mysqld.sock
port=3306

[mysqld_safe]
socket=/var/run/mysqld/mysqld.sock
nice=0

[mysqld]
user=mysql
bind-address=127.0.0.1
datadir=/var/lib/mysql
pid-file=/var/run/mysqld/mysqld.pid
socket=/var/run/mysql/mysql.sock
port=3306
tmpdir=/tmp
language=/usr/share/mysql/english
skip-external-locking
query_cache_limit=1M
query_cache_size=32M
query_cache_type=1
max_connections=3000
max_user_connections=600
interactive_timeout=100
wait_timeout=100
connect_timeout=10
thread_stack=128K
thread_cache_size=128
myisam-recover=BACKUP
#key_buffer - 64M for 1GB, 128M for 2GB, 256 for 4GB
key_buffer=64M
#join_buffer_size - 1M for 1GB, 2M for 2GB, 4M for 4GB
join_buffer=1M
max_allowed_packet=32M
table_cache=1024
#sort_buffer_size - 1M for 1GB, 2M for 2GB, 4M for 4GB
sort_buffer_size=1M
#read_buffer_size - 1M for 1GB, 2M for 2GB, 4M for 4GB
read_buffer_size=1M
#read_rnd_buffer_size - 768K for 1GB, 1536K for 2GB, 3072K for 4GB
read_rnd_buffer_size=768K
max_connect_errors=10
thread_concurrency=4
#myisam_sort_buffer_size - 32M for 1GB, 64M for 2GB, 128 for 4GB
myisam_sort_buffer_size=32M
skip-locking
skip-bdb
expire_logs_days=10
max_binlog_size=100M
server-id=1

[mysql.server]
user=mysql
basedir=/usr

[safe_mysqld]
bind-address=127.0.0.1
err-log=/var/log/mysqld.log
pid-file=/var/run/mysqld/mysqld.pid
open_files_limit=8192
SAFE_MYSQLD_OPTIONS=”–defaults-file=/etc/my.cnf –log-slow-queries=/var/log/slow-queries.log”

#[mysqldump]
#quick
#quote-names
#max_allowed_packet=16M

[mysql]
#no-auto-rehash # faster start of mysql but no tab completition

[isamchk]
#key_buffer - 64M for 1GB, 128M for 2GB, 256M for 4GB
key_buffer=64M
#sort_buffer - 64M for 1GB, 128M for 2GB, 256M for 4GB
sort_buffer=64M
#read_buffer - 16M for 1GB, 32M for 2GB, 64M for 4GB
read_buffer=16M
#write_buffer - 16M for 1GB, 32M for 2GB, 64M for 4GB
write_buffer=16M

[myisamchk]
#key_buffer - 64M for 1GB, 128M for 2GB, 256M for 4GB
key_buffer=64M
#sort_buffer - 64M for 1GB, 128M for 2GB, 256M for 4GB
sort_buffer=64M
#read_buffer - 16M for 1GB, 32M for 2GB, 64M for 4GB
read_buffer=16M
#write_buffer - 16M for 1GB, 32M for 2GB, 64M for 4GB
write_buffer=16M

[mysqlhotcopy]
interactive-timeout

!includedir /etc/mysql/conf.d/

Related Posts

]]> http://fred.oracle1.com/weblog/2010/09/09/howto-configure-mysql%e2%80%99s-my-cnf-file/feed/ 0 MySQL性能优化21 – 使用随机函数产生采样 http://fred.oracle1.com/weblog/2010/09/08/mysql%e6%80%a7%e8%83%bd%e4%bc%98%e5%8c%9621-%e4%bd%bf%e7%94%a8%e9%9a%8f%e6%9c%ba%e5%87%bd%e6%95%b0%e4%ba%a7%e7%94%9f%e9%87%87%e6%a0%b7/ http://fred.oracle1.com/weblog/2010/09/08/mysql%e6%80%a7%e8%83%bd%e4%bc%98%e5%8c%9621-%e4%bd%bf%e7%94%a8%e9%9a%8f%e6%9c%ba%e5%87%bd%e6%95%b0%e4%ba%a7%e7%94%9f%e9%87%87%e6%a0%b7/#comments Wed, 08 Sep 2010 09:37:30 +0000 Fred http://fred.oracle1.com/weblog/?p=1917 RAND() 函数是 MySQL 提供的产生随机数的函数。没有指定参数时，每次执行会返回 0-1 的浮点数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
mysql> select rand();

+------------------+
| rand() |
+------------------+
| 0.56110724207117 |
+------------------+

1 row in set (0.02 sec)

mysql> select rand();

+-----------------+
| rand() |
+-----------------+
| 0.3343874880433 |
+-----------------+

1 row in set (0.00 sec)


有些时候，我们需要在统计操作的时候进行随机的采样，可以使用 ORDER BY RAND() 按照随机顺序检索数据行，如下：

1
2
3
4
5
6
7
8
9
10
mysql> select * from employee order by rand();

+------+--------+------+------+------+
| id | name | dep | pos | sal |
+------+--------+------+------+------+
| 4 | cathey | 02 | 02 | 3000 |
| 10 | sun | 02 | 02 | 1900 |
| 6 | lily | 03 | 02 | 2200 |
| 3 | micro | 02 | 01 | 1500 |
......

ORDER BY RAND() 同 LIMIT 的结合可以从一组列中选择随机样本，下面的例子就是使用 ORDER BY RAND() LIMIT 从雇员表随机获得 6 个样本的方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
mysql> select * from employee order by rand() limit 6;

+------+--------+------+------+------+
| id | name | dep | pos | sal |
+------+--------+------+------+------+
| 4 | cathey | 02 | 02 | 3000 |
| 5 | amy | 03 | 01 | 2500 |
| 2 | eefs | 01 | 02 | 2000 |
| 3 | micro | 02 | 01 | 1500 |
| 10 | sun | 02 | 02 | 1900 |
| 1 | abcd | 01 | 01 | 1000 |
+------+--------+------+------+------+

6 rows in set (0.00 sec)

随机抽取样本对总体的统计具有十分重要的意义，这个函数在进行统计操作的时候非常有用。

Related Posts

]]> http://fred.oracle1.com/weblog/2010/09/08/mysql%e6%80%a7%e8%83%bd%e4%bc%98%e5%8c%9621-%e4%bd%bf%e7%94%a8%e9%9a%8f%e6%9c%ba%e5%87%bd%e6%95%b0%e4%ba%a7%e7%94%9f%e9%87%87%e6%a0%b7/feed/ 0 MySQL性能优化20 – ORDER BY 操作的优化 http://fred.oracle1.com/weblog/2010/09/08/mysql%e6%80%a7%e8%83%bd%e4%bc%98%e5%8c%9620-order-by-%e6%93%8d%e4%bd%9c%e7%9a%84%e4%bc%98%e5%8c%96/ http://fred.oracle1.com/weblog/2010/09/08/mysql%e6%80%a7%e8%83%bd%e4%bc%98%e5%8c%9620-order-by-%e6%93%8d%e4%bd%9c%e7%9a%84%e4%bc%98%e5%8c%96/#comments Wed, 08 Sep 2010 09:35:14 +0000 Fred http://fred.oracle1.com/weblog/?p=1915 在某些情况中， MySQL 可以使用一个索引来满足 ORDER BY 子句，而不需要额外的排序。 where 条件和 order by 使用相同的索引，并且 order by 的顺序和索引顺序相同，并且 order by 的字段都是升序或者都是降序。

例如：下列 sql 可以使用索引。

1
2
3
4
5
SELECT * FROM t1 ORDER BY key_part1,key_part2,... ;

SELECT * FROM t1 WHERE key_part1=1 ORDER BY key_part1 DESC, key_part2 DESC;

SELECT * FROM t1 ORDER BY key_part1 DESC, key_part2 DESC;

但是以下情况不使用索引：

1
SELECT * FROM t1 ORDER BY key_part1 DESC, key_part2 ASC ；

–order by 的字段混合 ASC 和 DESC

1
SELECT * FROM t1 WHERE key2=constant ORDER BY key1 ；

– 用于查询行的关键字与 ORDER BY 中所使用的不相同

1
SELECT * FROM t1 ORDER BY key1, key2 ；

– 对不同的关键字使用 ORDER BY 。

Related Posts

]]> http://fred.oracle1.com/weblog/2010/09/08/mysql%e6%80%a7%e8%83%bd%e4%bc%98%e5%8c%9620-order-by-%e6%93%8d%e4%bd%9c%e7%9a%84%e4%bc%98%e5%8c%96/feed/ 0 MySQL性能优化19 – GROUP BY 操作的优化 http://fred.oracle1.com/weblog/2010/09/08/mysql%e6%80%a7%e8%83%bd%e4%bc%98%e5%8c%9619-group-by-%e6%93%8d%e4%bd%9c%e7%9a%84%e4%bc%98%e5%8c%96/ http://fred.oracle1.com/weblog/2010/09/08/mysql%e6%80%a7%e8%83%bd%e4%bc%98%e5%8c%9619-group-by-%e6%93%8d%e4%bd%9c%e7%9a%84%e4%bc%98%e5%8c%96/#comments Wed, 08 Sep 2010 09:33:33 +0000 Fred http://fred.oracle1.com/weblog/?p=1912 默认情况下， MySQL 在执行 GROUP BY col1 ， col2.... 操作的时候，会按照 GROUP BY 字段的顺序进行排序。如果显式包括一个包含相同的列的 ORDER BY 子句，则对 MySQL 的实际执行性能没有什么额外的影响。

如果查询包括 GROUP BY 操作， 但是不需要对结果进行排序，或者对默认的排序结果不满意，希望获得结果后再由程序进一步处理的时候，可以指定 ORDER BY NULL 禁止排序，从而避免排序结果的消耗。

下面介绍的例子对比了开启 / 关闭 GROUP BY 排序的执行计划：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
mysql> desc select dep,pos,avg(sal) from employee group by dep,pos \G

*************************** 1. row ***************************
id: 1
select_type: SIMPLE
table: employee
type: ALL
possible_keys: NULL
key: NULL
key_len: NULL
ref: NULL
rows: 10
Extra: Using temporary; Using filesort
1 row in set (0.00 sec)

mysql> desc select dep,pos,avg(sal) from employee group by dep,pos order by null \G
*************************** 1. row ***************************
id: 1
select_type: SIMPLE
table: employee
type: ALL
possible_keys: NULL
key: NULL
key_len: NULL
ref: NULL
rows: 10
Extra: Using temporary

1 row in set (0.00 sec)

从执行计划可以看到，使用了 ORDER BY NULL 的 SQL 减少了文件排序的步骤，当返回结果集很大时，对于 GROUP BY 的性能是有很大改善的。

Related Posts

]]> http://fred.oracle1.com/weblog/2010/09/08/mysql%e6%80%a7%e8%83%bd%e4%bc%98%e5%8c%9619-group-by-%e6%93%8d%e4%bd%9c%e7%9a%84%e4%bc%98%e5%8c%96/feed/ 0 MySQL性能优化18 – 使用 GROUP BY WITH ROLLUP 改善统计性能 http://fred.oracle1.com/weblog/2010/09/08/mysql%e6%80%a7%e8%83%bd%e4%bc%98%e5%8c%9618-%e4%bd%bf%e7%94%a8-group-by-with-rollup-%e6%94%b9%e5%96%84%e7%bb%9f%e8%ae%a1%e6%80%a7%e8%83%bd/ http://fred.oracle1.com/weblog/2010/09/08/mysql%e6%80%a7%e8%83%bd%e4%bc%98%e5%8c%9618-%e4%bd%bf%e7%94%a8-group-by-with-rollup-%e6%94%b9%e5%96%84%e7%bb%9f%e8%ae%a1%e6%80%a7%e8%83%bd/#comments Wed, 08 Sep 2010 09:31:20 +0000 Fred http://fred.oracle1.com/weblog/?p=1910 使用 GROUP BY 的 WITH ROLLUP 字句可以检索出更多的分组聚合信息，它不仅仅能像一般的 GROUP BY 语句那样检索出各组的聚合信息，还能检索出本组类的整体聚合信息。

下面我们的例子对比了普通的 GROUP BY 操作和有 WITH ROLLUP 子句的 GROUP BY 操作的不同：

查询表的内容，是雇员的基础信息表：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
mysql> select * from employee;

+------+--------+------+------+------+
| id | name | dep | pos | sal |
+------+--------+------+------+------+
| 1 | abcd | 01 | 01 | 1000 |
| 2 | eefs | 01 | 02 | 2000 |
| 3 | micro | 02 | 01 | 1500 |
| 4 | cathey | 02 | 02 | 3000 |
| 5 | amy | 03 | 01 | 2500 |
| 6 | lily | 03 | 02 | 2200 |
| 7 | bobo | 01 | 01 | 2000 |
| 8 | gray | 01 | 02 | 1900 |
| 9 | leon | 03 | 02 | 2900 |
| 10 | sun | 02 | 02 | 1900 |
+------+--------+------+------+------+

10 rows in set (0.00 sec)

普通的 GROUP BY 操作，可以按照部门和职位进行分组，计算每个部门，每个职位的工资平均值：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
mysql> select dep,pos,avg(sal) from employee group by dep,pos;

+------+------+-----------+
| dep | pos | avg(sal) |
+------+------+-----------+
| 01 | 01 | 1500.0000 |
| 01 | 02 | 1950.0000 |
| 02 | 01 | 1500.0000 |
| 02 | 02 | 2450.0000 |
| 03 | 01 | 2500.0000 |
| 03 | 02 | 2550.0000 |
+------+------+-----------+

6 rows in set (0.02 sec)

如果我们希望再显示部门的平均值和全部雇员的平均值，普通的 GROUP BY 语句是不能实现的，需要另外执行一个查询操作，或者通过程序来计算。如果使用有 WITH ROLLUP 子句的 GROUP BY 语句，则可以轻松实现这个要求：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
mysql> select dep,pos,avg(sal) from employee group by dep,pos with rollup;

+------+------+-----------+
| dep | pos | avg(sal) |
+------+------+-----------+
| 01 | 01 | 1500.0000 |
| 01 | 02 | 1950.0000 |
| 01 | NULL | 1725.0000 |
| 02 | 01 | 1500.0000 |
| 02 | 02 | 2450.0000 |
| 02 | NULL | 2133.3333 |
| 03 | 01 | 2500.0000 |
| 03 | 02 | 2550.0000 |
| 03 | NULL | 2533.3333 |
| NULL | NULL | 2090.0000 |
+------+------+-----------+

10 rows in set (0.00 sec)

需要注意的是，使用有 WITH ROLLUP 子句的 GROUP BY 语句时，不能再使用 ORDER BY 语句对结果集进行排序，如果对返回的结果顺序不满意，需要应用程序获得结果后在程序中进行排序。

Related Posts

]]> http://fred.oracle1.com/weblog/2010/09/08/mysql%e6%80%a7%e8%83%bd%e4%bc%98%e5%8c%9618-%e4%bd%bf%e7%94%a8-group-by-with-rollup-%e6%94%b9%e5%96%84%e7%bb%9f%e8%ae%a1%e6%80%a7%e8%83%bd/feed/ 0 MySQL性能优化17 – INSERT操作的优化 http://fred.oracle1.com/weblog/2010/09/08/mysql%e6%80%a7%e8%83%bd%e4%bc%98%e5%8c%9617-insert%e6%93%8d%e4%bd%9c%e7%9a%84%e4%bc%98%e5%8c%96/ http://fred.oracle1.com/weblog/2010/09/08/mysql%e6%80%a7%e8%83%bd%e4%bc%98%e5%8c%9617-insert%e6%93%8d%e4%bd%9c%e7%9a%84%e4%bc%98%e5%8c%96/#comments Wed, 08 Sep 2010 09:28:31 +0000 Fred http://fred.oracle1.com/weblog/?p=1908 执行 INSERT 操作的时候，可以考虑使用以下的方式优化 SQL 的执行效率：

  • 如果你同时从同一客户插入很多行，使用多个值表的 INSERT 语句。这比使用分开 INSERT 语句快。
    1
    Insert into test values(1,2),(1,3),(1,4) …
  • 如果你从不同客户插入很多行，能通过使用 INSERT DELAYED 语句得到更高的速度。 Delayed的含义是让 INSERT 语句马上执行，其实数据都被放在内存的队列中，并没有真正写入磁盘；这比每条语句分别插入要快的多； LOW_PRIORITY 刚好相反，在所有其他用户对表的读写完后才进行插入；
  • 将索引文件和数据文件分在不同的磁盘上存放；
  • 如果进行批量插入，可以增加 bulk_insert_buffer_size 变量值的方法来提高速度，但是，这只能对 MyISAM 表使用；
  • 当从一个文本文件装载一个表时，使用 LOAD DATA INFILE。这通常比使用很多 INSERT 语句快 20 倍；
  • 根据应用情况使用 REPLACE 语句代替 INSERT ；
  • 根据应用情况使用 IGNORE 关键字忽略重复记录。

Related Posts

]]> http://fred.oracle1.com/weblog/2010/09/08/mysql%e6%80%a7%e8%83%bd%e4%bc%98%e5%8c%9617-insert%e6%93%8d%e4%bd%9c%e7%9a%84%e4%bc%98%e5%8c%96/feed/ 0 MySQL性能优化16 – InnoDB 存储引擎 http://fred.oracle1.com/weblog/2010/09/08/mysql%e6%80%a7%e8%83%bd%e4%bc%98%e5%8c%9616-innodb-%e5%ad%98%e5%82%a8%e5%bc%95%e6%93%8e/ http://fred.oracle1.com/weblog/2010/09/08/mysql%e6%80%a7%e8%83%bd%e4%bc%98%e5%8c%9616-innodb-%e5%ad%98%e5%82%a8%e5%bc%95%e6%93%8e/#comments Wed, 08 Sep 2010 09:26:44 +0000 Fred http://fred.oracle1.com/weblog/?p=1906 对于 InnoDB 类型的表，这种方式并不能提高导入数据的效率。对于 InnoDB 类型的表，我们有以下几种方式可以提高导入的效率：

因为 InnoDB 类型的表是按照主键的顺序保存的，所以将导入的数据按照主键的顺序排列，可以有效的提高导入数据的效率。如果 InnoDB 表没有主键，那么系统会默认创建一个内部列作为主键，所以如果可以给表创建一个主键，将可以利用这个优势提高导入数据的效率。

在导入数据前执行 SET UNIQUE_CHECKS=0 ，关闭唯一性校验，在导入结束后执行 SET UNIQUE_CHECKS=1 ，恢复唯一性校验，可以提高导入的效率。

如果应用使用自动提交的方式，建议在导入前执行 SET AUTOCOMMIT=0 ，关闭自动提交，导入结束后再执行 SET AUTOCOMMIT=1，打开自动提交，也可以提高导入的效率。

Related Posts

]]> http://fred.oracle1.com/weblog/2010/09/08/mysql%e6%80%a7%e8%83%bd%e4%bc%98%e5%8c%9616-innodb-%e5%ad%98%e5%82%a8%e5%bc%95%e6%93%8e/feed/ 0 MySQL性能优化15 – MyISAM 存储引擎 http://fred.oracle1.com/weblog/2010/09/08/mysql%e6%80%a7%e8%83%bd%e4%bc%98%e5%8c%9615-myisam-%e5%ad%98%e5%82%a8%e5%bc%95%e6%93%8e/ http://fred.oracle1.com/weblog/2010/09/08/mysql%e6%80%a7%e8%83%bd%e4%bc%98%e5%8c%9615-myisam-%e5%ad%98%e5%82%a8%e5%bc%95%e6%93%8e/#comments Wed, 08 Sep 2010 09:25:16 +0000 Fred http://fred.oracle1.com/weblog/?p=1904 对于 MyISAM 类型的表，可以通过以下方式快速的导入大量的数据。

1
ALTER TABLE tblname DISABLE KEYS;

loading the data

1
ALTER TABLE tblname ENABLE KEYS;

这两个命令用来打开或者关闭 MyISAM 表非唯一索引的更新。在导入大量的数据到一个非空的 MyISAM 表时，通过设置这两个命令，可以提高导入的效率。对于导入大量数据到一个空的 MyISAM 表，默认就是先导入数据然后才创建索引的，所以不用进行设置。

Related Posts

]]> http://fred.oracle1.com/weblog/2010/09/08/mysql%e6%80%a7%e8%83%bd%e4%bc%98%e5%8c%9615-myisam-%e5%ad%98%e5%82%a8%e5%bc%95%e6%93%8e/feed/ 0