服务器上一直用着mysql_pconnect,之前听说它会出现各种各样的问题,但服务器一直没事,也就没去管。今天看这篇文章,才知道原来mysql_pconnect有这么多的道道。

原文地址:http://www.cnblogs.com/funlake/archive/2011/09/08/2171822.html

  php的mysql持久化连接,美好的目标,却拥有糟糕的口碑,往往令人敬而远之。这到底是为啥么。近距离观察后发现,这家伙也不容易啊,要看apache的脸色,还得听mysql指挥。

  对于做为apache模块运行的php来说,要实现mysql持久化连接,首先得取决于apache这个web服务器是否支持Keep-Alive。

  Keep-Alive

  Keep-Alive是什么东西?它是http协议的一部分,让我们复习一下没有Keep-Alive的http请求,从客户在浏览器输入一个有效url地址开始,浏览器就会利用socket向url对应的web服务器发送一条tcp请求,这个请求成功一次就得需要来回握三次手才能确定,成功以后,浏览器利用socket tcp连接资源向web服务器请求http协议,发送以后就等着web服务器把http返回头和body发送回来,发回来后浏览器关闭socket连接,然后做http返回头和body的解析工作,最后呈现在浏览器上的就是漂亮的页面了。这里面有什么问题呢?tcp连接需要三次握手,也就是来回请求三次方能确定一个tcp请求是否成功,然后tcp关闭呢?来回需要4次请求才能完成!每次http请求就3次握手,4次拜拜,这来来回回的不嫌累啊,多少时间和资源都被浪费在socket连接关闭上了,能不能一次socket tcp连接发送多次http请求呢?于是Keep-Alive就应运而生,http/1.0里需要客户端自己在请求头加入Connection:Keep-alive方能实现,在这里我们只考虑http1.1了,只需要设置一下apache,让它默认就是Keep-Alive持久连接模式(apache必须1.2+才能支持Keep-Alive).在httpd.conf里找到KeepAive配置项,果断设置为On,MaxKeepAliveRequests果断为0(一个持久tcp最多允许的请求数,如果过小,很容易在tcp未过期的情况下,达到最大连接,那下次连接就又是新的tcp连接了,这里设置0表示不限制),然后对于mysql_pconnect最重要的选项KeepAliveTimeout设置为15(表示15秒).

  好了,重启apache,测试一下,赶紧写行东西

<?php
    echo "Apache进程号:".getmypid();
?>

很简单,获取当前php执行者(apache)的进程号,用浏览器浏览这个页面,看到什么?对,有看到一串进程号数字,15秒内,连续刷新页面,看看进程号有无变化?木有吧?现在把手拿开,交叉在胸前,度好时间,1秒,2秒,3,…15,16。好,过了15秒了,再去刷新页面,进程号有没有变化?变了!又是一个新的apache进程了,为什么15秒后就变成新的进程了?记得我们在apache里设置的KeepAliveTimeout吗?它的值就是15秒.现在我们应该大致清楚了,在web服务器默认打开KeepAlive的情况下,客户端第一次http成功请求后,apache不会立刻断开socket,而是一直监听来自这一客户端的请求,监听多久?根据KeepAliveTimeout选项配置的时间决定,一旦超过这一时间,apache就会断开socket了,那么下次同一客户端再次请求,apache就会新开一个进程来相应。所以我们之前15内不停的刷新页面,看到的进程号都是一致的,表明是浏览器请求给了同一个apache进程。

  浏览器是怎么知道不需要重新进行tcp连接就可以直接发送http请求呢?因为http返回头里就会带上Connection:keep-alive,Keep-alive:15两行,意思就是让客户端浏览器明白,这次socket连接我这边还没关闭呢,你可以在15内继续使用这个连接,并发送http请求,于是乎浏览器就知道应该怎么做了.

  php怎么做

  那么,php的mysql连接资源是怎么被hold住的呢,这需要查看php的mysql_pconnect的函数代码,我看了下,大概的做法就是根据当前apache进程号,生成hash key,找hash表内有无对应的连接资源,没有则推入hash表,有则直接使用。有些代码片段可以说明(具体可查看php5.3.8源码ext/mysql/php_mysql.c文件690行php_mysql_do_connect函数)

    #1.生成hash key
        user=php_get_current_user();//获取当前php执行者(apache)的进程唯一标识号
        hashed_details_length = spprintf(&hashed_details, 0, "mysql__%s_", user);//hashed_details就是hash key
    #2.如果未找到已有资源,就推入hash表,名字叫persistent_list,如果找到就直接使用
         /* try to find if we already have this link in our persistent list */
         if (zend_hash_find(&EG(persistent_list), hashed_details, hashed_details_length+1, (void **) &le)==FAILURE) {  /* we don't */
            ...
            ...
            /* hash it up(推入hash表) */
            Z_TYPE(new_le) = le_plink;
            new_le.ptr = mysql;
            if (zend_hash_update(&EG(persistent_list), hashed_details, hashed_details_length+1, (void *) &new_le, sizeof(zend_rsrc_list_entry), NULL)==FAILURE) {
                ...
                ...
            }

         }else{/* The link is in our list of persistent connections(连接已在hash表里)*/
            ...
            ...
            mysql = (php_mysql_conn *) le->ptr;//直接使用对应的sql连接资源
            ...
            ...

         }

zend_hash_find比较容易看明白,原型是zend_hash_find(hash表,key名,key长,value);如果找到,value就有值了。

      mysql的wait_timeout和interactive_timeout

  说完Keep-Alive,该到mysql家串串门了,说的是mysql_pconnect,怎么能绕开mysql的设置。

  影响mysql_pconnect最重要的两个参数就是wait_timeout和interactive_timeout,它们是什么东西?先撇一边,首先让我们把上面的代码改动一下php代码

<?php
    $conn = mysql_pconnect("localhost","root","123456") or die("Can not connect to mysql");
    echo "Mysql线程号:".mysql_thread_id($conn)."<br/>";
    echo "Apache进程号".getmypid();
?>

以上的代码没啥好解释的,让我们用浏览器浏览这个页面,看到什么?看到两个显眼的数字。一个是mysql线程号,一个是apache进程号,好了,15秒后再刷新这个页面,发现这两个id都变了,因为已经是新的apache进程了,进程id是新的,hash key就变了,php只好重新连接mysql,连接资源推入persistent list。如果15内刷新呢?apache进程肯定不变,mysql线程号会变吗?答案得问mysql了。首先这个mysql_thread_id是什么东西?shell方式登录mysql后执行命令’show processlist’,看到了什么?

mysql> show processlist;
+-----+------+-----------+------+---------+------+-------+------------------+
| Id  | User | Host      | db   | Command | Time | State | Info             |
+-----+------+-----------+------+---------+------+-------+------------------+
| 348 | root | localhost | NULL | Query   |    0 | NULL  | show processlist |
| 349 | root | localhost | NULL | Sleep   |    2 |       | NULL             |
+-----+------+-----------+------+---------+------+-------+------------------+

