(SELECT a FROM tbl_name WHERE a=10 AND B=1)  
UNION  
(SELECT a FROM tbl_name WHERE a=11 AND B=2)  
ORDER BY a LIMIT 10；

如果，需要对单个SQL语句进行order by，则应把order by子句放入圆括号中，如下：

(SELECT a FROM tbl_name WHERE a=10 AND B=1 ORDER BY a LIMIT 10)  
UNION  
(SELECT a FROM tbl_name WHERE a=11 AND B=2 ORDER BY a LIMIT 10);

另外注意：圆括号中用于单个SQL语句的ORDER BY只有当与LIMIT结合后，才起作用。否则，ORDER BY被优化去除。
我在innodb引擎的2个表上测试了没有加()，进行union和order by的操作，如下：

SELECT a FROM tbl_name WHERE a=10 AND B=1  
UNION  
SELECT a FROM tbl_name WHERE a=11 AND B=2  
ORDER BY a LIMIT 10;

发现，它默认的结果也是先进行union，然后再order by，和第一种情况执行结果相同
不过，为了逻辑清晰，最好还是加上对应的()比较好
另外：Mysql中union可以有union，union distinct，union all这3中形式
union和union distinct会对union后的结果进行排重，保证所有返回的行都是唯一的
union all则会返回所有SELECT语句中得到所有匹配的行

您可能也喜欢：

PHP中操作mysql执行存储过程

mysql内存表heap使用总结

MySQL通信协议

MySQL视图介绍

MySQL中索引限制

无觅

上面是网上看的，我发现慢查询日志内有很多update和insert的查询，就把innodb_flush_log_at_trx_commit改成了2，效果很明显，改成0会更明显，但安全性比较差。做下面的操作启动mysqld就生效：
vim /etc/my.cnf
innodb_flush_log_at_trx_commit=2

也可以在mysqld运行时执行：
set GLOBAL innodb_flush_log_at_trx_commit = 2

下面是mysql手册上innodb_flush_log_at_trx_commit的解释：
如果innodb_flush_log_at_trx_commit设置为0，log buffer将每秒一次地写入log file中，并且log file的flush(刷到磁盘)操作同时进行；但是，这种模式下，在事务提交的时候，不会有任何动作。如果 innodb_flush_log_at_trx_commit设置为1(默认值)，log buffer每次事务提交都会写入log file，并且，flush刷到磁盘中去。如果innodb_flush_log_at_trx_commit设置为2，log buffer在每次事务提交的时候都会写入log file，但是，flush(刷到磁盘)操作并不会同时进行。这种模式下，MySQL会每秒一次地去做flush(刷到磁盘)操作。注意：由于进程调度策 略问题，这个“每秒一次的flush(刷到磁盘)操作”并不是保证100%的“每秒”。
默认值1是为了ACID (atomicity, consistency, isolation, durability)原子性，一致性，隔离性和持久化的考虑。如果你不把innodb_flush_log_at_trx_commit设置为1，你将获得更好的性能，但是，你在系统崩溃的情况，可能会丢失最多一秒钟的事务数据。当你把innodb_flush_log_at_trx_commit设置 为0，mysqld进程的崩溃会导致上一秒钟所有事务数据的丢失。如果你把innodb_flush_log_at_trx_commit设置为2，只有在操作系统崩溃或者系统掉电的情况下，上一秒钟所有事务数据才可能丢失。InnoDB的crash recovery崩溃恢复机制并不受这个值的影响，不管这个值设置为多少，crash recovery崩溃恢复机制都会工作。

另外innodb_flush_method参数也值得关注，对写操作有影响：
innodb_flush_method： 设置InnoDB同步IO的方式：
1) Default – 使用fsync（）。
2) O_SYNC 以sync模式打开文件，通常比较慢。
3) O_DIRECT，在Linux上使用Direct IO。可以显著提高速度，特别是在RAID系统上。避免额外的数据复制和double buffering（mysql buffering 和OS buffering）。

