mysql dba系统学习(20)mysql存储引擎MyISAM

Mysql 路人甲 131℃ 0评论

mysql存储引擎MyISAM

1,创建myisam表

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
mysql> create table t (id int , name varchar(30) , msg varchar(100)) engine = MyISAM;
mysql> show table status like "t" \G ;
*************************** 1. row ***************************
Name: t
Engine: MyISAM
Version: 10
Row_format: Dynamic
Rows: 0
Avg_row_length: 0
Data_length: 0
Max_data_length: 281474976710655
Index_length: 1024
Data_free: 0
Auto_increment: NULL
Create_time: 2013-09-12 00:39:29
Update_time: 2013-09-12 00:39:29
Check_time: NULL
Collation: utf8_general_ci
Checksum: NULL
Create_options:
Comment:
1 row in set (0.00 sec)

2,auto_increment

当使用这个参数的时候,这个列一定要是主键

1
2
3
4
5
6
7
8
9
10
11
12
mysql> create table tt (id int auto_increment primary key  , name varchar(30) , msg varchar(100)) engine = MyISAM;
Query OK, 0 rows affected (0.01 sec)
mysql> insert into tt(name,msg) values('chenzhongyang','good');
Query OK, 1 row affected (0.00 sec)
虽然我们没有指定名字是chenzhongyang的id是1,但是有了auto_increment这个参数,系统会自动给他加上1
mysql> select * from tt;
+----+---------------+------+
| id | name          | msg  |
+----+---------------+------+
|  1 | chenzhongyang | good |
+----+---------------+------+
1 row in set (0.01 sec)

我们还可以设置auto_increment的值,但是这个值设置了的话,就会从这个值开始累积

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
mysql> alter table tt auto_increment=2000;
Query OK, 1 row affected (0.02 sec)
Records: 1  Duplicates: 0  Warnings: 0
mysql> insert into tt(name,msg) values('tianhongyan','baby');
Query OK, 1 row affected (0.00 sec)
mysql> select * from tt;
+------+---------------+------+
| id   | name          | msg  |
+------+---------------+------+
|    1 | chenzhongyang | good |
| 2000 | tianhongyan   | baby |
+------+---------------+------+
2 rows in set (0.00 sec)
mysql> insert into tt(name,msg) values('zhongguo','XXXXXXX-YYYYYYYYY-+VVVV');
Query OK, 1 row affected (0.00 sec)
mysql> select * FROM tt;
+------+---------------+-------------------------+
| id   | name          | msg                     |
+------+---------------+-------------------------+
|    1 | chenzhongyang | good                    |
| 2000 | tianhongyan   | baby                    |
| 2001 | zhongguo      | XXXXXXX-YYYYYYYYY-+VVVV |
+------+---------------+-------------------------+
3 rows in set (0.00 sec)

还有一个函数比较有用last_insert_id()。这个函数可以查出最后一次insert的id

1
2
3
4
5
6
7
mysql> select  last_insert_id();
+------------------+
| last_insert_id() |
+------------------+
|             2001 |
+------------------+
1 row in set (0.00 sec)

3,存储结构

数据文件(.MYD),索引文件(.MYI)和结构文件(.frm)

特点:可以在不同服务器上拷贝数据文件和索引文件。

如果我们把索引文件和数据文件放到不同的机器上,那么可以提高系统i/o

4,不支持事务

即使我们关闭autocommit,myisam引擎还是会立即执行我们的命令,这个时候rollback已经没有用了

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
mysql> show variables like "%autocommit%";
+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| autocommit    | ON    |
+---------------+-------+
1 row in set (0.00 sec)
mysql> set autocommit=OFF ;
Query OK, 0 rows affected (0.00 sec)
mysql> show variables like "%autocommit%";
+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| autocommit    | OFF   |
+---------------+-------+
1 row in set (0.00 sec)
mysql> delete from tt where id=1;
Query OK, 1 row affected (0.00 sec)
mysql> rollback;
Query OK, 0 rows affected, 1 warning (0.00 sec)
mysql> select   * from tt;
+------+-------------+-------------------------+
| id   | name        | msg                     |
+------+-------------+-------------------------+
| 2000 | tianhongyan | baby                    |
| 2001 | zhongguo    | XXXXXXX-YYYYYYYYY-+VVVV |
+------+-------------+-------------------------+
2 rows in set (0.00 sec)