,发现了很重要的信息,这个processlist列表就是记录了正在跑的线程,忽略Info列为show processlist那行,那行是你当前shell登录mysql的线程。php连接mysql的线程就是Id为349那行,如果读者自己做测试,应该知道这个Id=349在你的测试环境里是另外一个值,我们把这个值和网页里输出的mysql_thread_id($conn)做做比较,对!他们是一样的。接下来最重要的是观察Command列和Time列,Command = Sleep,表明什么?表明我们mysql_pconnect连接后就一直在sleep,Time字段就告诉我们,这个线程Sleep了多久,那么Sleep了多久这个线程才能作废呢?那就是wait_timeout或者interactive_timeout要做的工作了,他们默认的值都是8小时,天啊,太久了,所以如果说web服务器关掉KeepAlive支持,那个这个processlist很容易就被撑爆,就爆出那个Too many connections的错误了,max_connectiosns配置得再多也没用。为了观察这两个参数,我们可以在mysql配置文件my.cnf里设置这两个值,找到[mysqld]节点,在里面设置多两行

interactive_timeout = 60
wait_timeout        = 30

配置完后,重启mysql,shell登录mysql,这时候show processlist可以发现只有当前线程。然后运行那个带有mysql_pconnect的php页面,再回来mysql端show processlist可发现,多了一个Commond为Sleep的线程,不停的show processlist(方向键上+enter键)观察Time列的变化2,5,10..14!,突然那个Sleep线程程被kill掉了,咋回事,还没到30秒呢,噢!忘了修改一下apache keepalive的参数了,把KeepAliveTimeOut从15改成120(只为观察,才这么改),重启apache.刷新那个页面,好,开始不停的show processlist,2..5..10..14,15,..20…26….28,29!线程被kill,这次是因为wait_timeout起了作用,浏览器那边停了30秒,30秒内如果浏览器刷新,那这个Time又会从0开始计时。这种连接不属于interactive connection(mysql shell登录那种连接就属于interactive connection),所以采用了wait_timeout的值。如果mysql_pconnect的第4个参数改改呢

<?php
$conn = mysql_pconnect('localhost','root','123456',MYSQL_CLIENT_INTERACTIVE);
echo "Mysql线程号:".mysql_thread_id($conn)."<br/>";
echo "Apache进程号:".getmypid();
?>

刷新下页面,mysql那边开始刷show processlist,这回Time > 30也不会被kill,>60才被kill了,说明设置了MYSQL_CLIENT_INTERACTIVE,就会被mysql视为interactive connection,那么这次php的mysql连接在120秒内未刷新页面的情况下,何时作废将取决于mysql的interactive_timeout的配置值。

  总结

  #1.php的mysql_pconnect要达到功效,首先必须保证apache是支持keep alive的,然后KeepAliveTimeOut应该设置多久呢,要根据自身站点的访问情况做调整,时间太短,keep alive没啥意义,时间太长,就很可能为一个闲客户端连接牺牲很多服务器资源,毕竟hold住socket监听进程是要消耗cpu内存的.

  #2.apache的KeepAliveTimeOut配置得和mysql的time out配置要有个平衡点,联系以上的观察,假设mysql_pconnect未带上第4个参数,如果apache的KeepAliveTimeOut设置的秒数比wait_timeout小,那真正对mysql_pconnect起作用的是apache而不是mysql的配置.这时如果mysql的wait_timeout偏大,并发量大的情况下,很可能就一堆废弃的connection了,mysql这边如果不及时回收,那就很可能Too many connections了.可是如果KeepAliveTimeOut太大呢,又回到之前的问题,所以貌似Apache.KeepAliveTimeOu不要太大,但比Mysql.wait_timeout 稍大,或者相等是比较好的方案,这样可以保证keep alive过期后,废弃的mysql连接可以及时被回收. 

  后记

  Pdo数据库的长连接机制是否和mysql_pconnect一样?经过试验观察和源码探究,发现也是一样的处理方式。

LINUX下将mysql从5.1升级至5.5后,发现存储过程不能用了。创建和使用存储过程时就会提示Cannot load from mysql.proc. The table is probably corrupted

查遍整个百度,结果还是印证了那一句话“天下文章一大抄”啊!

所有的文章几乎都是这么说的

解决方法非常简单,运行mysql_upgrade命令即可。此命令会在数据目录下生成一个文本文件mysql_upgrade_info,里面的内容为升级后的数据库版本。

但不知道什么原因,我这里无效,升级后各种升级OK,但仍然报这个错误。

最后还是求助GOOGLE吧

http://bugs.mysql.com/bug.php?id=50183

原因是mysql.proc升级时有个字段没有升级成功。

在5.1中mysql.proc表的comment字段是varchar(64):

 `comment` char(64) CHARACTER SET utf8 COLLATE utf8_bin NOT NULL DEFAULT '',

但在5.5中应该是text:

`comment` text CHARACTER SET utf8 COLLATE utf8_bin NOT NULL,


So,执行下面的语句,把这个字段修改为text,就彻底OK了:
ALTER TABLE `proc`
MODIFY COLUMN `comment`  text CHARACTER SET utf8 COLLATE utf8_bin NOT NULL AFTER `sql_mode`;

								

下面文章中研究的问题是大家经常会遇到的,尤其是做BBS、CMS一类的项目。文章分析的非常透彻,分享之。原文

这两天让一个数据查询难了。主要是对group by 理解的不够深入。才出现这样的情况
这种需求,我想很多人都遇到过。下面是我模拟我的内容表

CREATE TABLE `test` (
`id` INT(10) NOT NULL  AUTO_INCREMENT,
`name` VARCHAR(255) NOT NULL,
`category_id`  INT(10) NOT NULL,
`date` TIMESTAMP NOT NULL DEFAULT  CURRENT_TIMESTAMP,
PRIMARY KEY (`id`)
)
ENGINE=MyISAM
ROW_FORMAT=DEFAULT;
INSERT  INTO `test` (`id`, `name`, `category_id`, `date`)
VALUES
(1,  'aaa', 1, '2010-06-10 19:14:37'),
(2, 'bbb', 2, '2010-06-10  19:14:55'),
(3, 'ccc', 1, '2010-06-10 19:16:02'),
(4, 'ddd', 1,  '2010-06-10 19:16:15'),
(5, 'eee', 2, '2010-06-10 19:16:35');

我现在需要取出每个分类中最 新的内容

select * from test group by category_id order  by `date`

结果如下

明显。这不是我想要的数据, 原因是msyql已经的执行顺序是

引用

写的顺序:select … from… where…. group by… having… order by..
执行顺序:from… where…group by… having…. select … order by…

所 以在order by拿到的结果里已经是分组的完的最后结果。
由from到where的结果如下的内容。

到group by时就得到了根据category_id分出来的多个小组


到了select的时候,只 从上面的每个组里取第一条信息结果会如下

即 使order by也只是从上面的结果里进行排序。并不是每个分类的最新信息。
回到我的目的上 --分类中最新的信息
根据上面的分 析,group by到select时只取到分组里的第一条信息。有两个解决方法
1,where+group by(对小组进行排序)
2, 从form返回的数据下手脚(即用子查询)

由where+group by的解决方法
对group by里的小组进行排序的函数我只查到group_concat()可以进行排序,但group_concat的作用是将小组里的字段里的值进行串联起来。

select group_concat(id order by `date` desc) from `test`  group by category_id

再改进一下

select * from `test` where id in(select  SUBSTRING_INDEX(group_concat(id order by `date` desc),',',1) from `test`  group by category_id ) order by `date` desc

子 查询解决方案

select * from (select * from `test`  order by `date` desc) `temp`  group by category_id order by `date` desc

据网上大牛们说,nginx性能比apache好,我又经不住诱惑,把服务器从apache更换为nginx了,参考了N多文章。因为网上能找到的文章都是他们自己安装的记录,根本不会考虑别人会出现的各种情况,就像我要安装nginx,是从APACHE更换过来,这类更新服务器软件的文章就少。总之,还算顺利,仅花了一个小时就搞定了,现在主要架构是ubuntu+nginx+php+fastcgi+mysql,性能方面还没测试(从目测和心理作用上,感觉是快了点),目前发现的主要一个问题就是php5-cgi进程过多,还不知道从哪里控制。过后再研究吧。