您可能也喜欢：

MySQL视图介绍

MySQL 5.1.56 使用 InnoDB Plugin

mysql root帐号丢失解决办法

PHP中操作mysql执行存储过程

Mysql中union和order by的问题及优先级

无觅

1.子查询优化法
先找出第一条数据，然后大于等于这条数据的id就是要获取的数据
缺点：数据必须是连续的，可以说不能有where条件，where条件会筛选数据，导致数据失去连续性

实验下

Sql代码 

1. mysql> set profiling=1;
2. Query OK, 0 rows affected (0.00 sec)
4. mysql> select count(*) from Member;
5. +———-+
6. | count(*) |
7. +———-+
8. |   169566 |
9. +———-+
10. 1 row in set (0.00 sec)
12. mysql> pager grep !~-
13. PAGER set to ’grep !~-’
15. mysql> select * from Member limit 10, 100;
16. 100 rows in set (0.00 sec)
18. mysql> select * from Member where MemberID >= (select MemberID from Member limit 10,1) limit 100;
19. 100 rows in set (0.00 sec)
21. mysql> select * from Member limit 1000, 100;
22. 100 rows in set (0.01 sec)
24. mysql> select * from Member where MemberID >= (select MemberID from Member limit 1000,1) limit 100;
25. 100 rows in set (0.00 sec)
27. mysql> select * from Member limit 100000, 100;
28. 100 rows in set (0.10 sec)
30. mysql> select * from Member where MemberID >= (select MemberID from Member limit 100000,1) limit 100;
31. 100 rows in set (0.02 sec)
33. mysql> nopager
34. PAGER set to stdout
37. mysql> show profiles\G
38. *************************** 1. row ***************************
39. Query_ID: 1
40. Duration: 0.00003300
41. Query: select count(*) from Member
43. *************************** 2. row ***************************
44. Query_ID: 2
45. Duration: 0.00167000
46. Query: select * from Member limit 10, 100
47. *************************** 3. row ***************************
48. Query_ID: 3
49. Duration: 0.00112400
50. Query: select * from Member where MemberID >= (select MemberID from Member limit 10,1) limit 100
52. *************************** 4. row ***************************
53. Query_ID: 4
54. Duration: 0.00263200
55. Query: select * from Member limit 1000, 100
56. *************************** 5. row ***************************
57. Query_ID: 5
58. Duration: 0.00134000
59. Query: select * from Member where MemberID >= (select MemberID from Member limit 1000,1) limit 100
61. *************************** 6. row ***************************
62. Query_ID: 6
63. Duration: 0.09956700
64. Query: select * from Member limit 100000, 100
65. *************************** 7. row ***************************
66. Query_ID: 7
67. Duration: 0.02447700
68. Query: select * from Member where MemberID >= (select MemberID from Member limit 100000,1) limit 100

从结果中可以得知，当偏移1000以上使用子查询法可以有效的提高性能。

2.倒排表优化法
倒排表法类似建立索引，用一张表来维护页数，然后通过高效的连接得到数据

缺点：只适合数据数固定的情况，数据不能删除，维护页表困难

具体请看，http://blog.chinaunix.net/u/29134/showart_1333566.html

3.反向查找优化法
当偏移超过一半记录数的时候，先用排序，这样偏移就反转了

缺点：order by优化比较麻烦，要增加索引，索引影响数据的修改效率，并且要知道总记录数
，偏移大于数据的一半

做下实验，看看性能如何

总记录数：1,628,775
每页记录数： 40
总页数：1,628,775 / 40 = 40720
中间页数：40720 / 2 = 20360

第21000页
正向查找SQL:

Sql代码 

1. SELECT * FROM `abc` WHERE `BatchID` = 123 LIMIT 839960, 40

时间：1.8696 秒

反向查找sql:

Sql代码 

1. SELECT * FROM `abc` WHERE `BatchID` = 123 ORDER BY InputDate DESC LIMIT 788775, 40

时间：1.8336 秒