5,myisam_data_pointer_size

默认的指针大小是6byte,一个字节是8bit那么数据文件的大小就是2的6*8次方byte

也就是1024*1024*1024*1024*256/1024/1024/1024/1024=256TB

1
2
3
4
5
6
7
mysql> show variables like "%pointer%";
+--------------------------+-------+
| Variable_name            | Value |
+--------------------------+-------+
| myisam_data_pointer_size | 6     |
+--------------------------+-------+
1 row in set (0.00 sec)

我们来做个实验试试

1
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
如果myisam_data_pointer_size=2,那么就意味着一个表的最大数据文件是65535/1024=64K
mysql> set global myisam_data_pointer_size=2;
Query OK, 0 rows affected (0.00 sec)
mysql> show variables like "%pointer%";
+--------------------------+-------+
| Variable_name            | Value |
+--------------------------+-------+
| myisam_data_pointer_size | 2     |
+--------------------------+-------+
1 row in set (0.00 sec)
我们来创建一个 大表ss
mysql> create table ss select * from information_schema.tables ;
Query OK, 54 rows affected (0.09 sec)
Records: 54  Duplicates: 0  Warnings: 0
mysql> insert into ss select * from ss;
Query OK, 108 rows affected (0.01 sec)
Records: 108  Duplicates: 0  Warnings: 0
mysql> insert into ss select * from ss;
Query OK, 216 rows affected (0.01 sec)
Records: 216  Duplicates: 0  Warnings: 0
这个时候出现了表ss满了的错误,我们看看数据文件 是64K,要想继续可以插入数据,那么就要把这个参数调大
mysql> insert into ss select * from ss;
ERROR 1114 (HY000): The table 'ss' is full
mysql> insert into ss select * from ss;
ERROR 1114 (HY000): The table 'ss' is full
mysql> insert into ss select * from ss;
ERROR 1114 (HY000): The table 'ss' is full
[root@test3 test]# ls -lh
total 116K
-rw-rw----. 1 mysql mysql 9.3K Sep 12 06:44 ss.frm
-rw-rw----. 1 mysql mysql  64K Sep 12 06:44 ss.MYD
-rw-rw----. 1 mysql mysql 1.0K Sep 12 06:44 ss.MYI
mysql> insert into ss select * from ss;
ERROR 1114 (HY000): The table 'ss' is full
mysql> alter table ss max_ROWS=10000000000 ;
Query OK, 496 rows affected (0.11 sec)
Records: 496  Duplicates: 0  Warnings: 0
mysql> insert into ss select * from ss;
Query OK, 496 rows affected (0.02 sec)
Records: 496  Duplicates: 0  Warnings: 0

6,myisam的存储行格式

MyISAM支持三种不同存储格式。

其中两个(固定格式和动态格式)根据正使用的列的类型来自动选择。第三个,即已压缩格式,只能使用myisampack工具来创建。

1.fixed静态格式(固定长度)表的一般特征:

·CHAR列对列宽度是空间填补的。

·非常快。

·容易缓存。

·崩溃后容易重建,因为记录位于固定位置。

·重新组织是不必要的,除非你删除巨量的记录并且希望为操作系统腾出磁盘空间。为此,可使用OPTIMIZETABLE或者myisamchk-r

·通常比动态格式表需要更多的磁盘空间。

2.dynamic动态格式表的一般特征:

·除了长度少于4的列外,所有的字符串列是动态的。

·在每个记录前面是一个位图,该位图表明哪一列包含空字符串(对于字符串列)或者0(对于数字列)。注意,这并不包括包含NULL值的列。如果一个字符列在拖曳空间移除后长度为零,或者一个数字列为零值,这都在位图中标注了且列不被保存到磁盘。非空字符串被存为一个长度字节加字符串的内容。

·通常比固定长度表需要更少的磁盘空间。

·每个记录仅使用必需大小的空间。尽管如此,如果一个记录变大,它就按需要被分开成多片,造成记录碎片的后果。比如,你用扩展行长度的信息更新一行,该行就变得有碎片。在这种情况下,你可以时不时运行OPTIMIZETABLE或myisamchk-r来改善性能。可使用myisamchk-ei来获取表的统计数据。