show tables或show tables from database_name或show database_name.tables;
解释:显示当前数据库中所有表的名称

show databases;
解释:显示mysql中所有数据库的名称

show processlist;
解释:显示系统中正在运行的所有进程,也就是当前正在执行的查询。大多数用户可以查看
他们自己的进程,但是如果他们拥有process权限,就可以查看所有人的进程,包括密码。

show table status;
解释:显示当前使用或者指定的database中的每个表的信息。信息包括表类型和表的最新更新时间

show columns from table_name from database_name; 或show columns from database_name.table_name;或show fields;
解释:显示表中列名称(和 desc table_name 命令的效果是一样的)

show grants for user_name@localhost;
解释:显示一个用户的权限,显示结果类似于grant 命令

show index from table_name;或show keys;
解释:显示表的索引

show status;
解释:显示一些系统特定资源的信息,例如,正在运行的线程数量

show variables;
解释:显示系统变量的名称和值

show privileges;
解释:显示服务器所支持的不同权限

show create database database_name;
解释:显示创建指定数据库的SQL语句

show create table table_name;
解释:显示创建指定数据表的SQL语句

show engies;
解释:显示安装以后可用的存储引擎和默认引擎。

show innodb status;
解释:显示innoDB存储引擎的状态

show logs;
解释:显示BDB存储引擎的日志

show warnings;
解释:显示最后一个执行的语句所产生的错误、警告和通知

show errors;
解释:只显示最后一个执行语句所产生的错误

上面的大部分命令都可以用like,比如 show table like ‘%abce%’  。

附:

show status 结果说明

含义
Name 表名
Type 表的类型 (ISAM,MyISAM或HEAP)
Row_format 行存储格式 (固定, 动态, 或压缩)
Rows 行数量
Avg_row_length 平均行长度
Data_length 数据文件的长度
Max_data_length 数据文件的最大长度
Index_length 索引文件的长度
Data_free 已分配但未使用了字节数
Auto_increment 下一个 autoincrement(自动加1)值
Create_time 表被创造的时间
Update_time 数据文件最后更新的时间
Check_time 最后对表运行一个检查的时间
Create_options CREATE TABLE一起使用的额外选项
Comment 当创造表时,使用的注释 (或为什么MySQL不能存取表信息的一些信息)。

show index 结果说明:

含义
Table 表名
Non_unique 0,如果索引不能包含重复。
Key_name 索引名
Seq_in_index 索引中的列顺序号, 从 1 开始。
Column_name 列名。
Collation 列怎样在索引中被排序。在MySQL中,这可以有值A(升序) 或NULL(不排序)。
Cardinality 索引中唯一值的数量。这可通过运行isamchk -a更改.
Sub_part 如果列只是部分被索引,索引字符的数量。NULL,如果整个键被索引。

show variables 结果说明:

Aborted_clients 由于客户没有正确关闭连接已经死掉,已经放弃的连接数量。
Aborted_connects 尝试已经失败的MySQL服务器的连接的次数。
Connections 试图连接MySQL服务器的次数。
Created_tmp_tables 当执行语句时,已经被创造了的隐含临时表的数量。
Delayed_insert_threads 正在使用的延迟插入处理器线程的数量。
Delayed_writes INSERT DELAYED写入的行数。
Delayed_errors INSERT DELAYED写入的发生某些错误(可能重复键值)的行数。
Flush_commands 执行FLUSH命令的次数。
Handler_delete 请求从一张表中删除行的次数。
Handler_read_first 请求读入表中第一行的次数。
Handler_read_key 请求数字基于键读行。
Handler_read_next 请求读入基于一个键的一行的次数。
Handler_read_rnd 请求读入基于一个固定位置的一行的次数。
Handler_update 请求更新表中一行的次数。
Handler_write 请求向表中插入一行的次数。
Key_blocks_used 用于关键字缓存的块的数量。
Key_read_requests 请求从缓存读入一个键值的次数。
Key_reads 从磁盘物理读入一个键值的次数。
Key_write_requests 请求将一个关键字块写入缓存次数。
Key_writes 将一个键值块物理写入磁盘的次数。
Max_used_connections 同时使用的连接的最大数目。
Not_flushed_key_blocks 在键缓存中已经改变但是还没被清空到磁盘上的键块。
Not_flushed_delayed_rows INSERT DELAY队列中等待写入的行的数量。
Open_tables 打开表的数量。
Open_files 打开文件的数量。
Open_streams 打开流的数量(主要用于日志记载)
Opened_tables 已经打开的表的数量。
Questions 发往服务器的查询的数量。
Slow_queries 要花超过long_query_time时间的查询数量。
Threads_connected 当前打开的连接的数量。
Threads_running 不在睡眠的线程数量。
Uptime 服务器工作了多少秒。

关于上面的一些注释:

  • 如果Opened_tables太大,那么你的table_cache变量可能太小。
  • 如果key_reads太大,那么你的key_cache可能太小。缓存命中率可以用key_reads/key_read_requests计算。
  • 如果Handler_read_rnd太大,那么你很可能有大量的查询需要MySQL扫描整个表或你有没正确使用键值的联结(join)。

mysql有以下几种日志:
错误日志:     -log-err
查询日志:     -log
慢查询日志:   -log-slow-queries
更新日志:     -log-update
二进制日志: -log-bin

是否启用了日志
mysql>show variables like ‘log_%’;

怎样知道当前的日志
mysql> show master status;

显示二进制日志数目
mysql> show master logs;

看二进制日志文件用mysqlbinlog
shell>mysqlbinlog mail-bin.000001
或者shell>mysqlbinlog mail-bin.000001 | tail

在配置文件中指定log的输出位置.
Windows:Windows 的配置文件为 my.ini,一般在 MySQL 的安装目录下或者 c:Windows 下。
Linux:Linux 的配置文件为 my.cnf ,一般在 /etc 下。

在linux下:
Sql代码

1. # 在[mysqld] 中输入
2. #log
3. log-error=/usr/local/mysql/log/error.log
4. log=/usr/local/mysql/log/mysql.log
5. long_query_time=2
6. log-slow-queries= /usr/local/mysql/log/slowquery.log

# 在[mysqld] 中输入
#log
log-error=/usr/local/mysql/log/error.log
log=/usr/local/mysql/log/mysql.log
long_query_time=2
log-slow-queries= /usr/local/mysql/log/slowquery.log

windows下:
Sql代码

1. # 在[mysqld] 中输入
2. #log
3. log-error=”E:/PROGRA~1/EASYPH~1.0B1/mysql/logs/error.log”
4. log=”E:/PROGRA~1/EASYPH~1.0B1/mysql/logs/mysql.log”
5. long_query_time=2
6. log-slow-queries= “E:/PROGRA~1/EASYPH~1.0B1/mysql/logs/slowquery.log”

# 在[mysqld] 中输入
#log
log-error=”E:/PROGRA~1/EASYPH~1.0B1/mysql/logs/error.log”
log=”E:/PROGRA~1/EASYPH~1.0B1/mysql/logs/mysql.log”
long_query_time=2
log-slow-queries= “E:/PROGRA~1/EASYPH~1.0B1/mysql/logs/slowquery.log”

