CentOS6.x使用YUM安装配置LNMP运行环境

一、Nginx
# cd /tmp
# wget http://nginx.org/packages/centos/6/noarch/RPMS/nginx-release-centos-6-0.el6.ngx.noarch.rpm
# rpm -ivh nginx-release-centos-6-0.el6.ngx.noarch.rpm
# yum install nginx

站点配置样本:
server {
listen 80;
server_name localhost;
root /usr/share/nginx/html;
index index.html index.php;

error_page 404 /404.html;
error_page 500 502 503 504 /50x.html;

location ~ \.php$ {
fastcgi_pass 127.0.0.1:9000;
fastcgi_index index.php;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
fastcgi_param PHP_ADMIN_VALUE open_basedir=$document_root/;
include fastcgi_params;
}
location ~ .*\.(gif|jpg|jpeg|png|bmp|swf)$ {
expires 30d;
}
location ~ .*\.(js|css)?$ {
expires 12h;
}
#access_log /var/log/nginx/log/host.access.log main;
}

默认安装目录: /etc/nginx/
默认SSL和虚拟主机配置目录: /etc/nginx/conf.d/
默认日志保存目录: /var/log/nginx/
默认网站文件目录: /usr/share/nginx/html
默认配置文件: /etc/nginx/nginx.conf
默认访问日志文件: /var/log/nginx/access.log
默认错误日志文件: /var/log/nginx/error.log

二、MYSQL
# yum install mysql mysql-server
# chkconfig mysqld on
# service mysqld start
# mysqladmin -u root password 'your-password'

配置文件路径:/etc/my.cnf
数据库路径:/var/lib/mysql

三、PHP
# yum install php-common php-fpm php-cli php-pdo php-mysql php-mcrypt php-mbstring php-gd php-tidy php-xml php-xmlrpc php-pear php-pecl-memcache php-eaccelerator
# chown nginx:nginx /etc/php-fpm.conf
# mkdir /var/lib/php/session
# chown -R nginx:nginx /var/lib/php/session
# chkconfig php-fpm on
# service php-fpm start

配置文件路径:/etc/php.ini
扩展模块路径:/usr/lib64/php/modules

MySQL LIMIT语句优化

MYSQL的优化是非常重要的。其他最常用也最需要优化的就是limit。mysql的limit给分页带来了极大的方便,但数据量一大的时候,limit的性能就急剧下降。
同样是取10条数据

select * from yanxue8_visit limit 10000,10

select * from yanxue8_visit limit 0,10
就不是一个数量级别的。

网上也很多关于limit的五条优化准则,都是翻译自mysql手册,虽然正确但不实用。今天发现一篇文章写了些关于limit优化的,很不错。

文中不是直接使用limit,而是首先获取到offset的id然后直接使用limit size来获取数据。根据他的数据,明显要好于直接使用limit。这里我具体使用数据分两种情况进行测试。(测试环境win2033+p4双核 (3GHZ) +4G内存 mysql 5.0.19)

1、offset比较小的时候。

select * from yanxue8_visit limit 10,10
多次运行,时间保持在0.0004-0.0005之间

Select * From yanxue8_visit Where vid >=(
Select vid From yanxue8_visit Order By vid limit 10,1
) limit 10
多次运行,时间保持在0.0005-0.0006之间,主要是0.0006
结论:偏移offset较小的时候,直接使用limit较优。这个显然是子查询的原因。

2、offset大的时候。

select * from yanxue8_visit limit 10000,10
多次运行,时间保持在0.0187左右

Select * From yanxue8_visit Where vid >=(
Select vid From yanxue8_visit Order By vid limit 10000,1
) limit 10

多次运行,时间保持在0.0061左右,只有前者的1/3。可以预计offset越大,后者越优。

附上原文:

select * from table LIMIT 5,10; #返回第6-15行数据
select * from table LIMIT 5; #返回前5行
select * from table LIMIT 0,5; #返回前5行

性能优化:

基于MySQL5.0中limit的高性能,我对数据分页也重新有了新的认识.

1.
Select * From cyclopedia Where ID>=(
Select Max(ID) From (
Select ID From cyclopedia Order By ID limit 90001
) As tmp
) limit 100;

2.
Select * From cyclopedia Where ID>=(
Select Max(ID) From (
Select ID From cyclopedia Order By ID limit 90000,1
) As tmp
) limit 100;