·动态格式表在崩溃后要比静态格式表更难重建,因为一个记录可能被分为多个碎片且链接(碎片)可能被丢失。

3.已压缩表有下列特征:

·已压缩表占据非常小的磁盘空间。这最小化了磁盘用量,当使用缓慢的磁盘(如CD-ROM)之时,这是很有用的。

·每个记录是被单独压缩的,所以只有非常小的访问开支。依据表中最大的记录,一个记录的头在每个表中占据1到3个字节。每个列被不同地压缩。通常每个列有一个不同的Huffman树。一些压缩类型如下:

-后缀空间压缩。

-前缀空间压缩。

-零值的数用一个位来存储。

-如果在一个整型列中的值有一个小的范围,列被用最小可能的类型来存储。比如,一个BIGINT列(8字节),如果所有它的值在-128到127范围内,它可以被存储为TINYINT列(1字节)

-如果一个列仅有一小组可能的值,列的类型被转化成ENUM。

-一个列可以使用先前压缩类型的任意合并。

·可以处理固定长度或动态长度记录。

7,加锁和并发

MyISAM存储引擎只支持表锁,这也是MySQL开始几个版本中唯一支持的锁类型。随着应用对事务完整性和并发性要求的不断提高,MySQL才开始开发基于事务的存储引擎,后来慢慢出现了支持页锁的BDB存储引擎和支持行锁的InnoDB存储引擎(实际InnoDB是单独的一个公司,现在已经被Oracle公司收购)。但是MyISAM的表锁依然是使用最为广泛的锁类型

加锁:对整张表进行加锁,而不是行。
并发:在读数据的时候,所有的表上都可以获得共享锁(读锁),每个连接都不互相干扰。
在写数据的时候,获得排他锁,会把整个表进行加锁,而其他的连接请求(读,写请求)都处于等待中。

可以通过检查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 | 2979 |
| Table_locks_waited | 0 |
+-----------------------+-------+
2 rows in set (0.00 sec))

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

对MyISAM表的读操作,不会阻塞其他用户对同一表的读请求,但会阻塞对同一表的写请求;对MyISAM表的写操作,则会阻塞其他用户对同一表的读和写操作;MyISAM表的读操作与写操作之间,以及写操作之间是串行的

MyISAM在执行查询语句(SELECT)前,会自动给涉及的所有表加读锁,在执行更新操作(UPDATE、DELETE、INSERT等)前,会自动给涉及的表加写锁,这个过程并不需要用户干预,因此,用户一般不需要直接用LOCKTABLE命令给MyISAM表显式加锁。显式加锁基本上都是为了方便而已,并非必须如此。也正是因为这样,所以myisam不会产生死锁。