开启慢查询
long_query_time =2  –是指执行超过多久的sql会被log下来,这里是2秒
log-slow-queries= /usr/local/mysql/log/slowquery.log  –将查询返回较慢的语句进行记录

log-queries-not-using-indexes = nouseindex.log  –就是字面意思,log下来没有使用索引的query

log=mylog.log  –对所有执行语句进行记录

转自http://blog.csdn.net/heiyeshuwu/archive/2006/10/14/1334224.aspx

普通MySQL运行,数据量和访问量不大的话,是足够快的,但是当数据量和访问量剧增的时候,那么就会明显发现MySQL很慢,甚至down掉,那么就要考虑优化我们的MySQL了。

优化无非是从三个角度入手:
第一个是从硬件,增加硬件,增加服务器
第二个就是对我们的MySQL服务器进行优化,增加缓存大小,开多端口,读写分开
第三个就是我们的应用优化,建立索引,优化SQL查询语句,建立缓存等等

我就简单的说说SQL查询语句的优化。因为如果我们Web服务器比数据库服 务器多或者性能优良的话,我们完全可以把数据库的压力转嫁到Web服务器上,因为如果单台MySQL,或者 Master/Slave 架构的数据库服务器都负担比较重,那么就可以考虑把MySQL的运算放到Web服务器上去进行。当然了,如果你Web服务器比数据库服务器差,那就把压力 放在数据库服务器上吧,呵呵。

如果是把MySQL服务器的压力放在Web服务器上,那么很多运算就需要我们的程序去执行,比如Web程序中全部交给PHP脚 本去处理数据。单台MySQL服务器,查询、更新、插入、删除都在一台服务器上的话,访问量一大,你会明显发现锁表现象,当对一个表进行更新删除操作的时 候,就会拒绝其他操作,这样就会导致锁表,解决这个问题最简单直接的办法就是拿两台MySQL服务器,一台负责查询(select)操作,另外一台负责更 改(update/delete/insert),然后进行同步,这样能够避免锁表,如果服务器更多,那么就更好处理了,可以采用分布式数据库架构和数据 的散列存储,下面我们会简单说一下。

一、SQL的优化和注意事项

现在我们假设我们只有一台MySQL服务器,所有的select/update/insert/delete操作都是在这上面进行的,我们同时有三台Web服务器,通过DNS轮巡来访问,那么我们如何进行我们应用程序和SQL的优化。

1. Where条件
在查询中,WHERE条件也是一个比较重要的因素,尽量少并且是合理的where条件是很重要的,在写每一个where条件的时候都要仔细考虑,尽量在多个条件的时候,把会提取尽量少数据量的条件放在前面,这样就会减少后一个where条件的查询时间。
有时候一些where条件会导致索引无效,当使用了Mysql函数的时候,索引将无效,比如:select * from tbl1 where left(name, 4) = ‘hylr’,那么这时候索引无效,还有就是使用LIKE进行搜索匹配的时候,这样的语句索引是无效的:select * from tbl1 where name like ‘%xxx%’,但是这样索引是有效的:select * from tbl1 where name like ‘xxx%’,所以谨慎的写你的SQL是很重要的。

2. 关联查询和子查询
数据库一个很重要的特点是关联查询,LEFT JOIN 和全关联,特别是多个表进行关联,因为每个关联表查询的时候,进行扫描的时候都是一个笛卡尔乘积的数量级,扫描数量很大,如果确实是需要进行关联操作,请给where或者on的条件进行索引。
关联操作也是可能交给应用去操作的,看数据量的大小,如果数据量不是非常大,比如10万条以下,那么就可以交给程序去处理(totododo提出笔误,特此修正),程序分别提取左右两个表的数据,然后进行循环的扫描处理,返回结果,这个过程同样非常耗费Web服务器的资源,那么就需要取决于你愿意把压力放在Web服务器上或者数据库服务器上了。
子查询是在mysql5中支持的功能,比如:select * from tbl1 where id in(select id from tbl1),那样效率是非常非常低,要尽量避免使用子查询,要是我,绝对不用,呵呵。

3. 一些耗费时间和资源的操作
SQL语句中一些浪费的操作,比如 DISTINCT、COUNT、GROUP BY、各种MySQL函数。这些操作都是比较耗资源的,我想应用最多的是count字句吧,如果使用count,尽量不要count(*),最好 count一个字段,比如count(id),或者count(1),(据totododo测 试效率其实是一样的),同样能够起到统计的作用。如果不是十分必要,尽量不要使用distinct操作,就是提取唯一值,你完全可以把这个操作交给脚本程 序去执行提取唯一值,减少MySQL的负担。group by 操作也是,确实需要分组的话,请谨慎的操作,如果是小批量的数据,可以考虑交给脚本程序去做。
至于MySQL的函数,估计很多常用,比如有人喜欢把截取字符串也交给MySQL去操作,或者时间转换操作,使用比较多的函数像 SUBSTR(), CONCAT(), DATE_FORMAT(), TO_DAYS(), MAX(), MIN(), MD5() 等等,这些操作完全可以交给脚本程序去做,减轻MySQL的负担。

4. 合理的建立索引
索引的提升速度的一个非常重要的手段,索引在对一些经常进行select操作,并且值比较唯一的字段是相当有效的,比如主键的id字段,唯一的名字name字段等等。
但是索引对于唯一值比较少的字段,比如性别gender字段,寥寥无几的类别字段等,意义不大,因为性别是50%的几率,索引几乎没有意义。对于update/delete/insert非常频繁的表,建立索引要慎重考虑,因为这些频繁的操作同样对于索引的维护工作量也是很大的,最后反而得不偿失,这个需要自己仔细考虑。索引同样不是越多越好,适当的索引会起到很关键的作用,不适当的索引,反而减低效率维护,增加维护索引的负担。

5. 监控sql执行效率
在select语句前面使用EXPLAIN字句能够查看当前这个select字句的执行情况,包括使用了什么操作、返回多少几率、对索引的使用情况如何等等,能够有效分析SQL语句的执行效率和合理程度。
另外使用MySQL中本身的慢查询日志:slow-log,同样能够记录查询中花费时间比较多的SQL语句,好对相应的语句进行优化和改写。
另外在MySQL终端下,使用show processlist命令能够有效的查看当前MySQL在进行的线程,包括线程的状态,是否锁表等等,可以实时的查看SQL执行情况,同时对一些锁表操作进行优化。

二、数据库服务器的架构和分布想法

对于服务器的架构设计,这个其实是比较重要的,一个合理的设计,能够让应用更好的运行。当然,架构的设计,取决于你的应用和你硬件的实际情况。我就简单的说说几种不同的数据库架构设计方式,权当是一个个人的想法,希望能够有帮助。

1. 单台服务器开多进程和端口
单台MySQL服务器,如果使用长链接等等都无法解决负载太大,连接太多的问题,不凡考虑采用一台MySQL上使用多个端口开启多个MySQL守护进程的方法来缓解压力。当然,前提是你的应用必须支持多端口,并且你的cpu和内存足够运行多个守护进程。
优点 是能够很好的缓解暂时服务器的压力,把不同的操作放在不同的端口,或者把不同的项目模块放在不同的端口去操作,良好的分担单个守护进程的压力。
缺点 是数据可能会产生紊乱,同时可能会导致很多未知的莫名错误。呵呵