第30000页
正向查找SQL:

Sql代码 

1. SELECT * FROM `abc` WHERE `BatchID` = 123 LIMIT 1199960, 40

时间：2.6493 秒

反向查找sql:

Sql代码 

1. SELECT * FROM `abc` WHERE `BatchID` = 123 ORDER BY InputDate DESC LIMIT 428775, 40

时间：1.0035 秒

注意，反向查找的结果是是降序desc的，并且InputDate是记录的插入时间，也可以用主键联合索引，但是不方便。

4.limit限制优化法
把limit偏移量限制低于某个数。。超过这个数等于没数据，我记得alibaba的dba说过他们是这样做的

5.只查索引法
http://willko.iteye.com/blog/670120

总结：limit的优化限制都比较多，所以实际情况用或者不用只能具体情况具体分析了。页数那么后，基本很少人看的。。。

Hive是搭建在Hadoop平台之上的。Hive并不是一个真正的数据库，它的元数据需要存储在其他数据库中(例如mysql)。。Hadoop平台提供了HDFS分布式存储系统和map/reduce分布式计算系统，而Hive在这两个系统之上，使得用户只需使用熟悉SQL语言就能进行分布式计算，而map/reduce编程往往是相当复杂的。Hive在少量数据运算或是短时间内的重复查询上，是不能和Oracle那样的数据库相比的。它的查询量通常相当大，一个大的job运行几个小时算是正常的。

数据类型 。HiveQL只支持以下几种基本数据类型TINYINT, SMALLINT, INT, BIGINT, DOUBLE, STRING。

支持的复杂数据类型有Structs, Maps, Arrays。

创建表。 Hive不同于其他数据库，它只有一个默认数据库”default” ，所有的table都保持在里面。

CREATE TABLE user(id BIGINT, name STRING);

可以指定将表创建到外部hdfs文件系统中。

CREATE EXTERNAL TABLE foo(id INT)

STORED AS TEXTFILE LOCALTION ‘/user/foo/foo_data’;

将数据文件导入到Hive表中。

LOAD DATA [LOCAL] INPATH ‘/data/userdata’ [OVERWRITE] INTO TABLE user;

使用LOCAL选项将使用本地文件系统 ，否则将使用hdfs文件系统。使用OVERWRITE选项将删除原来table中的数据，否则将新数据添加到文件末尾。

Load data导入数据将仅仅将文件拷贝到hive管理的目录下，并用table的元数据去解释这个文件。所以必须保证数据文件的结构必须和table的结构一 致，否则可以load data成功但是数据解释不正确。特别注意fields分隔符和lines分隔符要和Table一致。我使用自定义分隔符导入数据，一直没有成功。不管我 怎么指定，Hive总是使用默认的分隔符来解释我的文件（默认使用001(ctrl-A)分隔列，012(\n)分隔行 ）。问题未解决。

查询语句。 这里列出一些和标准SQL不同的地方。

不能使用select count(*)；需要指定count的列下标，select count(1) 。

不能使用CREATE TABLE newtable SELECT * FROM user；必须事先Create table，再用INSERT向其中写入数据。

排序关键字是SORT BY。

LIMIT关键字只能跟一个数字，即从第一条记录开始选出若干条。

INSERT语句变换很大，不能直接插入一条记录。插入的数据必须用SELECT子查询获取或者从某个文件导入。我还没细看。

> SELECT * FROM user LIMIT 10;

> INSERT OVERWRITE TABLE foo SELECT DESTIN(id) FROM user;

> SELECT M.id FROM user M JOIN foo S ON M.id = S.id;

> SELECT id FROM user GROUP BY id;

