抛出异常的爱
- 浏览: 627757 次
- 性别:
- 来自: 北京
-
最新评论
启动：net start mySql;
进入：mysql -u root -p/mysql -h localhost -u root -p databaseName;
列出数据库：show databases;
选择数据库：use databaseName;
列出表格：show tables；
显示表格列的属性：show columns from tableName；
建立数据库：source fileName.txt;
匹配字符：可以用通配符_代表任何一个字符，％代表任何字符串;
增加一个字段：alter table tabelName add column fieldName dateType;
增加多个字段：alter table tabelName add column fieldName1 dateType,add columns fieldName2 dateType;
多行命令输入:注意不能将单词断开;当插入或更改数据时，不能将字段的字符串展开到多行里，否则硬回车将被储存到数据中;
增加一个管理员帐户：grant all on *.* to user@localhost identified by "password";
每条语句输入完毕后要在末尾填加分号';'，或者填加'\g'也可以；
查询时间：select now();
查询当前用户：select user();
查询数据库版本：select version();
查询当前使用的数据库：select database();
1、删除student_course数据库中的students数据表：
rm -f student_course/students.*
2、备份数据库：(将数据库test备份)
mysqldump -u root -p test>c:\test.txt
备份表格：(备份test数据库下的mytable表格)
mysqldump -u root -p test mytable>c:\test.txt
将备份数据导入到数据库：(导回test数据库)
mysql -u root -p test
3、创建临时表：(建立临时表zengchao)
create temporary table zengchao(name varchar(10));
4、创建表是先判断表是否存在
create table if not exists students(……);
5、从已经有的表中复制表的结构
create table table2 select * from table1 where 1<>1;
6、复制表
create table table2 select * from table1;
7、对表重新命名
alter table table1 rename as table2;
8、修改列的类型
alter table table1 modify id int unsigned;//修改列id的类型为int unsigned
alter table table1 change id sid int unsigned;//修改列id的名字为sid，而且把属性修改为int unsigned
9、创建索引
alter table table1 add index ind_id (id);
create index ind_id on table1 (id);
create unique index ind_id on table1 (id);//建立唯一性索引
10、删除索引
drop index idx_id on table1;
alter table table1 drop index ind_id;
11、联合字符或者多个列(将列id与":"和列name和"="连接)
select concat(id,':',name,'=') from students;
12、limit(选出10到20条)<第一个记录集的编号是0>
select * from students order by id limit 9,10;
13、MySQL不支持的功能
事务，视图，外键和引用完整性，存储过程和触发器
14、MySQL会使用索引的操作符号
<,<=,>=,>,=,between,in,不带%或者_开头的like
15、使用索引的缺点
1)减慢增删改数据的速度；
2）占用磁盘空间；
3）增加查询优化器的负担；
当查询优化器生成执行计划时，会考虑索引，太多的索引会给查询优化器增加工作量，导致无法选择最优的查询方案；
16、分析索引效率
方法：在一般的SQL语句前加上explain；
分析结果的含义：
1）table：表名；
2）type：连接的类型，(ALL/Range/Ref)。其中ref是最理想的；
3）possible_keys：查询可以利用的索引名；
4）key：实际使用的索引；
5）key_len：索引中被使用部分的长度（字节）；
6）ref：显示列名字或者"const"（不明白什么意思）；
7）rows：显示MySQL认为在找到正确结果之前必须扫描的行数；
8）extra：MySQL的建议；
17、使用较短的定长列
1）尽可能使用较短的数据类型；
2）尽可能使用定长数据类型；
a）用char代替varchar，固定长度的数据处理比变长的快些；
b）对于频繁修改的表，磁盘容易形成碎片，从而影响数据库的整体性能；
c）万一出现数据表崩溃，使用固定长度数据行的表更容易重新构造。使用固定长度的数据行，每个记录的开始位置都是固定记录长度的倍数，可以很容易被检测到，但是使用可变长度的数据行就不一定了；
d）对于MyISAM类型的数据表，虽然转换成固定长度的数据列可以提高性能，但是占据的空间也大；
18、使用not null和enum
尽量将列定义为not null，这样可使数据的出来更快，所需的空间更少，而且在查询时，MySQL不需要检查是否存在特例，即null值，从而优化查询；
如果一列只含有有限数目的特定值，如性别，是否有效或者入学年份等，在这种情况下应该考虑将其转换为enum列的值，MySQL处理的更快，因为所有的enum值在系统内都是以标识数值来表示的；
19、使用optimize table
对于经常修改的表，容易产生碎片，使在查询数据库时必须读取更多的磁盘块，降低查询性能。具有可变长的表都存在磁盘碎片问题，这个问题对blob数据类型更为突出，因为其尺寸变化非常大。可以通过使用optimize table来整理碎片，保证数据库性能不下降，优化那些受碎片影响的数据表。 optimize table可以用于MyISAM和BDB类型的数据表。实际上任何碎片整理方法都是用mysqldump来转存数据表，然后使用转存后的文件并重新建数据表；
20、使用procedure analyse()
可以使用procedure analyse()显示最佳类型的建议，使用很简单，在select语句后面加上procedure analyse()就可以了；例如：
select * from students procedure analyse();
select * from students procedure analyse(16,256);
第二条语句要求procedure analyse()不要建议含有多于16个值，或者含有多于256字节的enum类型，如果没有限制，输出可能会很长；
21、使用查询缓存
1）查询缓存的工作方式：
第一次执行某条select语句时，服务器记住该查询的文本内容和查询结果，存储在缓存中，下次碰到这个语句时，直接从缓存中返回结果；当更新数据表后，该数据表的任何缓存查询都变成无效的，并且会被丢弃。
2）配置缓存参数：
变量：query_cache _type，查询缓存的操作模式。有3中模式，0：不缓存；1：缓存查询，除非与 select sql_no_cache开头；2：根据需要只缓存那些以select sql_cache开头的查询； query_cache_size：设置查询缓存的最大结果集的大小，比这个值大的不会被缓存。
22、调整硬件
1）在机器上装更多的内存；
2）增加更快的硬盘以减少I/O等待时间；
寻道时间是决定性能的主要因素，逐字地移动磁头是最慢的，一旦磁头定位，从磁道读则很快；
3）在不同的物理硬盘设备上重新分配磁盘活动；
如果可能，应将最繁忙的数据库存放在不同的物理设备上，这跟使用同一物理设备的不同分区是不同的，因为它们将争用相同的物理资源（磁头）。
进入：mysql -u root -p/mysql -h localhost -u root -p databaseName;
列出数据库：show databases;
选择数据库：use databaseName;
列出表格：show tables；
显示表格列的属性：show columns from tableName；
建立数据库：source fileName.txt;
匹配字符：可以用通配符_代表任何一个字符，％代表任何字符串;
增加一个字段：alter table tabelName add column fieldName dateType;
增加多个字段：alter table tabelName add column fieldName1 dateType,add columns fieldName2 dateType;
多行命令输入:注意不能将单词断开;当插入或更改数据时，不能将字段的字符串展开到多行里，否则硬回车将被储存到数据中;
增加一个管理员帐户：grant all on *.* to user@localhost identified by "password";
每条语句输入完毕后要在末尾填加分号';'，或者填加'\g'也可以；
查询时间：select now();
查询当前用户：select user();
查询数据库版本：select version();
查询当前使用的数据库：select database();
1、删除student_course数据库中的students数据表：
rm -f student_course/students.*
2、备份数据库：(将数据库test备份)
mysqldump -u root -p test>c:\test.txt
备份表格：(备份test数据库下的mytable表格)
mysqldump -u root -p test mytable>c:\test.txt
将备份数据导入到数据库：(导回test数据库)
mysql -u root -p test
3、创建临时表：(建立临时表zengchao)
create temporary table zengchao(name varchar(10));
4、创建表是先判断表是否存在
create table if not exists students(……);
5、从已经有的表中复制表的结构
create table table2 select * from table1 where 1<>1;
6、复制表
create table table2 select * from table1;
7、对表重新命名
alter table table1 rename as table2;
8、修改列的类型
alter table table1 modify id int unsigned;//修改列id的类型为int unsigned
alter table table1 change id sid int unsigned;//修改列id的名字为sid，而且把属性修改为int unsigned
9、创建索引
alter table table1 add index ind_id (id);
create index ind_id on table1 (id);
create unique index ind_id on table1 (id);//建立唯一性索引
10、删除索引
drop index idx_id on table1;
alter table table1 drop index ind_id;
11、联合字符或者多个列(将列id与":"和列name和"="连接)
select concat(id,':',name,'=') from students;
12、limit(选出10到20条)<第一个记录集的编号是0>
select * from students order by id limit 9,10;
13、MySQL不支持的功能
事务，视图，外键和引用完整性，存储过程和触发器
14、MySQL会使用索引的操作符号
<,<=,>=,>,=,between,in,不带%或者_开头的like
15、使用索引的缺点
1)减慢增删改数据的速度；
2）占用磁盘空间；
3）增加查询优化器的负担；
当查询优化器生成执行计划时，会考虑索引，太多的索引会给查询优化器增加工作量，导致无法选择最优的查询方案；
16、分析索引效率
方法：在一般的SQL语句前加上explain；
分析结果的含义：
1）table：表名；
2）type：连接的类型，(ALL/Range/Ref)。其中ref是最理想的；
3）possible_keys：查询可以利用的索引名；
4）key：实际使用的索引；
5）key_len：索引中被使用部分的长度（字节）；
6）ref：显示列名字或者"const"（不明白什么意思）；
7）rows：显示MySQL认为在找到正确结果之前必须扫描的行数；
8）extra：MySQL的建议；
17、使用较短的定长列
1）尽可能使用较短的数据类型；
2）尽可能使用定长数据类型；
a）用char代替varchar，固定长度的数据处理比变长的快些；
b）对于频繁修改的表，磁盘容易形成碎片，从而影响数据库的整体性能；
c）万一出现数据表崩溃，使用固定长度数据行的表更容易重新构造。使用固定长度的数据行，每个记录的开始位置都是固定记录长度的倍数，可以很容易被检测到，但是使用可变长度的数据行就不一定了；
d）对于MyISAM类型的数据表，虽然转换成固定长度的数据列可以提高性能，但是占据的空间也大；
18、使用not null和enum
尽量将列定义为not null，这样可使数据的出来更快，所需的空间更少，而且在查询时，MySQL不需要检查是否存在特例，即null值，从而优化查询；
如果一列只含有有限数目的特定值，如性别，是否有效或者入学年份等，在这种情况下应该考虑将其转换为enum列的值，MySQL处理的更快，因为所有的enum值在系统内都是以标识数值来表示的；
19、使用optimize table
对于经常修改的表，容易产生碎片，使在查询数据库时必须读取更多的磁盘块，降低查询性能。具有可变长的表都存在磁盘碎片问题，这个问题对blob数据类型更为突出，因为其尺寸变化非常大。可以通过使用optimize table来整理碎片，保证数据库性能不下降，优化那些受碎片影响的数据表。 optimize table可以用于MyISAM和BDB类型的数据表。实际上任何碎片整理方法都是用mysqldump来转存数据表，然后使用转存后的文件并重新建数据表；
20、使用procedure analyse()
可以使用procedure analyse()显示最佳类型的建议，使用很简单，在select语句后面加上procedure analyse()就可以了；例如：
select * from students procedure analyse();
select * from students procedure analyse(16,256);
第二条语句要求procedure analyse()不要建议含有多于16个值，或者含有多于256字节的enum类型，如果没有限制，输出可能会很长；
21、使用查询缓存
1）查询缓存的工作方式：
第一次执行某条select语句时，服务器记住该查询的文本内容和查询结果，存储在缓存中，下次碰到这个语句时，直接从缓存中返回结果；当更新数据表后，该数据表的任何缓存查询都变成无效的，并且会被丢弃。
2）配置缓存参数：
变量：query_cache _type，查询缓存的操作模式。有3中模式，0：不缓存；1：缓存查询，除非与 select sql_no_cache开头；2：根据需要只缓存那些以select sql_cache开头的查询； query_cache_size：设置查询缓存的最大结果集的大小，比这个值大的不会被缓存。
22、调整硬件
1）在机器上装更多的内存；
2）增加更快的硬盘以减少I/O等待时间；
寻道时间是决定性能的主要因素，逐字地移动磁头是最慢的，一旦磁头定位，从磁道读则很快；
3）在不同的物理硬盘设备上重新分配磁盘活动；
如果可能，应将最繁忙的数据库存放在不同的物理设备上，这跟使用同一物理设备的不同分区是不同的，因为它们将争用相同的物理资源（磁头）。
分享到：
评论
5 楼
xuejianshan
2007-12-11
你公司用的是mysql数据库吗?
4 楼
kyo100900
2007-10-23
mysql有类似于SQL Server那样的backup disk的备份能力吗?
3 楼
抛出异常的爱
2007-10-22
MySQL 备份和恢复
<script language="javascript" type="text" src="misc/cr.js" /></script>
作/译者：叶金荣（Email: ），来源：http://imysql.cn，转载请注明作/译者和出处，并且不能用于商业用途，违者必究。
日期：2006/10/01
本文讨论 MySQL 的备份和恢复机制，以及如何维护数据表，包括最主要的两种表类型：MyISAM 和 Innodb，文中设计的 MySQL 版本为 5.0.22。
目前 MySQL 支持的免费备份工具有：mysqldump、mysqlhotcopy，还可以用 SQL 语法进行备份：BACKUP TABLE 或者 SELECT INTO OUTFILE，又或者备份二进制日志（binlog），还可以是直接拷贝数据文件和相关的配置文件。MyISAM 表是保存成文件的形式，因此相对比较容易备份，上面提到的几种方法都可以使用。Innodb 所有的表都保存在同一个数据文件 ibdata1 中（也可能是多个文件，或者是独立的表空间文件），相对来说比较不好备份，免费的方案可以是拷贝数据文件、备份 binlog，或者用 mysqldump。
1、mysqldump
1.1 备份
mysqldump 是采用SQL级别的备份机制，它将数据表导成 SQL 脚本文件，在不同的 MySQL 版本之间升级时相对比较合适，这也是最常用的备份方法。
现在来讲一下 mysqldump 的一些主要参数：
* --compatible=name
它告诉 mysqldump，导出的数据将和哪种数据库或哪个旧版本的 MySQL 服务器相兼容。值可以为 ansi、mysql323、mysql40、postgresql、oracle、mssql、db2、maxdb、no_key_options、no_tables_options、no_field_options 等，要使用几个值，用逗号将它们隔开。当然了，它并不保证能完全兼容，而是尽量兼容。
* --complete-insert，-c
导出的数据采用包含字段名的完整 INSERT 方式，也就是把所有的值都写在一行。这么做能提高插入效率，但是可能会受到 max_allowed_packet 参数的影响而导致插入失败。因此，需要谨慎使用该参数，至少我不推荐。
* --default-character-set=charset
指定导出数据时采用何种字符集，如果数据表不是采用默认的 latin1 字符集的话，那么导出时必须指定该选项，否则再次导入数据后将产生乱码问题。
* --disable-keys
告诉 mysqldump 在 INSERT 语句的开头和结尾增加 /*!40000 ALTER TABLE table DISABLE KEYS */; 和 /*!40000 ALTER TABLE table ENABLE KEYS */; 语句，这能大大提高插入语句的速度，因为它是在插入完所有数据后才重建索引的。该选项只适合 MyISAM 表。
* --extended-insert = true|false
默认情况下，mysqldump 开启 --complete-insert 模式，因此不想用它的的话，就使用本选项，设定它的值为 false 即可。
* --hex-blob
使用十六进制格式导出二进制字符串字段。如果有二进制数据就必须使用本选项。影响到的字段类型有 BINARY、VARBINARY、BLOB。
* --lock-all-tables，-x
在开始导出之前，提交请求锁定所有数据库中的所有表，以保证数据的一致性。这是一个全局读锁，并且自动关闭 --single-transaction 和 --lock-tables 选项。
* --lock-tables
它和 --lock-all-tables 类似，不过是锁定当前导出的数据表，而不是一下子锁定全部库下的表。本选项只适用于 MyISAM 表，如果是 Innodb 表可以用 --single-transaction 选项。
* --no-create-info，-t
只导出数据，而不添加 CREATE TABLE 语句。
* --no-data，-d
不导出任何数据，只导出数据库表结构。
* --opt
这只是一个快捷选项，等同于同时添加 --add-drop-tables --add-locking --create-option --disable-keys --extended-insert --lock-tables --quick --set-charset 选项。本选项能让 mysqldump 很快的导出数据，并且导出的数据能很快导回。该选项默认开启，但可以用 --skip-opt 禁用。注意，如果运行 mysqldump 没有指定 --quick 或 --opt 选项，则会将整个结果集放在内存中。如果导出大数据库的话可能会出现问题。
* --quick，-q
该选项在导出大表时很有用，它强制 mysqldump 从服务器查询取得记录直接输出而不是取得所有记录后将它们缓存到内存中。
* --routines，-R
导出存储过程以及自定义函数。
* --single-transaction
该选项在导出数据之前提交一个 BEGIN SQL语句，BEGIN 不会阻塞任何应用程序且能保证导出时数据库的一致性状态。它只适用于事务表，例如 InnoDB 和 BDB。
本选项和 --lock-tables 选项是互斥的，因为 LOCK TABLES 会使任何挂起的事务隐含提交。
要想导出大表的话，应结合使用 --quick 选项。
* --triggers
同时导出触发器。该选项默认启用，用 --skip-triggers 禁用它。
其他参数详情请参考手册，我通常使用以下 SQL 来备份 MyISAM 表：
/usr/local/mysql/bin/mysqldump -uyejr -pyejr \
--default-character-set=utf8 --opt --extended-insert=false \
--triggers -R --hex-blob -x db_name > db_name.sql
使用以下 SQL 来备份 Innodb 表：
/usr/local/mysql/bin/mysqldump -uyejr -pyejr \
--default-character-set=utf8 --opt --extended-insert=false \
--triggers -R --hex-blob --single-transaction db_name > db_name.sql
另外，如果想要实现在线备份，还可以使用 --master-data 参数来实现，如下：
/usr/local/mysql/bin/mysqldump -uyejr -pyejr \
--default-character-set=utf8 --opt --master-data=1 \
--single-transaction --flush-logs db_name > db_name.sql
它只是在一开始的瞬间请求锁表，然后就刷新binlog了，而后在导出的文件中加入CHANGE MASTER 语句来指定当前备份的binlog位置，如果要把这个文件恢复到slave里去，就可以采用这种方法来做。
1.2 还原
用 mysqldump 备份出来的文件是一个可以直接倒入的 SQL 脚本，有两种方法可以将数据导入。
* 直接用 mysql 客户端
例如：
/usr/local/mysql/bin/mysql -uyejr -pyejr db_name < db_name.sql
* 用 SOURCE 语法
其实这不是标准的 SQL 语法，而是 mysql 客户端提供的功能，例如：
SOURCE /tmp/db_name.sql;
这里需要指定文件的绝对路径，并且必须是 mysqld 运行用户(例如 nobody)有权限读取的文件。
2、 mysqlhotcopy
2.1 备份
mysqlhotcopy 是一个 PERL 程序，最初由Tim Bunce编写。它使用 LOCK TABLES、FLUSH TABLES 和 cp 或 scp 来快速备份数据库。它是备份数据库或单个表的最快的途径，但它只能运行在数据库文件（包括数据表定义文件、数据文件、索引文件）所在的机器上。mysqlhotcopy 只能用于备份 MyISAM，并且只能运行在 类Unix 和 NetWare 系统上。
mysqlhotcopy 支持一次性拷贝多个数据库，同时还支持正则表达。以下是几个例子：
root#/usr/local/mysql/bin/mysqlhotcopy -h=localhost -u=yejr -p=yejr \
db_name /tmp (把数据库目录 db_name 拷贝到 /tmp 下)
root#/usr/local/mysql/bin/mysqlhotcopy -h=localhost -u=yejr -p=yejr \
db_name_1 ... db_name_n /tmp
root#/usr/local/mysql/bin/mysqlhotcopy -h=localhost -u=yejr -p=yejr \
db_name./regex/ /tmp
更详细的使用方法请查看手册，或者调用下面的命令来查看 mysqlhotcopy 的帮助：
perldoc /usr/local/mysql/bin/mysqlhotcopy
注意，想要使用 mysqlhotcopy，必须要有 SELECT、RELOAD(要执行 FLUSH TABLES) 权限，并且还必须要能够有读取 datadir/db_name 目录的权限。
2.2 还原
mysqlhotcopy 备份出来的是整个数据库目录，使用时可以直接拷贝到 mysqld 指定的 datadir (在这里是 /usr/local/mysql/data/)目录下即可，同时要注意权限的问题，如下例：
root#cp -rf db_name /usr/local/mysql/data/
root#chown -R nobody:nobody /usr/local/mysql/data/ (将 db_name 目录的属主改成 mysqld 运行用户)
3、 SQL 语法备份
3.1 备份
BACKUP TABLE 语法其实和 mysqlhotcopy 的工作原理差不多，都是锁表，然后拷贝数据文件。它能实现在线备份，但是效果不理想，因此不推荐使用。它只拷贝表结构文件和数据文件，不同时拷贝索引文件，因此恢复时比较慢。
例子：
BACK TABLE tbl_name TO '/tmp/db_name/';
注意，必须要有 FILE 权限才能执行本SQL，并且目录 /tmp/db_name/ 必须能被 mysqld 用户可写，导出的文件不能覆盖已经存在的文件，以避免安全问题。
SELECT INTO OUTFILE 则是把数据导出来成为普通的文本文件，可以自定义字段间隔的方式，方便处理这些数据。
例子：
SELECT * INTO OUTFILE '/tmp/db_name/tbl_name.txt' FROM tbl_name;
注意，必须要有 FILE 权限才能执行本SQL，并且文件 /tmp/db_name/tbl_name.txt 必须能被 mysqld 用户可写，导出的文件不能覆盖已经存在的文件，以避免安全问题。
3.2 恢复
用 BACKUP TABLE 方法备份出来的文件，可以运行 RESTORE TABLE 语句来恢复数据表。
例子：
RESTORE TABLE FROM '/tmp/db_name/';
权限要求类似上面所述。
用 SELECT INTO OUTFILE 方法备份出来的文件，可以运行 LOAD DATA INFILE 语句来恢复数据表。
例子：
LOAD DATA INFILE '/tmp/db_name/tbl_name.txt' INTO TABLE tbl_name;
权限要求类似上面所述。倒入数据之前，数据表要已经存在才行。如果担心数据会发生重复，可以增加 REPLACE 关键字来替换已有记录或者用 IGNORE 关键字来忽略他们。
4、 启用二进制日志(binlog)
采用 binlog 的方法相对来说更灵活，省心省力，而且还可以支持增量备份。
启用 binlog 时必须要重启 mysqld。首先，关闭 mysqld，打开 my.cnf，加入以下几行：
server-id = 1
log-bin = binlog
log-bin-index = binlog.index
然后启动 mysqld 就可以了。运行过程中会产生 binlog.000001 以及 binlog.index，前面的文件是 mysqld 记录所有对数据的更新操作，后面的文件则是所有 binlog 的索引，都不能轻易删除。关于 binlog 的信息请查看手册。
需要备份时，可以先执行一下 SQL 语句，让 mysqld 终止对当前 binlog 的写入，就可以把文件直接备份，这样的话就能达到增量备份的目的了：
FLUSH LOGS;
如果是备份复制系统中的从服务器，还应该备份 master.info 和 relay-log.info 文件。
备份出来的 binlog 文件可以用 MySQL 提供的工具 mysqlbinlog 来查看，如：
/usr/local/mysql/bin/mysqlbinlog /tmp/binlog.000001
该工具允许你显示指定的数据库下的所有 SQL 语句，并且还可以限定时间范围，相当的方便，详细的请查看手册。
恢复时，可以采用类似以下语句来做到：
/usr/local/mysql/bin/mysqlbinlog /tmp/binlog.000001 | mysql -uyejr -pyejr db_name
把 mysqlbinlog 输出的 SQL 语句直接作为输入来执行它。
如果你有空闲的机器，不妨采用这种方式来备份。由于作为 slave 的机器性能要求相对不是那么高，因此成本低，用低成本就能实现增量备份而且还能分担一部分数据查询压力，何乐而不为呢？
5、 直接备份数据文件
相较前几种方法，备份数据文件最为直接、快速、方便，缺点是基本上不能实现增量备份。为了保证数据的一致性，需要在靠背文件前，执行以下 SQL 语句：
FLUSH TABLES WITH READ LOCK;
也就是把内存中的数据都刷新到磁盘中，同时锁定数据表，以保证拷贝过程中不会有新的数据写入。这种方法备份出来的数据恢复也很简单，直接拷贝回原来的数据库目录下即可。
注意，对于 Innodb 类型表来说，还需要备份其日志文件，即 ib_logfile* 文件。因为当 Innodb 表损坏时，就可以依靠这些日志文件来恢复。
6、 备份策略
对于中等级别业务量的系统来说，备份策略可以这么定：第一次全量备份，每天一次增量备份，每周再做一次全量备份，如此一直重复。而对于重要的且繁忙的系统来说，则可能需要每天一次全量备份，每小时一次增量备份，甚至更频繁。为了不影响线上业务，实现在线备份，并且能增量备份，最好的办法就是采用主从复制机制(replication)，在 slave 机器上做备份。
7、 数据维护和灾难恢复
作为一名DBA(我目前还不是，呵呵)，最重要的工作内容之一是保证数据表能安全、稳定、高速使用。因此，需要定期维护你的数据表。以下 SQL 语句就很有用：
CHECK TABLE 或 REPAIR TABLE，检查或维护 MyISAM 表
OPTIMIZE TABLE，优化 MyISAM 表
ANALYZE TABLE，分析 MyISAM 表
当然了，上面这些命令起始都可以通过工具 myisamchk 来完成，在这里不作详述。
Innodb 表则可以通过执行以下语句来整理碎片，提高索引速度：
ALTER TABLE tbl_name ENGINE = Innodb;
这其实是一个 NULL 操作，表面上看什么也不做，实际上重新整理碎片了。
通常使用的 MyISAM 表可以用上面提到的恢复方法来完成。如果是索引坏了，可以用 myisamchk 工具来重建索引。而对于 Innodb 表来说，就没这么直接了，因为它把所有的表都保存在一个表空间了。不过 Innodb 有一个检查机制叫 模糊检查点，只要保存了日志文件，就能根据日志文件来修复错误。可以在 my.cnf 文件中，增加以下参数，让 mysqld 在启动时自动检查日志文件：
innodb_force_recovery = 4
关于该参数的信息请查看手册。
8、 总结
做好数据备份，定只好合适的备份策略，这是一个DBA所做事情的一小部分，万事开头难，就从现在开始吧！
<script language="javascript" type="text" src="misc/cr.js" /></script>
作/译者：叶金荣（Email: ），来源：http://imysql.cn，转载请注明作/译者和出处，并且不能用于商业用途，违者必究。
日期：2006/10/01
本文讨论 MySQL 的备份和恢复机制，以及如何维护数据表，包括最主要的两种表类型：MyISAM 和 Innodb，文中设计的 MySQL 版本为 5.0.22。
目前 MySQL 支持的免费备份工具有：mysqldump、mysqlhotcopy，还可以用 SQL 语法进行备份：BACKUP TABLE 或者 SELECT INTO OUTFILE，又或者备份二进制日志（binlog），还可以是直接拷贝数据文件和相关的配置文件。MyISAM 表是保存成文件的形式，因此相对比较容易备份，上面提到的几种方法都可以使用。Innodb 所有的表都保存在同一个数据文件 ibdata1 中（也可能是多个文件，或者是独立的表空间文件），相对来说比较不好备份，免费的方案可以是拷贝数据文件、备份 binlog，或者用 mysqldump。
1、mysqldump
1.1 备份
mysqldump 是采用SQL级别的备份机制，它将数据表导成 SQL 脚本文件，在不同的 MySQL 版本之间升级时相对比较合适，这也是最常用的备份方法。
现在来讲一下 mysqldump 的一些主要参数：
* --compatible=name
它告诉 mysqldump，导出的数据将和哪种数据库或哪个旧版本的 MySQL 服务器相兼容。值可以为 ansi、mysql323、mysql40、postgresql、oracle、mssql、db2、maxdb、no_key_options、no_tables_options、no_field_options 等，要使用几个值，用逗号将它们隔开。当然了，它并不保证能完全兼容，而是尽量兼容。
* --complete-insert，-c
导出的数据采用包含字段名的完整 INSERT 方式，也就是把所有的值都写在一行。这么做能提高插入效率，但是可能会受到 max_allowed_packet 参数的影响而导致插入失败。因此，需要谨慎使用该参数，至少我不推荐。
* --default-character-set=charset
指定导出数据时采用何种字符集，如果数据表不是采用默认的 latin1 字符集的话，那么导出时必须指定该选项，否则再次导入数据后将产生乱码问题。
* --disable-keys
告诉 mysqldump 在 INSERT 语句的开头和结尾增加 /*!40000 ALTER TABLE table DISABLE KEYS */; 和 /*!40000 ALTER TABLE table ENABLE KEYS */; 语句，这能大大提高插入语句的速度，因为它是在插入完所有数据后才重建索引的。该选项只适合 MyISAM 表。
* --extended-insert = true|false
默认情况下，mysqldump 开启 --complete-insert 模式，因此不想用它的的话，就使用本选项，设定它的值为 false 即可。
* --hex-blob
使用十六进制格式导出二进制字符串字段。如果有二进制数据就必须使用本选项。影响到的字段类型有 BINARY、VARBINARY、BLOB。
* --lock-all-tables，-x
在开始导出之前，提交请求锁定所有数据库中的所有表，以保证数据的一致性。这是一个全局读锁，并且自动关闭 --single-transaction 和 --lock-tables 选项。
* --lock-tables
它和 --lock-all-tables 类似，不过是锁定当前导出的数据表，而不是一下子锁定全部库下的表。本选项只适用于 MyISAM 表，如果是 Innodb 表可以用 --single-transaction 选项。
* --no-create-info，-t
只导出数据，而不添加 CREATE TABLE 语句。
* --no-data，-d
不导出任何数据，只导出数据库表结构。
* --opt
这只是一个快捷选项，等同于同时添加 --add-drop-tables --add-locking --create-option --disable-keys --extended-insert --lock-tables --quick --set-charset 选项。本选项能让 mysqldump 很快的导出数据，并且导出的数据能很快导回。该选项默认开启，但可以用 --skip-opt 禁用。注意，如果运行 mysqldump 没有指定 --quick 或 --opt 选项，则会将整个结果集放在内存中。如果导出大数据库的话可能会出现问题。
* --quick，-q
该选项在导出大表时很有用，它强制 mysqldump 从服务器查询取得记录直接输出而不是取得所有记录后将它们缓存到内存中。
* --routines，-R
导出存储过程以及自定义函数。
* --single-transaction
该选项在导出数据之前提交一个 BEGIN SQL语句，BEGIN 不会阻塞任何应用程序且能保证导出时数据库的一致性状态。它只适用于事务表，例如 InnoDB 和 BDB。
本选项和 --lock-tables 选项是互斥的，因为 LOCK TABLES 会使任何挂起的事务隐含提交。
要想导出大表的话，应结合使用 --quick 选项。
* --triggers
同时导出触发器。该选项默认启用，用 --skip-triggers 禁用它。
其他参数详情请参考手册，我通常使用以下 SQL 来备份 MyISAM 表：
/usr/local/mysql/bin/mysqldump -uyejr -pyejr \
--default-character-set=utf8 --opt --extended-insert=false \
--triggers -R --hex-blob -x db_name > db_name.sql
使用以下 SQL 来备份 Innodb 表：
/usr/local/mysql/bin/mysqldump -uyejr -pyejr \
--default-character-set=utf8 --opt --extended-insert=false \
--triggers -R --hex-blob --single-transaction db_name > db_name.sql
另外，如果想要实现在线备份，还可以使用 --master-data 参数来实现，如下：
/usr/local/mysql/bin/mysqldump -uyejr -pyejr \
--default-character-set=utf8 --opt --master-data=1 \
--single-transaction --flush-logs db_name > db_name.sql
它只是在一开始的瞬间请求锁表，然后就刷新binlog了，而后在导出的文件中加入CHANGE MASTER 语句来指定当前备份的binlog位置，如果要把这个文件恢复到slave里去，就可以采用这种方法来做。
1.2 还原
用 mysqldump 备份出来的文件是一个可以直接倒入的 SQL 脚本，有两种方法可以将数据导入。
* 直接用 mysql 客户端
例如：
/usr/local/mysql/bin/mysql -uyejr -pyejr db_name < db_name.sql
* 用 SOURCE 语法
其实这不是标准的 SQL 语法，而是 mysql 客户端提供的功能，例如：
SOURCE /tmp/db_name.sql;
这里需要指定文件的绝对路径，并且必须是 mysqld 运行用户(例如 nobody)有权限读取的文件。
2、 mysqlhotcopy
2.1 备份
mysqlhotcopy 是一个 PERL 程序，最初由Tim Bunce编写。它使用 LOCK TABLES、FLUSH TABLES 和 cp 或 scp 来快速备份数据库。它是备份数据库或单个表的最快的途径，但它只能运行在数据库文件（包括数据表定义文件、数据文件、索引文件）所在的机器上。mysqlhotcopy 只能用于备份 MyISAM，并且只能运行在 类Unix 和 NetWare 系统上。
mysqlhotcopy 支持一次性拷贝多个数据库，同时还支持正则表达。以下是几个例子：
root#/usr/local/mysql/bin/mysqlhotcopy -h=localhost -u=yejr -p=yejr \
db_name /tmp (把数据库目录 db_name 拷贝到 /tmp 下)
root#/usr/local/mysql/bin/mysqlhotcopy -h=localhost -u=yejr -p=yejr \
db_name_1 ... db_name_n /tmp
root#/usr/local/mysql/bin/mysqlhotcopy -h=localhost -u=yejr -p=yejr \
db_name./regex/ /tmp
更详细的使用方法请查看手册，或者调用下面的命令来查看 mysqlhotcopy 的帮助：
perldoc /usr/local/mysql/bin/mysqlhotcopy
注意，想要使用 mysqlhotcopy，必须要有 SELECT、RELOAD(要执行 FLUSH TABLES) 权限，并且还必须要能够有读取 datadir/db_name 目录的权限。
2.2 还原
mysqlhotcopy 备份出来的是整个数据库目录，使用时可以直接拷贝到 mysqld 指定的 datadir (在这里是 /usr/local/mysql/data/)目录下即可，同时要注意权限的问题，如下例：
root#cp -rf db_name /usr/local/mysql/data/
root#chown -R nobody:nobody /usr/local/mysql/data/ (将 db_name 目录的属主改成 mysqld 运行用户)
3、 SQL 语法备份
3.1 备份
BACKUP TABLE 语法其实和 mysqlhotcopy 的工作原理差不多，都是锁表，然后拷贝数据文件。它能实现在线备份，但是效果不理想，因此不推荐使用。它只拷贝表结构文件和数据文件，不同时拷贝索引文件，因此恢复时比较慢。
例子：
BACK TABLE tbl_name TO '/tmp/db_name/';
注意，必须要有 FILE 权限才能执行本SQL，并且目录 /tmp/db_name/ 必须能被 mysqld 用户可写，导出的文件不能覆盖已经存在的文件，以避免安全问题。
SELECT INTO OUTFILE 则是把数据导出来成为普通的文本文件，可以自定义字段间隔的方式，方便处理这些数据。
例子：
SELECT * INTO OUTFILE '/tmp/db_name/tbl_name.txt' FROM tbl_name;
注意，必须要有 FILE 权限才能执行本SQL，并且文件 /tmp/db_name/tbl_name.txt 必须能被 mysqld 用户可写，导出的文件不能覆盖已经存在的文件，以避免安全问题。
3.2 恢复
用 BACKUP TABLE 方法备份出来的文件，可以运行 RESTORE TABLE 语句来恢复数据表。
例子：
RESTORE TABLE FROM '/tmp/db_name/';
权限要求类似上面所述。
用 SELECT INTO OUTFILE 方法备份出来的文件，可以运行 LOAD DATA INFILE 语句来恢复数据表。
例子：
LOAD DATA INFILE '/tmp/db_name/tbl_name.txt' INTO TABLE tbl_name;
权限要求类似上面所述。倒入数据之前，数据表要已经存在才行。如果担心数据会发生重复，可以增加 REPLACE 关键字来替换已有记录或者用 IGNORE 关键字来忽略他们。
4、 启用二进制日志(binlog)
采用 binlog 的方法相对来说更灵活，省心省力，而且还可以支持增量备份。
启用 binlog 时必须要重启 mysqld。首先，关闭 mysqld，打开 my.cnf，加入以下几行：
server-id = 1
log-bin = binlog
log-bin-index = binlog.index
然后启动 mysqld 就可以了。运行过程中会产生 binlog.000001 以及 binlog.index，前面的文件是 mysqld 记录所有对数据的更新操作，后面的文件则是所有 binlog 的索引，都不能轻易删除。关于 binlog 的信息请查看手册。
需要备份时，可以先执行一下 SQL 语句，让 mysqld 终止对当前 binlog 的写入，就可以把文件直接备份，这样的话就能达到增量备份的目的了：
FLUSH LOGS;
如果是备份复制系统中的从服务器，还应该备份 master.info 和 relay-log.info 文件。
备份出来的 binlog 文件可以用 MySQL 提供的工具 mysqlbinlog 来查看，如：
/usr/local/mysql/bin/mysqlbinlog /tmp/binlog.000001
该工具允许你显示指定的数据库下的所有 SQL 语句，并且还可以限定时间范围，相当的方便，详细的请查看手册。
恢复时，可以采用类似以下语句来做到：
/usr/local/mysql/bin/mysqlbinlog /tmp/binlog.000001 | mysql -uyejr -pyejr db_name
把 mysqlbinlog 输出的 SQL 语句直接作为输入来执行它。
如果你有空闲的机器，不妨采用这种方式来备份。由于作为 slave 的机器性能要求相对不是那么高，因此成本低，用低成本就能实现增量备份而且还能分担一部分数据查询压力，何乐而不为呢？
5、 直接备份数据文件
相较前几种方法，备份数据文件最为直接、快速、方便，缺点是基本上不能实现增量备份。为了保证数据的一致性，需要在靠背文件前，执行以下 SQL 语句：
FLUSH TABLES WITH READ LOCK;
也就是把内存中的数据都刷新到磁盘中，同时锁定数据表，以保证拷贝过程中不会有新的数据写入。这种方法备份出来的数据恢复也很简单，直接拷贝回原来的数据库目录下即可。
注意，对于 Innodb 类型表来说，还需要备份其日志文件，即 ib_logfile* 文件。因为当 Innodb 表损坏时，就可以依靠这些日志文件来恢复。
6、 备份策略
对于中等级别业务量的系统来说，备份策略可以这么定：第一次全量备份，每天一次增量备份，每周再做一次全量备份，如此一直重复。而对于重要的且繁忙的系统来说，则可能需要每天一次全量备份，每小时一次增量备份，甚至更频繁。为了不影响线上业务，实现在线备份，并且能增量备份，最好的办法就是采用主从复制机制(replication)，在 slave 机器上做备份。
7、 数据维护和灾难恢复
作为一名DBA(我目前还不是，呵呵)，最重要的工作内容之一是保证数据表能安全、稳定、高速使用。因此，需要定期维护你的数据表。以下 SQL 语句就很有用：
CHECK TABLE 或 REPAIR TABLE，检查或维护 MyISAM 表
OPTIMIZE TABLE，优化 MyISAM 表
ANALYZE TABLE，分析 MyISAM 表
当然了，上面这些命令起始都可以通过工具 myisamchk 来完成，在这里不作详述。
Innodb 表则可以通过执行以下语句来整理碎片，提高索引速度：
ALTER TABLE tbl_name ENGINE = Innodb;
这其实是一个 NULL 操作，表面上看什么也不做，实际上重新整理碎片了。
通常使用的 MyISAM 表可以用上面提到的恢复方法来完成。如果是索引坏了，可以用 myisamchk 工具来重建索引。而对于 Innodb 表来说，就没这么直接了，因为它把所有的表都保存在一个表空间了。不过 Innodb 有一个检查机制叫 模糊检查点，只要保存了日志文件，就能根据日志文件来修复错误。可以在 my.cnf 文件中，增加以下参数，让 mysqld 在启动时自动检查日志文件：
innodb_force_recovery = 4
关于该参数的信息请查看手册。
8、 总结
做好数据备份，定只好合适的备份策略，这是一个DBA所做事情的一小部分，万事开头难，就从现在开始吧！
2 楼
抛出异常的爱
2007-10-22
1016错误：文件无法打开，使用后台修复或者使用phpmyadmin进行修复。
1044错误：数据库用户权限不足，请联系空间商解决
1045错误：数据库服务器/数据库用户名/数据库名/数据库密码错误，请联系空间商检查帐户。
1054错误：程序文件跟数据库有冲突，请使用正确的程序文件上传上去覆盖。
1146错误：数据表缺失,请恢复备份数据.
1005：创建表失败
1006：创建数据库失败
1007：数据库已存在，创建数据库失败
1008：数据库不存在，删除数据库失败
1009：不能删除数据库文件导致删除数据库失败
1010：不能删除数据目录导致删除数据库失败
1011：删除数据库文件失败
1012：不能读取系统表中的记录
1020：记录已被其他用户修改
1021：硬盘剩余空间不足，请加大硬盘可用空间
1022：关键字重复，更改记录失败
1023：关闭时发生错误
1024：读文件错误
1025：更改名字时发生错误
1026：写文件错误
1032：记录不存在
1036：数据表是只读的，不能对它进行修改
1037：系统内存不足，请重启数据库或重启服务器
1038：用于排序的内存不足，请增大排序缓冲区
1040：已到达数据库的最大连接数，请加大数据库可用连接数
1041：系统内存不足
1042：无效的主机名
1043：无效连接
1044：当前用户没有访问数据库的权限
1045：不能连接数据库，用户名或密码错误
1048：字段不能为空
1049：数据库不存在
1050：数据表已存在
1051：数据表不存在
1054：字段不存在
1065：无效的SQL语句，SQL语句为空
1081：不能建立Socket连接
1114：数据表已满，不能容纳任何记录
1116：打开的数据表太多
1129：数据库出现异常，请重启数据库
1130：连接数据库失败，没有连接数据库的权限
1133：数据库用户不存在
1141：当前用户无权访问数据库
1142：当前用户无权访问数据表
1143：当前用户无权访问数据表中的字段
1146：数据表不存在
1147：未定义用户对数据表的访问权限
1149：SQL语句语法错误
1158：网络错误，出现读错误，请检查网络连接状况
1159：网络错误，读超时，请检查网络连接状况
1160：网络错误，出现写错误，请检查网络连接状况
1161：网络错误，写超时，请检查网络连接状况
1062：字段值重复，入库失败
1169：字段值重复，更新记录失败
1177：打开数据表失败
1180：提交事务失败
1181：回滚事务失败
1203：当前用户和数据库建立的连接已到达数据库的最大连接数，请增大可用的数据库连接数或重启数据库
1205：加锁超时
1211：当前用户没有创建用户的权限
1216：外键约束检查失败，更新子表记录失败
1217：外键约束检查失败，删除或修改主表记录失败
1226：当前用户使用的资源已超过所允许的资源，请重启数据库或重启服务器
1227：权限不足，您无权进行此操作
1235：MySQL版本过低，不具有本功能
2002：Can't connect to ...通常意味着没有一个MySQL服务器运行在系统上或当试图连接mysqld服务器时，你正在使用一个错误的套接字文件或TCP/IP端口。
说明：以上只是常见错误号，并且解决办法也不一定肯定管用！具体请参考MYSQL手册（各大下载站均有下载）
更多详细错误代码
错误名称 / 错误代码 SQL状态
ER_HASHCHK 1000 HY000
ER_NISAMCHK 1001 HY000
ER_NO 1002 HY000
ER_YES 1003 HY000
ER_CANT_CREATE_FILE 1004 HY000
ER_CANT_CREATE_TABLE 1005 HY000
ER_CANT_CREATE_DB 1006 HY000
ER_DB_CREATE_EXISTS 1007 HY000
ER_DB_DROP_EXISTS 1008 HY000
ER_DB_DROP_DELETE 1009 HY000
ER_DB_DROP_RMDIR 1010 HY000
ER_CANT_DELETE_FILE 1011 HY000
ER_CANT_FIND_SYSTEM_REC 1012 HY000
ER_CANT_GET_STAT 1013 HY000
ER_CANT_GET_WD 1014 HY000
ER_CANT_LOCK 1015 HY000
ER_CANT_OPEN_FILE 1016 HY000
ER_FILE_NOT_FOUND 1017 HY000
ER_CANT_READ_DIR 1018 HY000
ER_CANT_SET_WD 1019 HY000
ER_CHECKREAD 1020 HY000
ER_DISK_FULL 1021 HY000
ER_DUP_KEY 1022 23000
ER_ERROR_ON_CLOSE 1023 HY000
ER_ERROR_ON_READ 1024 HY000
ER_ERROR_ON_RENAME 1025 HY000
ER_ERROR_ON_WRITE 1026 HY000
ER_FILE_USED 1027 HY000
ER_FILSORT_ABORT 1028 HY000
ER_FORM_NOT_FOUND 1029 HY000
ER_GET_ERRNO 1030 HY000
ER_ILLEGAL_HA 1031 HY000
ER_KEY_NOT_FOUND 1032 HY000
ER_NOT_FORM_FILE 1033 HY000
ER_NOT_KEYFILE 1034 HY000
ER_OLD_KEYFILE 1035 HY000
ER_OPEN_AS_READONLY 1036 HY000
ER_OUTOFMEMORY 1037 HY001
ER_OUT_OF_SORTMEMORY 1038 HY001
ER_UNEXPECTED_EOF 1039 HY000
ER_CON_COUNT_ERROR 1040 08004
ER_OUT_OF_RESOURCES 1041 08004
ER_BAD_HOST_ERROR 1042 08S01
ER_HANDSHAKE_ERROR 1043 08S01
ER_DBACCESS_DENIED_ERROR 1044 42000
ER_ACCESS_DENIED_ERROR 1045 42000
ER_NO_DB_ERROR 1046 42000
ER_UNKNOWN_COM_ERROR 1047 08S01
ER_BAD_NULL_ERROR 1048 23000
ER_BAD_DB_ERROR 1049 42000
ER_TABLE_EXISTS_ERROR 1050 42S01
ER_BAD_TABLE_ERROR 1051 42S02
ER_NON_UNIQ_ERROR 1052 23000
ER_SERVER_SHUTDOWN 1053 08S01
ER_BAD_FIELD_ERROR 1054 42S22
ER_WRONG_FIELD_WITH_GROUP 1055 42000
ER_WRONG_GROUP_FIELD 1056 42000
ER_WRONG_SUM_SELECT 1057 42000
ER_WRONG_VALUE_COUNT 1058 21S01
ER_TOO_LONG_IDENT 1059 42000
ER_DUP_FIELDNAME 1060 42S21
ER_DUP_KEYNAME 1061 42000
ER_DUP_ENTRY 1062 23000
ER_WRONG_FIELD_SPEC 1063 42000
ER_PARSE_ERROR 1064 42000
ER_EMPTY_QUERY 1065 42000
ER_NONUNIQ_TABLE 1066 42000
ER_INVALID_DEFAULT 1067 42000
ER_MULTIPLE_PRI_KEY 1068 42000
ER_TOO_MANY_KEYS 1069 42000
ER_TOO_MANY_KEY_PARTS 1070 42000
ER_TOO_LONG_KEY 1071 42000
ER_KEY_COLUMN_DOES_NOT_EXITS 1072 42000
ER_BLOB_USED_AS_KEY 1073 42000
ER_TOO_BIG_FIELDLENGTH 1074 42000
ER_WRONG_AUTO_KEY 1075 42000
ER_READY 1076 00000
ER_NORMAL_SHUTDOWN 1077 00000
ER_GOT_SIGNAL 1078 00000
ER_SHUTDOWN_COMPLETE 1079 00000
ER_FORCING_CLOSE 1080 08S01
ER_IPSOCK_ERROR 1081 08S01
ER_NO_SUCH_INDEX 1082 42S12
ER_WRONG_FIELD_TERMINATORS 1083 42000
ER_BLOBS_AND_NO_TERMINATED 1084 42000
ER_TEXTFILE_NOT_READABLE 1085 HY000
ER_FILE_EXISTS_ERROR 1086 HY000
ER_LOAD_INFO 1087 HY000
ER_ALTER_INFO 1088 HY000
ER_WRONG_SUB_KEY 1089 HY000
ER_CANT_REMOVE_ALL_FIELDS 1090 42000
ER_CANT_DROP_FIELD_OR_KEY 1091 42000
ER_INSERT_INFO 1092 HY000
ER_UPDATE_TABLE_USED 1093 HY000
ER_NO_SUCH_THREAD 1094 HY000
ER_KILL_DENIED_ERROR 1095 HY000
ER_NO_TABLES_USED 1096 HY000
ER_TOO_BIG_SET 1097 HY000
ER_NO_UNIQUE_LOGFILE 1098 HY000
ER_TABLE_NOT_LOCKED_FOR_WRITE 1099 HY000
ER_TABLE_NOT_LOCKED 1100 HY000
ER_BLOB_CANT_HAVE_DEFAULT 1101 42000
ER_WRONG_DB_NAME 1102 42000
ER_WRONG_TABLE_NAME 1103 42000
ER_TOO_BIG_SELECT 1104 42000
ER_UNKNOWN_ERROR 1105 HY000
ER_UNKNOWN_PROCEDURE 1106 42000
ER_WRONG_PARAMCOUNT_TO_PROCEDURE 1107 42000
ER_WRONG_PARAMETERS_TO_PROCEDURE 1108 HY000
ER_UNKNOWN_TABLE 1109 42S02
ER_FIELD_SPECIFIED_TWICE 1110 42000
ER_INVALID_GROUP_FUNC_USE 1111 42000
ER_UNSUPPORTED_EXTENSION 1112 42000
ER_TABLE_MUST_HAVE_COLUMNS 1113 42000
ER_RECORD_FILE_FULL 1114 HY000
ER_UNKNOWN_CHARACTER_SET 1115 42000
ER_TOO_MANY_TABLES 1116 HY000
ER_TOO_MANY_FIELDS 1117 HY000
ER_TOO_BIG_ROWSIZE 1118 42000
ER_STACK_OVERRUN 1119 HY000
ER_WRONG_OUTER_JOIN 1120 42000
ER_NULL_COLUMN_IN_INDEX 1121 42000
ER_CANT_FIND_UDF 1122 HY000
ER_CANT_INITIALIZE_UDF 1123 HY000
ER_UDF_NO_PATHS 1124 HY000
ER_UDF_EXISTS 1125 HY000
ER_CANT_OPEN_LIBRARY 1126 HY000
ER_CANT_FIND_DL_ENTRY 1127 HY000
ER_FUNCTION_NOT_DEFINED 1128 HY000
ER_HOST_IS_BLOCKED 1129 HY000
ER_HOST_NOT_PRIVILEGED 1130 HY000
ER_PASSWORD_ANONYMOUS_USER 1131 42000
ER_PASSWORD_NOT_ALLOWED 1132 42000
ER_PASSWORD_NO_MATCH 1133 42000
ER_UPDATE_INFO 1134 HY000
ER_CANT_CREATE_THREAD 1135 HY000
ER_WRONG_VALUE_COUNT_ON_ROW 1136 21S01
ER_CANT_REOPEN_TABLE 1137 HY000
ER_INVALID_USE_OF_NULL 1138 42000
ER_REGEXP_ERROR 1139 42000
ER_MIX_OF_GROUP_FUNC_AND_FIELDS 1140 42000
ER_NONEXISTING_GRANT 1141 42000
ER_TABLEACCESS_DENIED_ERROR 1142 42000
ER_COLUMNACCESS_DENIED_ERROR 1143 42000
ER_ILLEGAL_GRANT_FOR_TABLE 1144 42000
ER_GRANT_WRONG_HOST_OR_USER 1145 42000
ER_NO_SUCH_TABLE 1146 42S02
ER_NONEXISTING_TABLE_GRANT 1147 42000
ER_NOT_ALLOWED_COMMAND 1148 42000
ER_SYNTAX_ERROR 1149 42000
ER_DELAYED_CANT_CHANGE_LOCK 1150 HY000
ER_TOO_MANY_DELAYED_THREADS 1151 HY000
ER_ABORTING_CONNECTION 1152 08S01
ER_NET_PACKET_TOO_LARGE 1153 08S01
ER_NET_READ_ERROR_FROM_PIPE 1154 08S01
ER_NET_FCNTL_ERROR 1155 08S01
ER_NET_PACKETS_OUT_OF_ORDER 1156 08S01
ER_NET_UNCOMPRESS_ERROR 1157 08S01
ER_NET_READ_ERROR 1158 08S01
ER_NET_READ_INTERRUPTED 1159 08S01
ER_NET_ERROR_ON_WRITE 1160 08S01
ER_NET_WRITE_INTERRUPTED 1161 08S01
ER_TOO_LONG_STRING 1162 42000
ER_TABLE_CANT_HANDLE_BLOB 1163 42000
ER_TABLE_CANT_HANDLE_AUTO_INCREMENT 1164 42000
ER_DELAYED_INSERT_TABLE_LOCKED 1165 HY000
ER_WRONG_COLUMN_NAME 1166 42000
ER_WRONG_KEY_COLUMN 1167 42000
ER_WRONG_MRG_TABLE 1168 HY000
ER_DUP_UNIQUE 1169 23000
ER_BLOB_KEY_WITHOUT_LENGTH 1170 42000
ER_PRIMARY_CANT_HAVE_NULL 1171 42000
ER_TOO_MANY_ROWS 1172 42000
ER_REQUIRES_PRIMARY_KEY 1173 42000
ER_NO_RAID_COMPILED 1174 HY000
ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE 1175 HY000
ER_KEY_DOES_NOT_EXITS 1176 HY000
ER_CHECK_NO_SUCH_TABLE 1177 42000
ER_CHECK_NOT_IMPLEMENTED 1178 42000
ER_CANT_DO_THIS_DURING_AN_TRANSACTION 1179 25000
ER_ERROR_DURING_COMMIT 1180 HY000
ER_ERROR_DURING_ROLLBACK 1181 HY000
ER_ERROR_DURING_FLUSH_LOGS 1182 HY000
ER_ERROR_DURING_CHECKPOINT 1183 HY000
ER_NEW_ABORTING_CONNECTION 1184 08S01
ER_DUMP_NOT_IMPLEMENTED 1185 HY000
ER_FLUSH_MASTER_BINLOG_CLOSED 1186 HY000
ER_INDEX_REBUILD 1187 HY000
ER_MASTER 1188 HY000
ER_MASTER_NET_READ 1189 08S01
ER_MASTER_NET_WRITE 1190 08S01
ER_FT_MATCHING_KEY_NOT_FOUND 1191 HY000
ER_LOCK_OR_ACTIVE_TRANSACTION 1192 HY000
ER_UNKNOWN_SYSTEM_VARIABLE 1193 HY000
ER_CRASHED_ON_USAGE 1194 HY000
ER_CRASHED_ON_REPAIR 1195 HY000
ER_WARNING_NOT_COMPLETE_ROLLBACK 1196 HY000
ER_TRANS_CACHE_FULL 1197 HY000
ER_SLAVE_MUST_STOP 1198 HY000
ER_SLAVE_NOT_RUNNING 1199 HY000
ER_BAD_SLAVE 1200 HY000
ER_MASTER_INFO 1201 HY000
ER_SLAVE_THREAD 1202 HY000
ER_TOO_MANY_USER_CONNECTIONS 1203 42000
ER_SET_CONSTANTS_ONLY 1204 HY000
ER_LOCK_WAIT_TIMEOUT 1205 HY000
ER_LOCK_TABLE_FULL 1206 HY000
ER_READ_ONLY_TRANSACTION 1207 25000
ER_DROP_DB_WITH_READ_LOCK 1208 HY000
ER_CREATE_DB_WITH_READ_LOCK 1209 HY000
ER_WRONG_ARGUMENTS 1210 HY000
ER_NO_PERMISSION_TO_CREATE_USER 1211 42000
ER_UNION_TABLES_IN_DIFFERENT_DIR 1212 HY000
ER_LOCK_DEADLOCK 1213 40001
ER_TABLE_CANT_HANDLE_FULLTEXT 1214 HY000
ER_CANNOT_ADD_FOREIGN 1215 HY000
ER_NO_REFERENCED_ROW 1216 23000
ER_ROW_IS_REFERENCED 1217 23000
ER_CONNECT_TO_MASTER 1218 08S01
ER_QUERY_ON_MASTER 1219 HY000
ER_ERROR_WHEN_EXECUTING_COMMAND 1220 HY000
ER_WRONG_USAGE 1221 HY000
ER_WRONG_NUMBER_OF_COLUMNS_IN_SELECT 1222 21000
ER_CANT_UPDATE_WITH_READLOCK 1223 HY000
ER_MIXING_NOT_ALLOWED 1224 HY000
ER_DUP_ARGUMENT 1225 HY000
ER_USER_LIMIT_REACHED 1226 42000
ER_SPECIFIC_ACCESS_DENIED_ERROR 1227 HY000
ER_LOCAL_VARIABLE 1228 HY000
ER_GLOBAL_VARIABLE 1229 HY000
ER_NO_DEFAULT 1230 42000
ER_WRONG_VALUE_FOR_VAR 1231 42000
ER_WRONG_TYPE_FOR_VAR 1232 42000
ER_VAR_CANT_BE_READ 1233 HY000
ER_CANT_USE_OPTION_HERE 1234 42000
ER_NOT_SUPPORTED_YET 1235 42000
ER_MASTER_FATAL_ERROR_READING_BINLOG 1236 HY000
ER_WRONG_FK_DEF 1237 42000
ER_KEY_REF_DO_NOT_MATCH_TABLE_REF 1238 HY000
ER_CARDINALITY_COL 1239 21000
ER_SUBSELECT_NO_1_ROW 1240 21000
ER_UNKNOWN_STMT_HANDLER 1241 HY000
ER_CORRUPT_HELP_DB 1242 HY000
ER_CYCLIC_REFERENCE 1243 HY000
ER_AUTO_CONVERT 1244 HY000
ER_ILLEGAL_REFERENCE 1245 42S22
ER_DERIVED_MUST_HAVE_ALIAS 1246 42000
ER_SELECT_REDUCED 1247 01000
ER_TABLENAME_NOT_ALLOWED_HERE 1248 42000
ER_NOT_SUPPORTED_AUTH_MODE 1249 08004
ER_SPATIAL_CANT_HAVE_NULL 1250 42000
ER_COLLATION_CHARSET_MISMATCH 1251 42000
ER_SLAVE_WAS_RUNNING 1252 HY000
ER_SLAVE_WAS_NOT_RUNNING 1253 HY000
ER_TOO_BIG_FOR_UNCOMPRESS 1254 HY000
ER_ZLIB_Z_MEM_ERROR 1255 HY000
ER_ZLIB_Z_BUF_ERROR 1256 HY000
ER_ZLIB_Z_DATA_ERROR 1257 HY000
ER_CUT_VALUE_GROUP_CONCAT 1258 HY000
ER_WARN_TOO_FEW_RECORDS 1259 01000
ER_WARN_TOO_MANY_RECORDS 1260 01000
ER_WARN_NULL_TO_NOTNULL 1261 01000
ER_WARN_DATA_OUT_OF_RANGE 1262 01000
ER_WARN_DATA_TRUNCATED 1263 01000
ER_WARN_USING_OTHER_HANDLER 1264 01000
ER_CANT_AGGREGATE_COLLATIONS 1265 42000
ER_DROP_USER 1266 42000
ER_REVOKE_GRANTS 1267 42000
1044错误：数据库用户权限不足，请联系空间商解决
1045错误：数据库服务器/数据库用户名/数据库名/数据库密码错误，请联系空间商检查帐户。
1054错误：程序文件跟数据库有冲突，请使用正确的程序文件上传上去覆盖。
1146错误：数据表缺失,请恢复备份数据.
1005：创建表失败
1006：创建数据库失败
1007：数据库已存在，创建数据库失败
1008：数据库不存在，删除数据库失败
1009：不能删除数据库文件导致删除数据库失败
1010：不能删除数据目录导致删除数据库失败
1011：删除数据库文件失败
1012：不能读取系统表中的记录
1020：记录已被其他用户修改
1021：硬盘剩余空间不足，请加大硬盘可用空间
1022：关键字重复，更改记录失败
1023：关闭时发生错误
1024：读文件错误
1025：更改名字时发生错误
1026：写文件错误
1032：记录不存在
1036：数据表是只读的，不能对它进行修改
1037：系统内存不足，请重启数据库或重启服务器
1038：用于排序的内存不足，请增大排序缓冲区
1040：已到达数据库的最大连接数，请加大数据库可用连接数
1041：系统内存不足
1042：无效的主机名
1043：无效连接
1044：当前用户没有访问数据库的权限
1045：不能连接数据库，用户名或密码错误
1048：字段不能为空
1049：数据库不存在
1050：数据表已存在
1051：数据表不存在
1054：字段不存在
1065：无效的SQL语句，SQL语句为空
1081：不能建立Socket连接
1114：数据表已满，不能容纳任何记录
1116：打开的数据表太多
1129：数据库出现异常，请重启数据库
1130：连接数据库失败，没有连接数据库的权限
1133：数据库用户不存在
1141：当前用户无权访问数据库
1142：当前用户无权访问数据表
1143：当前用户无权访问数据表中的字段
1146：数据表不存在
1147：未定义用户对数据表的访问权限
1149：SQL语句语法错误
1158：网络错误，出现读错误，请检查网络连接状况
1159：网络错误，读超时，请检查网络连接状况
1160：网络错误，出现写错误，请检查网络连接状况
1161：网络错误，写超时，请检查网络连接状况
1062：字段值重复，入库失败
1169：字段值重复，更新记录失败
1177：打开数据表失败
1180：提交事务失败
1181：回滚事务失败
1203：当前用户和数据库建立的连接已到达数据库的最大连接数，请增大可用的数据库连接数或重启数据库
1205：加锁超时
1211：当前用户没有创建用户的权限
1216：外键约束检查失败，更新子表记录失败
1217：外键约束检查失败，删除或修改主表记录失败
1226：当前用户使用的资源已超过所允许的资源，请重启数据库或重启服务器
1227：权限不足，您无权进行此操作
1235：MySQL版本过低，不具有本功能
2002：Can't connect to ...通常意味着没有一个MySQL服务器运行在系统上或当试图连接mysqld服务器时，你正在使用一个错误的套接字文件或TCP/IP端口。
说明：以上只是常见错误号，并且解决办法也不一定肯定管用！具体请参考MYSQL手册（各大下载站均有下载）
更多详细错误代码
错误名称 / 错误代码 SQL状态
ER_HASHCHK 1000 HY000
ER_NISAMCHK 1001 HY000
ER_NO 1002 HY000
ER_YES 1003 HY000
ER_CANT_CREATE_FILE 1004 HY000
ER_CANT_CREATE_TABLE 1005 HY000
ER_CANT_CREATE_DB 1006 HY000
ER_DB_CREATE_EXISTS 1007 HY000
ER_DB_DROP_EXISTS 1008 HY000
ER_DB_DROP_DELETE 1009 HY000
ER_DB_DROP_RMDIR 1010 HY000
ER_CANT_DELETE_FILE 1011 HY000
ER_CANT_FIND_SYSTEM_REC 1012 HY000
ER_CANT_GET_STAT 1013 HY000
ER_CANT_GET_WD 1014 HY000
ER_CANT_LOCK 1015 HY000
ER_CANT_OPEN_FILE 1016 HY000
ER_FILE_NOT_FOUND 1017 HY000
ER_CANT_READ_DIR 1018 HY000
ER_CANT_SET_WD 1019 HY000
ER_CHECKREAD 1020 HY000
ER_DISK_FULL 1021 HY000
ER_DUP_KEY 1022 23000
ER_ERROR_ON_CLOSE 1023 HY000
ER_ERROR_ON_READ 1024 HY000
ER_ERROR_ON_RENAME 1025 HY000
ER_ERROR_ON_WRITE 1026 HY000
ER_FILE_USED 1027 HY000
ER_FILSORT_ABORT 1028 HY000
ER_FORM_NOT_FOUND 1029 HY000
ER_GET_ERRNO 1030 HY000
ER_ILLEGAL_HA 1031 HY000
ER_KEY_NOT_FOUND 1032 HY000
ER_NOT_FORM_FILE 1033 HY000
ER_NOT_KEYFILE 1034 HY000
ER_OLD_KEYFILE 1035 HY000
ER_OPEN_AS_READONLY 1036 HY000
ER_OUTOFMEMORY 1037 HY001
ER_OUT_OF_SORTMEMORY 1038 HY001
ER_UNEXPECTED_EOF 1039 HY000
ER_CON_COUNT_ERROR 1040 08004
ER_OUT_OF_RESOURCES 1041 08004
ER_BAD_HOST_ERROR 1042 08S01
ER_HANDSHAKE_ERROR 1043 08S01
ER_DBACCESS_DENIED_ERROR 1044 42000
ER_ACCESS_DENIED_ERROR 1045 42000
ER_NO_DB_ERROR 1046 42000
ER_UNKNOWN_COM_ERROR 1047 08S01
ER_BAD_NULL_ERROR 1048 23000
ER_BAD_DB_ERROR 1049 42000
ER_TABLE_EXISTS_ERROR 1050 42S01
ER_BAD_TABLE_ERROR 1051 42S02
ER_NON_UNIQ_ERROR 1052 23000
ER_SERVER_SHUTDOWN 1053 08S01
ER_BAD_FIELD_ERROR 1054 42S22
ER_WRONG_FIELD_WITH_GROUP 1055 42000
ER_WRONG_GROUP_FIELD 1056 42000
ER_WRONG_SUM_SELECT 1057 42000
ER_WRONG_VALUE_COUNT 1058 21S01
ER_TOO_LONG_IDENT 1059 42000
ER_DUP_FIELDNAME 1060 42S21
ER_DUP_KEYNAME 1061 42000
ER_DUP_ENTRY 1062 23000
ER_WRONG_FIELD_SPEC 1063 42000
ER_PARSE_ERROR 1064 42000
ER_EMPTY_QUERY 1065 42000
ER_NONUNIQ_TABLE 1066 42000
ER_INVALID_DEFAULT 1067 42000
ER_MULTIPLE_PRI_KEY 1068 42000
ER_TOO_MANY_KEYS 1069 42000
ER_TOO_MANY_KEY_PARTS 1070 42000
ER_TOO_LONG_KEY 1071 42000
ER_KEY_COLUMN_DOES_NOT_EXITS 1072 42000
ER_BLOB_USED_AS_KEY 1073 42000
ER_TOO_BIG_FIELDLENGTH 1074 42000
ER_WRONG_AUTO_KEY 1075 42000
ER_READY 1076 00000
ER_NORMAL_SHUTDOWN 1077 00000
ER_GOT_SIGNAL 1078 00000
ER_SHUTDOWN_COMPLETE 1079 00000
ER_FORCING_CLOSE 1080 08S01
ER_IPSOCK_ERROR 1081 08S01
ER_NO_SUCH_INDEX 1082 42S12
ER_WRONG_FIELD_TERMINATORS 1083 42000
ER_BLOBS_AND_NO_TERMINATED 1084 42000
ER_TEXTFILE_NOT_READABLE 1085 HY000
ER_FILE_EXISTS_ERROR 1086 HY000
ER_LOAD_INFO 1087 HY000
ER_ALTER_INFO 1088 HY000
ER_WRONG_SUB_KEY 1089 HY000
ER_CANT_REMOVE_ALL_FIELDS 1090 42000
ER_CANT_DROP_FIELD_OR_KEY 1091 42000
ER_INSERT_INFO 1092 HY000
ER_UPDATE_TABLE_USED 1093 HY000
ER_NO_SUCH_THREAD 1094 HY000
ER_KILL_DENIED_ERROR 1095 HY000
ER_NO_TABLES_USED 1096 HY000
ER_TOO_BIG_SET 1097 HY000
ER_NO_UNIQUE_LOGFILE 1098 HY000
ER_TABLE_NOT_LOCKED_FOR_WRITE 1099 HY000
ER_TABLE_NOT_LOCKED 1100 HY000
ER_BLOB_CANT_HAVE_DEFAULT 1101 42000
ER_WRONG_DB_NAME 1102 42000
ER_WRONG_TABLE_NAME 1103 42000
ER_TOO_BIG_SELECT 1104 42000
ER_UNKNOWN_ERROR 1105 HY000
ER_UNKNOWN_PROCEDURE 1106 42000
ER_WRONG_PARAMCOUNT_TO_PROCEDURE 1107 42000
ER_WRONG_PARAMETERS_TO_PROCEDURE 1108 HY000
ER_UNKNOWN_TABLE 1109 42S02
ER_FIELD_SPECIFIED_TWICE 1110 42000
ER_INVALID_GROUP_FUNC_USE 1111 42000
ER_UNSUPPORTED_EXTENSION 1112 42000
ER_TABLE_MUST_HAVE_COLUMNS 1113 42000
ER_RECORD_FILE_FULL 1114 HY000
ER_UNKNOWN_CHARACTER_SET 1115 42000
ER_TOO_MANY_TABLES 1116 HY000
ER_TOO_MANY_FIELDS 1117 HY000
ER_TOO_BIG_ROWSIZE 1118 42000
ER_STACK_OVERRUN 1119 HY000
ER_WRONG_OUTER_JOIN 1120 42000
ER_NULL_COLUMN_IN_INDEX 1121 42000
ER_CANT_FIND_UDF 1122 HY000
ER_CANT_INITIALIZE_UDF 1123 HY000
ER_UDF_NO_PATHS 1124 HY000
ER_UDF_EXISTS 1125 HY000
ER_CANT_OPEN_LIBRARY 1126 HY000
ER_CANT_FIND_DL_ENTRY 1127 HY000
ER_FUNCTION_NOT_DEFINED 1128 HY000
ER_HOST_IS_BLOCKED 1129 HY000
ER_HOST_NOT_PRIVILEGED 1130 HY000
ER_PASSWORD_ANONYMOUS_USER 1131 42000
ER_PASSWORD_NOT_ALLOWED 1132 42000
ER_PASSWORD_NO_MATCH 1133 42000
ER_UPDATE_INFO 1134 HY000
ER_CANT_CREATE_THREAD 1135 HY000
ER_WRONG_VALUE_COUNT_ON_ROW 1136 21S01
ER_CANT_REOPEN_TABLE 1137 HY000
ER_INVALID_USE_OF_NULL 1138 42000
ER_REGEXP_ERROR 1139 42000
ER_MIX_OF_GROUP_FUNC_AND_FIELDS 1140 42000
ER_NONEXISTING_GRANT 1141 42000
ER_TABLEACCESS_DENIED_ERROR 1142 42000
ER_COLUMNACCESS_DENIED_ERROR 1143 42000
ER_ILLEGAL_GRANT_FOR_TABLE 1144 42000
ER_GRANT_WRONG_HOST_OR_USER 1145 42000
ER_NO_SUCH_TABLE 1146 42S02
ER_NONEXISTING_TABLE_GRANT 1147 42000
ER_NOT_ALLOWED_COMMAND 1148 42000
ER_SYNTAX_ERROR 1149 42000
ER_DELAYED_CANT_CHANGE_LOCK 1150 HY000
ER_TOO_MANY_DELAYED_THREADS 1151 HY000
ER_ABORTING_CONNECTION 1152 08S01
ER_NET_PACKET_TOO_LARGE 1153 08S01
ER_NET_READ_ERROR_FROM_PIPE 1154 08S01
ER_NET_FCNTL_ERROR 1155 08S01
ER_NET_PACKETS_OUT_OF_ORDER 1156 08S01
ER_NET_UNCOMPRESS_ERROR 1157 08S01
ER_NET_READ_ERROR 1158 08S01
ER_NET_READ_INTERRUPTED 1159 08S01
ER_NET_ERROR_ON_WRITE 1160 08S01
ER_NET_WRITE_INTERRUPTED 1161 08S01
ER_TOO_LONG_STRING 1162 42000
ER_TABLE_CANT_HANDLE_BLOB 1163 42000
ER_TABLE_CANT_HANDLE_AUTO_INCREMENT 1164 42000
ER_DELAYED_INSERT_TABLE_LOCKED 1165 HY000
ER_WRONG_COLUMN_NAME 1166 42000
ER_WRONG_KEY_COLUMN 1167 42000
ER_WRONG_MRG_TABLE 1168 HY000
ER_DUP_UNIQUE 1169 23000
ER_BLOB_KEY_WITHOUT_LENGTH 1170 42000
ER_PRIMARY_CANT_HAVE_NULL 1171 42000
ER_TOO_MANY_ROWS 1172 42000
ER_REQUIRES_PRIMARY_KEY 1173 42000
ER_NO_RAID_COMPILED 1174 HY000
ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE 1175 HY000
ER_KEY_DOES_NOT_EXITS 1176 HY000
ER_CHECK_NO_SUCH_TABLE 1177 42000
ER_CHECK_NOT_IMPLEMENTED 1178 42000
ER_CANT_DO_THIS_DURING_AN_TRANSACTION 1179 25000
ER_ERROR_DURING_COMMIT 1180 HY000
ER_ERROR_DURING_ROLLBACK 1181 HY000
ER_ERROR_DURING_FLUSH_LOGS 1182 HY000
ER_ERROR_DURING_CHECKPOINT 1183 HY000
ER_NEW_ABORTING_CONNECTION 1184 08S01
ER_DUMP_NOT_IMPLEMENTED 1185 HY000
ER_FLUSH_MASTER_BINLOG_CLOSED 1186 HY000
ER_INDEX_REBUILD 1187 HY000
ER_MASTER 1188 HY000
ER_MASTER_NET_READ 1189 08S01
ER_MASTER_NET_WRITE 1190 08S01
ER_FT_MATCHING_KEY_NOT_FOUND 1191 HY000
ER_LOCK_OR_ACTIVE_TRANSACTION 1192 HY000
ER_UNKNOWN_SYSTEM_VARIABLE 1193 HY000
ER_CRASHED_ON_USAGE 1194 HY000
ER_CRASHED_ON_REPAIR 1195 HY000
ER_WARNING_NOT_COMPLETE_ROLLBACK 1196 HY000
ER_TRANS_CACHE_FULL 1197 HY000
ER_SLAVE_MUST_STOP 1198 HY000
ER_SLAVE_NOT_RUNNING 1199 HY000
ER_BAD_SLAVE 1200 HY000
ER_MASTER_INFO 1201 HY000
ER_SLAVE_THREAD 1202 HY000
ER_TOO_MANY_USER_CONNECTIONS 1203 42000
ER_SET_CONSTANTS_ONLY 1204 HY000
ER_LOCK_WAIT_TIMEOUT 1205 HY000
ER_LOCK_TABLE_FULL 1206 HY000
ER_READ_ONLY_TRANSACTION 1207 25000
ER_DROP_DB_WITH_READ_LOCK 1208 HY000
ER_CREATE_DB_WITH_READ_LOCK 1209 HY000
ER_WRONG_ARGUMENTS 1210 HY000
ER_NO_PERMISSION_TO_CREATE_USER 1211 42000
ER_UNION_TABLES_IN_DIFFERENT_DIR 1212 HY000
ER_LOCK_DEADLOCK 1213 40001
ER_TABLE_CANT_HANDLE_FULLTEXT 1214 HY000
ER_CANNOT_ADD_FOREIGN 1215 HY000
ER_NO_REFERENCED_ROW 1216 23000
ER_ROW_IS_REFERENCED 1217 23000
ER_CONNECT_TO_MASTER 1218 08S01
ER_QUERY_ON_MASTER 1219 HY000
ER_ERROR_WHEN_EXECUTING_COMMAND 1220 HY000
ER_WRONG_USAGE 1221 HY000
ER_WRONG_NUMBER_OF_COLUMNS_IN_SELECT 1222 21000
ER_CANT_UPDATE_WITH_READLOCK 1223 HY000
ER_MIXING_NOT_ALLOWED 1224 HY000
ER_DUP_ARGUMENT 1225 HY000
ER_USER_LIMIT_REACHED 1226 42000
ER_SPECIFIC_ACCESS_DENIED_ERROR 1227 HY000
ER_LOCAL_VARIABLE 1228 HY000
ER_GLOBAL_VARIABLE 1229 HY000
ER_NO_DEFAULT 1230 42000
ER_WRONG_VALUE_FOR_VAR 1231 42000
ER_WRONG_TYPE_FOR_VAR 1232 42000
ER_VAR_CANT_BE_READ 1233 HY000
ER_CANT_USE_OPTION_HERE 1234 42000
ER_NOT_SUPPORTED_YET 1235 42000
ER_MASTER_FATAL_ERROR_READING_BINLOG 1236 HY000
ER_WRONG_FK_DEF 1237 42000
ER_KEY_REF_DO_NOT_MATCH_TABLE_REF 1238 HY000
ER_CARDINALITY_COL 1239 21000
ER_SUBSELECT_NO_1_ROW 1240 21000
ER_UNKNOWN_STMT_HANDLER 1241 HY000
ER_CORRUPT_HELP_DB 1242 HY000
ER_CYCLIC_REFERENCE 1243 HY000
ER_AUTO_CONVERT 1244 HY000
ER_ILLEGAL_REFERENCE 1245 42S22
ER_DERIVED_MUST_HAVE_ALIAS 1246 42000
ER_SELECT_REDUCED 1247 01000
ER_TABLENAME_NOT_ALLOWED_HERE 1248 42000
ER_NOT_SUPPORTED_AUTH_MODE 1249 08004
ER_SPATIAL_CANT_HAVE_NULL 1250 42000
ER_COLLATION_CHARSET_MISMATCH 1251 42000
ER_SLAVE_WAS_RUNNING 1252 HY000
ER_SLAVE_WAS_NOT_RUNNING 1253 HY000
ER_TOO_BIG_FOR_UNCOMPRESS 1254 HY000
ER_ZLIB_Z_MEM_ERROR 1255 HY000
ER_ZLIB_Z_BUF_ERROR 1256 HY000
ER_ZLIB_Z_DATA_ERROR 1257 HY000
ER_CUT_VALUE_GROUP_CONCAT 1258 HY000
ER_WARN_TOO_FEW_RECORDS 1259 01000
ER_WARN_TOO_MANY_RECORDS 1260 01000
ER_WARN_NULL_TO_NOTNULL 1261 01000
ER_WARN_DATA_OUT_OF_RANGE 1262 01000
ER_WARN_DATA_TRUNCATED 1263 01000
ER_WARN_USING_OTHER_HANDLER 1264 01000
ER_CANT_AGGREGATE_COLLATIONS 1265 42000
ER_DROP_USER 1266 42000
ER_REVOKE_GRANTS 1267 42000
1 楼
抛出异常的爱
2007-10-22
1. Mysql 培训
1.1. 培训目的
本文档是针对MySQL 数据库方面的基础培训，为了使项目组成员能够达到使用MySQL 数据库的目的。
1.2. 培训对象
开发人员
1.3. 常用词及符号说明
常用词：
Mysql：一种免费的跨平台的数据库系统
E:\mysql：表示是在dos 命令窗口下面
mysql> 表示是在mysql 的命令行下
1.4. 参考信息
http://dev.mysql.com/doc/refman/5.0/en/index.html
2. MYSQL
2.1. 连接MYSQL
格式： mysql -h主机地址 -u用户名 -p用户密码
连接远程机器：
E:\mysql>mysql -h10.4.3.188 -uptsdb -p
等价写法
E:\mysql>mysql --host=10.4.3.188 --user=ptsdb --password
连接本地机器：
E:\mysql>mysql -uroot -p
等价写法
E:\mysql>mysql --user=root -password
（注:u与root可以不用加空格，其它也一样）
注意事项：环境变量path 里面要设定mysql的bin的路径：
C:\Program Files\MySQL\MySQL Server 5.0\bin
2.2. 修改密码
方法一：使用mysqladmin
格式：mysqladmin -u用户名 -p旧密码 password 新密码
例1：E:\mysql>mysqladmin -uroot password root
注：因为开始时root没有密码，所以-p旧密码一项就可以省略了。
例2：再将root的密码改为root123。
E:\mysql>mysqladmin -uroot -proot password root123
方法二：直接更新 user 表
mysql>UPDATE user SET password=PASSWORD("test123") WHERE user='test';
mysql> FLUSH PRIVILEGES;
mysql> SET PASSWORD FOR test=PASSWORD('test123');
mysql> FLUSH PRIVILEGES;
方法三：使用 grant
格式：grant 权限 on 数据库.表格| 其他 to 用户@主机 IDENTIFIED BY 口令
例1：给test用户在本地localhost 所有权限(除了GRANT OPTION)，口令为 test
(相当于修改了test 用户的口令)
mysql>grant all on *.* to test@localhost identified by "test";
等同于
mysql>grant all on *.* to test @localhost identified by PASSWORD " *94BDCEBE19083CE2A1F959FD02F964C7AF4CFC29 ";
例2、增加一个用户test密码为abc，让他可以在任何主机上登录，并对test数据库有查询、插入、修改、删除的权限。首先用以root用户连入MYSQL，然后键入以下命令：
mysql>grant select,insert,update,delete on test.* to test@"%" Identified by "abc";
在mysql.user 表中，有两个test 用户
一个test 用户，在本地有所有的权限
另外的test 用户，在所有主机上有增删改查权限
同样可以取消部分权限（全部）
mysql>revoke insert,update,delete on test.* from test@"%"
mysql>REVOKE ALL PRIVILEGES, GRANT OPTION FROM test@"%"
然后 mysql> FLUSH PRIVILEGES;
Test 用户不再使用用了，也可以删除
mysql>Delete from user where user='test' and host='%'
mysql> FLUSH PRIVILEGES;
注意：例2增加的用户是比较危险的，你想如某个人知道test的密码，那么他就可以在internet上的任何一台电脑上登录你的mysql数据库并对你的数据库test为所欲为了(可以通过限定主机)
mysql>grant select,insert,update,delete on test.* to test@"IP地址" Identified by "abc";
2.3. 显示命令
显示数据库列表:
mysql>show databases;
mysql>show schemas; --mysql 5.0.2
显示表格
mysql>show tables from mydb;
显示表格状态
Mysql>SHOW TABLE STATUS;
显示字符集:
mysql> SHOW CHARACTER SET;
显示创建表:
mysql> show create table quote;
显示用户权限:
mysql> SHOW GRANTS FOR 'test'@'localhost';
mysql>SHOW GRANTS;
mysql>SHOW GRANTS FOR CURRENT_USER;
mysql>SHOW GRANTS FOR CURRENT_USER();
显示index:
mysql>SHOW INDEX FROM mydb.mytable;
显示表结构:
mysql>desc mydb.tablename;
mysql>show columns from mydb.tablename;
显示MySQL数据库的版本：
mysql>select version();
显示函数
mysql>Select * from mysql.func;
显示存储过程
mysql>Select * from mysql.proc;
显示存储引擎
mysql> SHOW ENGINES;
显示变量:
mysql>SHOW VARIABLES;
显示状态:
Mysql> SHOW STATUS;
显示进程
Mysql>SHOW PROCESSLIST
显示 INNODB 状态
Mysql>SHOW INNODB STATUS
显示连接状态
Mysql>SHOW STATUS LIKE '%CONNECT%';
显示线程状态
Mysql>SHOW STATUS LIKE '%THREAD%';
等等..
2.4. 创建.修改.删除
2.4.1. 创建数据库
CREATE {DATABASE | SCHEMA} [IF NOT EXISTS] db_name
[create_specification [, create_specification] ...]
create_specification:
[DEFAULT] CHARACTER SET charset_name
| [DEFAULT] COLLATE collation_name
例如:
CREATE DATABASE IF NOT EXISTS ddd --如果不存在,则创建.
CHARACTER SET 'ujis' --设定字符集
COLLATE 'ujis_japanese_ci';
2.4.2. 创建表
CREATE [TEMPORARY] TABLE [IF NOT EXISTS] tbl_name
[(create_definition,...)]
[table_options] [select_statement]
例子:
CREATE TABLE if not exists `Admin_User` (
`id` int(11) NOT NULL auto_increment, --PRIMARY KEY，
`livedoorId` varchar(255) NOT NULL default '',
`password` varchar(255) NOT NULL default '',
`auth` int(11) default '0',
PRIMARY KEY (`id`) --设定主健
) ENGINE=MyISAM DEFAULT CHARSET=ujis ?设定字符集
ENGINE=MyISAM 默认存储引擎
The binary portable storage engine that is the default storage engine used by MySQL
对于每个MyISAM 存储引擎的表,在硬盘上存在3个文件
File Purpose
tbl_name.frm Table format (definition) file
tbl_name.MYD Data file
tbl_name.MYI Index file
ENGINE= InnoDB
Transaction-safe tables with row locking and foreign keys.
ENGINE = BDB
Transaction-safe tables with page locking.
还有其他的内存引擎 MEMORY 归档 ARCHIVE 等等
ISAM 不再使用了
2.4.3. 创建索引
CREATE [UNIQUE|FULLTEXT|SPATIAL] INDEX index_name
[USING index_type]
ON tbl_name (index_col_name,...)
index_col_name:
col_name [(length)] [ASC | DESC]
将customer 表的name 字段前十个字符做为索引
CREATE INDEX part_of_name ON customer (name(10));
MYSQL 5.0 特性
存储引擎为 MyISAM, InnoDB, or BDB 的表格上,可以在有null值的字段上创建索引
存储引擎为 MyISAM, InnoDB, or BDB 的表格上,可以在BLOB TEXT 上创建索引
只有在MyISAM 类型表格上,可以在CHAR, VARCHAR, and TEXT 字段类型上创建FULLTEXT 索引
Storage Engine Allowable Index Types
MyISAM BTREE
InnoDB BTREE
MEMORY/HEAP HASH, BTREE
可以指定索引类型
Example:
CREATE TABLE testtable (id INT) ENGINE = MEMORY;
CREATE INDEX id_index USING BTREE ON testtable (id);
2.4.4. 修改表
ALTER [IGNORE] TABLE tbl_name
alter_specification [, alter_specification] ...
IGNORE 忽略主健重复的错误,如果重复,采用第一条,其余删除
例子:同时多个操作
mysql> ALTER TABLE t2 DROP COLUMN c, DROP COLUMN d;
例子, 重命名 INTEGER 字段,从 a 到 b:
mysql> ALTER TABLE t1 CHANGE a b INTEGER;
例子 修改字段类型,仍然需要新旧字段名称,即使字段名称相同:
mysql> ALTER TABLE t1 CHANGE b b BIGINT NOT NULL;
也可以使用modify
mysql> ALTER TABLE t1 MODIFY b BIGINT NOT NULL;
在mysql 5.0 可以使用FIRST or AFTER 字段来添加add 字段,默认是在最后
modify change 也可以使用
在mysql 5.0 InnoDB 存储引擎支持 ALTER TABLE 删除外健:
mysql>ALTER TABLE yourtablename DROP FOREIGN KEY fk_symbol;
例子:
创建表
mysql> CREATE TABLE t1 (a INTEGER,b CHAR(10));
重命名表
mysql> ALTER TABLE t1 RENAME t2;
MODIFY a 字段为 TINYINT NOT NULL , 并且 change 字段 b,从 CHAR(10) 到 CHAR(20) 并改名为c:
mysql> ALTER TABLE t2 MODIFY a TINYINT NOT NULL, CHANGE b c CHAR(20);
添加新字段 d:
mysql> ALTER TABLE t2 ADD d TIMESTAMP;
在a d 上增加索引:
mysql> ALTER TABLE t2 ADD INDEX (d), ADD INDEX (a);
删除字段c:
mysql> ALTER TABLE t2 DROP COLUMN c;
添加一个自动增长的字段c ,并且添加c 为主健:
mysql> ALTER TABLE t2 ADD c INT UNSIGNED NOT NULL AUTO_INCREMENT,
-> ADD PRIMARY KEY (c);
2.4.4.1. 修改外键
语法:
ALTER TABLE tbl_name
ADD [CONSTRAINT symbol] FOREIGN KEY [id] (index_col_name, ...)
REFERENCES tbl_name (index_col_name, ...)
[ON DELETE {RESTRICT | CASCADE | SET NULL | NO ACTION}]
[ON UPDATE {RESTRICT | CASCADE | SET NULL | NO ACTION}]
例子:
create table aa (id1 int not null,name varchar(20),primary key(id1))type=InnoDB;
create table b(id2 int not null,lessonname varchar(20),primary key(id2))type=InnoDB;
alter table b add FOREIGN KEY id (id2) references aa(id1);
2.4.5. 删除
删除数据库
DROP {DATABASE | SCHEMA} [IF EXISTS] db_name
例子: mysql>drop DATABASE IF EXISTS testdb;
删除表
DROP [TEMPORARY] TABLE [IF EXISTS]
tbl_name [, tbl_name] ...
[RESTRICT | CASCADE]
例子: mysql>drop TABLE IF EXISTS testTable;
删除索引
DROP INDEX index_name ON tbl_name
例子: mysql>drop index testIndex on testTable;
重命名
RENAME TABLE tbl_name TO new_tbl_name
[, tbl_name2 TO new_tbl_name2] ...
例子:RENAME TABLE current_db.tbl_name TO other_db.tbl_name;
2.5. 数据库备份恢复
数据库备份
数据库备份命令：
mysqldump --opt --user=用户名 --password=密码 --default_character-set=字符集 -B数据库> 输出的sql文件
例子:
E:\mysql>Mysqldump --user=ptsdb --password=ptsdb --default_character-set=ujis --opt pts>dump.sql
参见批处理文件
数据库导入命令：
mysql --user=用户名 --password=密码 --default_character-set=字符集 [数据库]<导入的sql 语句
E:\mysql>mysql -uptsdb -pptsdb --default-character-set=ujis
例子： 对于InnoDB（没有设定字符集）
Following mysqldump import example for InnoDB tables is at least 100x faster than previous examples.
1. mysqldump --opt --user=username --password database > dumbfile.sql
2. Edit the dump file and put these lines at the beginning:
SET AUTOCOMMIT = 0;
SET FOREIGN_KEY_CHECKS=0;
3. Put these lines at the end:
SET FOREIGN_KEY_CHECKS = 1;
COMMIT;
SET AUTOCOMMIT = 1;
4. mysql --user=username --password database < dumpfile.sql
参数说明：
--add-drop-database
Add a DROP DATABASE statement before each CREATE DATABASE statement.
--add-drop-table
Add a DROP TABLE statement before each CREATE TABLE statement.
--all-databases, -A
Dump all tables in all databases. This is the same as using the --databases option and naming all the databases on the command line.
--databases, -B
Dump several databases. Normally, mysqldump treats the first name argument on the command line as a database name
and following names as table names. With this option, it treats all name arguments as database names.
CREATE DATABASE IF NOT EXISTS db_name and USE db_name statements are included in the output before each new database.
--host=host_name, -h host_name
Dump data from the MySQL server on the given host. The default host is localhost.
--opt
This option is shorthand; it is the same as specifying --add-drop-table --add-locks --create-options
--disable-keys --extended-insert --lock-tables --quick --set-charset.
It should give you a fast dump operation and produce a dump file that can be reloaded into a MySQL server quickly.
In MySQL 5.0, --opt is on by default, but can be disabled with --skip-opt.
To disable only certain of the options enabled by --opt, use their --skip forms;
for example, --skip-add-drop-table or --skip-quick.
还有一些其他参数，有兴趣可以学习
2.6. 表数据备份
mysql>use test;
mysql> CREATE TABLE imptest(id INT, n VARCHAR(30));
Query OK, 0 rows affected (0.03 sec)
方法一：
导出使用：Mysqldump
E:\mysql>mysqldump -uptsdb -pptsdb -where "id>='100'"
test imptest
E:\mysql>mysqldump -uptsdb -pptsdb test imptest>e:\mysql\imp\imptest2.txt
导入使用 mysql
mysql -uptsdb -pptsdb< imptest2.txt
方法二：
导出使用 select into OUTFILE
mysql> select * from imptest where id=101 into OUTFILE 'e:\\mysql\\imp\\test3.txt' FIELDS TERMINATED BY ',';
导入使用 LOAD DATA INFILE
LOAD DATA [LOW_PRIORITY | CONCURRENT] [LOCAL] INFILE 'file_name.txt'
[REPLACE | IGNORE]
INTO TABLE tbl_name
[FIELDS
[TERMINATED BY 'string']
[[OPTIONALLY] ENCLOSED BY 'char']
[ESCAPED BY 'char' ]
]
[LINES
[STARTING BY 'string']
[TERMINATED BY 'string']
]
[IGNORE number LINES]
[(col_name_or_user_var,...)]
[SET col_name = expr,...]]
例子：
mysql> LOAD DATA INFILE 'e:\\mysql\\imp\\test3.txt' INTO TABLE imptest FIELDS TERMINATED BY ',';
导入使用mysqlimport：
E:\mysql>mysqlimport -uptsdb -pptsdb --local test E:\mysql\imp\imp.txt
mysqlimport: Error: Table 'test.imp' doesn't exist, when using table: imp
E:\mysql>mysqlimport -uptsdb -pptsdb --local test E:\mysql\imp\imptest.txt
test.imptest: Records: 2 Deleted: 0 Skipped: 0 Warnings: 0
注意：文件名必须跟表名相同
参数
-d or --delete 新数据导入数据表中之前删除数据数据表中的所有信息
-f or --force 不管是否遇到错误，mysqlimport将强制继续插入数据
-i or --ignore mysqlimport跳过或者忽略那些有相同唯一
-r or -replace 这个选项与－i选项的作用相反；此选项将替代 表中有相同唯一关键字的记录
2.7. 数据管道导入导出
E:\mysql>mysql -h10.5.1.66 -uroot -proot --default-character-set=name frontdb_20060415(databasename)
>e:/mysql/test.txt (输出的sql 语句)
1:>;create databases newname(在新的server上建立空的数据库)
2:#/usr/local/mysql/bin/mysqldump databasename >*.sql(在旧的服务器上导出数据库)
3:#/usr/local/mysql/bin/mysql databasename < *.sql(在新的服务器上导入*.sql)
注意数据库名要一一对应.
2.8. 各种字段的取值范围
TINYINT 1 byte
-128 - 127
TINYINT UNSIGNED 1 byte
0 ? 255 即0-（28-1）
SMALLINT 2 bytes
-32768 - 32767 即-215至(215-1)
SMALLINT UNSIGNED 2 bytes
0 - 65535 即0至(216-1)
MEDIUMINT 3 bytes
-8388608 - 8388607 即?223至(223-1)
MEDIUMINT UNSIGNED 3 bytes
0 - 16777215 即0至(224-1)
INT 或 INTEGER 4 bytes
-2147483648 - 2147483647 即?231至(231-1)
INT UNSIGNED 或 INTEGER UNSIGNED 4 bytes
0 - 4294967295 即0至(232-1)
BIGINT 8 bytes
-9223372036854775808 - 9223372036854775807 即?263至(263-1)
BIGINT UNSIGNED 8 bytes
0 - 18446744073709551615 即0至(264-1)
FLOAT 4 bytes
-3.402823466E+38 - -1.175494351E-38
0
1.175494351E-38 - 3.402823466E+38
DOUBLE 或 DOUBLE PRECISION 或 REAL 8 bytes
-1.7976931348623157E+308 - -2.2250738585072014E-308
0
2.2250738585072014E-308 - 1.7976931348623157E+308
DECIMAL[(M,[D])] 或 NUMERIC(M,D) 不定
由M(整个数字的长度,包括小数点,小数点左边的位数,小数点右边的位数,但不包括负号)和
D(小数点右边的位数)来决定,M缺省为10,D缺省为0
DATE 3 bytes
1000-01-01 - 9999-12-31
DATETIME 8 bytes
1000-01-01 00:00:00 - 9999-12-31 23:59:59
TIMESTAMP 4 bytes
1970-01-01 00:00:00 - 2037-12-31 23:59:59
TIME 3 bytes
-838:59:59' to 838:59:59
YEAR[(2|4)] 1 byte
缺省为4位格式,4位格式取值范围为1901 - 2155,0000,2位格式取值范围为70-69(1970-2069)
CHAR(M) [BINARY] 或 NCHAR(M) [BINARY] M bytes
M的范围为1 - 255,如果没有BINARY项,则不分大小写,NCHAR表示使用缺省的字符集.在数据库 中以空格补足,但在取出来时末尾的空格将被去掉.
[NATIONAL] VARCHAR(M) [BINARY]
Before 5.0.3 M的范围为0?255 L+1 bytes L<=M
5.0.3 以及以后 M 范围为 0-65535
L+1 bytes L<=M 0<=M<=256
L+2 bytes L<=M 256<=65535
在数据库中末尾的空格将自动去掉.
TINYBLOB 或 TINYTEXT L+1 bytes
255(2^8-1)个字符
BLOB 或 TEXT L+2 bytes
65535(2^16-1)个字符
MEDIUMBLOB 或 MEDIUMTEXT L+3 bytes
16777215 (2^24-1)个字符
LONGBLOB 或 LONGTEXT L+4 bytes
4294967295 (2^32-1)个字符
ENUM('value1','value2',...) 1 or 2 bytes
可以总共有65535个不同的值
SET('value1','value2',...) 1/2/3/4/8 bytes
最多有64个成员
2.9. 查询
2.9.1. limit
LIMIT子句可以用来限制由SELECT语句返回过来的数据数量，它有一个或两个参数，如果给出两个参数，
第一个参数指定返回的第一行在所有数据中的位置，从0开始（注意不是1），第二个参数指定最多返回行
数。例如：
select * from table LIMIT 5,10; #返回第6-15行数据
select * from table LIMIT 5; #返回前5行
select * from table LIMIT 0,5; #返回前5行
2.9.2. join 详解
还是先 Create table 吧
create table emp(
id int not null primary key,
name varchar(10)
);
create table emp_dept(
dept_id varchar(4) not null,
emp_id int not null,
emp_name varchar(10),
primary key (dept_id,emp_id));
insert into emp() values
(1,"Dennis-1"),
(2,"Dennis-2"),
(3,"Dennis-3"),
(4,"Dennis-4"),
(5,"Dennis-5"),
(6,"Dennis-6"),
(7,"Dennis-7"),
(8,"Dennis-8"),
(9,"Dennis-9"),
(10,"Dennis-10");
insert into emp_dept() values
("R&D",1,"Dennis-1"),
("DEv",2,"Dennis-2"),
("R&D",3,"Dennis-3"),
("Test",4,"Dennis-4"),
("Test",5,"Dennis-5");
("dddd",20,"eeee");
>> left join
-------------
select a.id,a.name,b.dept_id
from emp a left join emp_dept b on (a.id=b.emp_id);
# 挑出左边的 table emp 中的所有资料,即使 emp_dept 中没有的资料也挑出来,没有的就用 NULL 来显示,
# 也即显示资料是以左边的 table emp 中的资料为基础
mysql> select a.id,a.name,b.dept_id
-> from emp a left join emp_dept b on (a.id=b.emp_id);
+----+-----------+---------+
| id | name | dept_id |
+----+-----------+---------+
| 1 | Dennis-1 | R&D |
| 2 | Dennis-2 | DEv |
| 3 | Dennis-3 | R&D |
| 4 | Dennis-4 | Test |
| 5 | Dennis-5 | Test |
| 6 | Dennis-6 | NULL |
| 7 | Dennis-7 | NULL |
| 8 | Dennis-8 | NULL |
| 9 | Dennis-9 | NULL |
| 10 | Dennis-10 | NULL |
+----+-----------+---------+
# 挑出 table emp 中有而 table emp_dept 中没有的人员资料
select a.id,a.name,b.dept_id
from emp a left join emp_dept b on (a.id=b.emp_id)
where b.dept_id IS NULL;
mysql> select a.id,a.name,b.dept_id
-> from emp a left join emp_dept b on (a.id=b.emp_id)
-> where b.dept_id IS NULL;
+----+-----------+---------+
| id | name | dept_id |
+----+-----------+---------+
| 6 | Dennis-6 | NULL |
| 7 | Dennis-7 | NULL |
| 8 | Dennis-8 | NULL |
| 9 | Dennis-9 | NULL |
| 10 | Dennis-10 | NULL |
+----+-----------+---------+
# 把 table emp_dept 放在左边的情形(当然以 emp_dept 中的数据为基础来显示资料,emp 中比emp_dept 中多的资料也就不会显示出来了):
select a.id,a.name,b.dept_id
from emp_dept b left join emp a on (a.id=b.emp_id);
mysql> select a.id,a.name,b.dept_id
-> from emp_dept b left join emp a on (a.id=b.emp_id);
+------+----------+---------+
| id | name | dept_id |
+------+----------+---------+
| NULL | NULL | dddd |
| 2 | Dennis-2 | DEv |
| 1 | Dennis-1 | R&D |
| 3 | Dennis-3 | R&D |
| 4 | Dennis-4 | Test |
| 5 | Dennis-5 | Test |
+------+----------+---------+
>> right join
---------------
select a.id,a.name,b.dept_id
from emp a right join emp_dept b on (a.id=b.emp_id);
# 挑资料时以右边 table emp_dept 中的资料为基础来显示资料
mysql> select a.id,a.name,b.dept_id
-> from emp a right join emp_dept b on (a.id=b.emp_id);
+------+----------+---------+
| id | name | dept_id |
+------+----------+---------+
| NULL | NULL | dddd |
| 2 | Dennis-2 | DEv |
| 1 | Dennis-1 | R&D |
| 3 | Dennis-3 | R&D |
| 4 | Dennis-4 | Test |
| 5 | Dennis-5 | Test |
+------+----------+---------+
6 rows in set (0.00 sec)
# 我们再把 table 的位置交换一下,再用 right join 试试
select a.id,a.name,b.dept_id
from emp_dept b right join emp a on (a.id=b.emp_id);
mysql> select a.id,a.name,b.dept_id
-> from emp_dept b right join emp a on (a.id=b.emp_id);
+----+-----------+---------+
| id | name | dept_id |
+----+-----------+---------+
| 1 | Dennis-1 | R&D |
| 2 | Dennis-2 | DEv |
| 3 | Dennis-3 | R&D |
| 4 | Dennis-4 | Test |
| 5 | Dennis-5 | Test |
| 6 | Dennis-6 | NULL |
| 7 | Dennis-7 | NULL |
| 8 | Dennis-8 | NULL |
| 9 | Dennis-9 | NULL |
| 10 | Dennis-10 | NULL |
+----+-----------+---------+
# 是不是和 left join 一样了?
>> inner join STRAIGHT_JOIN
select a.id,a.name,b.dept_id
from emp a ,emp_dept b
where a.id=b.emp_id;
mysql> select a.id,a.name,b.dept_id
-> from emp a ,emp_dept b
-> where a.id=b.emp_id;
+----+----------+---------+
| id | name | dept_id |
+----+----------+---------+
| 2 | Dennis-2 | DEv |
| 1 | Dennis-1 | R&D |
| 3 | Dennis-3 | R&D |
| 4 | Dennis-4 | Test |
| 5 | Dennis-5 | Test |
+----+----------+---------+
2.9.3. 别名 alias
你可以在GROUP BY、ORDER BY或在HAVING部分中使用别名引用列。别名也可以用来为列取一个更好点的名字：
SELECT SQRT(a*b) as rt FROM table_name GROUP BY rt HAVING rt > 0;
SELECT id,COUNT(*) AS cnt FROM table_name GROUP BY id HAVING cnt > 0;
SELECT id AS "Customer identity" FROM table_name;
注意，你的 ANSI SQL 不允许你在一个WHERE子句中引用一个别名。这是因为在WHERE代码被执行时，列值还可能没有终结。例如下列查询是不合法：
SELECT id,COUNT(*) AS cnt FROM table_name WHERE cnt > 0 GROUP BY id;
WHERE语句被执行以确定哪些行应该包括GROUP BY部分中，而HAVING用来决定应该只用结果集合中的哪些行。
2.9.4. 正则
正则表达式（regex）是定义复杂查询的一个强有力的工具。
这里是一个简单的资料，它忽略了一些详细的信息。
正则表达式定义了一个字符串的规则。最简单的正则表达式不包含任何保留字。例如，
正则表达式hello只和字符串“hello”匹配。
一般的正则表达式使用了某些特殊的结构，所以它能匹配更多的字符串。例如，正则
表达式hello|word既能匹配字符串“hello”也能匹配字符串“word”。
举一个更复杂一点的例子，正则表达式B[an]*s可以匹配字符串“Bananas”、“Baaaaa
s”
、“Bs”以及其他任何以B开头以s结尾的字符串，中间可以包括任意个a和任意个n的组
合。
一个正则表达式中的可以使用以下保留字
^
所匹配的字符串以后面的字符串开头
mysql> select "fonfo" REGEXP "^fo$"; -> 0（表示不匹配）
mysql> select "fofo" REGEXP "^fo"; -> 1（表示匹配）
$
所匹配的字符串以前面的字符串结尾
mysql> select "fono" REGEXP "^fono$"; -> 1（表示匹配）
mysql> select "fono" REGEXP "^fo$"; -> 0（表示不匹配）
..
匹配任何字符（包括新行）
mysql> select "fofo" REGEXP "^f.*"; -> 1（表示匹配）
mysql> select "fonfo" REGEXP "^f.*"; -> 1（表示匹配）
a*
匹配任意0-n多个a（包括空串）
mysql> select "Ban" REGEXP "^Ba*n"; -> 1（表示匹配）
mysql> select "Baaan" REGEXP "^Ba*n"; -> 1（表示匹配）
mysql> select "Bn" REGEXP "^Ba*n"; -> 1（表示匹配）
a+
匹配任意1-n多个a（不包括空串）
mysql> select "Ban" REGEXP "^Ba+n"; -> 1（表示匹配）
mysql> select "Bn" REGEXP "^Ba+n"; -> 0（表示不匹配）
a?
匹配0-1个a
mysql> select "Bn" REGEXP "^Ba?n"; -> 1（表示匹配）
mysql> select "Ban" REGEXP "^Ba?n"; -> 1（表示匹配）
mysql> select "Baan" REGEXP "^Ba?n"; -> 0（表示不匹配）
de|abc
匹配de或abc
mysql> select "pi" REGEXP "pi|apa"; -> 1（表示匹配）
mysql> select "axe" REGEXP "pi|apa"; -> 0（表示不匹配）
mysql> select "apa" REGEXP "pi|apa"; -> 1（表示匹配）
mysql> select "apa" REGEXP "^(pi|apa)$"; -> 1（表示匹配）
mysql> select "pi" REGEXP "^(pi|apa)$"; -> 1（表示匹配）
mysql> select "pix" REGEXP "^(pi|apa)$"; -> 0（表示不匹配）
(abc)*
匹配任意多个（0-n个）abc（包括空串)
mysql> select "pi" REGEXP "^(pi)*$"; -> 1（表示匹配）
mysql> select "pip" REGEXP "^(pi)*$"; -> 0（表示不匹配）
mysql> select "pipi" REGEXP "^(pi)*$"; -> 1（表示匹配）
{1}
{2,3}
这是一个更全面的方法，它可以实现前面好几种保留字的功能
a*
可以写成a{0,}
a+
可以写成a{1,}
a?
可以写成a{0,1}
在{}内只有一个整型参数i，表示字符只能出现i次；在{}内有一个整型参数i，
后面跟一个“，”，表示字符可以出现i次或i次以上；在{}内只有一个整型参数i，
后面跟一个“，”，再跟一个整型参数j,表示字符只能出现i次以上，j次以下
（包括i次和j次）。其中的整型参数必须大于等于0，小于等于 RE_DUP_MAX（默认是25
5）。
如果有两个参数，第二个必须大于等于第一个
[a-dX]
匹配“a”、“b”、“c”、“d”或“X”
[^a-dX]
匹配除“a”、“b”、“c”、“d”、“X”以外的任何字符。
“[”、“]”必须成对使用
mysql> select "aXbc" REGEXP "[a-dXYZ]"; -> 1（表示匹配）
mysql> select "aXbc" REGEXP "^[a-dXYZ]$"; -> 0（表示不匹配）
mysql> select "aXbc" REGEXP "^[a-dXYZ]+$"; -> 1（表示匹配）
mysql> select "aXbc" REGEXP "^[^a-dXYZ]+$"; -> 0（表示不匹配）
mysql> select "gheis" REGEXP "^[^a-dXYZ]+$"; -> 1（表示匹配）
mysql> select "gheisa" REGEXP "^[^a-dXYZ]+$"; -> 0（表示不匹配）
------------------------------------------------------------
[[.characters.]]
表示比较元素的顺序。在括号内的字符顺序是唯一的。但是括号中可以包含通配符,
所以他能匹配更多的字符。举例来说：正则表达式[[.ch.]]*c匹配chchcc的前五个字符
。
[=character_class=]
表示相等的类，可以代替类中其他相等的元素，包括它自己。例如，如果o和(+)是
一个相等的类的成员，那么[[=o=]]、[[=(+)=]]和[o(+)]是完全等价的。
[:character_class:]
在括号里面，在[:和:]中间是字符类的名字，可以代表属于这个类的所有字符。
字符类的名字有: alnum、digit、punct、alpha、graph、space、blank、lower、uppe
r、cntrl、print和xdigit
mysql> select "justalnums" REGEXP "[[:alnum:]]+"; -> 1（表示匹配）
mysql> select "!!" REGEXP "[[:alnum:]]+"; -> 0（表示不匹配）
[[:<:>
[[:>:]]
分别匹配一个单词开头和结尾的空的字符串，这个单词开头和结尾都不是包含在alnum中
的字符也不能是下划线。
mysql> select "a word a" REGEXP "[[:<:>:]]"; -> 1（表示匹配）
mysql> select "a xword a" REGEXP "[[:<:>:]]"; -> 0（表示不匹配）
mysql> select "weeknights" REGEXP "^(wee|week)(knights|nights)$"; -> 1（表示
匹配）
2.9.5. Select 中使用 IF Statement
mysql> select * from test;
+------+------+------+-------+
| dept | id | sex | name |
+------+------+------+-------+
| 1 | 1 | 0 | wang |
| 2 | 2 | 1 | zhang |
| 3 | 3 | 0 | li |
+------+------+------+-------+
3 rows in set (0.00 sec)
mysql> select dept,id,if(sex=0,'女','男') sex,name from test;
+------+------+-----+-------+
| dept | id | sex | name |
+------+------+-----+-------+
| 1 | 1 | 女 | wang |
| 2 | 2 | 男 | zhang |
| 3 | 3 | 女 | li |
+------+------+-----+-------+
3 rows in set (0.00 sec)
2.9.6. Select中使用CASE Statement
mysql> select dept,id,(case sex when '0' then '女' else '男' end) as sex,name from test;
+------+------+------+-------+
| dept | id | sex | name |
+------+------+------+-------+
| 1 | 1 | 女 | wang |
| 2 | 2 | 男 | zhang |
| 3 | 3 | 女 | li |
+------+------+------+-------+
mysql> select (case dept when '1' then 'no1' when '2' then 'no2' else 'other' end) as dept from test;
+-------+
| dept |
+-------+
| no1 |
| no2 |
| other |
+-------+
3 rows in set (0.00 sec)
注意: 相当于Oracle 中的decode 和case when
在统计报表中很有用处
2.10. 存储过程和函数
CREATE PROCEDURE sp_name ([proc_parameter[,...]])
[characteristic ...] routine_body
CREATE FUNCTION sp_name ([func_parameter[,...]])
RETURNS type
[characteristic ...] routine_body
proc_parameter:
[ IN | OUT | INOUT ] param_name type
func_parameter:
param_name type
type:
Any valid MySQL data type
characteristic:
LANGUAGE SQL
| [NOT] DETERMINISTIC
| { CONTAINS SQL | NO SQL | READS SQL DATA | MODIFIES SQL DATA }
| SQL SECURITY { DEFINER | INVOKER }
| COMMENT 'string'
routine_body:
Valid SQL procedure statement or statements
例子：创建一个过程hello，显示问候语
mysql> delimiter ;
mysql> drop PROCEDURE if exists hello;
Query OK, 0 rows affected (0.00 sec)
mysql> delimiter //
mysql>
mysql> CREATE PROCEDURE hello (IN s varchar(20))
-> BEGIN
-> SELECT CONCAT('Hello,',s,'!') as hello;
-> END;
-> //
Query OK, 0 rows affected (0.00 sec)
mysql> delimiter ;
mysql> call hello('wangyl');
+---------------+
| hello |
+---------------+
| Hello,wangyl! |
+---------------+
1 row in set (0.00 sec)
Query OK, 0 rows affected (0.00 sec)
例子2: 查询t表的记录总数
mysql> delimiter //
mysql> CREATE PROCEDURE simpleproc (OUT param1 INT)
-> BEGIN
-> SELECT COUNT(*) INTO param1 FROM t;
-> END
-> //
Query OK, 0 rows affected (0.00 sec)
mysql> delimiter ;
mysql> CALL simpleproc(@a);
Query OK, 0 rows affected (0.00 sec)
mysql> SELECT @a;
+------+
| @a |
+------+
| 3 |
+------+
1 row in set (0.00 sec)
例子：创建一个函数
mysql> delimiter ;
mysql> drop FUNCTION if exists dateFunction;
Query OK, 0 rows affected (0.00 sec)
mysql> delimiter //
mysql> CREATE FUNCTION dateFunction (iCase int)
-> RETURNS varchar(50)
-> begin
-> DECLARE iType int;
-> DECLARE sReturn varchar(50);
-> set iType =icase +1;
-> case iType
-> when 1 then select DATE_FORMAT(NOW(),'%Y-%m-%d') into sReturn;
-> when 2 then select DATE_FORMAT(NOW(),'%W %M %Y') into sReturn;
-> else
-> select NOW() into sReturn;
-> end case;
-> return sReturn;
-> end;
-> //
Query OK, 0 rows affected (0.00 sec)
mysql> delimiter ;
mysql> select dateFunction(0);
+-----------------+
| dateFunction(0) |
+-----------------+
| 2005-11-14 |
+-----------------+
1 row in set (0.00 sec)
mysql> select dateFunction(1);
+----------------------+
| dateFunction(1) |
+----------------------+
| Monday November 2005 |
+----------------------+
1 row in set (0.00 sec)
mysql> select dateFunction(2);
+---------------------+
| dateFunction(2) |
+---------------------+
| 2005-11-14 15:05:43 |
+---------------------+
1 row in set (0.00 sec)
2.11. 补充：trigger
CREATE TRIGGER trigger_name trigger_time trigger_event
ON tbl_name FOR EACH ROW trigger_stmt
CREATE TABLE test1(a1 INT);
CREATE TABLE test2(a2 INT);
CREATE TABLE test3(a3 INT NOT NULL AUTO_INCREMENT PRIMARY KEY);
CREATE TABLE test4(
a4 INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
b4 INT DEFAULT 0
);
DELIMITER |
CREATE TRIGGER testref BEFORE INSERT ON test1
FOR EACH ROW BEGIN
INSERT INTO test2 SET a2 = NEW.a1;
DELETE FROM test3 WHERE a3 = NEW.a1;
UPDATE test4 SET b4 = b4 + 1 WHERE a4 = NEW.a1;
END|
DELIMITER ;
INSERT INTO test3 (a3) VALUES
(NULL), (NULL), (NULL), (NULL), (NULL),
(NULL), (NULL), (NULL), (NULL), (NULL);
INSERT INTO test4 (a4) VALUES
(0), (0), (0), (0), (0), (0), (0), (0), (0), (0);
If you insert the following values into table test1 as shown here:
mysql> INSERT INTO test1 VALUES
-> (1), (3), (1), (7), (1), (8), (4), (4);
Query OK, 8 rows affected (0.01 sec)
Records: 8 Duplicates: 0 Warnings: 0
Then the data in the four tables will be as follows:
mysql> SELECT * FROM test1;
+------+
| a1 |
+------+
| 1 |
| 3 |
| 1 |
| 7 |
| 1 |
| 8 |
| 4 |
| 4 |
+------+
8 rows in set (0.00 sec)
mysql> SELECT * FROM test2;
+------+
| a2 |
+------+
| 1 |
| 3 |
| 1 |
| 7 |
| 1 |
| 8 |
| 4 |
| 4 |
+------+
8 rows in set (0.00 sec)
mysql> SELECT * FROM test3;
+----+
| a3 |
+----+
| 2 |
| 5 |
| 6 |
| 9 |
| 10 |
+----+
5 rows in set (0.00 sec)
mysql> SELECT * FROM test4;
+----+------+
| a4 | b4 |
+----+------+
| 1 | 3 |
| 2 | 0 |
| 3 | 1 |
| 4 | 2 |
| 5 | 0 |
| 6 | 0 |
| 7 | 1 |
| 8 | 1 |
| 9 | 0 |
| 10 | 0 |
+----+------+
10 rows in set (0.00 sec)
2.12. 删除 DELETE Syntax
Single-table syntax:
DELETE [LOW_PRIORITY] [QUICK] [IGNORE] FROM tbl_name
[WHERE where_condition]
[ORDER BY ...]
[LIMIT row_count]
Multiple-table syntax:
DELETE [LOW_PRIORITY] [QUICK] [IGNORE]
tbl_name[.*] [, tbl_name[.*]] ...
FROM table_references
[WHERE where_condition]
Or:
DELETE [LOW_PRIORITY] [QUICK] [IGNORE]
FROM tbl_name[.*] [, tbl_name[.*]] ...
USING table_references
[WHERE where_condition]
对于删除多个表,不能使用order by 和limit
多表删除语法一: ,只是在删除 在from 前面的表所中匹配的记录
DELETE t1, t2 FROM t1, t2, t3 WHERE t1.id=t2.id AND t2.id=t3.id;
从t1,t2,t3 表选出要删除的记录,只是删除t1,t2 表中所匹配得这些记录.
多表删除语法二: 在from 列出的表中删除选中的记录.
DELETE FROM t1, t2 USING t1, t2, t3 WHERE t1.id=t2.id AND t2.id=t3.id;
从t1,t2,t3 表选出要删除的记录(使用using ),只是删除t1,t2 表中所匹配得这些记录.
注意: 如果您使用一个别名,您必须使用别名.
DELETE t1 FROM test AS t1, test2 WHERE ...
支持多个数据之间的多表删除,但是在这种情况下,你必须指定表,而不能使用别名:
DELETE test1.tmp1, test2.tmp2 FROM test1.tmp1, test2.tmp2 WHERE ...
当前,您不能从相同表的子查询中,删除同一表的数据
1.1. 培训目的
本文档是针对MySQL 数据库方面的基础培训，为了使项目组成员能够达到使用MySQL 数据库的目的。
1.2. 培训对象
开发人员
1.3. 常用词及符号说明
常用词：
Mysql：一种免费的跨平台的数据库系统
E:\mysql：表示是在dos 命令窗口下面
mysql> 表示是在mysql 的命令行下
1.4. 参考信息
http://dev.mysql.com/doc/refman/5.0/en/index.html
2. MYSQL
2.1. 连接MYSQL
格式： mysql -h主机地址 -u用户名 -p用户密码
连接远程机器：
E:\mysql>mysql -h10.4.3.188 -uptsdb -p
等价写法
E:\mysql>mysql --host=10.4.3.188 --user=ptsdb --password
连接本地机器：
E:\mysql>mysql -uroot -p
等价写法
E:\mysql>mysql --user=root -password
（注:u与root可以不用加空格，其它也一样）
注意事项：环境变量path 里面要设定mysql的bin的路径：
C:\Program Files\MySQL\MySQL Server 5.0\bin
2.2. 修改密码
方法一：使用mysqladmin
格式：mysqladmin -u用户名 -p旧密码 password 新密码
例1：E:\mysql>mysqladmin -uroot password root
注：因为开始时root没有密码，所以-p旧密码一项就可以省略了。
例2：再将root的密码改为root123。
E:\mysql>mysqladmin -uroot -proot password root123
方法二：直接更新 user 表
mysql>UPDATE user SET password=PASSWORD("test123") WHERE user='test';
mysql> FLUSH PRIVILEGES;
mysql> SET PASSWORD FOR test=PASSWORD('test123');
mysql> FLUSH PRIVILEGES;
方法三：使用 grant
格式：grant 权限 on 数据库.表格| 其他 to 用户@主机 IDENTIFIED BY 口令
例1：给test用户在本地localhost 所有权限(除了GRANT OPTION)，口令为 test
(相当于修改了test 用户的口令)
mysql>grant all on *.* to test@localhost identified by "test";
等同于
mysql>grant all on *.* to test @localhost identified by PASSWORD " *94BDCEBE19083CE2A1F959FD02F964C7AF4CFC29 ";
例2、增加一个用户test密码为abc，让他可以在任何主机上登录，并对test数据库有查询、插入、修改、删除的权限。首先用以root用户连入MYSQL，然后键入以下命令：
mysql>grant select,insert,update,delete on test.* to test@"%" Identified by "abc";
在mysql.user 表中，有两个test 用户
一个test 用户，在本地有所有的权限
另外的test 用户，在所有主机上有增删改查权限
同样可以取消部分权限（全部）
mysql>revoke insert,update,delete on test.* from test@"%"
mysql>REVOKE ALL PRIVILEGES, GRANT OPTION FROM test@"%"
然后 mysql> FLUSH PRIVILEGES;
Test 用户不再使用用了，也可以删除
mysql>Delete from user where user='test' and host='%'
mysql> FLUSH PRIVILEGES;
注意：例2增加的用户是比较危险的，你想如某个人知道test的密码，那么他就可以在internet上的任何一台电脑上登录你的mysql数据库并对你的数据库test为所欲为了(可以通过限定主机)
mysql>grant select,insert,update,delete on test.* to test@"IP地址" Identified by "abc";
2.3. 显示命令
显示数据库列表:
mysql>show databases;
mysql>show schemas; --mysql 5.0.2
显示表格
mysql>show tables from mydb;
显示表格状态
Mysql>SHOW TABLE STATUS;
显示字符集:
mysql> SHOW CHARACTER SET;
显示创建表:
mysql> show create table quote;
显示用户权限:
mysql> SHOW GRANTS FOR 'test'@'localhost';
mysql>SHOW GRANTS;
mysql>SHOW GRANTS FOR CURRENT_USER;
mysql>SHOW GRANTS FOR CURRENT_USER();
显示index:
mysql>SHOW INDEX FROM mydb.mytable;
显示表结构:
mysql>desc mydb.tablename;
mysql>show columns from mydb.tablename;
显示MySQL数据库的版本：
mysql>select version();
显示函数
mysql>Select * from mysql.func;
显示存储过程
mysql>Select * from mysql.proc;
显示存储引擎
mysql> SHOW ENGINES;
显示变量:
mysql>SHOW VARIABLES;
显示状态:
Mysql> SHOW STATUS;
显示进程
Mysql>SHOW PROCESSLIST
显示 INNODB 状态
Mysql>SHOW INNODB STATUS
显示连接状态
Mysql>SHOW STATUS LIKE '%CONNECT%';
显示线程状态
Mysql>SHOW STATUS LIKE '%THREAD%';
等等..
2.4. 创建.修改.删除
2.4.1. 创建数据库
CREATE {DATABASE | SCHEMA} [IF NOT EXISTS] db_name
[create_specification [, create_specification] ...]
create_specification:
[DEFAULT] CHARACTER SET charset_name
| [DEFAULT] COLLATE collation_name
例如:
CREATE DATABASE IF NOT EXISTS ddd --如果不存在,则创建.
CHARACTER SET 'ujis' --设定字符集
COLLATE 'ujis_japanese_ci';
2.4.2. 创建表
CREATE [TEMPORARY] TABLE [IF NOT EXISTS] tbl_name
[(create_definition,...)]
[table_options] [select_statement]
例子:
CREATE TABLE if not exists `Admin_User` (
`id` int(11) NOT NULL auto_increment, --PRIMARY KEY，
`livedoorId` varchar(255) NOT NULL default '',
`password` varchar(255) NOT NULL default '',
`auth` int(11) default '0',
PRIMARY KEY (`id`) --设定主健
) ENGINE=MyISAM DEFAULT CHARSET=ujis ?设定字符集
ENGINE=MyISAM 默认存储引擎
The binary portable storage engine that is the default storage engine used by MySQL
对于每个MyISAM 存储引擎的表,在硬盘上存在3个文件
File Purpose
tbl_name.frm Table format (definition) file
tbl_name.MYD Data file
tbl_name.MYI Index file
ENGINE= InnoDB
Transaction-safe tables with row locking and foreign keys.
ENGINE = BDB
Transaction-safe tables with page locking.
还有其他的内存引擎 MEMORY 归档 ARCHIVE 等等
ISAM 不再使用了
2.4.3. 创建索引
CREATE [UNIQUE|FULLTEXT|SPATIAL] INDEX index_name
[USING index_type]
ON tbl_name (index_col_name,...)
index_col_name:
col_name [(length)] [ASC | DESC]
将customer 表的name 字段前十个字符做为索引
CREATE INDEX part_of_name ON customer (name(10));
MYSQL 5.0 特性
存储引擎为 MyISAM, InnoDB, or BDB 的表格上,可以在有null值的字段上创建索引
存储引擎为 MyISAM, InnoDB, or BDB 的表格上,可以在BLOB TEXT 上创建索引
只有在MyISAM 类型表格上,可以在CHAR, VARCHAR, and TEXT 字段类型上创建FULLTEXT 索引
Storage Engine Allowable Index Types
MyISAM BTREE
InnoDB BTREE
MEMORY/HEAP HASH, BTREE
可以指定索引类型
Example:
CREATE TABLE testtable (id INT) ENGINE = MEMORY;
CREATE INDEX id_index USING BTREE ON testtable (id);
2.4.4. 修改表
ALTER [IGNORE] TABLE tbl_name
alter_specification [, alter_specification] ...
IGNORE 忽略主健重复的错误,如果重复,采用第一条,其余删除
例子:同时多个操作
mysql> ALTER TABLE t2 DROP COLUMN c, DROP COLUMN d;
例子, 重命名 INTEGER 字段,从 a 到 b:
mysql> ALTER TABLE t1 CHANGE a b INTEGER;
例子 修改字段类型,仍然需要新旧字段名称,即使字段名称相同:
mysql> ALTER TABLE t1 CHANGE b b BIGINT NOT NULL;
也可以使用modify
mysql> ALTER TABLE t1 MODIFY b BIGINT NOT NULL;
在mysql 5.0 可以使用FIRST or AFTER 字段来添加add 字段,默认是在最后
modify change 也可以使用
在mysql 5.0 InnoDB 存储引擎支持 ALTER TABLE 删除外健:
mysql>ALTER TABLE yourtablename DROP FOREIGN KEY fk_symbol;
例子:
创建表
mysql> CREATE TABLE t1 (a INTEGER,b CHAR(10));
重命名表
mysql> ALTER TABLE t1 RENAME t2;
MODIFY a 字段为 TINYINT NOT NULL , 并且 change 字段 b,从 CHAR(10) 到 CHAR(20) 并改名为c:
mysql> ALTER TABLE t2 MODIFY a TINYINT NOT NULL, CHANGE b c CHAR(20);
添加新字段 d:
mysql> ALTER TABLE t2 ADD d TIMESTAMP;
在a d 上增加索引:
mysql> ALTER TABLE t2 ADD INDEX (d), ADD INDEX (a);
删除字段c:
mysql> ALTER TABLE t2 DROP COLUMN c;
添加一个自动增长的字段c ,并且添加c 为主健:
mysql> ALTER TABLE t2 ADD c INT UNSIGNED NOT NULL AUTO_INCREMENT,
-> ADD PRIMARY KEY (c);
2.4.4.1. 修改外键
语法:
ALTER TABLE tbl_name
ADD [CONSTRAINT symbol] FOREIGN KEY [id] (index_col_name, ...)
REFERENCES tbl_name (index_col_name, ...)
[ON DELETE {RESTRICT | CASCADE | SET NULL | NO ACTION}]
[ON UPDATE {RESTRICT | CASCADE | SET NULL | NO ACTION}]
例子:
create table aa (id1 int not null,name varchar(20),primary key(id1))type=InnoDB;
create table b(id2 int not null,lessonname varchar(20),primary key(id2))type=InnoDB;
alter table b add FOREIGN KEY id (id2) references aa(id1);
2.4.5. 删除
删除数据库
DROP {DATABASE | SCHEMA} [IF EXISTS] db_name
例子: mysql>drop DATABASE IF EXISTS testdb;
删除表
DROP [TEMPORARY] TABLE [IF EXISTS]
tbl_name [, tbl_name] ...
[RESTRICT | CASCADE]
例子: mysql>drop TABLE IF EXISTS testTable;
删除索引
DROP INDEX index_name ON tbl_name
例子: mysql>drop index testIndex on testTable;
重命名
RENAME TABLE tbl_name TO new_tbl_name
[, tbl_name2 TO new_tbl_name2] ...
例子:RENAME TABLE current_db.tbl_name TO other_db.tbl_name;
2.5. 数据库备份恢复
数据库备份
数据库备份命令：
mysqldump --opt --user=用户名 --password=密码 --default_character-set=字符集 -B数据库> 输出的sql文件
例子:
E:\mysql>Mysqldump --user=ptsdb --password=ptsdb --default_character-set=ujis --opt pts>dump.sql
参见批处理文件
数据库导入命令：
mysql --user=用户名 --password=密码 --default_character-set=字符集 [数据库]<导入的sql 语句
E:\mysql>mysql -uptsdb -pptsdb --default-character-set=ujis
例子： 对于InnoDB（没有设定字符集）
Following mysqldump import example for InnoDB tables is at least 100x faster than previous examples.
1. mysqldump --opt --user=username --password database > dumbfile.sql
2. Edit the dump file and put these lines at the beginning:
SET AUTOCOMMIT = 0;
SET FOREIGN_KEY_CHECKS=0;
3. Put these lines at the end:
SET FOREIGN_KEY_CHECKS = 1;
COMMIT;
SET AUTOCOMMIT = 1;
4. mysql --user=username --password database < dumpfile.sql
参数说明：
--add-drop-database
Add a DROP DATABASE statement before each CREATE DATABASE statement.
--add-drop-table
Add a DROP TABLE statement before each CREATE TABLE statement.
--all-databases, -A
Dump all tables in all databases. This is the same as using the --databases option and naming all the databases on the command line.
--databases, -B
Dump several databases. Normally, mysqldump treats the first name argument on the command line as a database name
and following names as table names. With this option, it treats all name arguments as database names.
CREATE DATABASE IF NOT EXISTS db_name and USE db_name statements are included in the output before each new database.
--host=host_name, -h host_name
Dump data from the MySQL server on the given host. The default host is localhost.
--opt
This option is shorthand; it is the same as specifying --add-drop-table --add-locks --create-options
--disable-keys --extended-insert --lock-tables --quick --set-charset.
It should give you a fast dump operation and produce a dump file that can be reloaded into a MySQL server quickly.
In MySQL 5.0, --opt is on by default, but can be disabled with --skip-opt.
To disable only certain of the options enabled by --opt, use their --skip forms;
for example, --skip-add-drop-table or --skip-quick.
还有一些其他参数，有兴趣可以学习
2.6. 表数据备份
mysql>use test;
mysql> CREATE TABLE imptest(id INT, n VARCHAR(30));
Query OK, 0 rows affected (0.03 sec)
方法一：
导出使用：Mysqldump
E:\mysql>mysqldump -uptsdb -pptsdb -where "id>='100'"
test imptest
E:\mysql>mysqldump -uptsdb -pptsdb test imptest>e:\mysql\imp\imptest2.txt
导入使用 mysql
mysql -uptsdb -pptsdb< imptest2.txt
方法二：
导出使用 select into OUTFILE
mysql> select * from imptest where id=101 into OUTFILE 'e:\\mysql\\imp\\test3.txt' FIELDS TERMINATED BY ',';
导入使用 LOAD DATA INFILE
LOAD DATA [LOW_PRIORITY | CONCURRENT] [LOCAL] INFILE 'file_name.txt'
[REPLACE | IGNORE]
INTO TABLE tbl_name
[FIELDS
[TERMINATED BY 'string']
[[OPTIONALLY] ENCLOSED BY 'char']
[ESCAPED BY 'char' ]
]
[LINES
[STARTING BY 'string']
[TERMINATED BY 'string']
]
[IGNORE number LINES]
[(col_name_or_user_var,...)]
[SET col_name = expr,...]]
例子：
mysql> LOAD DATA INFILE 'e:\\mysql\\imp\\test3.txt' INTO TABLE imptest FIELDS TERMINATED BY ',';
导入使用mysqlimport：
E:\mysql>mysqlimport -uptsdb -pptsdb --local test E:\mysql\imp\imp.txt
mysqlimport: Error: Table 'test.imp' doesn't exist, when using table: imp
E:\mysql>mysqlimport -uptsdb -pptsdb --local test E:\mysql\imp\imptest.txt
test.imptest: Records: 2 Deleted: 0 Skipped: 0 Warnings: 0
注意：文件名必须跟表名相同
参数
-d or --delete 新数据导入数据表中之前删除数据数据表中的所有信息
-f or --force 不管是否遇到错误，mysqlimport将强制继续插入数据
-i or --ignore mysqlimport跳过或者忽略那些有相同唯一
-r or -replace 这个选项与－i选项的作用相反；此选项将替代 表中有相同唯一关键字的记录
2.7. 数据管道导入导出
E:\mysql>mysql -h10.5.1.66 -uroot -proot --default-character-set=name frontdb_20060415(databasename)
>e:/mysql/test.txt (输出的sql 语句)
1:>;create databases newname(在新的server上建立空的数据库)
2:#/usr/local/mysql/bin/mysqldump databasename >*.sql(在旧的服务器上导出数据库)
3:#/usr/local/mysql/bin/mysql databasename < *.sql(在新的服务器上导入*.sql)
注意数据库名要一一对应.
2.8. 各种字段的取值范围
TINYINT 1 byte
-128 - 127
TINYINT UNSIGNED 1 byte
0 ? 255 即0-（28-1）
SMALLINT 2 bytes
-32768 - 32767 即-215至(215-1)
SMALLINT UNSIGNED 2 bytes
0 - 65535 即0至(216-1)
MEDIUMINT 3 bytes
-8388608 - 8388607 即?223至(223-1)
MEDIUMINT UNSIGNED 3 bytes
0 - 16777215 即0至(224-1)
INT 或 INTEGER 4 bytes
-2147483648 - 2147483647 即?231至(231-1)
INT UNSIGNED 或 INTEGER UNSIGNED 4 bytes
0 - 4294967295 即0至(232-1)
BIGINT 8 bytes
-9223372036854775808 - 9223372036854775807 即?263至(263-1)
BIGINT UNSIGNED 8 bytes
0 - 18446744073709551615 即0至(264-1)
FLOAT 4 bytes
-3.402823466E+38 - -1.175494351E-38
0
1.175494351E-38 - 3.402823466E+38
DOUBLE 或 DOUBLE PRECISION 或 REAL 8 bytes
-1.7976931348623157E+308 - -2.2250738585072014E-308
0
2.2250738585072014E-308 - 1.7976931348623157E+308
DECIMAL[(M,[D])] 或 NUMERIC(M,D) 不定
由M(整个数字的长度,包括小数点,小数点左边的位数,小数点右边的位数,但不包括负号)和
D(小数点右边的位数)来决定,M缺省为10,D缺省为0
DATE 3 bytes
1000-01-01 - 9999-12-31
DATETIME 8 bytes
1000-01-01 00:00:00 - 9999-12-31 23:59:59
TIMESTAMP 4 bytes
1970-01-01 00:00:00 - 2037-12-31 23:59:59
TIME 3 bytes
-838:59:59' to 838:59:59
YEAR[(2|4)] 1 byte
缺省为4位格式,4位格式取值范围为1901 - 2155,0000,2位格式取值范围为70-69(1970-2069)
CHAR(M) [BINARY] 或 NCHAR(M) [BINARY] M bytes
M的范围为1 - 255,如果没有BINARY项,则不分大小写,NCHAR表示使用缺省的字符集.在数据库 中以空格补足,但在取出来时末尾的空格将被去掉.
[NATIONAL] VARCHAR(M) [BINARY]
Before 5.0.3 M的范围为0?255 L+1 bytes L<=M
5.0.3 以及以后 M 范围为 0-65535
L+1 bytes L<=M 0<=M<=256
L+2 bytes L<=M 256<=65535
在数据库中末尾的空格将自动去掉.
TINYBLOB 或 TINYTEXT L+1 bytes
255(2^8-1)个字符
BLOB 或 TEXT L+2 bytes
65535(2^16-1)个字符
MEDIUMBLOB 或 MEDIUMTEXT L+3 bytes
16777215 (2^24-1)个字符
LONGBLOB 或 LONGTEXT L+4 bytes
4294967295 (2^32-1)个字符
ENUM('value1','value2',...) 1 or 2 bytes
可以总共有65535个不同的值
SET('value1','value2',...) 1/2/3/4/8 bytes
最多有64个成员
2.9. 查询
2.9.1. limit
LIMIT子句可以用来限制由SELECT语句返回过来的数据数量，它有一个或两个参数，如果给出两个参数，
第一个参数指定返回的第一行在所有数据中的位置，从0开始（注意不是1），第二个参数指定最多返回行
数。例如：
select * from table LIMIT 5,10; #返回第6-15行数据
select * from table LIMIT 5; #返回前5行
select * from table LIMIT 0,5; #返回前5行
2.9.2. join 详解
还是先 Create table 吧
create table emp(
id int not null primary key,
name varchar(10)
);
create table emp_dept(
dept_id varchar(4) not null,
emp_id int not null,
emp_name varchar(10),
primary key (dept_id,emp_id));
insert into emp() values
(1,"Dennis-1"),
(2,"Dennis-2"),
(3,"Dennis-3"),
(4,"Dennis-4"),
(5,"Dennis-5"),
(6,"Dennis-6"),
(7,"Dennis-7"),
(8,"Dennis-8"),
(9,"Dennis-9"),
(10,"Dennis-10");
insert into emp_dept() values
("R&D",1,"Dennis-1"),
("DEv",2,"Dennis-2"),
("R&D",3,"Dennis-3"),
("Test",4,"Dennis-4"),
("Test",5,"Dennis-5");
("dddd",20,"eeee");
>> left join
-------------
select a.id,a.name,b.dept_id
from emp a left join emp_dept b on (a.id=b.emp_id);
# 挑出左边的 table emp 中的所有资料,即使 emp_dept 中没有的资料也挑出来,没有的就用 NULL 来显示,
# 也即显示资料是以左边的 table emp 中的资料为基础
mysql> select a.id,a.name,b.dept_id
-> from emp a left join emp_dept b on (a.id=b.emp_id);
+----+-----------+---------+
| id | name | dept_id |
+----+-----------+---------+
| 1 | Dennis-1 | R&D |
| 2 | Dennis-2 | DEv |
| 3 | Dennis-3 | R&D |
| 4 | Dennis-4 | Test |
| 5 | Dennis-5 | Test |
| 6 | Dennis-6 | NULL |
| 7 | Dennis-7 | NULL |
| 8 | Dennis-8 | NULL |
| 9 | Dennis-9 | NULL |
| 10 | Dennis-10 | NULL |
+----+-----------+---------+
# 挑出 table emp 中有而 table emp_dept 中没有的人员资料
select a.id,a.name,b.dept_id
from emp a left join emp_dept b on (a.id=b.emp_id)
where b.dept_id IS NULL;
mysql> select a.id,a.name,b.dept_id
-> from emp a left join emp_dept b on (a.id=b.emp_id)
-> where b.dept_id IS NULL;
+----+-----------+---------+
| id | name | dept_id |
+----+-----------+---------+
| 6 | Dennis-6 | NULL |
| 7 | Dennis-7 | NULL |
| 8 | Dennis-8 | NULL |
| 9 | Dennis-9 | NULL |
| 10 | Dennis-10 | NULL |
+----+-----------+---------+
# 把 table emp_dept 放在左边的情形(当然以 emp_dept 中的数据为基础来显示资料,emp 中比emp_dept 中多的资料也就不会显示出来了):
select a.id,a.name,b.dept_id
from emp_dept b left join emp a on (a.id=b.emp_id);
mysql> select a.id,a.name,b.dept_id
-> from emp_dept b left join emp a on (a.id=b.emp_id);
+------+----------+---------+
| id | name | dept_id |
+------+----------+---------+
| NULL | NULL | dddd |
| 2 | Dennis-2 | DEv |
| 1 | Dennis-1 | R&D |
| 3 | Dennis-3 | R&D |
| 4 | Dennis-4 | Test |
| 5 | Dennis-5 | Test |
+------+----------+---------+
>> right join
---------------
select a.id,a.name,b.dept_id
from emp a right join emp_dept b on (a.id=b.emp_id);
# 挑资料时以右边 table emp_dept 中的资料为基础来显示资料
mysql> select a.id,a.name,b.dept_id
-> from emp a right join emp_dept b on (a.id=b.emp_id);
+------+----------+---------+
| id | name | dept_id |
+------+----------+---------+
| NULL | NULL | dddd |
| 2 | Dennis-2 | DEv |
| 1 | Dennis-1 | R&D |
| 3 | Dennis-3 | R&D |
| 4 | Dennis-4 | Test |
| 5 | Dennis-5 | Test |
+------+----------+---------+
6 rows in set (0.00 sec)
# 我们再把 table 的位置交换一下,再用 right join 试试
select a.id,a.name,b.dept_id
from emp_dept b right join emp a on (a.id=b.emp_id);
mysql> select a.id,a.name,b.dept_id
-> from emp_dept b right join emp a on (a.id=b.emp_id);
+----+-----------+---------+
| id | name | dept_id |
+----+-----------+---------+
| 1 | Dennis-1 | R&D |
| 2 | Dennis-2 | DEv |
| 3 | Dennis-3 | R&D |
| 4 | Dennis-4 | Test |
| 5 | Dennis-5 | Test |
| 6 | Dennis-6 | NULL |
| 7 | Dennis-7 | NULL |
| 8 | Dennis-8 | NULL |
| 9 | Dennis-9 | NULL |
| 10 | Dennis-10 | NULL |
+----+-----------+---------+
# 是不是和 left join 一样了?
>> inner join STRAIGHT_JOIN
select a.id,a.name,b.dept_id
from emp a ,emp_dept b
where a.id=b.emp_id;
mysql> select a.id,a.name,b.dept_id
-> from emp a ,emp_dept b
-> where a.id=b.emp_id;
+----+----------+---------+
| id | name | dept_id |
+----+----------+---------+
| 2 | Dennis-2 | DEv |
| 1 | Dennis-1 | R&D |
| 3 | Dennis-3 | R&D |
| 4 | Dennis-4 | Test |
| 5 | Dennis-5 | Test |
+----+----------+---------+
2.9.3. 别名 alias
你可以在GROUP BY、ORDER BY或在HAVING部分中使用别名引用列。别名也可以用来为列取一个更好点的名字：
SELECT SQRT(a*b) as rt FROM table_name GROUP BY rt HAVING rt > 0;
SELECT id,COUNT(*) AS cnt FROM table_name GROUP BY id HAVING cnt > 0;
SELECT id AS "Customer identity" FROM table_name;
注意，你的 ANSI SQL 不允许你在一个WHERE子句中引用一个别名。这是因为在WHERE代码被执行时，列值还可能没有终结。例如下列查询是不合法：
SELECT id,COUNT(*) AS cnt FROM table_name WHERE cnt > 0 GROUP BY id;
WHERE语句被执行以确定哪些行应该包括GROUP BY部分中，而HAVING用来决定应该只用结果集合中的哪些行。
2.9.4. 正则
正则表达式（regex）是定义复杂查询的一个强有力的工具。
这里是一个简单的资料，它忽略了一些详细的信息。
正则表达式定义了一个字符串的规则。最简单的正则表达式不包含任何保留字。例如，
正则表达式hello只和字符串“hello”匹配。
一般的正则表达式使用了某些特殊的结构，所以它能匹配更多的字符串。例如，正则
表达式hello|word既能匹配字符串“hello”也能匹配字符串“word”。
举一个更复杂一点的例子，正则表达式B[an]*s可以匹配字符串“Bananas”、“Baaaaa
s”
、“Bs”以及其他任何以B开头以s结尾的字符串，中间可以包括任意个a和任意个n的组
合。
一个正则表达式中的可以使用以下保留字
^
所匹配的字符串以后面的字符串开头
mysql> select "fonfo" REGEXP "^fo$"; -> 0（表示不匹配）
mysql> select "fofo" REGEXP "^fo"; -> 1（表示匹配）
$
所匹配的字符串以前面的字符串结尾
mysql> select "fono" REGEXP "^fono$"; -> 1（表示匹配）
mysql> select "fono" REGEXP "^fo$"; -> 0（表示不匹配）
..
匹配任何字符（包括新行）
mysql> select "fofo" REGEXP "^f.*"; -> 1（表示匹配）
mysql> select "fonfo" REGEXP "^f.*"; -> 1（表示匹配）
a*
匹配任意0-n多个a（包括空串）
mysql> select "Ban" REGEXP "^Ba*n"; -> 1（表示匹配）
mysql> select "Baaan" REGEXP "^Ba*n"; -> 1（表示匹配）
mysql> select "Bn" REGEXP "^Ba*n"; -> 1（表示匹配）
a+
匹配任意1-n多个a（不包括空串）
mysql> select "Ban" REGEXP "^Ba+n"; -> 1（表示匹配）
mysql> select "Bn" REGEXP "^Ba+n"; -> 0（表示不匹配）
a?
匹配0-1个a
mysql> select "Bn" REGEXP "^Ba?n"; -> 1（表示匹配）
mysql> select "Ban" REGEXP "^Ba?n"; -> 1（表示匹配）
mysql> select "Baan" REGEXP "^Ba?n"; -> 0（表示不匹配）
de|abc
匹配de或abc
mysql> select "pi" REGEXP "pi|apa"; -> 1（表示匹配）
mysql> select "axe" REGEXP "pi|apa"; -> 0（表示不匹配）
mysql> select "apa" REGEXP "pi|apa"; -> 1（表示匹配）
mysql> select "apa" REGEXP "^(pi|apa)$"; -> 1（表示匹配）
mysql> select "pi" REGEXP "^(pi|apa)$"; -> 1（表示匹配）
mysql> select "pix" REGEXP "^(pi|apa)$"; -> 0（表示不匹配）
(abc)*
匹配任意多个（0-n个）abc（包括空串)
mysql> select "pi" REGEXP "^(pi)*$"; -> 1（表示匹配）
mysql> select "pip" REGEXP "^(pi)*$"; -> 0（表示不匹配）
mysql> select "pipi" REGEXP "^(pi)*$"; -> 1（表示匹配）
{1}
{2,3}
这是一个更全面的方法，它可以实现前面好几种保留字的功能
a*
可以写成a{0,}
a+
可以写成a{1,}
a?
可以写成a{0,1}
在{}内只有一个整型参数i，表示字符只能出现i次；在{}内有一个整型参数i，
后面跟一个“，”，表示字符可以出现i次或i次以上；在{}内只有一个整型参数i，
后面跟一个“，”，再跟一个整型参数j,表示字符只能出现i次以上，j次以下
（包括i次和j次）。其中的整型参数必须大于等于0，小于等于 RE_DUP_MAX（默认是25
5）。
如果有两个参数，第二个必须大于等于第一个
[a-dX]
匹配“a”、“b”、“c”、“d”或“X”
[^a-dX]
匹配除“a”、“b”、“c”、“d”、“X”以外的任何字符。
“[”、“]”必须成对使用
mysql> select "aXbc" REGEXP "[a-dXYZ]"; -> 1（表示匹配）
mysql> select "aXbc" REGEXP "^[a-dXYZ]$"; -> 0（表示不匹配）
mysql> select "aXbc" REGEXP "^[a-dXYZ]+$"; -> 1（表示匹配）
mysql> select "aXbc" REGEXP "^[^a-dXYZ]+$"; -> 0（表示不匹配）
mysql> select "gheis" REGEXP "^[^a-dXYZ]+$"; -> 1（表示匹配）
mysql> select "gheisa" REGEXP "^[^a-dXYZ]+$"; -> 0（表示不匹配）
------------------------------------------------------------
[[.characters.]]
表示比较元素的顺序。在括号内的字符顺序是唯一的。但是括号中可以包含通配符,
所以他能匹配更多的字符。举例来说：正则表达式[[.ch.]]*c匹配chchcc的前五个字符
。
[=character_class=]
表示相等的类，可以代替类中其他相等的元素，包括它自己。例如，如果o和(+)是
一个相等的类的成员，那么[[=o=]]、[[=(+)=]]和[o(+)]是完全等价的。
[:character_class:]
在括号里面，在[:和:]中间是字符类的名字，可以代表属于这个类的所有字符。
字符类的名字有: alnum、digit、punct、alpha、graph、space、blank、lower、uppe
r、cntrl、print和xdigit
mysql> select "justalnums" REGEXP "[[:alnum:]]+"; -> 1（表示匹配）
mysql> select "!!" REGEXP "[[:alnum:]]+"; -> 0（表示不匹配）
[[:<:>
[[:>:]]
分别匹配一个单词开头和结尾的空的字符串，这个单词开头和结尾都不是包含在alnum中
的字符也不能是下划线。
mysql> select "a word a" REGEXP "[[:<:>:]]"; -> 1（表示匹配）
mysql> select "a xword a" REGEXP "[[:<:>:]]"; -> 0（表示不匹配）
mysql> select "weeknights" REGEXP "^(wee|week)(knights|nights)$"; -> 1（表示
匹配）
2.9.5. Select 中使用 IF Statement
mysql> select * from test;
+------+------+------+-------+
| dept | id | sex | name |
+------+------+------+-------+
| 1 | 1 | 0 | wang |
| 2 | 2 | 1 | zhang |
| 3 | 3 | 0 | li |
+------+------+------+-------+
3 rows in set (0.00 sec)
mysql> select dept,id,if(sex=0,'女','男') sex,name from test;
+------+------+-----+-------+
| dept | id | sex | name |
+------+------+-----+-------+
| 1 | 1 | 女 | wang |
| 2 | 2 | 男 | zhang |
| 3 | 3 | 女 | li |
+------+------+-----+-------+
3 rows in set (0.00 sec)
2.9.6. Select中使用CASE Statement
mysql> select dept,id,(case sex when '0' then '女' else '男' end) as sex,name from test;
+------+------+------+-------+
| dept | id | sex | name |
+------+------+------+-------+
| 1 | 1 | 女 | wang |
| 2 | 2 | 男 | zhang |
| 3 | 3 | 女 | li |
+------+------+------+-------+
mysql> select (case dept when '1' then 'no1' when '2' then 'no2' else 'other' end) as dept from test;
+-------+
| dept |
+-------+
| no1 |
| no2 |
| other |
+-------+
3 rows in set (0.00 sec)
注意: 相当于Oracle 中的decode 和case when
在统计报表中很有用处
2.10. 存储过程和函数
CREATE PROCEDURE sp_name ([proc_parameter[,...]])
[characteristic ...] routine_body
CREATE FUNCTION sp_name ([func_parameter[,...]])
RETURNS type
[characteristic ...] routine_body
proc_parameter:
[ IN | OUT | INOUT ] param_name type
func_parameter:
param_name type
type:
Any valid MySQL data type
characteristic:
LANGUAGE SQL
| [NOT] DETERMINISTIC
| { CONTAINS SQL | NO SQL | READS SQL DATA | MODIFIES SQL DATA }
| SQL SECURITY { DEFINER | INVOKER }
| COMMENT 'string'
routine_body:
Valid SQL procedure statement or statements
例子：创建一个过程hello，显示问候语
mysql> delimiter ;
mysql> drop PROCEDURE if exists hello;
Query OK, 0 rows affected (0.00 sec)
mysql> delimiter //
mysql>
mysql> CREATE PROCEDURE hello (IN s varchar(20))
-> BEGIN
-> SELECT CONCAT('Hello,',s,'!') as hello;
-> END;
-> //
Query OK, 0 rows affected (0.00 sec)
mysql> delimiter ;
mysql> call hello('wangyl');
+---------------+
| hello |
+---------------+
| Hello,wangyl! |
+---------------+
1 row in set (0.00 sec)
Query OK, 0 rows affected (0.00 sec)
例子2: 查询t表的记录总数
mysql> delimiter //
mysql> CREATE PROCEDURE simpleproc (OUT param1 INT)
-> BEGIN
-> SELECT COUNT(*) INTO param1 FROM t;
-> END
-> //
Query OK, 0 rows affected (0.00 sec)
mysql> delimiter ;
mysql> CALL simpleproc(@a);
Query OK, 0 rows affected (0.00 sec)
mysql> SELECT @a;
+------+
| @a |
+------+
| 3 |
+------+
1 row in set (0.00 sec)
例子：创建一个函数
mysql> delimiter ;
mysql> drop FUNCTION if exists dateFunction;
Query OK, 0 rows affected (0.00 sec)
mysql> delimiter //
mysql> CREATE FUNCTION dateFunction (iCase int)
-> RETURNS varchar(50)
-> begin
-> DECLARE iType int;
-> DECLARE sReturn varchar(50);
-> set iType =icase +1;
-> case iType
-> when 1 then select DATE_FORMAT(NOW(),'%Y-%m-%d') into sReturn;
-> when 2 then select DATE_FORMAT(NOW(),'%W %M %Y') into sReturn;
-> else
-> select NOW() into sReturn;
-> end case;
-> return sReturn;
-> end;
-> //
Query OK, 0 rows affected (0.00 sec)
mysql> delimiter ;
mysql> select dateFunction(0);
+-----------------+
| dateFunction(0) |
+-----------------+
| 2005-11-14 |
+-----------------+
1 row in set (0.00 sec)
mysql> select dateFunction(1);
+----------------------+
| dateFunction(1) |
+----------------------+
| Monday November 2005 |
+----------------------+
1 row in set (0.00 sec)
mysql> select dateFunction(2);
+---------------------+
| dateFunction(2) |
+---------------------+
| 2005-11-14 15:05:43 |
+---------------------+
1 row in set (0.00 sec)
2.11. 补充：trigger
CREATE TRIGGER trigger_name trigger_time trigger_event
ON tbl_name FOR EACH ROW trigger_stmt
CREATE TABLE test1(a1 INT);
CREATE TABLE test2(a2 INT);
CREATE TABLE test3(a3 INT NOT NULL AUTO_INCREMENT PRIMARY KEY);
CREATE TABLE test4(
a4 INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
b4 INT DEFAULT 0
);
DELIMITER |
CREATE TRIGGER testref BEFORE INSERT ON test1
FOR EACH ROW BEGIN
INSERT INTO test2 SET a2 = NEW.a1;
DELETE FROM test3 WHERE a3 = NEW.a1;
UPDATE test4 SET b4 = b4 + 1 WHERE a4 = NEW.a1;
END|
DELIMITER ;
INSERT INTO test3 (a3) VALUES
(NULL), (NULL), (NULL), (NULL), (NULL),
(NULL), (NULL), (NULL), (NULL), (NULL);
INSERT INTO test4 (a4) VALUES
(0), (0), (0), (0), (0), (0), (0), (0), (0), (0);
If you insert the following values into table test1 as shown here:
mysql> INSERT INTO test1 VALUES
-> (1), (3), (1), (7), (1), (8), (4), (4);
Query OK, 8 rows affected (0.01 sec)
Records: 8 Duplicates: 0 Warnings: 0
Then the data in the four tables will be as follows:
mysql> SELECT * FROM test1;
+------+
| a1 |
+------+
| 1 |
| 3 |
| 1 |
| 7 |
| 1 |
| 8 |
| 4 |
| 4 |
+------+
8 rows in set (0.00 sec)
mysql> SELECT * FROM test2;
+------+
| a2 |
+------+
| 1 |
| 3 |
| 1 |
| 7 |
| 1 |
| 8 |
| 4 |
| 4 |
+------+
8 rows in set (0.00 sec)
mysql> SELECT * FROM test3;
+----+
| a3 |
+----+
| 2 |
| 5 |
| 6 |
| 9 |
| 10 |
+----+
5 rows in set (0.00 sec)
mysql> SELECT * FROM test4;
+----+------+
| a4 | b4 |
+----+------+
| 1 | 3 |
| 2 | 0 |
| 3 | 1 |
| 4 | 2 |
| 5 | 0 |
| 6 | 0 |
| 7 | 1 |
| 8 | 1 |
| 9 | 0 |
| 10 | 0 |
+----+------+
10 rows in set (0.00 sec)
2.12. 删除 DELETE Syntax
Single-table syntax:
DELETE [LOW_PRIORITY] [QUICK] [IGNORE] FROM tbl_name
[WHERE where_condition]
[ORDER BY ...]
[LIMIT row_count]
Multiple-table syntax:
DELETE [LOW_PRIORITY] [QUICK] [IGNORE]
tbl_name[.*] [, tbl_name[.*]] ...
FROM table_references
[WHERE where_condition]
Or:
DELETE [LOW_PRIORITY] [QUICK] [IGNORE]
FROM tbl_name[.*] [, tbl_name[.*]] ...
USING table_references
[WHERE where_condition]
对于删除多个表,不能使用order by 和limit
多表删除语法一: ,只是在删除 在from 前面的表所中匹配的记录
DELETE t1, t2 FROM t1, t2, t3 WHERE t1.id=t2.id AND t2.id=t3.id;
从t1,t2,t3 表选出要删除的记录,只是删除t1,t2 表中所匹配得这些记录.
多表删除语法二: 在from 列出的表中删除选中的记录.
DELETE FROM t1, t2 USING t1, t2, t3 WHERE t1.id=t2.id AND t2.id=t3.id;
从t1,t2,t3 表选出要删除的记录(使用using ),只是删除t1,t2 表中所匹配得这些记录.
注意: 如果您使用一个别名,您必须使用别名.
DELETE t1 FROM test AS t1, test2 WHERE ...
支持多个数据之间的多表删除,但是在这种情况下,你必须指定表,而不能使用别名:
DELETE test1.tmp1, test2.tmp2 FROM test1.tmp1, test2.tmp2 WHERE ...
当前,您不能从相同表的子查询中,删除同一表的数据
发表评论
-
vlc 必要的参数
2021-08-31 17:18 0vlc.exe -vvv -Idummy "rt ... -
grafana+mysql 页面设计
2019-02-25 08:51 0前提 1。主要是SELECT 。 2。使用mysql ... -
测试用例到底怎么才值的写
2016-04-30 10:32 0有个方法是这样的 public function ... -
postman cookies登陆设置
2016-04-28 09:30 2054必须登陆才能测试的接口如何测试? 打开这个开关就可以共用coo ... -
将png 切成ios android能用的格式
2016-04-28 01:24 741由于要求不高找了个在线切图的工具 http://images. ... -
如何在原有系统中加入功能(一数据库)
2016-04-24 11:06 821第一步想办法把建表语句导入一powerdesginer ... -
php递归 格式化 数字类型
2016-04-20 12:35 792/** * 数字转日期递归 ... -
freemind 怎么处理成为word
2015-06-11 19:37 16写文章用freemind打了一个草稿. 先导出成为htm ... -
架构师之路（工欲善其事，必先利其器）纸牌屋
2014-03-27 06:48 0起因：小胖的一个征集实现过程 https://gist.git ... -
油猴对抗一般广告
2012-11-14 00:07 1885看小说 好多好多的广告是必然的.. 所以 去掉iframe 去 ... -
回答一些很有共性的东西
2011-02-24 21:24 5604我作软件第二第三年时 ... -
粗糙的object打印日志用....
2010-11-04 18:40 2167function logJquery(o){ ... -
拳皇连招
2010-09-29 13:46 2371从列表中找到录入的后N位 class KOFTest { ... -
一个activeX方法 刚刚发现
2010-09-14 19:14 1510解答:此题 http://www.iteye.com/prob ... -
[反例]超短代码,意义不明
2010-08-19 17:49 1562public String logout(HttpServl ... -
站读帝
2010-07-26 09:29 1309http://www.hudong.com/wiki/%E7% ... -
不要重复发明轮子
2010-07-06 17:20 2172一直以为不要重复发明轮子的意义很简单. 今天看了人件.... ... -
答复: 不用判断语句求俩数中的大（或者小）数
2010-05-31 12:55 2125跳大神也是一种艺术: public class MaxMin ... -
集合合并
2010-05-28 10:15 1957用于时间表的合并 时间段的合并工作. public cla ... -
删除重名的记录
2010-04-05 23:04 1941面试看到这种题。。。。。 我估计考官的正确答案有可能是错的 所 ...
相关推荐
标题中的“简洁清爽个人blog博客模板”表明这是一个专为个人博客设计的网页模板，强调了设计风格的简洁和清爽，适合那些希望展示个人思想、作品或者日常分享的用户使用。这个模板可能包含了基本的博客功能，如文章...
标题和描述所提及的“解决mp3不能开机的问题，百试不爽”，显然是提供了一种针对这个问题的有效解决方案。下面将详细探讨MP3播放器无法开机的可能原因以及相应的解决策略。 1. **电池问题**：MP3播放器无法开机的...
简洁清爽个人blog博客模板下载_简洁 清爽 个人主页 博客 blog 整站 简单 响应式 bootstrap 手机 新闻.zi简洁清爽个人blog博客模板下载_简洁 清爽 个人主页 博客 blog 整站 简单 响应式 bootstrap 手机 新闻.zi
在Z-Blog随心轻蓝主题中，简约并不意味着简单乏味，而是通过精简不必要的元素，使博客界面更加整洁，让用户能够快速聚焦于内容本身。这种设计思路符合现代用户的阅读习惯，避免了视觉干扰，提升了用户体验。主题的...
这种设计让博客不仅仅是个人的网络日志，还能作为一个展示个人品牌形象的平台。 Bootstrap框架内建的响应式栅格系统在本模板中发挥了关键作用。栅格系统允许开发者根据屏幕大小划分列（columns），在大屏幕设备上...
《Z-Blog随心轻蓝单栏博客清爽简洁主题》 在互联网的海洋中，一个优秀的博客主题可以为网站增添无限魅力，同时也能提升用户体验。本文将深入探讨名为"Z-Blog随心轻蓝单栏博客清爽简洁主题"的软件应用，它是一个专为...
【标题】"wp博客程序清爽模板"涉及到的主要知识点是WordPress（简称WP）的博客主题定制与设计。WordPress是一种流行的开源内容管理系统（CMS），用于构建网站和博客。它提供了丰富的主题库，用户可以根据自己的需求...
此外，作为个人主页或博客，这样的设计风格也能更好地突出作者的个性和文章内容。 "新闻"标签可能意味着这个模板包含了一些新闻展示的特性，比如文章列表、分类、日期等，使得用户能够方便地发布和管理自己的博客...
该压缩包包含的是一个简洁清爽的个人博客模板，适合用于创建个人主页或博客网站。这个模板基于Bootstrap框架，具有响应式设计，能适应各种设备，包括手机和平板。以下是关于这个模板及其相关技术的详细解释： 1. **...
【简洁清爽WordPress博客模板】是专为个人博客网站设计的一款主题，它以其独特的设计风格和高效的功能特性，深受用户喜爱。这款模板强调的是简洁与清爽，旨在为博主提供一个无干扰、易于阅读和写作的环境，同时也能...
本站采用PJBLOG3最新版本程序PJBLOG3 v3.2.9.506，ASP ACCESS。可以生成全站静态，非常适合在乎SEO的朋友。...程序使用方式见目录中的使用说明文档，有不明白的也可以去官方留言。你不是一个人在战斗!
灰尘渐变背景简洁清爽博客模板_灰色 渐变 博客 简洁 线条 清爽 博客 整站 html 圆角 标准.zip灰尘渐变背景简洁清爽博客模板_灰色 渐变 博客 简洁 线条 清爽 博客 整站 html 圆角 标准.zip
该压缩包文件“清爽简单的英文博客模板下载_蓝色 整站 简洁清爽 博客 英文.zip”提供了一款设计简洁、风格清爽的英文博客模板，适合那些希望创建个人博客或在线日记的人使用。这个模板以蓝色为主色调，给人一种清新...
首先，博客模板是网页设计的重要组成部分，它为博客作者提供了一个预设的布局和样式，使得用户无需从零开始设计就能拥有专业外观的博客。这个“清爽简单的英文博客模板”显然以蓝色为主色调，旨在提供一种简洁、清晰...
此外，响应式设计也是现代模板不可或缺的一部分，它确保博客在不同设备上（如桌面、平板电脑和手机）都能正常显示。 总的来说，这个压缩包提供了一个完整的英文博客解决方案，用户可以根据readme.md的指示快速搭建...
它可能包含了字体、颜色、间距、布局和响应式设计规则，确保博客在不同设备上都能良好显示。 2. **main_bg.gif、footer_bg.gif** - 这些是背景图像文件，分别用于主内容区域和页脚部分。它们可能用于添加视觉效果，...
清爽博客自媒体网站模板是一款大气清爽的博客自媒体网站模板。提示：本模板调用到谷歌字体库，可能会出现页面打开比较缓慢。