同样是取90000条后100条记录,第1句快还是第2句快?
第1句是先取了前90001条记录,取其中最大一个ID值作为起始标识,然后利用它可以快速定位下100条记录
第2句择是仅仅取90000条记录后1条,然后取ID值作起始标识定位下100条记录
第1句执行结果.100 rows in set (0.23) sec
第2句执行结果.100 rows in set (0.19) sec

很明显第2句胜出.看来limit好像并不完全像我之前想象的那样做全表扫描返回limit offset+length条记录,这样看来limit比起MS-SQL的Top性能还是要提高不少的.

其实第2句完全可以简化成

Select * From cyclopedia Where ID>=(
Select ID From cyclopedia limit 90000,1
)limit 100;

直接利用第90000条记录的ID,不用经过Max运算,这样做理论上效率因该高一些,但在实际使用中几乎看不到效果,因为本身定位ID返回的就是1条记录,Max几乎不用运作就能得到结果,但这样写更清淅明朗,省去了画蛇那一足.

可是,既然MySQL有limit可以直接控制取出记录的位置,为什么不干脆用Select * From cyclopedia limit 90000,1呢?岂不更简洁?
这样想就错了,试了就知道,结果是:1 row in set (8.88) sec,怎么样,够吓人的吧,让我想起了昨天在4.1中比这还有过之的”高分”.Select * 最好不要随便用,要本着用什么,选什么的原则, Select的字段越多,字段数据量越大,速度就越慢. 上面2种分页方式哪种都比单写这1句强多了,虽然看起来好像查询的次数更多一些,但实际上是以较小的代价换取了高效的性能,是非常值得的.

第1种方案同样可用于MS-SQL,而且可能是最好的.因为靠主键ID来定位起始段总是最快的.

Select Top 100 * From cyclopedia Where ID>=(
Select Top 90001 Max(ID) From (
Select ID From cyclopedia Order By ID
) As tmp
)

但不管是实现方式是存贮过程还是直接代码中,瓶颈始终在于MS-SQL的TOP总是要返回前N个记录,这种情况在数据量不大时感受不深,但如果成百上千万,效率肯定会低下的.相比之下MySQL的limit就有优势的多,执行:
Select ID From cyclopedia limit 90000
Select ID From cyclopedia limit 90000,1
的结果分别是:
90000 rows in set (0.36) sec
1 row in set (0.06) sec
而MS-SQL只能用Select Top 90000 ID From cyclopedia 执行时间是390ms,执行同样的操作时间也不及MySQL的360ms.

个人测试分析:

这个例子非常经典,但个人感觉说明不详细,经分析,总结如下(其中,id为主键):
主要值得注意的有好几项:

第一:
SELECT * FROM tbl_name LIMIT 1000000,10
SELECT id FROM tbl_name LIMIT 1000000,10
第一条SQL没有能使用主键进行索引,而第二条则使用了,经测试,使用主键进行索引反而变慢,前者大约快一倍。
如果把第二条改为:
SELECT id FROM tbl_name IGNORE INDEX(primary) LIMIT 1000000,10

速度就一样了,因此,估计是因为多了对索引文件(这里是主键)的相关操作.不使用的话,就直接对主表进行扫描就行。

第二:
在第一点的基础上,加上ORDER BY,情况就完全不同了:
SELECT * FROM tbl_name ORDER BY id DESC LIMIT 1000000,10
SELECT id FROM tbl_name ORDER BY id DESC LIMIT 1000000,10
由于第二条SQL使用了索引,ORDER BY就能使用该索引,效果明显,前者需要5秒多,后者只要 0.6秒多点

第三:
这里解释一下引文中的例子:
Select * From cyclopedia Where ID>=(
Select Max(ID) From (
Select ID From cyclopedia Order By ID limit 90000,1
) As tmp
) limit 100;
正如引文所说,该语句可以改写为:
Select * From cyclopedia Where ID>=(
Select ID From cyclopedia Order By ID limit 90000,1
) limit 100;
好,为什么这里会比直接使用 LIMIT 快呢?

正如前两点说的,第一子查询中使用了ORDER BY,因此只使用 `ID`使用查询结果的字段,才会使用索引,如果这里在`ID`后加多一个不在索引内的字段(如:`ID`,`other_field`),那么也要5秒多的时间,这就是第一点快的原因。