2. 使用Master/Slave的服务器结构
Mysql本身具有同步功能,完全可以利用这个功能。构建 Master/Slave 的主从服务器结构,最少只需要两台MySQL服务器,我们可以把 Master 服务器用户更新操作,包括 update/delete/insert,把Slave服务器用于查询操作,包括 select 操作,然后两机进行同步。
优点 是合理的把更新和查询的压力分担,并且能够避免锁表的问题。
缺点 是更新部实时,如果网络繁忙,可能会存在延迟的问题,并且任何一台服务器down掉了都很麻烦。

3. 使用分布式的散列存储
这种结构适合大数据量,并且负载比较大,然后服务器比较充足的情况。分布式存储结构,简单的可以是多台服务器,每台服务器功能是类似的,但是存储的数据不 一样,比如做一个用户系统,那么把用户ID在1-10万以内的存储在A服务器,用户ID在10-20万存储在B服务器,20-3-万存储在C服务器,以此 类推。如果每个用户访问的服务器不足,可以构建组服务器,就是每组用户拥有多台服务器,比如可以在某用户组建立两台MySQL服务器,一台Master, 一台Slave,同样分离他们的更新和查询操作,或者可以设计成双向同步。同时,你的应用程序必须支持跨数据库和跨服务器的操作能力。
优点 是服务器的负载合理的被平摊,每台服务器都是负责一部分用户,如果一台服务器down掉了,不会影响其他用户ID的用户正常访问。同时添加节点比较容易,如果又增加了10万用户,那么又可以增加一个节点服务器,升级很方便。
缺点 是任何一台数据库服务器down掉或者数据丢失,那么这部分服务器的用户将很郁闷,数据都没了,当然,这个需要良好的备份机制。

在MYSQL数据库查询时,排序是经常用到的一个功能。单纯按照某字段排序查询较为简单,无非就是order by `field` (DESC/ASC)。如:


SELECT * FROM `table`
ORDER BY `field` DESC

注:上面的table换成要查询的表名,field换成要排序的字段名,DESC表示从大到小,去掉则从小到大。

下面介绍几个复杂一点的应用:

自定义排序

需求:查询table表,取出id为1,5,9,7的记录,并按1597的顺序显示.

解决


SELECT * FROM `table`
WHERE id in(1,5,7,9)
ORDER BY FIELD(`id`,1,5,9,7) //注意FIELD后面无空格

文章置顶

需求一:查询文章表table,取出所有文章,但字段zj为1的记录置顶(均以time字段排序,time大的放在前面)。

解决一


SELECT * FROM `table`
ORDER BY `zj` DESC,`time` DESC

解决二


SELECT * FROM `table`
WHERE zj=1
ORDER BY `time` DESC
UNION
SELECT * FROM `table`
WHERE zj!=1
ORDER BY `time` DESC

需求二:查询文章表table,取出所有文章,置顶ID为1、5、12、2的文章,并按上述顺序显示。

解决


SELECT * FROM `table`
ORDER BY FIELD(`zj`,1,5,12,2) DESC,`time` DESC

字符串函数ASCII(str)
 返回字符串str的第一个字符的ASCII值(str是空串时返回0)
mysql> select ASCII(‘2’);
  -> 50
mysql> select ASCII(2);
  -> 50
mysql> select ASCII(‘dete’);
  -> 100

ORD(str)
 如果字符串str句首是单字节返回与ASCII()函数返回的相同值。
 如果是一个多字节字符,以格式返回((first byte ASCII code)*256+(second byte ASCII code))[*256+third byte ASCII code…]
mysql> select ORD(‘2’);
  -> 50
 
CONV(N,from_base,to_base)
 对数字N进制转换,并转换为字串返回(任何参数为NULL时返回NULL,进制范围为2-36进制,当to_base是负数时N作为有符号数否则作无符号数,CONV以64位点精度工作)
mysql> select CONV(“a”,16,2);
  -> ‘1010’
mysql> select CONV(“6E”,18,8);
  -> ‘172’
mysql> select CONV(-17,10,-18);
  -> ‘-H’
mysql> select CONV(10+”10″+’10’+0xa,10,10);
  -> ’40’
 
BIN(N)
 把N转为二进制值并以字串返回(N是BIGINT数字,等价于CONV(N,10,2))
mysql> select BIN(12);
  -> ‘1100’

OCT(N)
 把N转为八进制值并以字串返回(N是BIGINT数字,等价于CONV(N,10,8))
mysql> select OCT(12);
  -> ’14’
 
HEX(N)
 把N转为十六进制并以字串返回(N是BIGINT数字,等价于CONV(N,10,16))
mysql> select HEX(255);
  -> ‘FF’
 
CHAR(N,…)
 返回由参数N,…对应的ASCII代码字符组成的一个字串(参数是N,…是数字序列,NULL值被跳过)
mysql> select CHAR(77,121,83,81,’76’);
  -> ‘MySQL’
mysql> select CHAR(77,77.3,’77.3′);
  -> ‘MMM’
 
CONCAT(str1,str2,…)
 把参数连成一个长字符串并返回(任何参数是NULL时返回NULL)
mysql> select CONCAT(‘My’, ‘S’, ‘QL’);
  -> ‘MySQL’
mysql> select CONCAT(‘My’, NULL, ‘QL’);
  -> NULL
mysql> select CONCAT(14.3);
  -> ‘14.3’

LENGTH(str)
OCTET_LENGTH(str)
CHAR_LENGTH(str)
CHARACTER_LENGTH(str)
 返回字符串str的长度(对于多字节字符CHAR_LENGTH仅计算一次)
mysql> select LENGTH(‘text’);
  -> 4
mysql> select OCTET_LENGTH(‘text’);
  -> 4

LOCATE(substr,str)
POSITION(substr IN str)
 返回字符串substr在字符串str第一次出现的位置(str不包含substr时返回0)
mysql> select LOCATE(‘bar’, ‘foobarbar’);
  -> 4
mysql> select LOCATE(‘xbar’, ‘foobar’);
  -> 0
 
LOCATE(substr,str,pos)
 返回字符串substr在字符串str的第pos个位置起第一次出现的位置(str不包含substr时返回0)
mysql> select LOCATE(‘bar’, ‘foobarbar’,5);
  -> 7

INSTR(str,substr)
 返回字符串substr在字符串str第一次出现的位置(str不包含substr时返回0)
mysql> select INSTR(‘foobarbar’, ‘bar’);
  -> 4
mysql> select INSTR(‘xbar’, ‘foobar’);
  -> 0

LPAD(str,len,padstr)
 用字符串padstr填补str左端直到字串长度为len并返回
mysql> select LPAD(‘hi’,4,’??’);
  -> ‘??hi’
 
RPAD(str,len,padstr)
 用字符串padstr填补str右端直到字串长度为len并返回
mysql> select RPAD(‘hi’,5,’?’);
  -> ‘hi???’

LEFT(str,len)
 返回字符串str的左端len个字符
mysql> select LEFT(‘foobarbar’, 5);
  -> ‘fooba’

RIGHT(str,len)
 返回字符串str的右端len个字符
mysql> select RIGHT(‘foobarbar’, 4);
  -> ‘rbar’

SUBSTRING(str,pos,len)
SUBSTRING(str FROM pos FOR len)
MID(str,pos,len)
 返回字符串str的位置pos起len个字符(使用FROM的丑陋语法是ANSI SQL92标准)
mysql> select SUBSTRING(‘Quadratically’,5,6);
  -> ‘ratica’

SUBSTRING(str,pos)
SUBSTRING(str FROM pos)
 返回字符串str的位置pos起的一个子串
mysql> select SUBSTRING(‘Quadratically’,5);
  -> ‘ratically’
