我用mysql数据库，sql编写了一半，突然想退出，该如何做？_百度知道
我用mysql数据库，sql编写了一半，突然想退出，该如何做？
比如像这样我应该怎么退出sql的编写，但不是ctrl+c这种完全退出...
比如像这样 我应该怎么退出sql的编写，但不是ctrl+c这种完全退出
答题抽奖
首次认真答题后
即可获得3次抽奖机会，100%中奖。
知道贡献者0944
知道贡献者0944
采纳数：746
获赞数：49643
擅长：暂未定制
如果你决定不想执行正在输入过程中的一个命令，输入\c取消它：mysql& SELECT
-& \cmysql&这里也要注意提示符，在你输入\c以后，它切换回到mysql&，提供反馈以表明mysql准备接受一个新命令。
采纳数：187
获赞数：1030
输入 “;”或者“/”回车
采纳数：125
获赞数：284
在命令行上输入 EXIT可以推出当前SQL命令
擅长：暂未定制
把sql语句保存在记事本上
其他1条回答
为你推荐：
其他类似问题
您可能关注的内容
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。mysql sql语句执行到一半会怎么样？
今天紧急上线添加字段，修改2000W条数据，一时疏忽，直接在前台就执行alter操作了；
半路一直祈祷别vpn别断，很不争气的是我电脑黑了，气的我想打人，没有办法，速度止损，打电话叫老大救命......
可结果确认数据全部修改同步成功了.....
MySQL innodb对于单条语句，它始终会开启一个事务，只不过这行语句执行之后立即提交；
也就是说，只有成功和失败两种情况，很幸运地是我这次是成功；
下次操作还是用percona-online-shema-change弄比较靠谱，不锁表；
80k条数据无论是insert还是update，如果采用逐条执行的话，缓慢不堪（超过90分钟），一直恼于找不到解决方案，终于在stack overflow http://stackoverflow.c...
由于临近考试，需要从前端页面将整个学校的学生信息通过Excel导入到数据库中。导入3万数据，先是进行各种数据校验，然后才进行入库操作。ito401三张表，云平台一张表。结果运行不到一半页面就卡死啦。最...
yum update更新一半挂了，会有很多软件包留在仓库，引起各种各样的问题
yum clean all
安装 package-cleanup工具，有下面命令就不需要安装了，有的系...
在mysql数据库中，MyISAM引擎和InnoDB引擎的主键和索引都使用了B+树，但是二者对B+树的使用略有区别，分别介绍如下。
注：B+树的叶子节点包含关键字和数据部分，还有指向下一个兄弟叶子节...
OPTIMIZE TABLE 当您的库中删除了大量的数据后，您可能会发现数据文件尺寸并没有减小。这是因为删除操作后在数据文件中留下碎片所致。OPTIMIZE TABLE 是指对表进行优化。如果已经删除...
Mysql新增字段到大数据表导致锁表
年初跳完槽，终于可以安心开始写一些博客了。进入新的公司，还是有蛮多收获的。那就先记一个昨天遇到的问题吧。
昨天晚上7点左右，对一张表进行加字段，大概200多万条记录，字段90多个的大表，结...
奇怪！同一条sql语句在数据库和代码中执行结果不同？！当然是人错了 ……
sql语句就是它：
select count(1) from syscolumns where [id]=object_id( 'tablecommon' )
Mysql数据库更新操作导致死锁问题
最近维护项目发现的一个有意思的问题，写篇文章记录一下。
项目的问题是数据库发生了死锁，在盘查的所有的业务代码后我认为是“单条”批量update语句需要锁表而引发的问题项目是基于spring的webs...
Mysql 将结果保存到文件 从文件中执行sql语句 记录操作过程（tee 命令的使用）
有时候我们可能需要记录我们对mysql的操作过程，这时我们可以使用mysql的tee命令
1）第一种情况是在链接数据库的时候使用tee
没有更多推荐了，Explain命令在解决数据库性能上是第一推荐使用命令，大部分的性能问题可以通过此命令来简单的解决，Explain可以用来查看
SQL 语句的执行效 果，可以帮助选择更好的索引和优化查询语句，写出更好的优化语句。
Explain语法：explain select & from & [where ...]
例如：explain select *
+----+-------------+-------+-------+-------------------+---------+---------+-------+------+-------+
| id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra |
+----+-------------+-------+-------+-------------------+---------+---------+-------+------+-------+
下面对各个属性进行了解：
1、id：这是SELECT的查询序列号
2、select_type：select_type就是select的类型，可以有以下几种：
SIMPLE：简单SELECT(不使用UNION或子查询等)
PRIMARY：最外面的SELECT
UNION：UNION中的第二个或后面的SELECT语句
DEPENDENT UNION：UNION中的第二个或后面的SELECT语句，取决于外面的查询
UNION RESULT：UNION的结果。
SUBQUERY：子查询中的第一个SELECT
DEPENDENT SUBQUERY：子查询中的第一个SELECT，取决于外面的查询
DERIVED：导出表的SELECT(FROM子句的子查询)
3、table：显示这一行的数据是关于哪张表的
4、type：这列最重要，显示了连接使用了哪种类别,有无使用索引，是使用Explain命令分析性能瓶颈的关键项之一。
结果值从好到坏依次是：
system & const & eq_ref & ref & fulltext & ref_or_null & index_merge & unique_subquery & index_subquery & range & index & ALL
一般来说，得保证查询至少达到range级别，最好能达到ref，否则就可能会出现性能问题。
5、possible_keys：列指出MySQL能使用哪个索引在该表中找到行
6、key：显示MySQL实际决定使用的键（索引）。如果没有选择索引，键是NULL
7、key_len：显示MySQL决定使用的键长度。如果键是NULL，则长度为NULL。使用的索引的长度。在不损失精确性的情况下，长度越短越好
8、ref：显示使用哪个列或常数与key一起从表中选择行。
9、rows：显示MySQL认为它执行查询时必须检查的行数。
10、Extra：包含MySQL解决查询的详细信息，也是关键参考项之一。
一旦MYSQL找到了与行相联合匹配的行，就不再搜索了
Not exists
MYSQL 优化了LEFT JOIN，一旦它找到了匹配LEFT JOIN标准的行，
就不再搜索了
Range checked for each
Record（index map:#）
没有找到理想的索引，因此对于从前面表中来的每一 个行组合，MYSQL检查使用哪个索引，并用它来从表中返回行。这是使用索引的最慢的连接之一
Using filesort
看 到这个的时候，查询就需要优化了。MYSQL需要进行额外的步骤来发现如何对返回的行排序。它根据连接类型以及存储排序键值和匹配条件的全部行的行指针来 排序全部行
Using index
列数据是从仅仅使用了索引中的信息而没有读取实际的行动的表返回的，这发生在对表 的全部的请求列都是同一个索引的部分的时候
Using temporary
看到这个的时候，查询需要优化了。这 里，MYSQL需要创建一个临时表来存储结果，这通常发生在对不同的列集进行ORDER BY上，而不是GROUP BY上
Using where
使用了WHERE从句来限制哪些行将与下一张表匹配或者是返回给用户。如果不想返回表中的全部行，并且连接类型ALL或index， 这就会发生，或者是查询有问题
其他一些Tip：
当type 显示为 &index& 时，并且Extra显示为&Using Index&， 表明使用了覆盖索引。&
阅读(...) 评论()扫一扫体验手机阅读
mysql面试题分享
<span type="1" blog_id="2049534" userid='
49篇文章，8W+人气，0粉丝
大牛就是量变到质变的过程，加油！
高并发架构之路
￥51.00194人订阅
MySQL全通晓
￥51.00166人订阅
<span type="1" blog_id="2049534" userid='当前位置： →
→ 查询mysql中执行效率低的sql语句的方法Mysql
查询mysql中执行效率低的sql语句的方法Mysql
& 作者及来源： 互联网 &
&收藏到→_→：
摘要: 查询mysql中执行效率低的sql语句的方法_Mysql
"查询mysql中执行效率低的sql语句的方法Mysql"：：
一些小技巧1. 如何查出效率低的语句？在mysql下，在启动参数中设置 --log-slow-queries=[文件名]，就可以在指定的日志文件中记录执行时间超过long_query_time（缺省为10秒）的 。你也可以在启动配置文件中修改long query的时间，如：
复制代码 代码如下:&# set long query time to 8 seconds&&& long_query_time=8
2. 如何查询某表的索引？可使用show index语句，如：
复制代码 代码如下:&show index from [表名]
3. 如何查询某条语句的索引使用情况？可用explain语句来看一下某条select语句的索引使用情况。如果是update或delete语句，需要先转换为select语句。4. 如何把导出innodb引擎的内容到错误日志文件中?我们可以使用show innodb status命令来查看innodb引擎的很多有用的信息，如当前进程、事务、外键错误、死锁问题和其它一些统计数据。如何让该信息能记录在日志文件中呢？只要使用如下语句创建innodb_monitor表，mysql就会每15秒钟把该写入到错误日志文件中：
复制代码 代码如下:create table innodb_monitor (a int) engine=
如果你不再需要导出到错误日志文件，只要删除该表即可：
复制代码 代码如下:&drop table innodb_
5. 如何定期删除庞大的日志文件？只要在启动配置文件中设置日志过期时间即可：
复制代码 代码如下:&expire_logs_days=10
经验教训1. 重点关注索引下面以表tsk_task表为例说明 优化 。tsk_task表用于保存监测任务，相关字段及索引如下：
&&& id：主键；&&& mon_time：监测时间；建了索引；&&& status_id：任务状态；与sys_hier_info.id建立了外键关系。
注mysql自动会为外键建立索引，在本次优化 中，发现这些自动建立的外键索引会对 的效率产生不必要的干扰，需要特别注意！
首先，我们在日志文件中查到下面语句的执行比较慢，超过10秒了：
复制代码 代码如下:&# query_time: 18 lock_time: 0 rows_sent: 295 rows_examined: 88143&&& select * from tsk_task where status_id = 1064 and mon_time &= '' and mon_time & '';
哦，原来在88143条记录中要查出符合条件的295条记录，那当然慢了。赶紧用explain语句看一下索引使用情况吧：
&&& +----+-------------+----------+------+----------------------------------------------------------+------------------------------------+---------+-------+--------+-------------+&&& | id | select_type | table | type | possible_keys | key | key_len | ref | rows | extra |&&& +----+-------------+----------+------+----------------------------------------------------------+------------------------------------+---------+-------+--------+-------------+&&& | 1 | simple | tsk_task | ref | fk_task_status_id_to_sys_hier_info,tsk_task_key_mon_time | fk_task_status_id_to_sys_hier_info | 9 | const | 276168 | using where |&&& +----+-------------+----------+------+----------------------------------------------------------+------------------------------------+---------+-------+--------+-------------+
可以看出，有两个索引可用fk_task_status_id_to_sys_hier_info,tsk_task_key_mon_time，而最终执行语句时采用了status_id上的外键索引。
再看一下tsk_task表的索引情况吧：
&&& +----------+------------------------------------+-------------+-------------+&&& | table | key_name | column_name | cardinality |&&& +----------+------------+------------------------------------+--------------+&&& | tsk_task | primary | id | 999149 |&&& | tsk_task | fk_task_status_id_to_sys_hier_info | status_id | 16 |&&& | tsk_task | tsk_task_key_mon_time | mon_time | 13502 |&&& +----------+------------------------------------+-------------+-----------+--
在oracle或其他关系 下，where条件中的字段顺序对索引的选择起着很重要的作用。我们调整一下字段顺序，把status_id放在后面，再explain一下：
复制代码 代码如下:explain select * from tsk_task where mon_time &= '' and mon_time & '' and status_id = 1064;
但是没什么效果，mysql还是选用建立的status_id外键索引。
仔细分析一下，看来cardinality属性（即索引中的唯一值的个数）对索引的选择起了极其重要的作用，mysql选择了索引值唯一值个数小的那个索引作为整条语句的索引。
针对这条语句，如果使用fk_task_status_id_to_sys_hier_info做索引，而tsk_task表中存放很多天数据的话，那扫描的记录数会很多，速度较慢。可以有以下几个优化方案：
&&& 如果一天的任务数不多的话，我们删除索引fk_task_status_id_to_sys_hier_info，那mysql会使用索引tsk_task_key_mon_time，然后在该天的数据中在扫描status_id为1064的记录，那速度也不慢；&&& 如果一天的任务数多的话，我们需删除索引fk_task_status_id_to_sys_hier_info和tsk_task_key_mon_time，然后再建立status_id,mon_time的联合索引，这样效率肯定会很高。
因此建议，对那些记录数多的表，建议不要使用外键，以避免造成性能效率的严重降低。2. 尽量控制每张表的记录数当一张表的记录数很大时，管理和维护就会很麻烦，如索引维护就会占用很长时间，从而会给的正常运行造成很大的干扰。
对随时间推移数据量不断增长的表，我们可以根据时间来区分实时数据和历史数据，可以使用后台服务程序定期 实时表中的数据到历史表中，从而控制实时表的记录数，提高查询和操作效率。但注意每次 的时间要足够短，不要影响正常程序的数据写入。如果占用时间太长，可能会造成死锁问题。3. 数据散列(partition)策略当客户数达到一定规模后，单个 将无法支撑更高的并发访问，此时可以考虑把客户数据散列(partition)到多个 中，以分担负载，提高的整体性能与效率。
数据散列可以考虑采用federeated或sharded方式，网上有不少这方面的资料。一些小技巧1. 如何查出效率低的语句？在mysql下，在启动参数中设置 --log-slow-queries=[文件名]，就可以在指定的日志文件中记录执行时间超过long_query_time（缺省为10秒）的 。你也可以在启动配置文件中修改long query的时间，如：
复制代码 代码如下:&&& # set long query time to 8 seconds&&& long_query_time=8
2. 如何查询某表的索引？可使用show index语句，如：复制代码 代码如下:& show index from [表名]3. 如何查询某条语句的索引使用情况？可用explain语句来看一下某条select语句的索引使用情况。如果是update或delete语句，需要先转换为select语句。4. 如何把导出innodb引擎的内容到错误日志文件中?我们可以使用show innodb status命令来查看innodb引擎的很多有用的信息，如当前进程、此文来自: 马开东博客
转载请注明出处 网址：
事务、外键错误、死锁问题和其它一些统计数据。如何让该信息能记录在日志文件中呢？只要使用如下语句创建innodb_monitor表，mysql就会每15秒钟把该写入到错误日志文件中：
复制代码 代码如下:create table innodb_monitor (a int) engine=
如果你不再需要导出到错误日志文件，只要删除该表即可：复制代码 代码如下:&&& drop table innodb_5. 如何定期删除庞大的日志文件？只要在启动配置文件中设置日志过期时间即可：复制代码 代码如下:&&& expire_logs_days=10经验教训1. 重点关注索引下面以表tsk_task表为例说明 优化 。tsk_task表用于保存监测任务，相关字段及索引如下：
&&& id：主键；&&& mon_time：监测时间；建了索引；&&& status_id：任务状态；与sys_hier_info.id建立了外键关系。
注mysql自动会为外键建立索引，在本次优化 中，发现这些自动建立的外键索引会对 的效率产生不必要的干扰，需要特别注意！
首先，我们在日志文件中查到下面语句的执行比较慢，超过10秒了：
复制代码 代码如下:&# query_time: 18 lock_time: 0 rows_sent: 295 rows_examined: 88143&&& select * from tsk_task where status_id = 1064 and mon_time &= '' and mon_time & '';
哦，原来在88143条记录中要查出符合条件的295条记录，那当然慢了。赶紧用explain语句看一下索引使用情况吧：
&&& +----+-------------+----------+------+----------------------------------------------------------+------------------------------------+---------+-------+--------+-------------+&&& | id | select_type | table | type | possible_keys | key | key_len | ref | rows | extra |&&& +----+-------------+----------+------+----------------------------------------------------------+------------------------------------+---------+-------+--------+-------------+&&& | 1 | simple | tsk_task | ref | fk_task_status_id_to_sys_hier_info,tsk_task_key_mon_time | fk_task_status_id_to_sys_hier_info | 9 | const | 276168 | using where |&&& +----+-------------+----------+------+----------------------------------------------------------+------------------------------------+---------+-------+--------+-------------+
可以看出，有两个索引可用fk_task_status_id_to_sys_hier_info,tsk_task_key_mon_time，而最终执行语句时采用了status_id上的外键索引。
再看一下tsk_task表的索引情况吧：
&&& +----------+------------------------------------+-------------+-------------+&&& | table | key_name | column_name | cardinality |&&& +----------+------------+------------------------------------+--------------+&&& | tsk_task | primary | id | 999149 |&&& | tsk_task | fk_task_status_id_to_sys_hier_info | status_id | 16 |&&& | tsk_task | tsk_task_key_mon_time | mon_time | 13502 |&&& +----------+------------------------------------+-------------+-----------+--
在oracle或其他关系 下，where条件中的字段顺序对索引的选择起着很重要的此文来自: 马开东博客
转载请注明出处 网址：
作用。我们调整一下字段顺序，把status_id放在后面，再explain一下：复制代码 代码如下:&&& explain select * from tsk_task where mon_time &= '' and mon_time & '' and status_id = 1064;
但是没什么效果，mysql还是选用建立的status_id外键索引。
仔细分析一下，看来cardinality属性（即索引中的唯一值的个数）对索引的选择起了极其重要的作用，mysql选择了索引值唯一值个数小的那个索引作为整条语句的索引。
针对这条语句，如果使用fk_task_status_id_to_sys_hier_info做索引，而tsk_task表中存放很多天数据的话，那扫描的记录数会很多，速度较慢。可以有以下几个优化方案：
&&& 如果一天的任务数不多的话，我们删除索引fk_task_status_id_to_sys_hier_info，那mysql会使用索引tsk_task_key_mon_time，然后在该天的数据中在扫描status_id为1064的记录，那速度也不慢；&&& 如果一天的任务数多的话，我们需删除索引fk_task_status_id_to_sys_hier_info和tsk_task_key_mon_time，然后再建立status_id,mon_time的联合索引，这样效率肯定会很高。
因此建议，对那些记录数多的表，建议不要使用外键，以避免造成性能效率的严重降低。2. 尽量控制每张表的记录数当一张表的记录数很大时，管理和维护就会很麻烦，如索引维护就会占用很长时间，从而会给的正常运行造成很大的干扰。
对随时间推移数据量不断增长的表，我们可以根据时间来区分实时数据和历史数据，可以使用后台服务程序定期 实时表中的数据到历史表中，从而控制实时表的记录数，提高查询和操作效率。但注意每次 的时间要足够短，不要影响正常程序的数据写入。如果占用时间太长，可能会造成死锁问题。3. 数据散列(partition)策略当客户数达到一定规模后，单个 将无法支撑更高的并发访问，此时可以考虑把客户数据散列(partition)到多个 中，以分担负载，提高的整体性能与效率。
数据散列可以考虑采用federeated或sharded方式，网上有不少这方面的资料。一些小技巧1. 如何查出效率低的语句？在mysql下，在启动参数中设置 --log-slow-queries=[文件名]，就可以在指定的日志文件中记录执行时间超过long_query_time（缺省为10秒）的 。你也可以在启动配置文件中修改long query的时间，如：复制代码 代码如下:&&& # set long query time to 8 seconds&&& long_query_time=82. 如何查询某表的索引？可使用show index语句，如：复制代码 代码如下:&&& show index from [表名]
3. 如何查询某条语句的索引使用情况？可用explain语句来看一下某条select语句的索引使用情况。如果是update或delete语句，需要先转换为select语句。4. 如何把导出innodb引擎的内容到错误日志文件中?我们可以使用show innodb status命令来查看innodb引擎的很多有用的信息，如当前进程、事务、外键错此文来自: 马开东博客
转载请注明出处 网址：
误、死锁问题和其它一些统计数据。如何让该信息能记录在日志文件中呢？只要使用如下语句创建innodb_monitor表，mysql就会每15秒钟把该写入到错误日志文件中：复制代码 代码如下:&&& create table innodb_monitor (a int) engine=如果你不再需要导出到错误日志文件，只要删除该表即可：复制代码 代码如下:&&& drop table innodb_5. 如何定期删除庞大的日志文件？只要在启动配置文件中设置日志过期时间即可：复制代码 代码如下:&&& expire_logs_days=10经验教训1. 重点关注索引下面以表tsk_task表为例说明 优化 。tsk_task表用于保存监测任务，相关字段及索引如下：
&&& id：主键；&&& mon_time：监测时间；建了索引；&&& status_id：任务状态；与sys_hier_info.id建立了外键关系。
注mysql自动会为外键建立索引，在本次优化 中，发现这些自动建立的外键索引会对 的效率产生不必要的干扰，需要特别注意！
首先，我们在日志文件中查到下面语句的执行比较慢，超过10秒了：复制代码 代码如下:&&& # query_time: 18 lock_time: 0 rows_sent: 295 rows_examined: 88143&&& select * from tsk_task where status_id = 1064 and mon_time &= '' and mon_time & '';
哦，原来在88143条记录中要查出符合条件的295条记录，那当然慢了。赶紧用explain语句看一下索引使用情况吧：
&&& +----+-------------+----------+------+----------------------------------------------------------+------------------------------------+---------+-------+--------+-------------+&&& | id | select_type | table | type | possible_keys | key | key_len | ref | rows | extra |&&& +----+-------------+----------+------+----------------------------------------------------------+------------------------------------+---------+-------+--------+-------------+&&& | 1 | simple | tsk_task | ref | fk_task_status_id_to_sys_hier_info,tsk_task_key_mon_time | fk_task_status_id_to_sys_hier_info | 9 | const | 276168 | using where |&&& +----+-------------+----------+------+----------------------------------------------------------+------------------------------------+---------+-------+--------+-------------+
可以看出，有两个索引可用fk_task_status_id_to_sys_hier_info,tsk_task_key_mon_time，而最终执行语句时采用了status_id上的外键索引。
再看一下tsk_task表的索引情况吧：
&&& +----------+------------------------------------+-------------+-------------+&&& | table | key_name | column_name | cardinality |&&& +----------+------------+------------------------------------+--------------+&&& | tsk_task | primary | id | 999149 |&&& | tsk_task | fk_task_status_id_to_sys_hier_info | status_id | 16 |&&& | tsk_task | tsk_task_key_mon_time | mon_time | 13502 |&&& +----------+------------------------------------+-------------+-----------+--
在oracle或其他关系 下，where条件中的字段顺序对索引的选择起着很重要的作用。我们调整一下字段顺序，把status_id放在后面，再explain一下：复制代码 代码如下:&&& explain select * from tsk_task where mon_time &= '' and mon_time & '' and status_id = 1064;
但是没什么效果，mysql还是选用建立的status_id外键索引。
仔细分析一下，看来cardinality属性（即索引中的唯一值的个数）对索引的选择起了极其重要的作用，mysql选择了索引值唯一值个数小的那个索引作为整条语句的索引。
针对这条语句，如果使用fk_task_status_id_to_sys_hier_info做索引，而tsk_task表中存放很多天数据的话，那扫描的记录数会很多，速度较慢。可以有以下几个优化方案：
&&& 如果一天的任务数不多的话，我们删除索引fk_task_status_id_to_sys_hier_info，那mysql会使用索引tsk_task_key_mon_time，然后在该天的数据中在扫描status_id为1064的记录，那速度也不慢；&&& 如果一天的任务数多的话，我们需删除索引fk_task_status_id_to_sys_hier_info和tsk_task_key_mon_time，然后再建立status_id,mon_time的联合索引，这样效率肯定会很高。
因此建议，对那些记录数多的表，建议不要使用外键，以避免造成性能效率的严重降低。2. 尽量控制每张表的记录数当一张表的记录数很大时，管理和维护就会很麻烦，如索引维护就会占用很长时间，从而会给的正常运行造成很大的干扰。
对随时间推移数据量不断增长的表，我们可以根据时间来区分实时数据和历史数据，可以使用后台服务程序定期 实时表中的数据到历史表中，从而控制实时表的记录数，提高查询和操作效率。但注意每次 的时间要足够短，不要影响正常程序的数据写入。如果占用时间太长，可能会造成死锁问题。3. 数据散列(partition)策略当客户数达到一定规模后，单个 将无法支撑更高的并发访问，此时可以考虑把客户数据散列(partition)到多个 中，以分担负载，提高的整体性能与效率。
数据散列可以考虑采用federeated或sharded方式，网上有不少这方面的资料。一些小技巧1. 如何查出效率低的语句？在mysql下，在启动参数中设置 --log-slow-queries=[文件名]，就可以在指定的日志文件中记录执行时间超过long_query_time（缺省为10秒）的 。你也可以在启动配置文件中修改long query的时间，如：复制代码 代码如下:&&& # set long query time to 8 seconds&&& long_query_time=82. 如何查询某表的索引？可使用show index语句，如：复制代码 代码如下:&&& show index from [表名]3. 如何查询某条语句的索引使用情况？可用explain语句来看一下某条select语句的索引使用情况。如果是update或delete语句，需要先转换为select语句。4. 如何把导出innodb引擎的内容到错误日志文件中?我们可以使用show innodb status命令来查看innodb引擎的很多有用的信息，如当前进程、事务、外键错误、死锁问题和其它一些统计数据。如何让该信息能记录在日志文件中呢？只要使用如下语句创建innodb_monitor表，mysql就会每15秒钟把该写入到错误日志文件中：复制代码 代码如下:&&& create table innodb_monitor (a int) engine=如果你不再需要导出到错误日志文件，只要删除该表即可：复制代码 代码如下:&&& drop table innodb_5. 如何定期删除庞大的日志文件？只要在启动配置文件中设置日志过期时间即可：复制代码 代码如下:&&& expire_logs_days=10经验教训1. 重点关注索引下面以表tsk_task表为例说明 优化 。tsk_task表用于保存监测任务，相关字段及索引如下：
&&& id：主键；&&& mon_time：监测时间；建了索引；&&& status_id：任务状态；与sys_hier_info.id建立了外键关系。
注mysql自动会为外键建立索引，在本次优化 中，发现这些自动建立的外键索引会对 的效率产生不必要的干扰，需要特别注意！
首先，我们在日志文件中查到下面语句的执行比较慢，超过10秒了：
&&& # query_time: 18 lock_time: 0 rows_sent: 295 rows_examined: 88143&&& select * from tsk_task where status_id = 1064 and mon_time &= '' and mon_time & '';
哦，原来在88143条记录中要查出符合条件的295条记录，那当然慢了。赶紧用explain语句看一下索引使用情况吧：
&&& +----+-------------+----------+------+----------------------------------------------------------+------------------------------------+---------+-------+--------+-------------+&&& | id | select_type | table | type | possible_keys | key | key_len | ref | rows | extra |&&& +----+-------------+----------+------+----------------------------------------------------------+------------------------------------+---------+-------+--------+-------------+&&& | 1 | simple | tsk_task | ref | fk_task_status_id_to_sys_hier_info,tsk_task_key_mon_time | fk_task_status_id_to_sys_hier_info | 9 | const | 276168 | using where |&&& +----+-------------+----------+------+----------------------------------------------------------+------------------------------------+---------+-------+--------+-------------+
可以看出，有两个索引可用fk_task_status_id_to_sys_hier_info,tsk_task_key_mon_time，而最终执行语句时采用了status_id上的外键索引。
再看一下tsk_task表的索引情况吧：
&&& +----------+------------------------------------+-------------+-------------+&&& | table | key_name | column_name | cardinality |&&& +----------+------------+------------------------------------+--------------+&&& | tsk_task | primary | id | 999149 |&&& | tsk_task | fk_task_status_id_to_sys_hier_info | status_id | 16 |&&& | tsk_task | tsk_task_key_mon_time | mon_time | 13502 |&&& +----------+------------------------------------+-------------+-----------+--
在oracle或其他关系 下，where条件中的字段顺序对索引的选择起着很重要的作用。我们调整一下字段顺序，把status_id放在后面，再explain一下：复制代码 代码如下:&&& explain select * from tsk_task where mon_time &= '' and mon_time & '' and status_id = 1064;
但是没什么效果，mysql还是选用建立的status_id外键索引。
仔细分析一下，看来cardinality属性（即索引中的唯一值的个数）对索引的选择起了极其重要的作用，mysql选择了索引值唯一值个数小的那个索引作为整条语句的索引。
针对这条语句，如果使用fk_task_status_id_to_sys_hier_info做索引，而tsk_task表中存放很多天数据的话，那扫描的记录数会很多，速度较慢。可以有以下几个优化方案：
&&& 如果一天的任务数不多的话，我们删除索引fk_task_status_id_to_sys_hier_info，那mysql会使用索引tsk_task_key_mon_time，然后在该天的数据中在扫描status_id为1064的记录，那速度也不慢；&&& 如果一天的任务数多的话，我们需删除索引fk_task_status_id_to_sys_hier_info和tsk_task_key_mon_time，然后再建立status_id,mon_time的联合索引，这样效率肯定会很高。
因此建议，对那些记录数多的表，建议不要使用外键，以避免造成性能效率的严重降低。2. 尽量控制每张表的记录数当一张表的记录数很大时，管理和维护就会很麻烦，如索引维护就会占用很长时间，从而会给的正常运行造成很大的干扰。
对随时间推移数据量不断增长的表，我们可以根据时间来区分实时数据和历史数据，可以使用后台服务程序定期 实时表中的数据到历史表中，从而控制实时表的记录数，提高查询和操作效率。但注意每次 的时间要足够短，不要影响正常程序的数据写入。如果占用时间太长，可能会造成死锁问题。3. 数据散列(partition)策略当客户数达到一定规模后，单个 将无法支撑更高的并发访问，此时可以考虑把客户数据散列(partition)到多个 中，以分担负载，提高的整体性能与效率。
数据散列可以考虑采用federeated或sharded方式，网上有不少这方面的资料。配置my.cnf/my.ini，增加 --log-slow-queries 配置，记录所有的slow query，然后挨个优化本文来源于 web开发网复制代码 代码如下:select @a=drclass1, @b=drclass2, @c=drclass3, @d=drclass4, @e=drclass5 from teacher where teacherid = @teacherid
create table classname(classname char(50))insert into classname (classname) values (@a)if (@b is not null)begininsert into classname (classname) values (@b)
if (@c is not null)begininsert into classname (classname) values (@c)
if (@d is not null)begininsert into classname (classname) values (@d)if (@e is not null)begininsert into classname (classname) values (@e)endendendend
select * from classname以上这些 能不能转成一个？我自己试了下复制代码 代码如下:alter procedure pr_getclass
@teacherid int,@a char(50),@b char(50),@c char(50),@d char(50),@e char(50)as
select @a=drclass1, @b=drclass2, @c=drclass3, @d=drclass4, @e=drclass5 from teacher where teacherid = @teacheriddrop table classnamecreate table classname(classname char(50))
insert into classname (classname) values (@a)if (@b is not null)begininsert into classname (classname) values (@b)
if (@c is not null)begininsert into classname (classname) values (@c)
if (@d is not null)begininsert into classname (classname) values (@d)if (@e is not null)begininsert into classname (classname) values (@e)endendendend
select * from classname但是这样的话，这个就有6个变量，实际上应该只提供一个变量就可以了
主要的问题就是自己没搞清楚 @a,@b,@c,@d 等是临时变量，是放在as后面重新做一些申明的，而不是放在开头整个的变量定义。
(标准化越来越近了):namespace prefix = o ns = "urn:schemas-microsoft-com:office:office" /&
实战 收集(不断更新中--)
前言：这里将我编程实践中遇到的有价值的 一路记下来，一方面方便自己查用，一方面也夯实下即将遗忘的回忆。整个 中我会不断更新，直到不能再加为止，同时，这里只记录最实用的咚咚，不效仿学院派的那一套。
一、常用 荟萃
1.1，简单查询：select * from table where
1.2，连接查询：
什么是连接查询？顾名释义，就是查询时涉及多个表的查询。是以说到连接，废话一下，要知道连接还是关系 的主要特点呢。
连接查询分为三种：外连接(outer join)，内连接(inner join)，交叉连接(cross join)。
(标准化越来越近了):namespace prefix = st1 ns = "urn:schemas-microsoft-com:office:smarttags" /&1.2.1，内连接(inner join)使用比较运算符进行表间某(些)列数据的比较操作，并列出这些表中与连接条件相匹配的数据行。根据所使用的比较方式不同此文来自: 马开东博客
转载请注明出处 网址：
，内连接又分为等值连接、自然连接和不等连接三种。
1.2.2，外连接分为左外连接(left outer join或left join)、右外连接(right outer join或right join)和全外连接(full outer join或full join)三种。与内连接不同的是，外连接不只列出与连接条件相匹配的行，而是列出左表(左外连接时)、右表(右外连接时)或两个表(全外连接时)中所有符合搜索条件的数据行。
1.2.3，交叉连接(cross join)没有where 子句，它返回连接表中所有数据行的笛卡尔积，其结果集合中的数据行数等于第一个表中符合查询条件的数据行数乘以第二个表中符合查询条件的数据行数。连接操作中的on (join_condition) 子句指出连接条件，它由被连接表中的列和比较运算符、逻辑运算符等构成。
1.2.4，无论哪种连接都不能对text、ntext和image数据类型列进行直接连接，但可以对这三种列进行间接连接。例如：
select p1.pub_id,p2.pub_id,p1.pr_infofrom pub_info as p1 inner join pub_info as p2on datalength(p1.pr_info)=datalength(p2.pr_info)
1.2.5，使用where子句设置查询条件
where子句设置查询条件，过滤掉不需要的数据行。例如下面语句查询年龄大于20的数据：复制代码 代码如下:select *
from usertable
where age&20where子句可包括各种条件运算符：
比较运算符(大小比较)：&、&=、=、&、&=、&&、!&、!&
范围运算符(表达式值是否在指定的范围)：between…and…
not between…and…
列表运算符(判断表达式是否为列表中的指定项)：in (项1,项2……)
not in (项1,项2……)
模式匹配符(判断值是否与指定的字符通配格式相符):like、not like
空值判断符(判断表达式是否为空)：is null、not is null
逻辑运算符(用于多条件的逻辑连接)：not、and、or
1、范围运算符例：age between 10 and 30相当于age&=10 and age&=30
2、列表运算符例：country in ('germany','china')
3、模式匹配符例：常用于模糊查找，它判断列值是否与指定的字符串格式相匹配。可用于char、varchar、text、ntext、datetime和smalldatetime等类型查询。
可使用以下通配字符：
百分号%：可匹配任意类型和长度的字符，如果是中文，请使用两个百分号即%%。
下划线_：匹配单个任意字符，它常用来限制表达式的字符长度。
方括号[]：指定一个字符、字符串或范围，要求所匹配对象为它们中的任一个。
[^]：其取值也[] 相同，但它要求所匹配对象为指定字符以外的任一个字符。
限制以publishing结尾，使用like '%publishing'
限制以a开头：like '[a]%'
限制以a开头外：like '[^a]%'
空值判断符例：where age is null
2，更新：update table
3.1，一般插入：复制代码 代码如下:insert into publishers(pub_id, pub_name, city, state)values('9001', 'acme publishing', 'new york', 'ny')3.2，插入多行
使用 insert 语句可以向表添加多行数据。这些多行数据是从已经存有这些数据的另一个表中选取的。本例中，向 pubhold 表中添加有关在加利福尼亚和德克萨斯州的出版商的数据。这些数据可从 publishers 表中获得。复制代码 代码如下:insert pubhpold select * from publisherswhere state = 'ca' or state = 'tx'　
4.1，delete语句联合删除：复制代码 代码如下:delete from uu_suitetominclassroomsect
where min_classroom_sect_id in
&& (select min_classroom_sect_id
&& from uu_minclassroomsect
&& where min_classroom_id = '112')二、视图使用细则
1，一个典型的视图复制代码 代码如下:create view view_uugrouptaxis
select uu_groupinfo.group_id, uu_groupinfo.group_name,
&&&&& uu_grouptype.main_type, uu_grouptype.group_type_name,
&&&&& uu_groupinfo.group_icon_url, isnull
&&&&&&&&& ((select count(*)
&&&&&&&&& from uu_groupuser
&&&&&&&&& where uu_groupinfo.group_id = uu_groupuser.group_id), 0)
&&&&& * 50 + isnull(uu_groupinfo.fundcount, 0) + isnull
&&&&&&&&& ((select count(*)
&&&&&&&&& from dv_topic
&&&&&&&&& where dv_topic.boardid = uu_groupinfo.subforum_id), 0) * 5 + isnull
&&&&&&&&& ((select count(*)
&&&&&&&&& from uu_groupphotos
&&&&&&&&& where uu_groupphotos.group_id = uu_groupinfo.group_id), 0)
&&&&& * 10 + isnull(uu_groupinfo.topic_account, 0)
&&&&& * 2 + isnull(uu_groupinfo.hit_account, 0) as group_activedegree,
&&&&& isnull
&&&&&&&&& ((select count(*)
&&&&&&&&& from uu_groupuser
&&&&&&&&& where uu_groupinfo.group_id = uu_groupuser.group_id), 0)
&&&&& as group_membernum, isnull(uu_groupinfo.fundcount, 0) as fundcount,
&&&&&&&&& (select count(*)
&&&&&&&& from dv_topic
&&&&&&&& where dv_topic.boardid = uu_groupinfo.subforum_id) as group_articlenum,
&&&&&&&&& (select count(*)
&&&&&&&& from uu_groupphotos
&&&&&&&& where uu_groupphotos.group_id = uu_groupinfo.group_id) as group_photonum,
&&&&& uu_groupinfo.topic_account, uu_groupinfo.hit_account,
&&&&&&&&& (select user_name
&&&&&&&& from uu_re teruser
&&&&&&&& where uu_re teruser.user_id = uu_groupinfo.creator_id)
&&&&& as group_creatorname, uu_groupinfo.create_time
from uu_groupinfo inner join
&&&&& uu_grouptype on
&&&&& uu_groupinfo.group_type_id = uu_grouptype.group_type_id三，的创建和调用
1，的调用复制代码 代码如下:execute procedurename @param='value'2，一个典型的带参数复制代码 代码如下:create procedure p_delminiclassproc
@miniclassroom_id int
declare @billtag varchar(4)
set nocount on
if @miniclassroom_id is null
&&&&&&&& begin
&&&&&&&&&&&&&&&&&& return(-1)
&&&&&&&& end
&&&&&&&&&&&&&&&&&& begin transaction
&&&&&&&&&&&&&&&&&& --删除套餐信息
&&&&&&&&&&&&&&&&&& delete from uu_suitetominclassroomsect
&&&&&&&&&&&&&&&&&& where min_classroom_sect_id in
&&&&&&&&&&&&&&&&&&&&& (select min_classroom_sect_id
&&&&&&&&&&&&&&&&&&&&& from uu_minclassroomsect
&&&&&&&&&&&&&&&&&&&&& where min_classroom_id =@miniclassroom_id)
&&&&&&&&&&&&&&&&&& --删除小课堂段信息
&&&&&&&&&&&&&&&&&& delete from uu_minclassroomsect
&&&&&&&&&&&&&&&&&& where min_classroom_id = @miniclassroom_id
&&&&&&&&&&&&&&&&&& --删除小课堂用户购买记录
&&&&&&&&&&&&&&&&&& delete from uu_userbuyminclassroom
&&&&&&&&&&&&&&&&&& where min_classroom_id = @miniclassroom_id
&&&&&&&&&&&&&&&&&& --删除对应小课堂年级学科信息
&&&&&&&&&&&&&&&&&& delete from uu_minclassroomtogradeclass
&&&&&&&&&&&&&&&&&& where min_classroom_id = @miniclassroom_id
&&&&&&&&&&&&&&&&&& --删除小课堂发言
&&&&&&&&&&&&&&&&&& delete from uu_minclassroomdiscuss
&&&&&&&&&&&&&&&&&& where min_classroom_id = @miniclassroom_id
&&&&&&&&&&&&&&&&&& --删除课程讨论
&&&&&&&&&&&&&&&&&& delete from uu_coursediscuss
&&&&&&&&&&&&&&&&&& where course_id in
&&&&&&&&&&&&&&&&&&&&& (select course_id
&&&&&&&&&&&&&&&&&&&&& from uu_courseinfo
&&&&&&&&&&&&&&&&&&&&& where min_classroom_id = @miniclassroom_id)
&&&&&&&&&&&&&&&&&& --删除用户课程收藏
的优化是将性能低下的 转换成目的相同的性能优异的 。
　　 自动sql优化就是使用 技术，自动对 进行重写，从而找到性能最好的等效 。
　　 性能的优化
　　一个的可以分成：设计、开发和成品三个阶段。在设计阶段进行 性能优化的成本最低，收益最大。在成品阶段进行 性能优化的成本最高，收益最小。
　　 的优化通常可以通过对网络、 、、 参数和程序的优化来进行。最常见的优化手段就是对 的升级。根据统计，对网络、 、、 参数进行优化所获得的性能提升，全部加起来只占性能提升的40%左右，其余的60%性能提升来自对程序的优化。许多优化专家认为，对程序的优化可以得到80%的性能的提升。
　　程序的优化
　　程序的优化通常可分为两个方面：源代码和 。由于涉及到对程序逻辑的改变，源代码的优化在时间成本和风险上代价很高，而对性能的提升收效有限。
　　为什么要优化
是对 进行操作的惟一途径，对的性能起着决定性的作用。
消耗了70%至90%的 资源。
独立于逻辑，对 进行优化不会影响程序逻辑。
有不同的写法，在性能上的差异非常大。
易学，但难精通。
　　优化 的传统 是通过手工重写来对 进行优化。dba或资深通过对 执行计划的分析，依靠经验，尝试重写 ，然后对结果和性能进行比较，以试图找到性能较佳的 。这种传统上的作法无法找出 的所有可能写法，且依赖于人的经验，非常耗费时间。
　　sql优化技术的发展历程
　　第一代sql优化是执行计划分析。这类针对输入的 ，从 提取执行计划，并解释执行计划中关键字的含义。
　　第二代sql优化只能提供增加索引的建议，它通过对输入的 的执行计划的分析，来产生是否要增加索引的建议。
　　第三代sql优化不仅分析输入 的执行计划，还对输入的 本身进行语法分析，经过分析产生写法上的改进建议。
　　 自动sql优化
性能优化--lecco sql expert图1
自动sql优化示意图
　　 自动sql优化出现在90年代末。目前在商用 领域，lecco technology limited(灵高科研有限公司)拥有该技术，并提供使用该技术的自动优化产品lecco sql expert，它支持oracle(大型网站 平台)、sybase、ms
(windows平台上强大的 平台)和ibm db2 平台。该产品针对 的开发和维护阶段提供的模块有：sql语法优化器、pl/sql集成化开发调试环境(ide)、扫描器、 监视器等。其核心模块sql 语法优化器的工作原理为：①输入一条源 ；②“ 反馈式 ”对输入的 ，结合检测到的 结构和索引进行重写，产生n条等效的 输出；③产生的n条等效 再送入“ 反馈式 ”进行重写，直至无法产生新的输出或搜索限额满；④对输出的 进行过滤，选出具有不同执行计划的 ；⑤对得到的 进行批量测试，找出性能最好的 。
　　lecco sql expert自动优化实例
　　假设我们从源代码中抽取出这条 (也可以通过内带的扫描器或监视器获得 )：复制代码 代码如下:　　select count(*)
　　 from employee
　　swheresexists (select 'x'
　　 from department
　　swheresemp_dept=dpt_id
　　 and dpt_name like 'ac%')
　　and emp_id in (select sal_emp_id
　　 from emp_sal_hist b
　　swheressal_salary ＞ 70000)　　按下“优化”按钮后，经过10几秒，sql expert就完成了优化的 ，并在这10几秒的时间里重写产生了2267 条等价的 ，其中136条 有不同的执行计划。
　　接下来，我们可以对自动重写产生的136条 进行批运行测试，以选出性能最佳的等效 。按下“批运行” 按钮，在“终止条件” 页选择“最佳运行时间 ”，按“确定”。
　　经过几分钟的测试运行后，我们可以发现sql124的运行时间和反应时间最短。运行速度约有22.75倍的提升(源 运行时间为2.73秒，sql124运行时间为0.12秒)。现在我们就可以把sql124放入源代码中，结束一条 的优化工作了。
　　“边做边学式训练”提升sql开发水平
　　lecco sql expert不仅能够找到最佳的 ，它所提供的“边做边学式训练”还能够教开发和如何写出性能最好的 。lecco sql expert的“sql比较器”可以标明源sql和待选sql间的不同之处。
　　以上面优化的结果为例，为了查看源 和sql124在写法上有什么不同，我们可以按下“比较器” 按钮，对sql124和源 进行比较。“sql 比较器”将sql124相对于源 的不同之处以蓝颜色表示了出来。如果选择“双向比较”复选框，“sql 比较器”可以将两条 的不同之处以蓝色表示。当然，我们也可以从源语句和重写后的sql 语句中任选两条进行比较。
　　从比较的结果可以看到，重写后的sql124把第一个exists改写成了in；在字段dpt_id上进行了合并空字符串的操作，以诱导 先执行子查询中的复制代码 代码如下:　　(select dpt_id||''
　　from department
　　where dpt_name like 'ac%')　　在子查询完成后，再与employee表进行嵌套循环连接(nested loop join)。
　　如果觉得对写法的改变难以理解，还可以点中“执行计划”复选框，通过比较两条 的执行计划的不同，来了解其中的差异。在查看执行计划 中，如果有什么不明白的地方，可以点中“sql信息按钮”，再点击执行计划看不明白的地方，lecco sql expert的上下文敏感帮助将提供执行计划该处的解释。
　　在“sql比较器”中，选中“统计信息”复选框后，可得到详细的两条 运行时的统计信息比较，这对于学习不同的sql写法对 资源的消耗很有帮助。
　　lecco sql expert优化模块的特点
　　lecco sql expert优化模块的特点主要表现为：自动优化 ；以独家的 知识库“反馈式 ”来重写性能优异的 ；找出所有等效的 及可能的执行计划；保证产生相同的结果；先进的sql语法分析器能处理最复杂的 ；可以重写select、select into、update、insert和delete语句；通过测试运行，为程序和 自动找到性能最好的 ；提供微秒级的计时，能够优化web程序和有大量用户的在线事务处理中运行时间很短的 ；为开发提供“边做边学式训练”，迅速提高开发的sql编程技能；提供上下文敏感的执行计划帮助和sql运行状态帮助；不是猜测或建议，而是独一无二的sql重写 。
　　写出专家级的
　　lecco sql expert的出现，使sql的优化变得极其简单，只要能够写出 ，它就能帮用户找到最好性能的写法。lecco sql expert不仅能在很短的时间内找到所有可能的优化方案，而且能够通过实际测试，确定最有效的优化方案。同以往的 优化手段相比较，lecco sql expert将 优化技术带到了一个崭新的技术高度，依赖人的经验、耗费大量时间、受人的思维束缚的 优化手段已经被高效、省时且准确的自动优化所取代了。通过内建的“lecco小助手”的帮助，即使是sql的开发新手，也能快速且简单地写出专家级的 。
比如现在有一表 （表名：peosons）若想将姓名、身份证号、住址这三个字段完全相同的记录查询出来复制代码 代码如下:select&& p1.*&& from&& persons&& p1,persons&& p2&& where&& p1.id&&p2.id&& and&& p1.cardid&& =&& p2.cardid&& and&& p1.pname&& =&& p2.pname&& and&& p1.address&& =&& p2.address可以实现上述效果．
　　select语句前加：declare @d datetimeset @d=getdate()并在select语句后加：select [语句执行花费时间(毫秒)]=datediff(ms,@d,getdate())
transact_sql小手册
*******************transact_sql********************
--语 句&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& 功 能--数据操作select&&&&& --从 表中检索数据行和列insert&&&&& --向 表添加新数据行delete&&&&& --从 表中删除数据行update&&&&& --更新 表中的数据--数据定义create table&&& --创建一个 表drop table&&&& --从 中删除表alter table&&&& --修改 表结构create view&&&& --创建一个视图drop view&&&& --从 中删除视图create index&&& --为 表创建一个索引drop index&&&& --从 中删除索引create procedure&& --创建一个drop procedure&&& --从 中删除create trigger&&& --创建一个drop trigger&&& --从 中删除create schema&&& --向 添加一个新模式drop schema&&&& --从 中删除一个模式create domain&&& --创建一个数据值域alter domain&&& --改变域定义drop domain&&&& --从 中删除一个域--数据控制grant&&&&& --授予用户访问权限deny&&&&& --拒绝用户访问revoke&&&&& --解除用户访问权限--事务控制commit&&&&& --结束当前事务rollback&&&& --中止当前事务set transaction&&& --定义当前事务数据访问特征--程序化sqldeclare&&&&& --为查询设定游标explan&&&&& --为查询描述数据访问计划open&&&&& --检索查询结果打开一个游标fetch&&&&& --检索一行查询结果close&&&&& --关闭游标prepare&&&&& --为动态执行准备sql 语句execute&&&&& --动态地执行sql 语句describe&&&& --描述准备好的查询
复制代码 代码如下:---局部变量declare @id char(10)--set @id = ''select @id = ''
---全局变量---必须以@@开头
--if elsedeclare @x int @y int @z intselect @x = 1 @y = 2 @z=3if @x & @yprint 'x & y' --打印字符串'x & y'else if @y & @zprint 'y & z'else print 'z & y'
--caseuse panguupdate employeeset e_wage =casewhen job_level = '1' then e_wage*1.08when job_level = '2' then e_wage*1.07when job_level = '3' then e_wage*1.06else e_wage*1.05end
--while continue breakdeclare @x int @y int @c intselect @x = 1 @y=1while @x & 3beginprint @x --打印变量x 的值while @y & 3&& begin&&& select @c = 100*@x + @y&&& print @c --打印变量c 的值&&& select @y = @y + 1&& endselect @x = @x + 1select @y = 1end
--waitfor--例 等待1 小时2 分零3 秒后才执行select 语句waitfor delay '01:02:03'select * from employee--例 等到晚上11 点零8 分后才执行select 语句waitfor time '23:08:00'select * from employee
***select***
&& select *(列名) from table_name(表名) where column_name operator value&& ex:(宿主)select * from stock_information where stockid&& = str(nid)&&&& stockname = 'str_name'&&&& stockname like '% find this %'&&&& stockname like '[a-za-z]%' --------- ([]指定值的范围)&&&& stockname like '[^f-m]%'&& --------- (^排除指定范围)&&&& --------- 只能在使用like关键字的where子句中使用通配符)&&&& or stockpath = 'stock_path'&&&& or stocknumber & 1000&&&& and stockindex = 24&&&& not stocksex = 'man'&&&& stocknumber between 20 and 100&&&& stocknumber in(10,20,30)&&&& order by stockid desc(asc) --------- 排序，desc-降序，asc-升序&&&& order by 1,2 --------- by列号&&&& stockname = (select stockname from stock_information where stockid = 4)&&&& --------- 子查询&&&& --------- 除非能确保内层select只返回一个行的值，&&&& --------- 否则应在外层where子句中用一个in限定符select distinct column_name form table_name --------- distinct指定检索独有的列值，不重复select stocknumber ,"stocknumber + 10" = stocknumber + 10 from table_nameselect stockname , "stocknumber" = count(*) from table_name group by stockname&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& --------- group by 将表按行分组,指定列中有相同的值&&&&&&&&& having count(*) = 2 --------- having选定指定的组select *from table1, table2&&&&&&&&&&&&&&&& where table1.id *= table2.id -------- 左外部连接，table1中有的而table2中没有得以null表示&&&& table1.id =* table2.id -------- 右外部连接
select stockname from table1union [all] ----- union合并查询结果集，all-保留重复行select stockname from table2***insert***复制代码 代码如下:insert into table_name (stock_name,stock_number) value ("xxx","xxxx")&&&&&&&&&&&&& value (select stockname , stocknumber from stock_table2)---value为select语句***update***复制代码 代码如下:update table_name set stockname = "xxx" [where stockid = 3]&&&&&&&& stockname = default&&&&&&&& stockname = null&&&&&&&& stocknumber = stockname + 4***delete***复制代码 代码如下:delete from table_name where stockid = 3truncate table_name ----------- 删除表中所有行，仍保持表的完整性drop table table_name --------------- 完全删除表***alter table*** --- 修改 表结构复制代码 代码如下:alter table
.owner.table_name add column_name char(2) null .....sp_help table_name ---- 显示表已有特征create table table_name (name char(20), age smallint, lname varchar(30))insert into table_name select ......... ----- 实现删除列的 （创建新表）alter table table_name drop constraint stockname_default ---- 删除stockname的default约束&***function(/*常用函数*/)***
----统计函数----avg&&& --求平均值count&& --统计数目max&&& --求最大值min&&& --求最小值sum&&& --求和复制代码 代码如下:--avguse panguselect avg(e_wage) as dept_avgwagefrom employeegroup by dept_id
--max--求工资最高的员工姓名use panguselect e_namefrom employeewhere e_wage =(select max(e_wage)from employee)
--stdev()--stdev()函数返回表达式中所有数据的标准差
--stdevp()--stdevp()函数返回总体标准差
--var()--var()函数返回表达式中所有值的统计变异数
--varp()--varp()函数返回总体变异数----算术函数----
/***三角函数***/sin(float_expression) --返回以弧度表示的角的正弦cos(float_expression) --返回以弧度表示的角的余弦tan(float_expression) --返回以弧度表示的角的正切cot(float_expression) --返回以弧度表示的角的余切/***反三角函数***/asin(float_expression) --返回正弦是float 值的以弧度表示的角acos(float_expression) --返回余弦是float 值的以弧度表示的角atan(float_expression) --返回正切是float 值的以弧度表示的角atan2(float_expression1,float_expression2)&&&&&&& --返回正切是float_expression1 /float_expres-sion2的以弧度表示的角degrees(numeric_expression)&&&&&&&&&&&&&&&&&&&&&& --把弧度转换为角度返回与表达式相同的数据类型可为&&&&&&& --integer/money/real/float 类型radians(numeric_expression) --把角度转换为弧度返回与表达式相同的数据类型可为&&&&&&& --integer/money/real/float 类型exp(float_expression) --返回表达式的指数值log(float_expression) --返回表达式的自然对数值log10(float_expression)--返回表达式的以10 为底的对数值sqrt(float_expression) --返回表达式的平方根/***取近似值函数***/ceiling(numeric_expression) --返回&=表达式的最小整数返回的数据类型与表达式相同可为&&&&&&& --integer/money/real/float 类型floor(numeric_expression)&&& --返回&=表达式的最小整数返回的数据类型与表达式相同可为&&&&&&& --integer/money/real/float 类型round(numeric_expression)&&& --返回以integer_expression 为精度的四舍五入值返回的数据&&&&&&& --类型与表达式相同可为integer/money/real/float 类型abs(numeric_expression)&&&&& --返回表达式的绝对值返回的数据类型与表达式相同可为&&&&&&& --integer/money/real/float 类型sign(numeric_expression)&&&& --测试参数的正负号返回0 零值1 正数或-1 负数返回的数据类型&&&&&&& --与表达式相同可为integer/money/real/float 类型pi()&&&&&& --返回值为π 即3.7936rand([integer_expression])&& --用任选的[integer_expression]做种子值得出0-1 间的随机浮点数
----字符串函数----ascii()&&&&&&&& --函数返回字符表达式最左端字符的ascii 码值char()&& --函数用于将ascii 码转换为字符&&& --如果没有输入0 ~ 255 之间的ascii 码值char 函数会返回一个null 值lower()&& --函数把字符串全部转换为小写upper()&& --函数把字符串全部转换为大写str()&& --函数把数值型数据转换为字符型数据ltrim()&& --函数把字符串头部的空格去掉rtrim()&& --函数把字符串尾部的空格去掉left(),right(),substring() --函数返回部分字符串charindex(),patindex() --函数返回字符串中某个指定的子串出现的开始位置soundex() --函数返回一个四位字符码&&& --soundex函数可用来查找声音相似的字符串但soundex函数对数字和汉字均只返回0 值&&& difference()&&& --函数返回由soundex 函数返回的两个字符表达式的值的差异&&& --0 两个soundex 函数返回值的第一个字符不同&&& --1 两个soundex 函数返回值的第一个字符相同&&& --2 两个soundex 函数返回值的第一二个字符相同&&& --3 两个soundex 函数返回值的第一二三个字符相同&&& --4 两个soundex 函数返回值完全相同&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
quotename() --函数返回被特定字符括起来的字符串
/*select quotename('abc', '{') quotename('abc')运行结果如下----------------------------------{{abc} [abc]*/
replicate()&&&& --函数返回一个重复character_expression 指定次数的字符串/*select replicate('abc', 3) replicate( 'abc', -2)运行结果如下----------- -----------abcabcabc null*/
reverse()&&&&&& --函数将指定的字符串的字符排列顺序颠倒replace()&&&&&& --函数返回被替换了指定子串的字符串/*select replace('abc123g', '123', 'def')运行结果如下----------- -----------abcdefg*/
space()&& --函数返回一个有指定长度的空白字符串stuff()&& --函数用另一子串替换字符串指定位置长度的子串
----数据类型转换函数----cast() 函数语法如下cast() (&expression& as &data_ type&[ length ])convert() 函数语法如下convert() (&data_ type&[ length ], &expression& [, style])
select cast(100+99 as char) convert(varchar(12), getdate())运行结果如下------------------------------ ------------199&& jan 15 2000
----日期函数----day()&& --函数返回date_expression 中的日期值month()&& --函数返回date_expression 中的月份值year()&& --函数返回date_expression 中的年份值dateadd(&datepart& ,&number& ,&date&)&&& --函数返回指定日期date 加上指定的额外日期间隔number 产生的新日期datediff(&datepart& ,&number& ,&date&)&&& --函数返回两个指定日期在datepart 方面的不同之处datename(&datepart& , &date&) --函数以字符串的形式返回日期的指定部分datepart(&datepart& , &date&) --函数以整数值的形式返回日期的指定部分getdate() --函数以datetime 的缺省格式返回当前的日期和时间
----函数----app_name()&&&&& --函数返回当前执行的程序的名称coalesce() --函数返回众多表达式中第一个非null 表达式的值col_length(&'table_name'&, &'column_name'&) --函数返回表中指定字段搜索此文相关文章： 的 Mysql此文来自: 马开东博客
网址: 站长QQ
查询mysql中执行效率低的sql语句的方法Mysql_脚本之家相关文章
脚本之家_总排行榜
脚本之家_最新
脚本之家_月排行榜
脚本之家_周排行榜
脚本之家_日排行榜}