第二,外层查询这里虽然使用 ‘*’作为要查询的字段,但由于使用了WHERE ID>=n ,因此使用了索引而作出了快速定位。

而单纯的Select * From cyclopedia ORDER BY `ID` DESC LIMIT 90000,1 由于是要查询的字段使用“*”,另外由于ORDER BY子句并不会使用索引,因此就会慢。

如果改定为:Select `ID` From cyclopedia ORDER BY `ID` DESC LIMIT 90000,1就会变快,但奇怪的是强制使用索引子句Select * From cyclopedia FORCE INDEX(PRIMARY) ORDER BY `ID` DESC LIMIT 90000,1居然无效,这样看来,MySQL的内置优先机制的优先级更高。

MySql的加密算法

1、双向加密

就让我们从最简单的加密开始:双向加密。在这里,一段数据通过一个密钥被加密,只能够由知道这个密钥的人来解密。MySQL有两个函数来支持这种类型的加密,分别叫做ENCODE()和DECODE()。下面是一个简单的实例:

mysql> INSERT INTO users (username, password) VALUES (‘joe’, ENCODE(‘guessme’, ‘abracadabra’)); Query OK, 1 row affected (0.14 sec)

其中,Joe的密码是guessme,它通过密钥abracadabra被加密。要注意的是,加密完的结果是一个二进制字符串,如下所示:

mysql> SELECT * FROM users WHERE username=’joe’;
+———-+———-+
| username | password |
+———-+———-+
| joe | ¡?i??!? |
+———-+———-+
1 row in set (0.02 sec)

abracadabra这个密钥对于恢复到原始的字符串至关重要。这个密钥必须被传递给DECODE()函数,以获得原始的、未加密的密码。下面就是它的使用方法:

mysql> SELECT DECODE(password, ‘abracadabra’) FROM users WHERE username=’joe’;
+———————————+
| DECODE(password, ‘abracadabra’) |
+———————————+
| guessme |
+———————————+
1 row in set (0.00 sec)

应该很容易就看到它在Web应用程序里是如何运行的——在验证用户登录的时候,DECODE()会用网站专用的密钥解开保存在数据库里的密码,并和用户输入的内容进行对比。假设您把PHP用作自己的脚本语言,那么可以像下面这样进行查询:

< ?php $query = "SELECT COUNT(*) FROM users WHERE username='$inputUser' AND DECODE(password, 'abracadabra') = '$inputPass'";?>

提示:虽然ENCODE()和DECODE()这两个函数能够满足大多数的要求,但是有的时候您希望使用强度更高的加密手段。在这种情况下,您可以使用AES_ENCRYPT()和AES_DECRYPT()函数,它们的工作方式是相同的,但是加密强度更高。
2、单向加密

单向加密与双向加密不同,一旦数据被加密就没有办法颠倒这一过程。因此密码的验证包括对用户输入内容的重新加密,并将它与保存的密文进行比对,看是否匹配。一种简单的单向加密方式是MD5校验码。MySQL的MD5()函数会为您的数据创建一个“指纹”并将它保存起来,供验证测试使用。下面就是如何使用它的一个简单例子:

mysql> INSERT INTO users (username, password) VALUES (‘joe’, MD5(‘guessme’)); Query OK, 1 row affected (0.00 sec) mysql> SELECT * FROM users WHERE username=’joe’;
+———-+———————————-+
| username | password |
+———-+———————————-+
| joe | 81a58e89df1f34c5487568e17327a219 |
+———-+———————————-+
1 row in set (0.02 sec)

现在您可以测试用户输入的内容是否与已经保存的密码匹配,方法是取得用户输入密码的MD5校验码,并将它与已经保存的密码进行比对,就像下面这样:

mysql> SELECT COUNT(*) FROM users WHERE username=’joe’ AND password=MD5(‘guessme’);
+———-+
| COUNT(*) |
+———-+
| 1 |
+———-+
1 row in set (0.00 sec)

或者,您考虑一下使用ENCRYPT()函数,它使用系统底层的crypt()系统调用来完成加密。这个函数有两个参数:一个是要被加密的字符串,另一个是双(或者多)字符的“salt”。它然后会用salt加密字符串;这个salt然后可以被用来再次加密用户输入的内容,并将它与先前加密的字符串进行比对。下面一个例子说明了如何使用它:

mysql> INSERT INTO users (username, password) VALUES (‘joe’, ENCRYPT(‘guessme’, ‘ab’)); Query OK, 1 row affected (0.00 sec) mysql> SELECT * FROM users WHERE username=’joe’;
+———-+—————+
| username | password |
+———-+—————+
| joe | ab/G8gtZdMwak |
+———-+—————+
1 row in set (0.00 sec)

结果是

mysql> SELECT COUNT(*) FROM users WHERE username=’joe’ AND password=ENCRYPT(‘guessme’, ‘ab’);
+———-+
| COUNT(*) |
+———-+
| 1 |
+———-+
1 row in set (0.00 sec)

提示:ENCRYPT()只能用在*NIX系统上,因为它需要用到底层的crypt()库。

幸运的是,上面的例子说明了能够如何利用MySQL对您的数据进行单向和双向的加密,并告诉了您一些关于如何保护数据库和其他敏感数据库信息安全的理念。

MySQL索引的查看创建和删除

1.索引作用
在索引列上,除了上面提到的有序查找之外,数据库利用各种各样的快速定位技术,能够大大提高查询效率。特别是当数据量非常大,查询涉及多个表时,使用索引往往能使查询速度加快成千上万倍。
例如,有3个未索引的表t1、t2、t3,分别只包含列c1、c2、c3,每个表分别含有1000行数据组成,指为1~1000的数值,查找对应值相等行的查询如下所示。

SELECT c1,c2,c3 FROM t1,t2,t3 WHERE c1=c2 AND c1=c3
此查询结果应该为1000行,每行包含3个相等的值。在无索引的情况下处理此查询,必须寻找3个表所有的组合,以便得出与WHERE子句相配的那些行。而可能的组合数目为1000×1000×1000(十亿),显然查询将会非常慢。
如果对每个表进行索引,就能极大地加速查询进程。利用索引的查询处理如下。
(1)从表t1中选择第一行,查看此行所包含的数据。
(2)使用表t2上的索引,直接定位t2中与t1的值匹配的行。类似,利用表t3上的索引,直接定位t3中与来自t1的值匹配的行。
(3)扫描表t1的下一行并重复前面的过程,直到遍历t1中所有的行。
在此情形下,仍然对表t1执行了一个完全扫描,但能够在表t2和t3上进行索引查找直接取出这些表中的行,比未用索引时要快一百万倍。
利用索引,MySQL加速了WHERE子句满足条件行的搜索,而在多表连接查询时,在执行连接时加快了与其他表中的行匹配的速度。
2. 创建索引
在执行CREATE TABLE语句时可以创建索引,也可以单独用CREATE INDEX或ALTER TABLE来为表增加索引。
1.ALTER TABLE
ALTER TABLE用来创建普通索引、UNIQUE索引或PRIMARY KEY索引。

ALTER TABLE table_name ADD INDEX index_name (column_list)
ALTER TABLE table_name ADD UNIQUE (column_list)
ALTER TABLE table_name ADD PRIMARY KEY (column_list)

其中table_name是要增加索引的表名,column_list指出对哪些列进行索引,多列时各列之间用逗号分隔。索引名index_name可选,缺省时,MySQL将根据第一个索引列赋一个名称。另外,ALTER TABLE允许在单个语句中更改多个表,因此可以在同时创建多个索引。
2.CREATE INDEX
CREATE INDEX可对表增加普通索引或UNIQUE索引。

CREATE INDEX index_name ON table_name (column_list)
CREATE UNIQUE INDEX index_name ON table_name (column_list)

table_name、index_name和column_list具有与ALTER TABLE语句中相同的含义,索引名不可选。另外,不能用CREATE INDEX语句创建PRIMARY KEY索引。
3.索引类型
在创建索引时,可以规定索引能否包含重复值。如果不包含,则索引应该创建为PRIMARY KEY或UNIQUE索引。对于单列惟一性索引,这保证单列不包含重复的值。对于多列惟一性索引,保证多个值的组合不重复。
PRIMARY KEY索引和UNIQUE索引非常类似。事实上,PRIMARY KEY索引仅是一个具有名称PRIMARY的UNIQUE索引。这表示一个表只能包含一个PRIMARY KEY,因为一个表中不可能具有两个同名的索引。
下面的SQL语句对students表在sid上添加PRIMARY KEY索引。

ALTER TABLE students ADD PRIMARY KEY (sid)