mysql> select SUBSTRING(‘foobarbar’ FROM 4);
  -> ‘barbar’

SUBSTRING_INDEX(str,delim,count)
 返回从字符串str的第count个出现的分隔符delim之后的子串(count为正数时返回左端,否则返回右端子串)
mysql> select SUBSTRING_INDEX(‘www.mysql.com’, ‘.’, 2);
  -> ‘www.mysql’
mysql> select SUBSTRING_INDEX(‘www.mysql.com’, ‘.’, -2);
  -> ‘mysql.com’

LTRIM(str)
 返回删除了左空格的字符串str
mysql> select LTRIM(‘  barbar’);
  -> ‘barbar’

RTRIM(str)
 返回删除了右空格的字符串str
mysql> select RTRIM(‘barbar   ‘);
  -> ‘barbar’

TRIM([[BOTH | LEADING | TRAILING] [remstr] FROM] str)
 返回前缀或后缀remstr被删除了的字符串str(位置参数默认BOTH,remstr默认值为空格)
mysql> select TRIM(‘  bar   ‘);
  -> ‘bar’
mysql> select TRIM(LEADING ‘x’ FROM ‘xxxbarxxx’);
  -> ‘barxxx’
mysql> select TRIM(BOTH ‘x’ FROM ‘xxxbarxxx’);
  -> ‘bar’
mysql> select TRIM(TRAILING ‘xyz’ FROM ‘barxxyz’);
  -> ‘barx’

SOUNDEX(str)
 返回str的一个同音字符串(听起来“大致相同”字符串有相同的同音字符串,非数字字母字符被忽略,在A-Z外的字母被当作元音)
mysql> select SOUNDEX(‘Hello’);
  -> ‘H400’
mysql> select SOUNDEX(‘Quadratically’);
  -> ‘Q36324’
 
SPACE(N)
 返回由N个空格字符组成的一个字符串
mysql> select SPACE(6);
  -> ‘      ‘
 
REPLACE(str,from_str,to_str)
 用字符串to_str替换字符串str中的子串from_str并返回
mysql> select REPLACE(‘www.mysql.com’, ‘w’, ‘Ww’);
  -> ‘WwWwWw.mysql.com’

REPEAT(str,count)
 返回由count个字符串str连成的一个字符串(任何参数为NULL时返回NULL,count<=0时返回一个空字符串)
mysql> select REPEAT(‘MySQL’, 3);
  -> ‘MySQLMySQLMySQL’
 
REVERSE(str)
 颠倒字符串str的字符顺序并返回
mysql> select REVERSE(‘abc’);
  -> ‘cba’

INSERT(str,pos,len,newstr)
 把字符串str由位置pos起len个字符长的子串替换为字符串newstr并返回
mysql> select INSERT(‘Quadratic’, 3, 4, ‘What’);
  -> ‘QuWhattic’

ELT(N,str1,str2,str3,…)
 返回第N个字符串(N小于1或大于参数个数返回NULL)
mysql> select ELT(1, ‘ej’, ‘Heja’, ‘hej’, ‘foo’);
  -> ‘ej’
mysql> select ELT(4, ‘ej’, ‘Heja’, ‘hej’, ‘foo’);
  -> ‘foo’

FIELD(str,str1,str2,str3,…)
 返回str等于其后的第N个字符串的序号(如果str没找到返回0)
mysql> select FIELD(‘ej’, ‘Hej’, ‘ej’, ‘Heja’, ‘hej’, ‘foo’);
  -> 2
mysql> select FIELD(‘fo’, ‘Hej’, ‘ej’, ‘Heja’, ‘hej’, ‘foo’);
  -> 0

FIND_IN_SET(str,strlist)
 返回str在字符串集strlist中的序号(任何参数是NULL则返回NULL,如果str没找到返回0,参数1包含”,”时工作异常)
mysql> SELECT FIND_IN_SET(‘b’,’a,b,c,d’);
  -> 2
 
MAKE_SET(bits,str1,str2,…)
 把参数1的数字转为二进制,假如某个位置的二进制位等于1,对应位置的字串选入字串集并返回(NULL串不添加到结果中)
mysql> SELECT MAKE_SET(1,’a’,’b’,’c’);
  -> ‘a’
mysql> SELECT MAKE_SET(1 | 4,’hello’,’nice’,’world’);
  -> ‘hello,world’
mysql> SELECT MAKE_SET(0,’a’,’b’,’c’);
  -> ”

EXPORT_SET(bits,on,off,[separator,[number_of_bits]])
 按bits排列字符串集,只有当位等于1时插入字串on,否则插入off(separator默认值”,”,number_of_bits参数使用时长度不足补0而过长截断)
mysql> select EXPORT_SET(5,’Y’,’N’,’,’,4)
  -> Y,N,Y,N

LCASE(str)
LOWER(str)
 返回小写的字符串str
mysql> select LCASE(‘QUADRATICALLY’);
  -> ‘quadratically’
 
UCASE(str)
UPPER(str)
 返回大写的字符串str
mysql> select UCASE(‘quadratically’);
  -> ‘QUADRATICALLY’

LOAD_FILE(file_name)
 读入文件并且作为一个字符串返回文件内容(文件无法找到,路径不完整,没有权限,长度大于max_allowed_packet会返回NULL)
mysql> UPDATE table_name SET blob_column=LOAD_FILE(“/tmp/picture”) WHERE id=1;

 

数学函数

ABS(N)
 返回N的绝对值
mysql> select ABS(2); 
  -> 2 
mysql> select ABS(-32); 
  -> 32 
 
SIGN(N)
 返回参数的符号(为-1、0或1)
mysql> select SIGN(-32); 
  -> -1 
mysql> select SIGN(0); 
  -> 0 
mysql> select SIGN(234); 
  -> 1 

MOD(N,M) 
 取模运算,返回N被M除的余数(同%操作符) 
mysql> select MOD(234, 10); 
  -> 4 
mysql> select 234 % 10; 
  -> 4 
mysql> select MOD(29,9); 
  -> 2 

FLOOR(N)
 返回不大于N的最大整数值
mysql> select FLOOR(1.23); 
  -> 1 
mysql> select FLOOR(-1.23); 
  -> -2 

CEILING(N)
 返回不小于N的最小整数值
mysql> select CEILING(1.23); 
  -> 2 
mysql> select CEILING(-1.23); 
  -> -1 

ROUND(N,D)
 返回N的四舍五入值,保留D位小数(D的默认值为0)
mysql> select ROUND(-1.23); 
  -> -1 
mysql> select ROUND(-1.58); 
  -> -2 
mysql> select ROUND(1.58); 
  -> 2 
mysql> select ROUND(1.298, 1); 
  -> 1.3 
mysql> select ROUND(1.298, 0); 
  -> 1 

EXP(N)
 返回值e的N次方(自然对数的底)
mysql> select EXP(2); 
  -> 7.389056 
mysql> select EXP(-2); 
  -> 0.135335 

LOG(N)
 返回N的自然对数
mysql> select LOG(2); 
  -> 0.693147 
mysql> select LOG(-2); 
  -> NULL 

LOG10(N)
 返回N以10为底的对数
mysql> select LOG10(2); 
  -> 0.301030 
mysql> select LOG10(100); 
  -> 2.000000 
mysql> select LOG10(-100); 
  -> NULL 

POW(X,Y) 
POWER(X,Y) 
 返回值X的Y次幂
mysql> select POW(2,2); 
  -> 4.000000 
mysql> select POW(2,-2); 
  -> 0.250000