READ锁表

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
获得表film_text的READ锁定
mysql> lock table film_text read;
Query OK, 0 rows affected (0.00 sec)
当前session可以查询该表记录
mysql> select film_id,title from film_text where film_id = 1001;
+---------+------------------+
| film_id | title            |
+---------+------------------+
| 1001     | ACADEMY DINOSAUR |
+---------+------------------+
1 row in set (0.00 sec)
其他session也可以查询该表的记录
mysql> select film_id,title from film_text where film_id = 1001;
+---------+------------------+
| film_id | title            |
+---------+------------------+
| 1001    | ACADEMY DINOSAUR |
+---------+------------------+
1 row in set (0.00 sec)
当前session不能查询没有锁定的表
mysql> select film_id,title from film where film_id = 1001;
ERROR 1100 (HY000): Table 'film' was not locked with LOCK TABLES
其他session可以查询或者更新未锁定的表
mysql> select film_id,title from film where film_id = 1001;
+---------+---------------+
| film_id | title         |
+---------+---------------+
| 1001    | update record |
+---------+---------------+
1 row in set (0.00 sec)
mysql> update film set title = 'Test' where film_id = 1001;
Query OK, 1 row affected (0.04 sec)
Rows matched: 1 Changed: 1 Warnings: 0
当前session中插入或者更新锁定的表都会提示错误:
mysql> insert into film_text (film_id,title) values(1002,'Test');
ERROR 1099 (HY000): Table 'film_text' was locked with a READ lock and can't be updated
mysql> update film_text set title = 'Test' where film_id = 1001;
ERROR 1099 (HY000): Table 'film_text' was locked with a READ lock and can't be updated
其他session更新锁定表会等待获得锁:
mysql> update film_text set title = 'Test' where film_id = 1001;
等待
释放锁
mysql> unlock tables;
Query OK, 0 rows affected (0.00 sec)
等待
Session获得锁,更新操作完成:
mysql> update film_text set title = 'Test' where film_id = 1001;
Query OK, 1 row affected (1 min 0.71 sec)
Rows matched: 1 Changed: 1 Warnings: 0
当使用LOCK TABLES时,不仅需要一次锁定用到的所有表,而且,同一个表在SQL语句中出现多少次,就要通过与SQL语句中相同的别名锁定多少次,否则也会出错!举例说明如下。
1)对actor表获得读锁:
mysql> lock table actor read;
Query OK, 0 rows affected (0.00 sec)
2)但是通过别名访问会提示错误:
mysql> select a.first_name,a.last_name,b.first_name,b.last_name from actor a,actor b where a.first_name = b.first_name and a.first_name = 'Lisa' and a.last_name = 'Tom' and a.last_name <> b.last_name;
ERROR 1100 (HY000): Table 'a' was not locked with LOCK TABLES
3)需要对别名分别锁定:
mysql> lock table actor as a read,actor as b read;
Query OK, 0 rows affected (0.00 sec)
4)按照别名的查询可以正确执行:
mysql> select a.first_name,a.last_name,b.first_name,b.last_name from actor a,actor b where a.first_name = b.first_name and a.first_name = 'Lisa' and a.last_name = 'Tom' and a.last_name <> b.last_name;
+------------+-----------+------------+-----------+
| first_name | last_name | first_name | last_name |
+------------+-----------+------------+-----------+
| Lisa       | Tom       | LISA       | MONROE    |
+------------+-----------+------------+-----------+
1 row in set (0.00 sec)

WRITE锁表

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
获得表film_text的WRITE锁定
mysql> lock table film_text write;
Query OK, 0 rows affected (0.00 sec)
当前session对锁定表的查询、更新、插入操作都可以执行:
mysql> select film_id,title from film_text where film_id = 1001;
+---------+-------------+
| film_id | title |
+---------+-------------+
| 1001 | Update Test |
+---------+-------------+
1 row in set (0.00 sec)
mysql> insert into film_text (film_id,title) values(1003,'Test');
Query OK, 1 row affected (0.00 sec)
mysql> update film_text set title = 'Test' where film_id = 1001;
Query OK, 1 row affected (0.00 sec)
Rows matched: 1 Changed: 1 Warnings: 0
其他session对锁定表的查询被阻塞,需要等待锁被释放:
mysql> select film_id,title from film_text where film_id = 1001;
等待
释放锁:

并发插入(ConcurrentInserts)

上文提到过MyISAM表的读和写是串行的,但这是就总体而言的。在一定条件下,MyISAM表也支持查询和插入操作的并发进行。

MyISAM存储引擎有一个系统变量concurrent_insert,专门用以控制其并发插入的行为,其值分别可以为0、1或2。

l当concurrent_insert设置为0时,不允许并发插入。

l当concurrent_insert设置为1时,如果MyISAM表中没有空洞(即表的中间没有被删除的行),MyISAM允许在一个进程读表的同时,另一个进程从表尾插入记录。这也是MySQL的默认设置。

l当concurrent_insert设置为2时,无论MyISAM表中有没有空洞,都允许在表尾并发插入记录。

在如表20-4所示的例子中,session_1获得了一个表的READLOCAL锁,该线程可以对表进行查询操作,但不能对表进行更新操作;其他的线程(session_2),虽然不能对表进行删除和更新操作,但却可以对该表进行并发插入操作,这里假设该表中间不存在空洞。