4. 删除索引
可利用ALTER TABLE或DROP INDEX语句来删除索引。类似于CREATE INDEX语句,DROP INDEX可以在ALTER TABLE内部作为一条语句处理,语法如下。

DROP INDEX index_name ON talbe_name
ALTER TABLE table_name DROP INDEX index_name
ALTER TABLE table_name DROP PRIMARY KEY

其中,前两条语句是等价的,删除掉table_name中的索引index_name。
第3条语句只在删除PRIMARY KEY索引时使用,因为一个表只可能有一个PRIMARY KEY索引,因此不需要指定索引名。如果没有创建PRIMARY KEY索引,但表具有一个或多个UNIQUE索引,则MySQL将删除第一个UNIQUE索引。
如果从表中删除了某列,则索引会受到影响。对于多列组合的索引,如果删除其中的某列,则该列也会从索引中删除。如果删除组成索引的所有列,则整个索引将被删除。

5.查看索引
mysql> show index from tblname;
mysql> show keys from tblname;
  · Table

  表的名称。

  · Non_unique

  如果索引不能包括重复词,则为0。如果可以,则为1。

  · Key_name

  索引的名称。

  · Seq_in_index

  索引中的列序列号,从1开始。

  · Column_name

  列名称。

  · Collation

  列以什么方式存储在索引中。在MySQL中,有值‘A’(升序)或NULL(无分类)。

  · Cardinality

  索引中唯一值的数目的估计值。通过运行ANALYZE TABLE或myisamchk -a可以更新。基数根据被存储为整数的统计数据来计数,所以即使对于小型表,该值也没有必要是精确的。基数越大,当进行联合时,MySQL使用该索引的机会就越大。

  · Sub_part

  如果列只是被部分地编入索引,则为被编入索引的字符的数目。如果整列被编入索引,则为NULL。

  · Packed

  指示关键字如何被压缩。如果没有被压缩,则为NULL。

  · Null

  如果列含有NULL,则含有YES。如果没有,则该列含有NO。

  · Index_type

  用过的索引方法(BTREE, FULLTEXT, HASH, RTREE)。

  · Comment

复制表结构和数据的SQL语句

1.复制表结构及数据到新表
CREATE TABLE 新表
SELECT * FROM 旧表

2.只复制表结构到新表
CREATE TABLE 新表
SELECT * FROM 旧表 WHERE 1=2
即:让WHERE条件不成立.
CREATE TABLE 新表
LIKE 旧表

3.复制旧表的数据到新表(假设两个表结构一样)
INSERT INTO 新表
SELECT * FROM 旧表

4.复制旧表的数据到新表(假设两个表结构不一样)
INSERT INTO 新表(字段1,字段2,…….)
SELECT 字段1,字段2,…… FROM 旧表

MySQL日志MySql-bin.0000*的删除方法

MySQL,运行一段时间后,在数据库目录下会自动产生mysql-bin.00000*的日志文件,从mysql-bin.000001开始一直排列下来,占用了大量的硬盘空间,这些日志文件要怎样删除呢?

删除方法:

mysql -u root -p #用ROOT身份登录数据库
reset master; #删除日志,完成

禁止生成日志文件:

vi /etc/my.cnf #编辑MySQL配置文件

找到如下两行并加#号注释掉:

#log-bin=mysql-bin
#binlog_format=mixed

重启MySQL服务:

service mysqld restart

MySQL数据库文件夹中的mysql-bin.00001是什么文件?
mysql-bin.000001、mysql- bin.000002等文件是数据库的操作日志,例如UPDATE一个表,或者DELETE一些数据,即使该语句没有匹配的数据,这个命令也会存储到日志 文件中,还包括每个语句执行的时间,也会记录进去的。

MySQL修改用户密码

方法1: 用SET PASSWORD命令

  mysql -u root

  mysql> SET PASSWORD FOR ‘root’@’localhost’ = PASSWORD(‘newpass’);

方法2:用mysqladmin

  mysqladmin -u root password “newpass”

  如果root已经设置过密码,采用如下方法

  mysqladmin -u root password oldpass “newpass”

方法3: 用UPDATE直接编辑user表

  mysql -u root

  mysql> use mysql;

  mysql> UPDATE user SET Password = PASSWORD(‘newpass’) WHERE user = ‘root’;

  mysql> FLUSH PRIVILEGES;