1. TCP/IP协议，通常我们通过来连接MySQL，各种主要编程语言都是根据这个协议实现了连接模块
2. Unix Socket协议，这个通常我们登入MySQL服务器中使用这个协议，因为要使用这个协议连接MySQL需要一个物理文件，文件的存放位置在配置文件中有定义，值得一提的是，这是所有协议中最高效的一个。
3. Share Memory协议，这个协议一般人不知道，肯定也没用过，因为这个只有windows可以使用，使用这个协议需要在配置文件中在启动的时候使用–shared-memory参数，注意的是，使用此协议，一个host上只能有一个server，所以这个东西一般没啥用的，除非你怀疑其他协议不能正常工作，实际上微软的SQL Sever也支持这个协议
4. Named Pipes协议，这个协议也是只有windows才可以用，同shared memory一样，使用此协议，一个host上依然只能有一个server，即使是使用不同的端口也不行，Named Pipes 是为局域网而开发的协议。内存的一部分被某个进程用来向另一个进程传递信息，因此一个进程的输出就是另一个进程的输入。第二个进程可以是本地的（与第一个进程位于同一台计算机上），也可以是远程的（位于联网的计算机上）。正因为如此，假如你的环境中没有或者禁用TCP/IP环境，而且是windows服务器，那么好歹你的数据库还能工作。使用这个协议需要在启动的时候添加–enable-named-pipe选项

Named Pipes和Shared Memory协议都非常的低效，而且只能用于windows环境，非必要情况尽量避免使用

建一个表试试

–
– 表的结构 `test`
–

CREATE TABLE IF NOT EXISTS `test` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`name` varchar(16) NOT NULL,
`phone` int(11) NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=MyISAM DEFAULT CHARSET=utf8;

–
– 导出表中的数据 `test`
–

INSERT INTO `test` (`id`, `name`, `phone`) VALUES
(1, ‘a’, 1234),
(2, ‘a’, 3333),
(3, ‘b’, 555),
(4, ‘b’, 6773),
(5, ‘a’, 743),
(6, ‘c’, 95434);

查询一下,
SELECT * FROM `test` group by name
得到
id name phone
1 a 1234
3 b 555
6 c 95434

但我们想得到id最大的name怎么办?
SELECT max(id),id,name,phone FROM test group by name
得到
max(id) id name phone
5 1 a 1234
4 3 b 555
6 6 c 95434
可以看到,虽然每个name的最大id得到了,但是,其他数据依然是每个name的第一行
用子查询
select * from (select * from test order by id desc) t group by name
得到
id name phone
5 a 743
4 b 6773
6 c 95434
这就是我们想要的结果了,但是,这种作法在行数非常多的情况下,相当于把整个表复制了一次,估计效率低.
那用这种子查询
select * from test t where id in (select max(id) from test group by name)
得到
id name phone
4 b 6773
5 a 743
6 c 95434
然而,这种子查询因为用了in,在数量多的情况下,也许还更慢些?不确定,没时间测试
另外,还有一种方法,不过原理我也有些糊涂了,只是看网上有人这样作,
select * from test t inner join (select * from test order by id desc) t2 on t.id=t2.id group by t.name
得到
id name phone id name phone
5 a 743 5 a 743
4 b 6773 4 b 6773
6 c 95434 6 c 95434
为了想提高效率,想到了视图,先按id desc排个视图,再group by name,岂不是相当于子查询?
CREATE VIEW `testv` AS select `test`.`id` AS `id`,`test`.`name` AS `name`,`test`.`phone` AS `phone` from `test` order by `test`.`id` desc;
视图建立了,再查询
SELECT * FROM `testv` group by name
结果竟然是
id name phone
1 a 1234
3 b 555
6 c 95434
和在原表用
SELECT * FROM `test` group by name
的结果一样.看来视图和真正的表毕竟是有区别的

补充:
上网再看了一下,原来第二种子查询方法网上不是那样的,尽管我那样写在这个例子上也成功了,但是,说不定其他表会错?没时间测试.网上的方法是
select * from test t inner join (select max(id) as id,name from test group by name) t2 on t.id=t2.id and t.name=t2.name
得到
id name phone id name
5 a 743 5 a
4 b 6773 4 b
6 c 95434 6 c
另外,把上面这些查询方法中的test表换成testv,都可以得到正确的结果,尽管order by有点不同.
上面的排序都只针对一个字段,两个及以上字段也可以采用类似于
select * from (select * from test order by id desc) t group by name
这样的方法,在子查询中可以多个字段来order by
下面删除原来的test,重建一下
–
– 表的结构 `test`
–