SQRT(N)
 返回非负数N的平方根
mysql> select SQRT(4); 
  -> 2.000000 
mysql> select SQRT(20); 
  -> 4.472136 

PI() 
 返回圆周率
mysql> select PI(); 
  -> 3.141593 

COS(N)
 返回N的余弦值
mysql> select COS(PI());
  -> -1.000000 

SIN(N)
 返回N的正弦值
mysql> select SIN(PI()); 
  -> 0.000000 

TAN(N)
 返回N的正切值
mysql> select TAN(PI()+1); 
  -> 1.557408 

ACOS(N)
 返回N反余弦(N是余弦值,在-1到1的范围,否则返回NULL)
mysql> select ACOS(1); 
  -> 0.000000 
mysql> select ACOS(1.0001); 
  -> NULL 
mysql> select ACOS(0); 
  -> 1.570796 

ASIN(N)
 返回N反正弦值
mysql> select ASIN(0.2); 
  -> 0.201358 
mysql> select ASIN(‘foo’); 
  -> 0.000000 

ATAN(N)
 返回N的反正切值
mysql> select ATAN(2); 
  -> 1.107149 
mysql> select ATAN(-2); 
  -> -1.107149 
ATAN2(X,Y) 
 返回2个变量X和Y的反正切(类似Y/X的反正切,符号决定象限)
mysql> select ATAN(-2,2); 
  -> -0.785398 
mysql> select ATAN(PI(),0); 
  -> 1.570796 

COT(N)
 返回X的余切
mysql> select COT(12); 
  -> -1.57267341 
mysql> select COT(0); 
  -> NULL 

RAND()
RAND(N) 
 返回在范围0到1.0内的随机浮点值(可以使用数字N作为初始值)
mysql> select RAND(); 
  -> 0.5925 
mysql> select RAND(20); 
  -> 0.1811 
mysql> select RAND(20); 
  -> 0.1811 
mysql> select RAND(); 
  -> 0.2079 
mysql> select RAND(); 
  -> 0.7888 

DEGREES(N)
 把N从弧度变换为角度并返回
mysql> select DEGREES(PI()); 
  -> 180.000000 

RADIANS(N)
 把N从角度变换为弧度并返回
mysql> select RADIANS(90); 
  -> 1.570796 

TRUNCATE(N,D) 
 保留数字N的D位小数并返回
mysql> select TRUNCATE(1.223,1); 
  -> 1.2 
mysql> select TRUNCATE(1.999,1); 
  -> 1.9 
mysql> select TRUNCATE(1.999,0); 
  -> 1 

LEAST(X,Y,…) 
 返回最小值(如果返回值被用在整数(实数或大小敏感字串)上下文或所有参数都是整数(实数或大小敏感字串)则他们作为整数(实数或大小敏感字串)比较,否则按忽略大小写的字符串被比较)
mysql> select LEAST(2,0); 
  -> 0 
mysql> select LEAST(34.0,3.0,5.0,767.0); 
  -> 3.0 
mysql> select LEAST(“B”,”A”,”C”); 
  -> “A” 

GREATEST(X,Y,…) 
 返回最大值(其余同LEAST())
mysql> select GREATEST(2,0); 
  -> 2 
mysql> select GREATEST(34.0,3.0,5.0,767.0); 
  -> 767.0 
mysql> select GREATEST(“B”,”A”,”C”); 
  -> “C” 

 

时期时间函数

DAYOFWEEK(date) 
 返回日期date是星期几(1=星期天,2=星期一,……7=星期六,ODBC标准)
mysql> select DAYOFWEEK(‘1998-02-03’); 
  -> 3 

WEEKDAY(date) 
 返回日期date是星期几(0=星期一,1=星期二,……6= 星期天)。 
mysql> select WEEKDAY(‘1997-10-04 22:23:00’); 
  -> 5 
mysql> select WEEKDAY(‘1997-11-05’); 
  -> 2 

DAYOFMONTH(date) 
 返回date是一月中的第几日(在1到31范围内) 
mysql> select DAYOFMONTH(‘1998-02-03’); 
  -> 3 

DAYOFYEAR(date) 
 返回date是一年中的第几日(在1到366范围内) 
mysql> select DAYOFYEAR(‘1998-02-03’); 
  -> 34 

MONTH(date) 
 返回date中的月份数值 
mysql> select MONTH(‘1998-02-03’); 
  -> 2 

DAYNAME(date) 
 返回date是星期几(按英文名返回)
mysql> select DAYNAME(“1998-02-05”); 
  -> ‘Thursday’ 

MONTHNAME(date) 
 返回date是几月(按英文名返回)
mysql> select MONTHNAME(“1998-02-05”); 
  -> ‘February’ 

QUARTER(date) 
 返回date是一年的第几个季度 
mysql> select QUARTER(’98-04-01′); 
  -> 2 

WEEK(date,first)
 返回date是一年的第几周(first默认值0,first取值1表示周一是周的开始,0从周日开始)
mysql> select WEEK(‘1998-02-20’); 
  -> 7 
mysql> select WEEK(‘1998-02-20’,0); 
  -> 7 
mysql> select WEEK(‘1998-02-20′,1); 
  -> 8 

YEAR(date) 
 返回date的年份(范围在1000到9999) 
mysql> select YEAR(’98-02-03′); 
  -> 1998 

HOUR(time) 
 返回time的小时数(范围是0到23)
mysql> select HOUR(’10:05:03′); 
  -> 10 

MINUTE(time) 
 返回time的分钟数(范围是0到59) 
mysql> select MINUTE(’98-02-03 10:05:03′); 
  -> 5 

SECOND(time) 
 返回time的秒数(范围是0到59)
mysql> select SECOND(’10:05:03’); 
  -> 3 

PERIOD_ADD(P,N) 
 增加N个月到时期P并返回(P的格式YYMM或YYYYMM) 
mysql> select PERIOD_ADD(9801,2); 
  -> 199803 

PERIOD_DIFF(P1,P2) 
 返回在时期P1和P2之间月数(P1和P2的格式YYMM或YYYYMM)
mysql> select PERIOD_DIFF(9802,199703); 
  -> 11 

DATE_ADD(date,INTERVAL expr type)
DATE_SUB(date,INTERVAL expr type) 
ADDDATE(date,INTERVAL expr type) 
SUBDATE(date,INTERVAL expr type)
 对日期时间进行加减法运算
 (ADDDATE()和SUBDATE()是DATE_ADD()和DATE_SUB()的同义词,也可以用运算符+和-而不是函数
 date是一个DATETIME或DATE值,expr对date进行加减法的一个表达式字符串type指明表达式expr应该如何被解释
 [type值 含义 期望的expr格式]:
 SECOND 秒 SECONDS 
 MINUTE 分钟 MINUTES 
 HOUR 时间 HOURS 
 DAY 天 DAYS 
 MONTH 月 MONTHS 
 YEAR 年 YEARS 
 MINUTE_SECOND 分钟和秒 “MINUTES:SECONDS” 
 HOUR_MINUTE 小时和分钟 “HOURS:MINUTES” 
 DAY_HOUR 天和小时 “DAYS HOURS” 
 YEAR_MONTH 年和月 “YEARS-MONTHS” 
 HOUR_SECOND 小时, 分钟, “HOURS:MINUTES:SECONDS” 
 DAY_MINUTE 天, 小时, 分钟 “DAYS HOURS:MINUTES” 
 DAY_SECOND 天, 小时, 分钟, 秒 “DAYS HOURS:MINUTES:SECONDS”
 expr中允许任何标点做分隔符,如果所有是DATE值时结果是一个DATE值,否则结果是一个DATETIME值)
 如果type关键词不完整,则MySQL从右端取值,DAY_SECOND因为缺少小时分钟等于MINUTE_SECOND)
 如果增加MONTH、YEAR_MONTH或YEAR,天数大于结果月份的最大天数则使用最大天数) 