在丢失root密码的时候,可以这样

  mysqld_safe –skip-grant-tables&

  mysql -u root mysql

  mysql> UPDATE user SET password=PASSWORD(“new password”) WHERE user=’root’;

  mysql> FLUSH PRIVILEGES;

MYSQL与SQLITE重置AUTO_INCREMENT初始值

MYSQL重置AUTO_INCREMENT初始值的方法很简单
可就是SQLITE的重置方法在国内还极少人有记载(至少本人找了很久没找到)
于是到美国漫游了一下,终于功夫不负有心人……

SQLITE AUTO_INCREMENT 复位:

DELETE FROM sqlite_sequence WHERE name = 'your_table_name'

MYSQL AUTO_INCREMENT 复位:

ALTER TABLE your_table_name AUTO_INCREMENT = 1

利用PHP将MYSQL数据输入成EXCEL格式

<?php 
$DB_Server = “localhost”;   
$DB_Username = “put your user name here”;   
$DB_Password = “put your password here”;   
$DB_DBName = “put your database name here”;   
$DB_TBLName = “put your table name here”;   
  
$savename = date(“YmjHis”);  // excel file name
$Connect = @mysql_connect($DB_Server, $DB_Username, $DB_Password) or die(“Couldn’t connect.”);   
mysql_query(“Set Names ‘utf-8′”);
$file_type = “vnd.ms-excel”;   
$file_ending = “xls”;
header(“Content-Type: application/$file_type;charset=utf-8″);
header(“Content-Disposition: attachment; filename=”.$savename.”.$file_ending”);   
//header(“Pragma: no-cache”);      
  
$now_date = date(“Y-m-j H:i:s”);    
$title = “User Email”;    
  
$sql = “SELECT entity_id, email from $DB_TBLName WHERE entity_id >’0′ AND entity_id<10001″;    //export entity_id from 1 to 1000
$ALT_Db = @mysql_select_db($DB_DBName, $Connect) or die(“Couldn’t select database”);   
$result = @mysql_query($sql,$Connect) or die(mysql_error()); 
  
echo(“$title\n”);    
$sep = “\t”;    
for ($i = 0; $i < mysql_num_fields($result); $i++) {
    echo mysql_field_name($result,$i) . “\t”;    
}    
print(“\n”);    
$i = 0;    
while($row = mysql_fetch_row($result)) {    
    $schema_insert = “”;
    for($j=0; $j<mysql_num_fields($result);$j++) {    
        if(!isset($row[$j]))    
            $schema_insert .= “NULL”.$sep;    
        elseif ($row[$j] != “”)    
            $schema_insert .= “$row[$j]“.$sep;
        else    
            $schema_insert .= “”.$sep;    
    }    
    $schema_insert = str_replace($sep.”$”, “”, $schema_insert);    
    $schema_insert .= “\t”;    
    print(trim($schema_insert));    
    print “\n”;    
    $i++;    
}    
return (true); 
?>

关于MYSQL的一道笔试题

题目要求是这样的,假设有如下表(MySQL):

TABLE: test

id a b
1 4 2
2 1 2
3 1 3
4 3 2
5 1 5
6 1 2
7 4 -1
8 1 2

 写一条SQL语句,

选择所有a=1或b=2的记录,

使得a=1且b=2的记录排在最前面,

并且a=1且b=2的记录按id降序排列。

分析:

很显然,直接的order by方案是不行的。

那我们就需要把条件分割:把a=1 or b=2分割成(a=1 and b=2) or (a=1 and b!=2) or (a!=1 and b=2)

再把选择的结果union一下就可以得到想要的结果了。

关于(a=1 and b=2)记录按id的降序排列,需要用到order by,如果直接这么用:

SELECT ... FROM ... ORDER BY ... DESC UNION ...

是会报错的, 把前面的select语句加上括号,不会报错,但是达不到想要的效果(order by 不起作用)。

这个时候就要用到derived table了,不过别忘了给derived table取一个别名(alias)。

SELECT * FROM (
    SELECT * FROM `test` WHERE `a`=1 AND `b`=2 ORDER BY `id` DESC
) `ab` UNION
SELECT * FROM `test` WHERE (`a`=1 AND `b`!=2) OR (`a`!=1 AND `b`=2)

 运行结果:

id a b
8 1 2
6 1 2
2 1 2
1 4 2
3 1 3
4 3 2
5 1 5