CREATE TABLE IF NOT EXISTS `test` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`name` varchar(16) NOT NULL,
`month` int(11) NOT NULL,
`serial` int(11) NOT NULL,
`other` varchar(20) NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=MyISAM DEFAULT CHARSET=utf8;

–
– 导出表中的数据 `test`
–

INSERT INTO `test` (`id`, `name`, `month`, `serial`, `other`) VALUES
(1, ‘a’, 200807, 2, ‘aaa1′),
(2, ‘a’, 200805, 2, ‘aaa2′),
(3, ‘b’, 200805, 3, ‘bbb3′),
(4, ‘b’, 200805, 4, ‘bbb4′),
(5, ‘a’, 200805, 1, ‘aaa5′),
(6, ‘c’, 200807, 5, ‘ccc6′),
(7, ‘b’, 200807, 8, ‘bbb7′),
(8, ‘c’, 200807, 3, ‘ccc8′),
(9, ‘a’, 200805, 6, ‘aaa9′);

查询
select * from (select * from test order by month desc,serial desc) t group by name
得到
id name month serial other
1 a 200807 2 aaa1
7 b 200807 8 bbb7
6 c 200807 5 ccc6
换一下排序方式
select * from (select * from test order by month asc,serial desc) t group by name
得到
id name month serial other
9 a 200805 6 aaa9
4 b 200805 4 bbb4
6 c 200807 5 ccc6
都按我们的要求显示了结果

在php中调用存储过程和函数。

1.调用存储过程的方法。

a. 如果存储过程有 IN/INOUT参数，声明一个变量，输入参数给存储过程，该变量是一对， 一个php变量（也可以不必，只是没有php变量时，没有办法进行动态输入），一个Mysql变量。
b.如果存储过程有OUT变量，声明一个Mysql变量。mysql变量的声明比较特殊，必须让mysql服务器知道此变量的存在，其实也就是执行一条mysql语句。
如 set @mysqlvar=$phpvar ;
c.使用mysql_query()/mysql_db_query()执行mysql 变量声明语句。
mysql_query(“set @mysqlvar [=$pbpvar]“);
这样，在mysql服务器里面就有一个变量，@mysqlar。如果时IN参数，那么其值可以有phpar传入。

d. 如果是存储过程。
1. 执行 call procedure（）语句。
也就是mysql_query(“call proceduer([var1]…)”);
2. 如果有返回值，执行select @ar，返回执行结果。
mysql_query(“select @var)”
接下来的操作就和php执行一般的mysql语句一样了。可以通过mydql_fetch_row()等函数获得结果。
如果时函数。 直接执行 select function（） 就可以了。

$host="localhost";
    $user="root";
    $passWord="11212";
    $db="samp_db";
    $dblink=mysql_connect($host,$user,$password)
            or die("can't connect to mysql");
mysql_select_db($db,$dblink)
      or die("can't select samp_db");
    $res=mysql_query("set @a=$password",$dblink);
    $res=mysql_query("call aa(@a)",$dblink);
    $res=mysql_query("select @a",$dblink);
    $row=mysql_fetch_row($res);
    echo $row[0];

其中，datatype为mysql的数据类型，如:INT, FLOAT, DATE, VARCHAR(length)

例:

DECLARE l_int INT unsigned default 4000000; DECLARE l_numeric NUMERIC(8,2) DEFAULT 9.95; DECLARE l_date DATE DEFAULT ’1999-12-31′; DECLARE l_datetime DATETIME DEFAULT ’1999-12-31 23:59:59′; DECLARE l_varchar VARCHAR(255) DEFAULT ‘This will not be padded’;  

变量赋值