表20-4MyISAM存储引擎的读写(INSERT)并发例子

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
session_1
session_2
获得表film_text的READ LOCAL锁定
mysql> lock table film_text read local;
Query OK, 0 rows affected (0.00 sec)
当前session不能对锁定表进行更新或者插入操作:
mysql> insert into film_text (film_id,title) values(1002,'Test');
ERROR 1099 (HY000): Table 'film_text' was locked with a READ lock and can't be updated
mysql> update film_text set title = 'Test' where film_id = 1001;
ERROR 1099 (HY000): Table 'film_text' was locked with a READ lock and can't be updated
其他session可以进行插入操作,但是更新会等待:
mysql> insert into film_text (film_id,title) values(1002,'Test');
Query OK, 1 row affected (0.00 sec)
mysql> update film_text set title = 'Update Test' where film_id = 1001;
等待
当前session不能访问其他session插入的记录:
mysql> select film_id,title from film_text where film_id = 1002;
Empty set (0.00 sec)
释放锁:
mysql> unlock tables;
Query OK, 0 rows affected (0.00 sec)
等待
当前session解锁后可以获得其他session插入的记录:
mysql> select film_id,title from film_text where film_id = 1002;
+---------+-------+
| film_id | title |
+---------+-------+
| 1002 | Test |
+---------+-------+
1 row in set (0.00 sec)
Session2获得锁,更新操作完成:
mysql> update film_text set title = 'Update Test' where film_id = 1001;
Query OK, 1 row affected (1 min 17.75 sec)
Rows matched: 1 Changed: 1 Warnings: 0

可以利用MyISAM存储引擎的并发插入特性,来解决应用中对同一表查询和插入的锁争用。例如,将concurrent_insert系统变量设为2,总是允许并发插入;同时,通过定期在系统空闲时段执行OPTIMIZETABLE语句来整理空间碎片,收回因删除记录而产生的中间空洞

MyISAM的锁调度

MyISAM存储引擎的读锁和写锁是互斥的,读写操作是串行的。那么,一个进程请求某个MyISAM表的读锁,同时另一个进程也请求同一表的写锁,MySQL如何处理呢?答案是写进程先获得锁。不仅如此,即使读请求先到锁等待队列,写请求后到,写锁也会插到读锁请求之前!这是因为MySQL认为写请求一般比读请求要重要。这也正是MyISAM表不太适合于有大量更新操作和查询操作应用的原因,因为,大量的更新操作会造成查询操作很难获得读锁,从而可能永远阻塞。这种情况有时可能会变得非常糟糕!幸好我们可以通过一些设置来调节MyISAM的调度行为。

通过指定启动参数low-priority-updates,使MyISAM引擎默认给予读请求以优先的权利。

通过执行命令SETLOW_PRIORITY_UPDATES=1,使该连接发出的更新请求优先级降低。

通过指定INSERT、UPDATE、DELETE语句的LOW_PRIORITY属性,降低该语句的优先级。

虽然上面3种方法都是要么更新优先,要么查询优先的方法,但还是可以用其来解决查询相对重要的应用(如用户登录系统)中,读锁等待严重的问题。

另外,MySQL也提供了一种折中的办法来调节读写冲突,即给系统参数max_write_lock_count设置一个合适的值,当一个表的读锁达到这个值后,MySQL就暂时将写请求的优先级降低,给读进程一定获得锁的机会。

上面已经讨论了写优先调度机制带来的问题和解决办法。这里还要强调一点:一些需要长时间运行的查询操作,也会使写进程“饿死”!因此,应用中应尽量避免出现长时间运行的查询操作,不要总想用一条SELECT语句来解决问题,因为这种看似巧妙的SQL语句,往往比较复杂,执行时间较长,在可能的情况下可以通过使用中间表等措施对SQL语句做一定的“分解”,使每一步查询都能在较短时间完成,从而减少锁冲突。如果复杂查询不可避免,应尽量安排在数据库空闲时段执行,比如一些定期统计可以安排在夜间执行。

本文出自 “好好活着” 博客,请务必保留此出处http://wolfword.blog.51cto.com/4892126/1295168

分享是种美德:运维博客 » mysql dba系统学习(20)mysql存储引擎MyISAM

喜欢 (0)or分享 (0)
发表我的评论
取消评论
表情

Hi,您需要填写昵称和邮箱!

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址