Oracle三组难缠的hint no_unnest/unnest，push_subq，push_pred--平展化(转)
经常有人把这三个hint搞混，主如果因为对三种重写道理不清楚。特总结如下。（实验景象为10204）
1. no_unnest， unnest
unnest我们称为对子查询展开，顾名思义，就是别让子查询孤单地嵌套（nest）在里面。
所以un_unnest双重否定代表必然，即让子查询不展开，让它嵌套（nest）在里面。
现做一个简单的实验：
create table hao1 as * dba_objects;
create table hao2 as * dba_objects;
analyze table hao1 compute statistics;
analyze table hao2 compute statistics;
SQL> hao1.object_id hao1 where exists
2 （ 1 hao2 where hao1.object_id=hao2.object_id*10）;
1038 rows ed.
ution Plan
----------------------------------------------------------
Plan hash value: 2662903432
---------------------------------------------------------------------------
| Id | Operation | Name | Rows | Bytes | Cost （％CPU）| Time |
---------------------------------------------------------------------------
| 0 | SELECT STATEMENT | | 1 | 8 | 80 （3）| 00:00:01 |
|* 1 | HASH JOIN SEMI | | 1 | 8 | 80 （3）| 00:00:01 |
| 2 | TABLE ACCESS FULL| HAO1 | 10662 | 42648 | 40 （3）| 00:00:01 |
| 3 | TABLE ACCESS FULL| HAO2 | 10663 | 42652 | 40 （3）| 00:00:01 |
---------------------------------------------------------------------------
Predicate Information （identified by operation id）:
---------------------------------------------------
1 - access（"HAO1"."OBJECT_ID"="HAO2"."OBJECT_ID"*10）
Statistics
----------------------------------------------------------
0 recursive calls
0 db block gets
352 consistent gets
0 physical reads
0 redo size
18715 bytes sent via SQL*Net to client
1251 bytes received via SQL*Net client
71 SQL*Net roundtrips to/ client
0 sorts （memory）
0 sorts （disk）
1038 rows processed
这里子查询主动展开（unnest），即HAO2和HAO1 hash join在一路。
接下来若是我们不HAO2展开，想先让它零丁的履行完，然后再来和外部查询进行一种叫做FILTER的操纵。
那么我们参加hint no_unnest:
SQL> hao1.object_id hao1 where exists
2 （ /*+no_unnest*/ 1 hao2 where hao1.object_id=hao2.object_id*10）;
1038 rows ed.
ution Plan
----------------------------------------------------------
Plan hash value: 2565749733
---------------------------------------------------------------------------
| Id | Operation | Name | Rows | Bytes | Cost （％CPU）| Time |
---------------------------------------------------------------------------
| 0 | SELECT STATEMENT | | 1 | 4 | 10750 （1）| 00:01:48 |
|* 1 | FILTER | | | | | |
| 2 | TABLE ACCESS FULL| HAO1 | 10662 | 42648 | 40 （3）| 00:00:01 |
|* 3 | TABLE ACCESS FULL| HAO2 | 1 | 4 | 2 （0）| 00:00:01 |
---------------------------------------------------------------------------
Predicate Information （identified by operation id）:
---------------------------------------------------
1 - filter（ EXISTS （SELECT /*+ NO_UNNEST */ 0 FROM "HAO2" "HAO2"
WHERE "HAO2"."OBJECT_ID"*10=:B1））
3 - filter（"HAO2"."OBJECT_ID"*10=:B1）
Statistics
----------------------------------------------------------
1 recursive calls
0 db block gets
1369157 consistent gets
0 physical reads
0 redo size
18715 bytes sent via SQL*Net to client
1251 bytes received via SQL*Net client
71 SQL*Net roundtrips to/ client
0 sorts （memory）
0 sorts （disk）
1038 rows processed
这里HAO1和HAO2进行了一种FILTER操纵，这个操纵在《Cost Based Oracle Fundamental》此书第九章有介绍。他其实很像我们熟悉的neested loop，但它的独特之处在于会保护一个hash table。
举例，若是HAO1里取出object_id=1，那么对于HAO2来说即 1 hao2 where hao2.object_id*10=1，若是前提满足，那么对于子查询，输入输出对，即为（1（HAO1.object_id），1（常量））。
他存储在hash table里，并且因为前提满足，HAO1.object_id=1被放入成果集。
然后接着从HAO1取出object_id=2，若是子查询依旧前提满足，那么子查询产生另一个输入和输出，即（2，1），被放入hash table里；并且HAO1.object_id=2被放入成果集。
接着假设HAO1里有反复的object_id，例如我们第三次从HAO1取出的object_id=2，那么因为我们对于子查询来说，已经有输入输出对（2，1）在hash table里了，所以就不消去再次全表扫描HAO2了，ORACLE很是聪慧地知道object_id=2是成果集。这里，filter和neested loop比拟，省去了一次全表扫描HAO2。
这个hash table是有大小限制的，当被占满的时辰，后续新的HAO1.object_id的FILTER就类似neested loop了。
由此可见，从buffer gets层面上来看，FILTER是应当优于neested loop的，尤其当外部查询须要传递给子查询的输入（此例中为HAO1.object_id）的distinct value很是小时，FILTER就会显得更优。
即使在我这个例子中，HAO1.object_id的distinct value上万，我对比了一下neested loop，FILTER仍然略优：
SQL> /*+use_nl（hao1 hao2）*/ hao1.object_id hao1，hao2 where hao1.object_id=hao2.object_id*10;
1038 rows ed.
ution Plan
----------------------------------------------------------
Plan hash value: 251947914
---------------------------------------------------------------------------
| Id | Operation | Name | Rows | Bytes | Cost （％CPU）| Time |
---------------------------------------------------------------------------
| 0 | SELECT STATEMENT | | 10663 | 85304 | 404K （2）| 01:07:23 |
| 1 | NESTED LOOPS | | 10663 | 85304 | 404K （2）| 01:07:23 |
| 2 | TABLE ACCESS FULL| HAO1 | 10662 | 42648 | 40 （3）| 00:00:01 |
|* 3 | TABLE ACCESS FULL| HAO2 | 1 | 4 | 38 （3）| 00:00:01 |
---------------------------------------------------------------------------
Predicate Information （identified by operation id）:
---------------------------------------------------
3 - filter（"HAO1"."OBJECT_ID"="HAO2"."OBJECT_ID"*10）
Statistics
----------------------------------------------------------
1 recursive calls
0 db block gets
1503621 consistent gets
0 physical reads
0 redo size
18715 bytes sent via SQL*Net to client
1251 bytes received via SQL*Net client
71 SQL*Net roundtrips to/ client
0 sorts （memory）
0 sorts （disk）
1038 rows processed
FILTER的consistent gets是1369157，neested loop的consistent gets是1503621。
若是我们验证我前面的结论，我们可以用distinct value较小的object_type来做个类似的对比实验。
SQL> hao1.object_id hao1 where exists
2 （ /*+no_unnest*/ 1 hao2 where hao1.object_type=hao2.object_type）;
10662 rows ed.
ution Plan
----------------------------------------------------------
Plan hash value: 2565749733
---------------------------------------------------------------------------
| Id | Operation | Name | Rows | Bytes | Cost （％CPU）| Time |
---------------------------------------------------------------------------
| 0 | SELECT STATEMENT | | 288 | 3168 | 114 （1）| 00:00:02 |
|* 1 | FILTER | | | | | |
| 2 | TABLE ACCESS FULL| HAO1 | 10662 | 114K| 40 （3）| 00:00:01 |
|* 3 | TABLE ACCESS FULL| HAO2 | 2 | 14 | 2 （0）| 00:00:01 |
---------------------------------------------------------------------------
Predicate Information （identified by operation id）:
---------------------------------------------------
1 - filter（ EXISTS （SELECT /*+ NO_UNNEST */ 0 FROM "HAO2" "HAO2"
WHERE "HAO2"."OBJECT_TYPE"=:B1））
3 - filter（"HAO2"."OBJECT_TYPE"=:B1）
Statistics
----------------------------------------------------------
1 recursive calls
0 db block gets
17012 consistent gets
0 physical reads
0 redo size
187491 bytes sent via SQL*Net to client
8302 bytes received via SQL*Net client
712 SQL*Net roundtrips to/ client
0 sorts （memory）
0 sorts （disk）
10662 rows processed
可见，同样是HAO1和HAO2的全表扫描后的FILTER操纵，却因为传给子查询的输入的distinct value的差别，两者相差的consistent gets却如此重大，这跟neested loop是完全不一样的。
当然，对于如此的两个全表扫描的成果集，应用hash join是最佳办法。
SQL> hao1.object_id hao1 where exists
2 （ 1 hao2 where hao1.object_type=hao2.object_type）;
10662 rows ed.
ution Plan
----------------------------------------------------------
Plan hash value: 3371915275
-----------------------------------------------------------------------------
| Id | Operation | Name | Rows | Bytes | Cost （％CPU）| Time |
-----------------------------------------------------------------------------
| 0 | SELECT STATEMENT | | 10662 | 187K| 81 （4）| 00:00:01 |
|* 1 | HASH JOIN RIGHT SEMI| | 10662 | 187K| 81 （4）| 00:00:01 |
| 2 | TABLE ACCESS FULL | HAO2 | 10663 | 74641 | 40 （3）| 00:00:01 |
| 3 | TABLE ACCESS FULL | HAO1 | 10662 | 114K| 40 （3）| 00:00:01 |
-----------------------------------------------------------------------------
Predicate Information （identified by operation id）:
---------------------------------------------------
1 - access（"HAO1"."OBJECT_TYPE"="HAO2"."OBJECT_TYPE"）
Statistics
----------------------------------------------------------
1 recursive calls
0 db block gets
985 consistent gets
0 physical reads
0 redo size
187491 bytes sent via SQL*Net to client
8302 bytes received via SQL*Net client
712 SQL*Net roundtrips to/ client
0 sorts （memory）
0 sorts （disk）
10662 rows processed
所以，什么时辰该用no_unnest使得子查询可以或许自力的履行完毕之后再跟外围的查询做FILTER？
起首，子查询的返回成果集应当较小，然后外围查询的输入的distinct value也应当较小（例如object_type）。
2.push_subq
若是说no_unnest是为了让子查询不展开，自力的完成，那么push_subq就是为了让子查询最进步前辈行join。
所以，这个hint其实是把握的join的次序。
例如某次在临盆库中碰到的一个SQL，简化一下然后模仿一下：
create table hao1 as * dba_objects;
create table hao2 as * dba_objects;
create table hao3 as * dba_objects;
create table hao4 as * dba_objects;
create index hao3idx on hao3（object_id）;
（analyze all tables。）
hao1.object_name
hao1，hao2，hao4
where hao1.object_name like ""％a％""
and hao1.object_id+hao2.object_id>50
and hao4.object_type=hao1.object_type
and 11 in
（SELECT hao3.object_id FROM hao3 WHERE hao1.object_id = hao3.object_id）;
对于如上的SQL，此中hao3和hao1在子查询中join，
很明显，若是先让hao1和hao3经由过程join，成果集估计只有一行，或者没有。
然则，此时CBO做出的履行规划为：
--------------------------------------------------------------------------------
| Id | Operation | Name | Rows | Bytes | Cost （％CPU）| Time |
--------------------------------------------------------------------------------
| 0 | SELECT STATEMENT | | 89077 | 3131K| 2070M （1）|999:59:59 |
|* 1 | FILTER | | | | | |
|* 2 | HASH JOIN | | 3234M| 108G| 289K （24）| 00:48:17 |
| 3 | TABLE ACCESS FULL | HAO4 | 36309 | 212K| 126 （3）| 00:00:02 |
| 4 | NESTED LOOPS | | 3296K| 94M| 224K （2）| 00:37:28 |
|* 5 | TABLE ACCESS FULL| HAO1 | 1816 | 47216 | 126 （3）| 00:00:02 |
|* 6 | TABLE ACCESS FULL| HAO2 | 1815 | 7260 | 124 （2）| 00:00:02 |
|* 7 | FILTER | | | | | |
|* 8 | INDEX RANGE SCAN | HAO3IDX | 1 | 4 | 1 （0）| 00:00:01 |
--------------------------------------------------------------------------------
Predicate Information （identified by operation id）:
---------------------------------------------------
1 - filter（ EXISTS （SELECT /*+ */ 0 FROM "HAO3" "HAO3" WHERE 11=:B1
AND "HAO3"."OBJECT_ID"=11））
2 - access（"HAO4"."OBJECT_TYPE"="HAO1"."OBJECT_TYPE"）
5 - filter（"HAO1"."OBJECT_NAME" LIKE ""％a％""）
6 - filter（"HAO1"."OBJECT_ID"+"HAO2"."OBJECT_ID">50）
7 - filter（11=:B1）
8 - access（"HAO3"."OBJECT_ID"=11）
由上可见，hao1和hao2，hao4进步前辈行无穷无尽的join之后，最后才跟hao3 join，这是很是坏的plan。
于是，我们hao1和hao3地点子查询先join，可以采取push_subq：
/*+push_subq（＠tmp）*/ hao1.object_name
hao1，hao2，hao4
where hao1.object_name like ""％a％""
and hao1.object_id+hao2.object_id>50
and hao4.object_type=hao1.object_type
and 11 in
（SELECT /*+QB_Name（tmp）*/ hao3.object_id FROM hao3 WHERE hao1.object_id = hao3.object_id）;
--------------------------------------------------------------------------------
| Id | Operation | Name | Rows | Bytes | Cost （％CPU）| Time |
--------------------------------------------------------------------------------
| 0 | SELECT STATEMENT | | 161M| 5552M| 14749 （24）| 00:02:28 |
|* 1 | HASH JOIN | | 161M| 5552M| 14748 （24）| 00:02:28 |
| 2 | TABLE ACCESS FULL | HAO4 | 36309 | 212K| 126 （3）| 00:00:02 |
| 3 | NESTED LOOPS | | 164K| 4828K| 11386 （2）| 00:01:54 |
|* 4 | TABLE ACCESS FULL | HAO1 | 91 | 2366 | 126 （3）| 00:00:02 |
|* 5 | FILTER | | | | | |
|* 6 | INDEX RANGE SCAN| HAO3IDX | 1 | 4 | 1 （0）| 00:00:01 |
|* 7 | TABLE ACCESS FULL | HAO2 | 1815 | 7260 | 124 （2）| 00:00:02 |
--------------------------------------------------------------------------------
Predicate Information （identified by operation id）:
---------------------------------------------------
1 - access（"HAO4"."OBJECT_TYPE"="HAO1"."OBJECT_TYPE"）
4 - filter（"HAO1"."OBJECT_NAME" LIKE ""％a％"" AND EXISTS （SELECT /*+
PUSH_SUBQ QB_NAME （"TMP"） */ 0 FROM "HAO3" "HAO3" WHERE 11=:B1 AND
"HAO3"."OBJECT_ID"=11））
5 - filter（11=:B1）
6 - access（"HAO3"."OBJECT_ID"=11）
7 - filter（"HAO1"."OBJECT_ID"+"HAO2"."OBJECT_ID">50）
加上hint后，SQL会在1秒以内完成。
3.push_pred
在谈到push_pred这个hint时，起首要搞清楚mergeable view和unmergeable view的差别。
这个在concept上有明白申明：
Mergeable and Unmergeable ViewsThe optimizer can merge a view into a referencing query block when the view has one or more base tables， provided the view does not contain:
- set operators （UNION， UNION ALL， INTERSECT， MINUS）
真谛，哪怕只见到一线，我们也不克不及让它的光辉变得暗淡。
- a CONNECT BY clause
- a ROWNUM pseudocolumn
- aggregate functions （AVG， COUNT， MAX， MIN， SUM） in the list
When a view contains one of the following structures， it can be merged into a referencing query block only if complex view merging is enabled （as described below）:
- a GROUP BY clause
- a DISTINCT operator in the list
View merging is not possible for a view that has multiple base tables if it is on the right side of an outer join. If a view on the right side of an outer join has only one base table， however， the optimizer can use complex view merging even if an expression in the view can return a non-null value for a NULL. See "Views in Outer Joins" for more information.
这里在最后，我们发明一个unmergeable view的一种景象就是view在outer join的右侧。
对于这种景象，我们熟知的merge hint也无效。
例如：
create or replace view haoview as
hao1.* hao1，hao2
where hao1.object_id=hao2.object_id;
那么对于如许一个简单的查询，可见谓词hao3.object_name=haoview.object_name被merge到了view中：
hao3.object_name
hao3，haoview
where hao3.object_name=haoview.object_name
and hao3.object_id=999;
-----------------------------------------------------------------------------------------
| Id | Operation | Name | Rows | Bytes | Cost （％CPU）| Time |
-----------------------------------------------------------------------------------------
| 0 | SELECT STATEMENT | | 1 | 44 | 129 （3）| 00:00:02 |
| 1 | NESTED LOOPS | | 1 | 44 | 129 （3）| 00:00:02 |
|* 2 | HASH JOIN | | 1 | 40 | 128 （3）| 00:00:02 |
| 3 | TABLE ACCESS BY INDEX ROWID| HAO3 | 1 | 20 | 2 （0）| 00:00:01 |
|* 4 | INDEX RANGE SCAN | HAO3IDX | 1 | | 1 （0）| 00:00:01 |
| 5 | TABLE ACCESS FULL | HAO1 | 36311 | 709K| 125 （2）| 00:00:02 |
|* 6 | INDEX RANGE SCAN | HAO2IDX | 1 | 4 | 1 （0）| 00:00:01 |
-----------------------------------------------------------------------------------------
Predicate Information （identified by operation id）:
---------------------------------------------------
2 - access（"HAO3"."OBJECT_NAME"="HAO1"."OBJECT_NAME"）
4 - access（"HAO3"."OBJECT_ID"=999）
6 - access（"HAO1"."OBJECT_ID"="HAO2"."OBJECT_ID"）
接着，我把haoview放到outer join的右侧，这是haoview就属于unmergeable view了，优化器默认无法将谓词merge进这个haoview中，于是就看到了haoview零丁先履行：
hao3.object_name
hao3，haoview
where hao3.object_name=haoview.object_name（+）
and hao3.object_id=999;
----------------------------------------------------------------------------------------
| Id | Operation | Name | Rows | Bytes | Cost （％CPU）| Time |
----------------------------------------------------------------------------------------
| 0 | SELECT STATEMENT | | 1 | 86 | 153 （5）| 00:00:02 |
|* 1 | HASH JOIN OUTER | | 1 | 86 | 153 （5）| 00:00:02 |
| 2 | TABLE ACCESS BY INDEX ROWID| HAO3 | 1 | 20 | 2 （0）| 00:00:01 |
|* 3 | INDEX RANGE SCAN | HAO3IDX | 1 | | 1 （0）| 00:00:01 |
| 4 | VIEW | HAOVIEW | 36309 | 2340K| 150 （4）| 00:00:02 |
|* 5 | HASH JOIN | | 36309 | 850K| 150 （4）| 00:00:02 |
| 6 | INDEX FAST FULL SCAN | HAO2IDX | 36309 | 141K| 22 （5）| 00:00:01 |
| 7 | TABLE ACCESS FULL | HAO1 | 36311 | 709K| 125 （2）| 00:00:02 |
----------------------------------------------------------------------------------------
Predicate Information （identified by operation id）:
---------------------------------------------------
1 - access（"HAO3"."OBJECT_NAME"="HAOVIEW"."OBJECT_NAME"（+））
3 - access（"HAO3"."OBJECT_ID"=999）
5 - access（"HAO1"."OBJECT_ID"="HAO2"."OBJECT_ID"）
接着，我们来应用这里的hint push_pred强迫优化器将谓词merge进view中，可见到“VIEW PUSHED PREDICATE”：
/*+push_pred（haoview）*/ hao3.object_name
hao3，haoview
where hao3.object_name=haoview.object_name（+）
and hao3.object_id=999;
----------------------------------------------------------------------------------------
| Id | Operation | Name | Rows | Bytes | Cost （％CPU）| Time |
----------------------------------------------------------------------------------------
| 0 | SELECT STATEMENT | | 1 | 40 | 128 （2）| 00:00:02 |
| 1 | NESTED LOOPS OUTER | | 1 | 40 | 128 （2）| 00:00:02 |
| 2 | TABLE ACCESS BY INDEX ROWID| HAO3 | 1 | 36 | 2 （0）| 00:00:01 |
|* 3 | INDEX RANGE SCAN | HAO3IDX | 1 | | 1 （0）| 00:00:01 |
| 4 | VIEW PUSHED PREDICATE | HAOVIEW | 1 | 4 | 126 （2）| 00:00:02 |
| 5 | NESTED LOOPS | | 1 | 24 | 126 （2）| 00:00:02 |
|* 6 | TABLE ACCESS FULL | HAO1 | 1 | 20 | 125 （2）| 00:00:02 |
|* 7 | INDEX RANGE SCAN | HAO2IDX | 1 | 4 | 1 （0）| 00:00:01 |
----------------------------------------------------------------------------------------
Predicate Information （identified by operation id）:
---------------------------------------------------
3 - access（"HAO3"."OBJECT_ID"=999）
6 - filter（"HAO1"."OBJECT_NAME"="HAO3"."OBJECT_NAME"）
7 - access（"HAO1"."OBJECT_ID"="HAO2"."OBJECT_ID"）
于是，会有同窗问，那么merge hint可否有同样的结果呢？答案是，对于这种unmergeable view来说，merge hint无效。
/*+merge（haoview）*/ hao3.object_name
hao3，haoview
where hao3.object_name=haoview.object_name（+）
and hao3.object_id=999;
----------------------------------------------------------------------------------------
| Id | Operation | Name | Rows | Bytes | Cost （％CPU）| Time |
----------------------------------------------------------------------------------------
| 0 | SELECT STATEMENT | | 1 | 86 | 153 （5）| 00:00:02 |
|* 1 | HASH JOIN OUTER | | 1 | 86 | 153 （5）| 00:00:02 |
| 2 | TABLE ACCESS BY INDEX ROWID| HAO3 | 1 | 20 | 2 （0）| 00:00:01 |
|* 3 | INDEX RANGE SCAN | HAO3IDX | 1 | | 1 （0）| 00:00:01 |
| 4 | VIEW | HAOVIEW | 36309 | 2340K| 150 （4）| 00:00:02 |
|* 5 | HASH JOIN | | 36309 | 850K| 150 （4）| 00:00:02 |
| 6 | INDEX FAST FULL SCAN | HAO2IDX | 36309 | 141K| 22 （5）| 00:00:01 |
| 7 | TABLE ACCESS FULL | HAO1 | 36311 | 709K| 125 （2）| 00:00:02 |
----------------------------------------------------------------------------------------
Predicate Information （identified by operation id）:
---------------------------------------------------
1 - access（"HAO3"."OBJECT_NAME"="HAOVIEW"."OBJECT_NAME"（+））
3 - access（"HAO3"."OBJECT_ID"=999）
5 - access（"HAO1"."OBJECT_ID"="HAO2"."OBJECT_ID"）
可见，对于此种身处outger join右侧的view来说，merge hint已经力所不及了。
综上，对于大师斗劲轻易混合的三个hint：
no_unnest/unnest是针对子查询是否展开的，push_subq是针对子查询的连接次序的，push_pred则是针对unmergeable view应用外部查询谓词。
http://www.cnpetweb.com/a/xinxizhongxin/lanmu9/2012/0224/35636.html
Oracle三组难缠的hint no_unnest/unnest，push_subq，push_pred--平展化(转)的更多相关文章
- qlserver、Mysql、Oracle三种数据库的优缺点总结
这篇文章主要介绍了sqlserver.Mysql.Oracle三种数据库的优缺点总结,需要的朋友可以参考下 一.sqlserver优点:易用性.适合分布式组织的可伸缩性.用于决策支持的数据仓库功能 ...
- MySQL、SqlServer、Oracle 三种数据库的优缺点
MySQL.SqlServer.Oracle 三种数据库的优缺点 一.MySQL 优点: 缺点: 二.SqlServer 优点: 缺点: 三.Oracle 优点: 缺点: 一.MySQL 优点: 体积 ...
- PBOC金融IC卡，卡片与终端交互的13个步骤，简介-第三组
七:终端风险管理-必选但包含可选步骤异常文件:终端检查应用主账号是否在异常文件列表(卡号黑名单)中.商户强制联机:商户可以将当前交易强制为联机处理.最低限额:控制交易当前交易金额或同一张卡片连续几笔交 ...
- select、poll、epoll三组IO复用
int select(int nfds,fd_set* readfds,fd_set* writefds,fd_set* exceptfds,struct timeval* timeout)//其中n ...
- 三组I/O复用模型的比较
概论: select.poll和epoll三组I/O复用系统调用,这3组系统调用都能同时监听多个文件描述符.它们将等待由timeout参数指定的超时时间,直到一个或者多个文件描述符上有事件发生时返回. ...
- UberX及以上级别车奖励政策(优步北京第二、三组)
优步北京第二.三组: 定义为2015年6月1日至7月19日激活的司机(以优步后台数据显示为准) 滴滴快车单单2.5倍,注册地址:http://www.udache.com/如何注册Uber司机(全国版 ...
- 将如下三组不同类型的数据利用DataInputStream和DataOutputStream写入文件,然后从文件中读出
三组数据如下: {19.99 , 9.99 , 15.99 , 3.99 , 4.99} {12 , 8 , 13 ,29 ,50} {"Java T-shirt" , " ...
- Uber优步北京第二、三组奖励政策
优步北京第二.三组: 定义为2015年6月1日至今激活的司机(以优步后台数据显示为准) 滴滴快车单单2.5倍,注册地址:http://www.udache.com/如何注册Uber司机(全国版最新最 ...
- 成都优步uber司机第三组奖励政策
今天成都优步又推出了优步司机第三组,第一二组的奖励大家都晓得,但是第三组的奖励怎么样呢?还是先看看官方给出的消息. 滴滴快车单单2.5倍,注册地址:http://www.udache.com/如何注册 ...
随机推荐
- android 12 click事件的不同实现方式
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layo ...
- 微信公众号支付流程（Node实现）
前言 花费了一天时间,调通了微信公众号支付.作下记录,方便以后再次填坑.先声明,微信公众号支付,不同于微信H5支付,这点在本文结束时再详细说明. 微信配置 设置测试目录 在微信公众平台设置,栏目见下图 ...
- memcached并发处理
memcached(十八)并发原语CAS与GETS操作 Memcached 并发控制 CAS 协议 memcache控制高并发问题 使用memcached进行并发控制 memcached的最佳实践方案
- 层叠样式优先级CSS
按照W3School网站(点这里直达)的说法,当同一个 HTML 元素被不止一个样式定义时,它们是有优先级之分的,如下,将优先级从小到大排列出来,其中4的优先级最高: 1.浏览器缺省设置2.外部样式表 ...
- JAva Collections类方法详解
http://blog.csdn.net/lskyne/article/details/8961014 Collections则是集合类的一个工具类/帮助类,其中提供了一系列静态方法,用于对集合中元素 ...
- xml中报错，验证是否是xml报错
1.xml中写入sql有时报错,例如有大于号小于号,要用<![CDATA[ ]]>扩起来 2.验证xml有错的方式,以浏览器方式打开,如果正常打开,无错. ...
- 【转】 UIView如何管理它的子视图
原文:http://my.oschina.net/u/1984662/blog/293690 目录[-] Core Animation基础 改变视图的层 动画支持 视图坐标系统 边框.边界.和中心的关 ...
- SGU 178.Chain
Solution: 一开始做的时候,以为可以将一条长度为n的链分成和n为的任意长度的3部分.结果第二组就Wa了 后来参考了题解,发现是将长度为n的链分成长度为1,x,n-1-x的三条链.再看看题目,不 ...
- spring配置中引入properties
<context:property-placeholder location="classpath*:db.properties" />
- IPython，让Python显得友好十倍的外套——windows XP/Win7安装详解
前言 学习python,官方版本其实足够了.但是如果追求更好的开发体验,耐得住不厌其烦地折腾.那么我可以负责任的告诉你:IPython是我认为的唯一显著好于原版python的工具. 整理了 ...