SET 变量名 = 表达式值 [,variable_name = expression ...]

参数

mysql存储过程的参数用在存储过程的定义，共有三种参数类型,IN,OUT,INOUT

IN 输入参数

表示该参数的值必须在调用存储过程时指定，在存储过程中修改该参数的值不能被返回，为默认值

OUT 输出参数

该值可在存储过程内部被改变，并可返回

INOUT 输入输出参数

调用时指定，并且可被改变和返回

IN参数例子:

创建

mysql> CREATE PROCEDURE sp_demo_in_parameter(IN p_in INT) BEGIN SELECT p_in; /*查询输入参数*/*/ SET p_in=2; /*修改*/ select p_in;/*查看修改后的值*/ END; 
执行结果:
mysql> set @p_in=1
mysql> call sp_demo_in_parameter(@p_in)
+——+
| p_in |
+——+
|    1 | 
+——+

+——+
| p_in |
+——+
|    2 | 
+——+

mysql> select @p_in;

+——-+
| @p_in |
+——-+
| 1     |
+——-+

以上可以看出，p_in虽然在存储过程中被修改，但并不影响@p_id的值

OUT参数例子

创建:

mysql> CREATE PROCEDURE sp_demo_out_parameter(OUT p_out INT) BEGIN SELECT p_out;/*查看输出参数*/ SET p_out=2;/*修改参数值*/ SELECT p_out;/*看看有否变化*/ END; 
执行结果:
mysql> SET @p_out=1
mysql> CALL sp_demo_out_parameter(@p_out)
+——-+
| p_out | 
+——-+
|  NULL | 
+——-+
/*未被定义，返回NULL*/
+——-+
| p_out |
+——-+
|     2 | 
+——-+

mysql> SELECT @p_out;
+——-+
| p_out |
+——-+
|     2 | 
+———-+

INOUT参数例子:

mysql> CREATE PROCEDURE sp_demo_inout_parameter(INOUT p_inout INT) BEGIN SELECT p_inout; SET p_inout=2; SELECT p_inout; END; 

执行结果:
set @p_inout=1
call sp_demo_inout_parameter(@p_inout) //
+———+
| p_inout |
+———+
|       1 |
+———+

+———+
| p_inout | 
+———+
|       2 |
+———+


select @p_inout;

+———-+
| @p_inout | 
+———-+
| 2        |
+———-+

用户变量

1、  在mysql客户端使用用户变量

mysql> SELECT ‘Hello World’ into @x;
mysql> SELECT @x;
+————-+
| @x          |
+————-+
| Hello World |
+————-+
mysql> SET @y=’Goodbye Cruel World’;

mysql> select @y;
+———————+
| @y                  |
+———————+
| Goodbye Cruel World |
+———————+

mysql> SET @z=1+2+3;
mysql> select @z;
+——+
| @z   |
+——+
| 6    |
+——+

2、  在存储过程中使用用户变量

mysql> CREATE PROCEDURE GreetWorld(  )  SELECT CONCAT(@greeting,’ World’);
mysql> SET @greeting=’Hello’;

mysql> CALL GreetWorld(  );
+—————————-+
| CONCAT(@greeting,’ World’) |
+—————————-+
| Hello World                |
+—————————-+

3、  在存储过程间传递全局范围的用户变量

mysql> CREATE PROCEDURE p1(  )   SET @last_procedure=’p1′;

mysql> CREATE PROCEDURE p2(  )  SELECT CONCAT(‘Last procedure was ‘,@last_procedure);

mysql> CALL p1(  );

mysql> CALL p2(  );
+———————————————–+
| CONCAT(‘Last procedure was ‘,@last_procedure) |
+———————————————–+
| Last procedure was p1                         |
+———————————————–+

注意:

①用户变量名一般以@开头

②滥用用户变量会导致程序难以理解及管理

注释

mysql存储过程可使用两种风格的注释

双模杠：–

该风格一般用于单行注释

c风格：/* 注释内容 */ 一般用于多行注释