mysql> SELECT “1997-12-31 23:59:59” + INTERVAL 1 SECOND; 
  -> 1998-01-01 00:00:00 
mysql> SELECT INTERVAL 1 DAY + “1997-12-31”; 
  -> 1998-01-01 
mysql> SELECT “1998-01-01” – INTERVAL 1 SECOND; 
  -> 1997-12-31 23:59:59 
mysql> SELECT DATE_ADD(“1997-12-31 23:59:59”,INTERVAL 1 SECOND); 
  -> 1998-01-01 00:00:00 
mysql> SELECT DATE_ADD(“1997-12-31 23:59:59”,INTERVAL 1 DAY); 
  -> 1998-01-01 23:59:59 
mysql> SELECT DATE_ADD(“1997-12-31 23:59:59”,INTERVAL “1:1” MINUTE_SECOND); 
  -> 1998-01-01 00:01:00 
mysql> SELECT DATE_SUB(“1998-01-01 00:00:00”,INTERVAL “1 1:1:1” DAY_SECOND); 
  -> 1997-12-30 22:58:59 
mysql> SELECT DATE_ADD(“1998-01-01 00:00:00”, INTERVAL “-1 10” DAY_HOUR);
  -> 1997-12-30 14:00:00 
mysql> SELECT DATE_SUB(“1998-01-02”, INTERVAL 31 DAY); 
  -> 1997-12-02 
mysql> SELECT EXTRACT(YEAR FROM “1999-07-02”); 
  -> 1999 
mysql> SELECT EXTRACT(YEAR_MONTH FROM “1999-07-02 01:02:03”); 
  -> 199907 
mysql> SELECT EXTRACT(DAY_MINUTE FROM “1999-07-02 01:02:03”); 
  -> 20102 

TO_DAYS(date) 
 返回日期date是西元0年至今多少天(不计算1582年以前)
mysql> select TO_DAYS(950501); 
  -> 728779 
mysql> select TO_DAYS(‘1997-10-07’); 
  -> 729669 

FROM_DAYS(N) 
 给出西元0年至今多少天返回DATE值(不计算1582年以前)
mysql> select FROM_DAYS(729669); 
  -> ‘1997-10-07’ 

DATE_FORMAT(date,format) 
 根据format字符串格式化date值
 (在format字符串中可用标志符:
 %M 月名字(January……December) 
 %W 星期名字(Sunday……Saturday) 
 %D 有英语前缀的月份的日期(1st, 2nd, 3rd, 等等。) 
 %Y 年, 数字, 4 位 
 %y 年, 数字, 2 位 
 %a 缩写的星期名字(Sun……Sat) 
 %d 月份中的天数, 数字(00……31) 
 %e 月份中的天数, 数字(0……31) 
 %m 月, 数字(01……12) 
 %c 月, 数字(1……12) 
 %b 缩写的月份名字(Jan……Dec) 
 %j 一年中的天数(001……366) 
 %H 小时(00……23) 
 %k 小时(0……23) 
 %h 小时(01……12) 
 %I 小时(01……12) 
 %l 小时(1……12) 
 %i 分钟, 数字(00……59) 
 %r 时间,12 小时(hh:mm:ss [AP]M) 
 %T 时间,24 小时(hh:mm:ss) 
 %S 秒(00……59) 
 %s 秒(00……59) 
 %p AM或PM 
 %w 一个星期中的天数(0=Sunday ……6=Saturday ) 
 %U 星期(0……52), 这里星期天是星期的第一天 
 %u 星期(0……52), 这里星期一是星期的第一天 
 %% 字符% )
mysql> select DATE_FORMAT(‘1997-10-04 22:23:00′,’%W %M %Y’); 
  -> ‘Saturday October 1997’ 
mysql> select DATE_FORMAT(‘1997-10-04 22:23:00′,’%H:%i:%s’); 
  -> ’22:23:00′ 
mysql> select DATE_FORMAT(‘1997-10-04 22:23:00′,’%D %y %a %d %m %b %j’); 
  -> ‘4th 97 Sat 04 10 Oct 277’ 
mysql> select DATE_FORMAT(‘1997-10-04 22:23:00′,’%H %k %I %r %T %S %w’); 
  -> ’22 22 10 10:23:00 PM 22:23:00 00 6′ 

TIME_FORMAT(time,format)
 和DATE_FORMAT()类似,但TIME_FORMAT只处理小时、分钟和秒(其余符号产生一个NULL值或0)

CURDATE()  
CURRENT_DATE()
 以’YYYY-MM-DD’或YYYYMMDD格式返回当前日期值(根据返回值所处上下文是字符串或数字) 
mysql> select CURDATE(); 
  -> ‘1997-12-15′ 
mysql> select CURDATE() + 0; 
  -> 19971215 

CURTIME() 
CURRENT_TIME()
 以’HH:MM:SS’或HHMMSS格式返回当前时间值(根据返回值所处上下文是字符串或数字)   
mysql> select CURTIME(); 
  -> ’23:50:26’ 
mysql> select CURTIME() + 0; 
  -> 235026 

NOW() 
SYSDATE() 
CURRENT_TIMESTAMP()
 以’YYYY-MM-DD HH:MM:SS’或YYYYMMDDHHMMSS格式返回当前日期时间(根据返回值所处上下文是字符串或数字)  
mysql> select NOW(); 
  -> ‘1997-12-15 23:50:26’ 
mysql> select NOW() + 0; 
  -> 19971215235026 

UNIX_TIMESTAMP() 
UNIX_TIMESTAMP(date) 
 返回一个Unix时间戳(从’1970-01-01 00:00:00’GMT开始的秒数,date默认值为当前时间)
mysql> select UNIX_TIMESTAMP(); 
  -> 882226357 
mysql> select UNIX_TIMESTAMP(‘1997-10-04 22:23:00’); 
  -> 875996580 

FROM_UNIXTIME(unix_timestamp) 
 以’YYYY-MM-DD HH:MM:SS’或YYYYMMDDHHMMSS格式返回时间戳的值(根据返回值所处上下文是字符串或数字)  
mysql> select FROM_UNIXTIME(875996580); 
  -> ‘1997-10-04 22:23:00′ 
mysql> select FROM_UNIXTIME(875996580) + 0; 
  -> 19971004222300 

FROM_UNIXTIME(unix_timestamp,format) 
 以format字符串格式返回时间戳的值
mysql> select FROM_UNIXTIME(UNIX_TIMESTAMP(),’%Y %D %M %h:%i:%s %x’); 
  -> ‘1997 23rd December 03:43:30 x’ 

SEC_TO_TIME(seconds) 
 以’HH:MM:SS’或HHMMSS格式返回秒数转成的TIME值(根据返回值所处上下文是字符串或数字)  
mysql> select SEC_TO_TIME(2378); 
  -> ’00:39:38′ 
mysql> select SEC_TO_TIME(2378) + 0; 
  -> 3938 

TIME_TO_SEC(time) 
 返回time值有多少秒 
mysql> select TIME_TO_SEC(’22:23:00′); 
  -> 80580 
mysql> select TIME_TO_SEC(’00:39:38′); 
  -> 2378