99久久精品久久久久久ai换脸,亚洲一区二区三区在线视频 ,青青草视频免费在线观看

... — Sat, 18 Jun 2011 08:33:00 GMT

��量用鸟语描�q�C��Q�翻译成中文反而容易误解�?br />

一、什么是执行计划

An explain plan is a representation of the access path that is taken when a query is executed within Oracle.

二、如何访问数�?/strong>

At the physical level Oracle reads blocks of data. The smallest amount of data read is a single Oracle block, the largest is constrained by operating system limits (and multiblock i/o). Logically Oracle finds the data to read by using the following methods:
Full Table Scan (FTS)    --全表扫描
Index Lookup (unique & non-unique)    --索引扫描�Q�唯一和非唯一�Q?/span>
Rowid    --物理行id

三、执行计划层�ơ关�p?/strong>

When looking at a plan, the rightmost (ie most inndented) uppermost operation is the first thing that is executed. --采用最��x��上最先执�?/span>的原则看层次关系�Q�在同一�U�如果某个动作没有子ID��最先执�?/span>

1.看一个简单的例子�Q?/span>

Query Plan
-----------------------------------------
SELECT STATEMENT [CHOOSE] Cost=1234
**TABLE ACCESS FULL LARGE [:Q65001] [ANALYZED] --[:Q65001]表示是�ƈ行方式，[ANALYZED]表示该对象已�l�分析过�?/span>

优化模式是CHOOSE的情况下�Q�看Cost参数是否有值来军_��采用CBO�q�是RBO�Q?br />SELECT STATEMENT [CHOOSE] Cost=1234 --Cost有��|��采用CBO
SELECT STATEMENT [CHOOSE] Cost= --Cost为空�Q�采用RBO

2.层次的父子关�p�，看比较复杂的例子�Q?/strong>

PARENT1
**FIRST CHILD
****FIRST GRANDCHILD
**SECOND CHILD

Here the same principles apply, the FIRST GRANDCHILD is the initial operation then the FIRST CHILD followed by the SECOND CHILD and finally the PARENT collates the output.

四、例子解�?/strong>

Execution Plan
----------------------------------------------------------
0 **SELECT STATEMENT Optimizer=CHOOSE (Cost=3 Card=8 Bytes=248)
1 0 **HASH JOIN (Cost=3 Card=8 Bytes=248)
2 1 ****TABLE ACCESS (FULL) OF 'DEPT' (Cost=1 Card=3 Bytes=36)
3 1 ****TABLE ACCESS (FULL) OF 'EMP' (Cost=1 Card=16 Bytes=304)

左侧的两排数据，前面的是序列号ID�Q�后面的是对应的PID�Q�父ID�Q��?br />

A shortened summary of this is:
Execution starts with ID=0: SELECT STATEMENT but this is dependand on it's child objects
So it executes its first child step: ID=1 PID=0 HASH JOIN but this is dependand on it's child objects
So it executes its first child step: ID=2 PID=1 TABLE ACCESS (FULL) OF 'DEPT'
Then the second child step: ID=3 PID=2 TABLE ACCESS (FULL) OF 'EMP'
Rows are returned to the parent step(s) until finished

五、表讉K��方式

1.Full Table Scan (FTS) 全表扫描

In a FTS operation, the whole table is read up to the high water mark (HWM). The HWM marks the last block in the table that has ever had data written to it. If you have deleted all the rows then you will still read up to the HWM. Truncate resets the HWM back to the start of the table. FTS uses multiblock i/o to read the blocks from disk.   --全表扫描模式下会��L��据到表的高水位线�Q�HWM卌��C��曄��扩展的最后一个数据块�Q�，��d��速度依赖于Oracle初始化参�?/span>db_block_multiblock_read_count

Query Plan
------------------------------------
SELECT STATEMENT [CHOOSE] Cost=1
**INDEX UNIQUE SCAN EMP_I1   --如果索引里就扑ֈ�了所要的数据�Q�就不会再去讉K��表了

2.Index Lookup 索引扫描

There are 5 methods of index lookup:

index unique scan   --索引唯一扫描
Method for looking up a single key value via a unique index. always returns a single value, You must supply AT LEAST the leading column of the index to access data via the index.
eg:
SQL> explain plan for select empno,ename from emp where empno=10;

index range scan   --索引局部扫�?/span>
Index range scan is a method for accessing a range values of a particular column. AT LEAST the leading column of the index must be supplied to access data via the index. Can be used for range operations (e.g. > < <> >= <= between) .
eg:
SQL> explain plan for select mgr from emp where mgr = 5;

index full scan   --索引全局扫描
Full index scans are only available in the CBO as otherwise we are unable to determine whether a full scan would be a good idea or not. We choose an index Full Scan when we have statistics that indicate that it is going to be more efficient than a Full table scan and a sort. For example we may do a Full index scan when we do an unbounded scan of an index and want the data to be ordered in the index order.
eg:
SQL> explain plan for select empno,ename from big_emp order by empno,ename;

index fast full scan   --索引快速全局扫描�Q�不带order by情况下常发生
Scans all the block in the index, Rows are not returned in sorted order, Introduced in 7.3 and requires V733_PLANS_ENABLED=TRUE and CBO, may be hinted using INDEX_FFS hint, uses multiblock i/o, can be executed in parallel, can be used to access second column of concatenated indexes. This is because we are selecting all of the index.
eg:
SQL> explain plan for select empno,ename from big_emp;

index skip scan   --索引跌��扫描�Q�where条�g列是非烦引的前导列情况下常发�?br />Index skip scan finds rows even if the column is not the leading column of a concatenated index. It skips the first column(s) during the search.
eg:
SQL> create index i_emp on emp(empno, ename);
SQL> select /*+ index_ss(emp i_emp)*/ job from emp where ename='SMITH';

3.Rowid 物理ID扫描

This is the quickest access method available.Oracle retrieves the specified block and extracts the rows it is interested in. --Rowid扫描是最快的讉K��数据方式

六、表�q�接方式

有三�U�连接方式：

1.Sort Merge Join (SMJ)    --�׃��sort是非常耗资源的�Q�所以这�U�连接方式要避免

Rows are produced by Row Source 1 and are then sorted Rows from Row Source 2 are then produced and sorted by the same sort key as Row Source 1. Row Source 1 and 2 are NOT accessed concurrently.

SQL> explain plan for
select /*+ ordered */ e.deptno,d.deptno
from emp e,dept d
where e.deptno = d.deptno
order by e.deptno,d.deptno;

Query Plan
-------------------------------------
SELECT STATEMENT [CHOOSE] Cost=17
**MERGE JOIN
****SORT JOIN
******TABLE ACCESS FULL EMP [ANALYZED]
****SORT JOIN
******TABLE ACCESS FULL DEPT [ANALYZED]

Sorting is an expensive operation, especially with large tables. Because of this, SMJ is often not a particularly efficient join method.

2.Nested Loops (NL)    --比较高效的一�U�连接方�?/span>

Fetches the first batch of rows from row source 1, Then we probe row source 2 once for each row returned from row source 1.
For nested loops to be efficient it is important that the first row source returns as few rows as possible as this directly controls the number of probes of the second row source. Also it helps if the access method for row source 2 is efficient as this operation is being repeated once for every row returned by row source 1.

SQL> explain plan for
select a.dname,b.sql
from dept a,emp b
where a.deptno = b.deptno;

Query Plan
-------------------------
SELECT STATEMENT [CHOOSE] Cost=5
**NESTED LOOPS
****TABLE ACCESS FULL DEPT [ANALYZED]
****TABLE ACCESS FULL EMP [ANALYZED]

3.Hash Join    --最为高效的一�U�连接方�?/span>

New join type introduced in 7.3, More efficient in theory than NL & SMJ, Only accessible via the CBO. Smallest row source is chosen and used to build a hash table and a bitmap The second row source is hashed and checked against the hash table looking for joins. The bitmap is used as a quick lookup to check if rows are in the hash table and are especially useful when the hash table is too large to fit in memory.

SQL> explain plan for
select /*+ use_hash(emp) */ empno
from emp,dept
where emp.deptno = dept.deptno;

Query Plan
----------------------------
SELECT STATEMENT [CHOOSE] Cost=3
**HASH JOIN
****TABLE ACCESS FULL DEPT
****TABLE ACCESS FULL EMP

Hash joins are enabled by the parameter HASH_JOIN_ENABLED=TRUE in the init.ora or session. TRUE is the default in 7.3.

3.Cartesian Product    --卡��_��积�Q�不��真正的�q�接方式�Q�sql肯定写的有问�?/span>

A Cartesian Product is done where they are no join conditions between 2 row sources and there is no alternative method of accessing the data. Not really a join as such as there is no join! Typically this is caused by a coding mistake where a join has been left out.
It can be useful in some circumstances - Star joins uses cartesian products.Notice that there is no join between the 2 tables:

SQL> explain plan for
select emp.deptno,dept,deptno
from emp,dept

Query Plan
------------------------------
SLECT STATEMENT [CHOOSE] Cost=5
**MERGE JOIN CARTESIAN
****TABLE ACCESS FULL DEPT
****SORT JOIN
******TABLE ACCESS FULL EMP

The CARTESIAN keyword indicate that we are doing a cartesian product.

七、运��符

1.sort    --排序�Q�很消耗资�?/span>

There are a number of different operations that promote sorts:
order by clauses
group by
sort merge join

2.filter    --�q��o�Q�如not in、min函数�{�容易��?br />

Has a number of different meanings, used to indicate partition elimination, may also indicate an actual filter step where one row source is filtering, another, functions such as min may introduce filter steps into query plans.

3.view    --视图�Q�大都由内联视图产生

When a view cannot be merged into the main query you will often see a projection view operation. This indicates that the 'view' will be selected from directly as opposed to being broken down into joins on the base tables. A number of constructs make a view non mergeable. Inline views are also non mergeable.
eg:
SQL> explain plan for
select ename,tot
from emp,(select empno,sum(empno) tot from big_emp group by empno) tmp
where emp.empno = tmp.empno;

Query Plan
------------------------
SELECT STATEMENT [CHOOSE]
**HASH JOIN
**TABLE ACCESS FULL EMP [ANALYZED]
**VIEW
****SORT GROUP BY
******INDEX FULL SCAN BE_IX

4.partition view     --分区视图

Partition views are a legacy technology that were superceded by the partitioning option. This section of the article is provided as reference for such legacy systems.

... 2011-06-18 16:33 发表评论

... — Sat, 18 Jun 2011 08:16:00 GMT

本文介绍了ORACLE执行计划的一些基本概念，供学习应用�?/span>

一�Q�相关的概念

Rowid的概念：rowid是一个伪列，既然是伪列，那么�q�个列就不是用户定义�Q�而是�pȝ��自己�l�加上的�?�Ҏ��个表都有一个rowid的伪列，但是表中�q�不物理存储ROWID列的倹{��不�q�你可以像��用其它列那样使用它，但是不能删除改列�Q�也不能对该列的��D��?修改、插入。一旦一行数据插入数据库�Q�则rowid在该行的生命周期内是唯一的，卛_��使该行��生行�q�移�Q�行的rowid也不会改变�?/span>

Recursive SQL概念�Q�有时�ؓ了执行用户发出的一个sql语句�Q�Oracle必须执行一些额外的语句�Q�我们将�q�些额外的语句称之�ؓ'recursive calls'�?recursive SQL statements'。如当一个DDL语句发出后，ORACLE��L��隐含的发��Z��些recursive SQL语句�Q�来修改数据字典信息�Q�以便用户可以成功的执行该DDL语句。当需要的数据字典信息没有在共享内存中�Ӟ��l�常会发生Recursive calls�Q�这些Recursive calls会将数据字典信息从硬盘读入内存中。用户不比关心这些recursive SQL语句的执行情况，在需要的时候，ORACLE会自动的在内部执行这些语句。当然DML语句与SELECT都可能引起recursive SQL。简单的��_��我们可以��触发器视�ؓrecursive SQL�?/span>

Row Source(行源)�Q�用在查询中�Q�由上一操作�q�回的符合条件的行的集合�Q�即可以是表的全部行数据的集合；也可以是表的部分行数据的集合�Q�也可以为对�?个row source�q�行�q�接操作(如join�q�接)后得到的行数据集合�?/span>

Predicate(谓词)�Q�一个查询中的WHERE限制条�g

Driving Table(驱动�?�Q�该表又�U�Cؓ外层�?OUTER TABLE)。这个概�는�于嵌套与HASH�q�接中。如果该row source�q�回较多的行数据�Q�则�Ҏ��有的后箋操作有负面媄响。注意此处虽然翻译�ؓ驱动表，但实际上��译为驱动行�?driving row source)更�ؓ��切。一般说来，是应用查询的限制条�g后，�q�回较少行源的表作�ؓ驱动表，所以如果一个大表在WHERE条�g有有限制条�g(如等值限 �?�Q�则该大表作为驱动表也是合适的�Q�所以�ƈ不是只有较小的表可以作�ؓ驱动表，正确说法应该为应用查询的限制条�g后，�q�回较少行源的表作�ؓ驱动表。在执行计划中，应该为靠上的那个row source�Q�后面会�l�出具体说明。在我们后面的描�q�C��Q�一般将该表�U�Cؓ�q�接操作的row source 1�?/span>

Probed Table(被探查表)�Q�该表又�U�Cؓ内层�?INNER TABLE)。在我们从驱动表中得到具体一行的数据后，在该表中��L��W�合�q�接条�g的行。所以该表应当�ؓ大表(实际上应该�ؓ�q�回较大row source的表)且相应的列上应该有烦引。在我们后面的描�q�C��Q�一般将该表�U�Cؓ�q�接操作的row source 2�?/span>

�l�合索引(concatenated index)�Q�由多个列构成的索引�Q�如create index idx_emp on emp(col1, col2, col3, ……)�Q�则我们�U�idx_emp索引为组合烦引。在�l�合索引中有一个重要的概念�Q�引导列(leading column)�Q�在上面的例子中�Q�col1列�ؓ引导列。当我们�q�行查询时可以��?#8221;where col1 = ? ”�Q�也可以使用”where col1 = ? and col2 = ?”�Q�这��L��限制条�g都会使用索引�Q�但�?#8221;where col2 = ? ”查询��׃��会��用该索引。所以限制条件中包含先导列时�Q�该限制条�g才会使用该组合烦引�?/span>

可选择�?selectivity)�Q�比较一下列中唯一键的数量和表中的行数�Q�就可以判断该列的可选择性�?如果该列�?#8221;唯一键的数量/表中的行�?#8221;的比��D��接近1�Q�则该列的可选择性越高，该列��p��适合创徏索引�Q�同��L��引的可选择性也��高。在可选择性高的列上进行查询时�Q�返回的数据��p��，比较适合使用索引查询�?/span>

二．oracle讉K��数据的存取方�?/span>

1) 全表扫描�Q�Full Table Scans, FTS�Q?/span>

为实现全表扫描，Oracle��d��表中所有的行，�q�检查每一行是否满��句的WHERE限制条�g一个多块读操作可以使一�ơI/O能读取多块数据块(db_block_multiblock_read_count参数讑֮�)�Q�而不是只��d��一个数据块�Q�这极大的减 ��了I/O��L��敎ͼ�提高了系�l�的吞吐量，所以利用多块读的方法可以十分高效地实现全表扫描�Q�而且只有在全表扫描的情况下才能��用多块读操作。在�q�种讉K��?式下�Q�每个数据块只被��M��ơ�?/span>

使用FTS的前提条�Ӟ��在较大的表上不徏议��用全表扫描，除非取出数据的比较多�Q�超�q�总量�?% -- 10%�Q�或你想使用�q�行查询功能时�?/span>

使用全表扫描的例子：

~~~~~~~~~~~~~~~~~~~~~~~~ SQL> explain plan for select * from dual;

Query Plan

-----------------------------------------

SELECT STATEMENT[CHOOSE] Cost=

TABLE ACCESS FULL DUAL

2) 通过ROWID的表存取�Q�Table Access by ROWID或rowid lookup�Q?/span>

行的ROWID指出了该行所在的数据文�g、数据块以及行在该块中的位置�Q�所以通过ROWID来存取数据可以快速定位到目标数据上，是Oracle存取单行数据的最快方法�?/span>

�q�种存取�Ҏ��不会用到多块��L��作，一�ơI/O只能��d��一个数据块。我们会�l�常在执行计划中看到该存取方法，如通过索引查询数据�?/span>

使用ROWID存取的方法： SQL> explain plan for select * from dept where rowid = 'AAAAyGAADAAAAATAAF';

Query Plan

------------------------------------

SELECT STATEMENT [CHOOSE] Cost=1

TABLE ACCESS BY ROWID DEPT [ANALYZED]

3�Q�烦引扫描（Index Scan或index lookup�Q?/span>

我们先通过index查找到数据对应的rowid�?对于非唯一索引可能�q�回多个rowid�?�Q�然后根据rowid直接从表中得到具体的数据�Q�这 �U�查找方式称为烦引扫描或索引查找(index lookup)。一个rowid唯一的表�C�Z��行数据，该行对应的数据块是通过一�ơi/o得到的，在此情况下该�ơi/o只会��d��一个数据库块�?/span>

在烦引中�Q�除了存储每个烦引的值外�Q�烦引还存储��h��此值的行对应的ROWID倹{��烦引扫描可以由2步组成：(1) 扫描索引得到对应的rowid倹{�?(2) 通过扑ֈ�的rowid从表中读出具体的数据。每步都是单独的一�ơI/O�Q�但是对于烦引，�׃��l�常使用�Q�绝大多数都已经CACHE到内存中�Q�所以第1步的 I/O�l�常是逻辑I/O�Q�即数据可以从内存中得到。但是对于第2步来��_��如果表比较大�Q�则其数据不可能全在内存中，所以其I/O很有可能是物理I/O�Q�这是一个机械操作，相对逻辑I/O来说�Q�是极其�Ҏ��间的。所以如果多大表�q�行索引扫描�Q�取出的数据如果大于总量�?% -- 10%�Q��用烦引扫描会效率下降很多。如下列所�C�：
SQL> explain plan for select empno, ename from emp where empno=10;

Query Plan

------------------------------------

SELECT STATEMENT [CHOOSE] Cost=1

TABLE ACCESS BY ROWID EMP [ANALYZED]

INDEX UNIQUE SCAN EMP_I1

但是如果查询的数据能全在索引中找刎ͼ��可以避免进行第2步操作，避免了不必要的I/O�Q�此时即佉K��过索引扫描取出的数据比较多�Q�效率还是很高的

SQL> explain plan for select empno from emp where empno=10;-- 只查询empno列�?/span>

Query Plan

------------------------------------

SELECT STATEMENT [CHOOSE] Cost=1

INDEX UNIQUE SCAN EMP_I1

�q�一步讲�Q�如果sql语句中对索引列进行排序，因�ؓ索引已经预先排序好了�Q�所以在执行计划中不需要再对烦引列�q�行排序
SQL> explain plan for select empno, ename from emp

where empno > 7876 order by empno;

Query Plan

--------------------------------------------------------------------------------

SELECT STATEMENT[CHOOSE] Cost=1

TABLE ACCESS BY ROWID EMP [ANALYZED]

INDEX RANGE SCAN EMP_I1 [ANALYZED]

从这个例子中可以看到�Q�因为烦引是已经排序了的�Q�所以将按照索引的顺序查询出�W�合条�g的行�Q�因此避免了�q�一步排序操作�?/span>

�Ҏ��索引的类型与where限制条�g的不同，�?�U�类型的索引扫描�Q?/span>

索引唯一扫描(index unique scan)

索引范围扫描(index range scan)

索引全扫�?index full scan)

索引快速扫�?index fast full scan)

(1) 索引唯一扫描(index unique scan)

通过唯一索引查找一个数值经常返回单个ROWID。如果存在UNIQUE 或PRIMARY KEY �U�束�Q�它保证了语句只存取单行�Q�的话，Oracle�l�常实现唯一性扫描�?/span>

使用唯一性约束的例子�Q?/span>

SQL> explain plan for

select empno,ename from emp where empno=10;

Query Plan

------------------------------------

SELECT STATEMENT [CHOOSE] Cost=1

TABLE ACCESS BY ROWID EMP [ANALYZED]

INDEX UNIQUE SCAN EMP_I1

(2) 索引范围扫描(index range scan)

使用一个烦引存取多行数据，在唯一索引上��用烦引范围扫描的典型情况下是在谓�?where限制条�g)中��用了范围操作�W?�?gt;�?lt;�?lt;>�?gt;=�?lt;=、between)

使用索引范围扫描的例子：

SQL> explain plan for select empno,ename from emp

where empno > 7876 order by empno;

Query Plan

--------------------------------------------------------------------------------

SELECT STATEMENT[CHOOSE] Cost=1

TABLE ACCESS BY ROWID EMP [ANALYZED]

INDEX RANGE SCAN EMP_I1 [ANALYZED]

在非唯一索引上，谓词col = 5可能�q�回多行数据�Q�所以在非唯一索引上都使用索引范围扫描�?/span>

使用index rang scan�?�U�情况：

(a) 在唯一索引列上使用了range操作�W?> < <> >= <= between)

(b) 在组合烦引上�Q�只使用部分列进行查询，��D��查询出多�?/span>

(c) 寚w��唯一索引列上�q�行的�Q何查询�?/span>

(3) 索引全扫�?index full scan)

与全表扫描对应，也有相应的全索引扫描。而且此时查询出的数据都必��M��索引中可以直接得到�?/span>

全烦引扫描的例子�Q?/span>

An Index full scan will not perform single block i/o's and so it may prove to be inefficient.

e.g.

Index BE_IX is a concatenated index on big_emp (empno, ename)

SQL> explain plan for select empno, ename from big_emp order by empno,ename;

Query Plan

--------------------------------------------------------------------------------

SELECT STATEMENT[CHOOSE] Cost=26

INDEX FULL SCAN BE_IX [ANALYZED]

(4) 索引快速扫�?index fast full scan)

扫描索引中的所有的数据块，�?index full scan很类��|��但是一个显著的区别��是它不�Ҏ��询出的数据进行排序，��x��据不是以排序��序被返回。在�q�种存取�Ҏ��中，可以使用多块��d��能，也可以��用�ƈ行读入，以便获得最大吞吐量与羃短执行时间�?/span>

索引快速扫描的例子�Q?/span>

BE_IX索引是一个多列烦引： big_emp (empno,ename)

SQL> explain plan for select empno,ename from big_emp;

Query Plan

------------------------------------------

SELECT STATEMENT[CHOOSE] Cost=1

INDEX FAST FULL SCAN BE_IX [ANALYZED]

只选择多列索引的第2列：

SQL> explain plan for select ename from big_emp;

Query Plan

------------------------------------------

SELECT STATEMENT[CHOOSE] Cost=1

INDEX FAST FULL SCAN BE_IX [ANALYZED]

�?表之间的�q�接

Join是一�U�试囑ְ�两个表结合在一��L��谓词�Q�一�ơ只能连�?个表�Q�表�q�接也可以被�U�Cؓ表关联。在后面的叙 �q�C��Q�我们将会��?#8221;row source”来代�?#8221;�?#8221;�Q�因��Z��用row source更严谨一些，�q�且��参与连接的2个row source分别�U�Cؓrow source1和row source 2。Join�q�程的各个步骤经常是串行操作�Q�即使相关的row source可以被�ƈ行访问，卛_��以�ƈ行的��d��做join�q�接的两个row source的数据，但是在将表中�W�合限制条�g的数据读入到内存形成row source后，join的其它步骤一般是串行的。有多种�Ҏ��可以��?个表�q�接��h��Q�当然每�U�方法都有自��q��优缺点，每种�q�接�c�d��只有在特定的条�g下才�?发挥出其最大优�ѝ�?/span>

row source(�?之间的连接顺序对于查询的效率有非常大的媄响。通过首先存取特定的表�Q�即��该表作为驱动表�Q�这样可以先应用某些限制条�g�Q�从而得��C��?较小的row source�Q��ɘq�接的效率较高，�q�也��是我们常说的要先执行限制条件的原因。一般是在将表读入内存时�Q�应用where子句中对该表的限制条件�?/span>

�Ҏ��2个row source的连接条件的中操作符的不同，可以��连接分为等��D��?如WHERE A.COL3 = B.COL4)、非�{��D��?WHERE A.COL3 > B.COL4)、外�q�接(WHERE A.COL3 = B.COL4(+))。上面的各个�q�接的连接原理都基本一��P��所以�ؓ了简单期��_��下面以等��D��接�ؓ例进行介�l��?/span>

在后面的介绍中，都已�Q?/span>

SELECT A.COL1, B.COL2

FROM A, B

WHERE A.COL3 = B.COL4;

��Z��q�行说明�Q�假设A表�ؓRow Soruce1�Q�则其对应的�q�接操作兌��列�ؓCOL 3�Q�B表�ؓRow Soruce2�Q�则其对应的�q�接操作兌��列�ؓCOL 4�Q?/span>

�q�接�c�d��Q?/span>

目前为止�Q�无��接操作符如何�Q�典型的�q�接�c�d��共有3�U�：

排序 - - 合�ƈ�q�接(Sort Merge Join (SMJ) )

嵌套循环(Nested Loops (NL) )

哈希�q�接(Hash Join)

排序 - - 合�ƈ�q�接(Sort Merge Join, SMJ)

内部�q�接�q�程�Q?/span>

1) 首先生成row source1需要的数据�Q�然后对�q�些数据按照�q�接操作兌��?如A.col3)�q�行排序�?/span>

2) 随后生成row source2需要的数据�Q�然后对�q�些数据按照与sort source1对应的连接操作关联列(如B.col4)�q�行排序�?/span>

3) 最后两边已排序的行被放在一��h��行合�q�操作，卛_��2个row source按照�q�接条�g�q�接��h��

下面是连接步骤的囑�Ş表示�Q?/span>

MERGE

/\

SORTSORT

||

Row Source 1Row Source 2

如果row source已经在连接关联列上被排序�Q�则该连接操作就不需要再�q�行sort操作�Q�这样可以大大提高这�U�连接操作的�q�接速度�Q�因为排序是个极其费资源的操作，特别是对于较大的表。预先排序的row source包括已经被烦引的�?如a.col3或b.col4上有索引)或row source已经在前面的步骤中被排序了。尽��合�q�两个row source的过�E�是串行的，但是可以�q�行讉K��q�两个row source(如�ƈ行读入数据，�q�行排序).

SMJ�q�接的例子：
SQL> explain plan for

select /*+ ordered */ e.deptno, d.deptno

from emp e, dept d

where e.deptno = d.deptno

order by e.deptno, d.deptno;

Query Plan

-------------------------------------

SELECT STATEMENT [CHOOSE] Cost=17

MERGE JOIN

SORT JOIN

TABLE ACCESS FULL EMP [ANALYZED]

SORT JOIN

TABLE ACCESS FULL DEPT [ANALYZED]

排序是一个费时、费资源的操作，特别对于大表。基于这个原因，SMJ�l�常不是一个特别有效的�q�接�Ҏ��Q�但是如�?个row source都已�l�预先排序，则这�U�连接方法的效率也是蛮高的�?/span>

嵌套循环(Nested Loops, NL)

�q�个�q�接�Ҏ��有驱动表(外部�?的概��c��其实，该连接过�E�就是一�?层嵌套��@环，所以外层��@环的�ơ数��少��好�Q�这也就是我们�ؓ什么将��表或返回较��?row source的表作�ؓ驱动�?用于外层循环)的理��Z��据。但是这个理论只是一般指导原则，因�ؓ遵��@�q�个理论�q�不能��M��证��语句产生的I/O�ơ数最��。有�?不遵守这个理��Z��据，反而会获得更好的效率。如果��用这�U�方法，军_��使用哪个表作为驱动表很重要。有时如果驱动表选择不正��，��会��D��语句的性能很差、很差�?/span>

内部�q�接�q�程�Q?/span>

Row source1的Row 1 ---------------- Probe ->Row source 2

Row source1的Row 2 ---------------- Probe ->Row source 2

Row source1的Row 3 ---------------- Probe ->Row source 2

…….

Row source1的Row n ---------------- Probe ->Row source 2

从内部连接过�E�来看，需要用row source1中的每一行，��d��配row source2中的所有行�Q�所以此时保持row source1��可能的��与高效的访问row source2(一般通过索引实现)是媄响这个连接效率的关键问题。这只是理论指导原则�Q�目的是使整个连接操作��生最��的物理I/O�ơ数�Q�而且如果遵守�q?个原则，一般也会��ȝ��物理I/O数最��。但是如果不遵从�q�个指导原则�Q�反而能用更��的物理I/O实现�q�接操作�Q�那��管�q�反指导原则吧！因�ؓ最��的物理 I/O�ơ数才是我们应该遵从的真正的指导原则�Q�在后面的具体案例分析中��q��L��例子�?/span>

在上面的�q�接�q�程中，我们�U�Row source1为驱动表或外部表。Row Source2被称��探查表或内部表�?/span>

在NESTED LOOPS�q�接中，Oracle��d��row source1中的每一行，然后在row sourc2中检查是否有匚w��的行�Q�所有被匚w��的行都被攑ֈ��l�果集中�Q�然后处理row source1中的下一行。这个过�E�一直��l�，直到row source1中的所有行都被处理。这是从�q�接操作中可以得到第一个匹配行的最快的�Ҏ��之一�Q�这�U�类型的�q�接可以用在需要快速响应的语句中，以响应速度�?主要目标�?/span>

如果driving row source(外部�?比较��，�q�且在inner row source(内部�?上有唯一索引�Q�或有高选择性非唯一索引�Ӟ��使用�q�种�Ҏ��可以得到较好的效率。NESTED LOOPS有其它连接方法没有的的一个优�Ҏ��Q�可以先�q�回已经�q�接的行�Q�而不必等待所有的�q�接操作处理完才�q�回数据�Q�这可以实现快速的响应旉��?/span>

如果不��用�ƈ行操作，最好的驱动表是那些应用了where 限制条�g后，可以�q�回较少行数据的的表�Q�所以大表也可能�U�Cؓ驱动表，关键看限制条件。对于�ƈ行查询，我们�l�常选择大表作�ؓ驱动表，因�ؓ大表可以充分利用�q?行功能。当�Ӟ��有时�Ҏ��询��用�ƈ行操作�ƈ不一定会比查询不使用�q�行操作效率高，因�ؓ最后可能每个表只有很少的行�W�合限制条�g�Q�而且�q�要看你的硬仉��|�是�?可以支持�q�行(如是否有多个CPU�Q�多个硬盘控制器)�Q�所以要具体问题具体对待�?/span>

NL�q�接的例子：

SQL> explain plan for

select a.dname,b.sql

from dept a,emp b

where a.deptno = b.deptno;

Query Plan

-------------------------

SELECT STATEMENT [CHOOSE] Cost=5

NESTED LOOPS

TABLE ACCESS FULL DEPT [ANALYZED]

TABLE ACCESS FULL EMP [ANALYZED]

哈希�q�接(Hash Join, HJ)

�q�种�q�接是在oracle 7.3以后引入的，从理��Z��来说比NL与SMJ更高效，而且只用在CBO优化器中�?/span>

较小的row source被用来构建hash table与bitmap�Q�第2个row source被用来被hansed�Q��ƈ与第一个row source生成的hash table�q�行匚w��Q�以便进行进一步的�q�接。Bitmap被用来作��Z��U�比较快的查找方法，来检查在hash table中是否有匚w��的行。特别的�Q�当hash table比较大而不能全部容�U�_��内存中时�Q�这�U�查找方法更为有用。这�U�连接方法也有NL�q�接中所谓的驱动表的概念�Q�被构徏为hash table与bitmap的表为驱动表�Q�当被构建的hash table与bitmap能被容纳在内存中�Ӟ��q�种�q�接方式的效率极高�?/span>

HASH�q�接的例子：

SQL> explain plan for

select /*+ use_hash(emp) */ empno

from emp, dept

where emp.deptno = dept.deptno;

Query Plan

----------------------------

SELECT STATEMENT[CHOOSE] Cost=3

HASH JOIN

TABLE ACCESS FULL DEPT

TABLE ACCESS FULL EMP

要��哈希�q�接有效�Q�需要设�|�HASH_JOIN_ENABLED=TRUE�Q�缺省情况下该参��CؓTRUE�Q�另外，不要忘了�q�要讄�� hash_area_size参数�Q�以使哈希连接高效运行，因�ؓ哈希�q�接会在该参数指定大��的内存中运行，�q�小的参��C��使哈希连接的性能比其他连接方式还要低�?/span>

�ȝ��一下，在哪�U�情况下用哪�U�连接方法比较好�Q?/span>

排序 - - 合�ƈ�q�接(Sort Merge Join, SMJ)�Q?/span>

a) 对于非等��D��接，�q�种�q�接方式的效率是比较高的�?/span>

b) 如果在关联的列上都有索引�Q�效果更好�?/span>

c) 对于��?个较大的row source做连接，该连接方法比NL�q�接要好一些�?/span>

d) 但是如果sort merge�q�回的row source�q�大�Q�则又会��D��使用�q�多的rowid在表中查询数据时�Q�数据库性能下降�Q�因��多的I/O�?/span>

嵌套循环(Nested Loops, NL)�Q?/span>

a) 如果driving row source(外部�?比较��，�q�且在inner row source(内部�?上有唯一索引�Q�或有高选择性非唯一索引�Ӟ��使用�q�种�Ҏ��可以得到较好的效率�?/span>

b) NESTED LOOPS有其它连接方法没有的的一个优�Ҏ��Q�可以先�q�回已经�q�接的行�Q�而不必等待所有的�q�接操作处理完才�q�回数据�Q�这可以实现快速的响应旉��?/span>

哈希�q�接(Hash Join, HJ)�Q?/span>

a) �q�种�Ҏ��是在oracle7后来引入的，使用了比较先�q�的�q�接理论�Q�一般来��_��其效率应该好于其�?�U�连接，但是�q�种�q�接只能用在CBO优化器中�Q�而且需要设�|�合适的hash_area_size参数�Q�才能取得较好的性能�?/span>

b) �?个较大的row source之间�q�接时会取得相对较好的效率，在一个row source较小时则能取得更好的效率�?/span>

c) 只能用于�{��D��接中

�W�卡儿乘�U?Cartesian Product)

当两个row source做连接，但是它们之间没有兌��条�g�Ӟ��׃��在两个row source中做�W�卡儿乘�U�，�q�通常��q��写代码疏漏造成(即程序员忘了写关联条�?。笛卡尔乘积是一个表的每一行依�ơ与另一个表中的所有行匚w��。在�Ҏ��?况下我们可以使用�W�卡儿乘�U�，如在星�Ş�q�接中，除此之外�Q�我们要��量使用�W�卡儿乘�U�，否则�Q�自己想�l�果是什么吧�Q?/span>

注意在下面的语句中，�?个表之间没有�q�接�?/span>

SQL> explain plan for

select emp.deptno,dept,deptno

from emp,dept

Query Plan

------------------------

SLECT STATEMENT [CHOOSE] Cost=5

MERGE JOIN CARTESIAN

TABLE ACCESS FULL DEPT

SORT JOIN

TABLE ACCESS FULL EMP

CARTESIAN关键字指��Z��?个表之间做笛卡尔乘积。假如表emp有n行，dept表有m行，�W�卡��乘�U�的�l�果��是得到n * m行结果�?/span>

... 2011-06-18 16:16 发表评论

[转]你是否懂得Oracle UNION ALL

... — Sat, 18 Jun 2011 08:01:00 GMT

Oracle有很多值得学习的地方，�q�里我们主要介绍Oracle UNION ALL�Q�包括介�l?span lang="EN-US">UNION�{�方面。通常情况下，�?span lang="EN-US">UNION替换WHERE子句中的OR��会起到较好的效果。对索引列��?span lang="EN-US">OR��造成全表扫描。注意，以上规则只针对多个烦引列有效。假如有column没有被烦引，查询效率可能会因为您没有选择OR而降低。在下面的例子中�Q?span lang="EN-US">LOC_ID �?span lang="EN-US">REGION上都建有索引�?span lang="EN-US">

高效�Q?span lang="EN-US">
1. SELECT LOC_ID �?/span> LOC_DESC �Q?/span>REGION FROM LOCATION WHERE LOC_ID = 10 UNION SELECT LOC_ID �Q?/span>
LOC_DESC �Q?/span>REGION FROM LOCATION WHERE REGION = “MELBOURNE”

低效:
1. SELECT LOC_ID �Q?/span>LOC_DESC �Q?/span>REGION FROM LOCATION WHERE LOC_ID = 10 OR REGION = “MELBOURNE”

�?span lang="EN-US">IN来替�?span lang="EN-US">OR�Q?/span>

�q�是一条简单易记的规则�Q�但是实际的执行效果�q�须��验，�?span lang="EN-US">Oracle8i下，两者的执行路径��g��是相同的:

低效:
1. SELECT…. FROM LOCATION WHERE LOC_ID = 10 OR LOC_ID = 20 OR LOC_ID = 30

高效�Q?span lang="EN-US">
1. SELECT… FROM LOCATION WHERE LOC_IN IN (10,20,30);

避免在烦引列上��?span lang="EN-US">IS NULL�?span lang="EN-US">IS NOT NULL�Q?/span>

避免在烦引中使用��M��能够为空的列�Q?span lang="EN-US">Oracle��无法��用该索引。对于单列烦引，假如列包含空��|��索引中将不存在此记录。对于复合烦引，假如每个列都为空�Q�烦引中同样不存在此记录。假如至��有一个列不�ؓ�I�，则记录存在于索引中。�D例：假如唯一性烦引徏立在表的A列和B列上�Q��ƈ且表中存在一条记录的 A�Q?span lang="EN-US">B��gؓ(123�Q?span lang="EN-US">null)�Q?span lang="EN-US"> Oracle��不接受下一条具备相�?span lang="EN-US">A�Q?span lang="EN-US">B��|��123,null�Q�的记录(插入)。然而假如�Q何的索引列都为空�Q?span lang="EN-US">Oracle��认为整个键��gؓ�I��空不等于空。因此您能够插入1000 条具备相同键值的记录,当然他们都是�I?span lang="EN-US">! 因�ؓ�I��g��存在于烦引列�?span lang="EN-US">,所�?span lang="EN-US">WHERE子句中对索引列进行空值比较将�?span lang="EN-US">ORACLE停用该烦引�?span lang="EN-US">

��L��使用索引的第一个列�Q?/span>

假如索引是徏立在多个列上�Q�只有在他的�W�一个列(leading column)�?span lang="EN-US">where子句引用�Ӟ��优化器才会选择使用该烦引。这也是一条简单而重要的规则�Q�当仅引用烦引的�W�二个列�Ӟ��优化器��用了全表扫描而忽略了索引�?span lang="EN-US">

�?span lang="EN-US">Oracle UNION ALL替换UNION ( 假如有可能的�?span lang="EN-US">)�Q?/span>

�?span lang="EN-US">SQL语句需�?span lang="EN-US">UNION两个查询�l�果集合�Ӟ��q�两个结果集合会�?span lang="EN-US">Oracle UNION ALL的方式被合�ƈ�Q�然后在输出最�l�结果前�q�行排序。假如用 Oracle UNION ALL替代UNION�Q�这��h��序就不是必要了。效率就会因此得到提高。需要注意的是，Oracle UNION ALL��重复输��Z��个结果集合中相同记录。因此各位还是要从业务需求分析��?span lang="EN-US">Oracle UNION ALL的可行性�?span lang="EN-US"> UNION ��对�l�果集合排序,�q�个操作会��用到SORT_AREA_SIZE�q�块内存。对于这块内存的优化也是相当重要的�?span lang="EN-US">

... 2011-06-18 16:01 发表评论

[转]hibernate抓取�{�略

... — Sat, 18 Jun 2011 07:33:00 GMT

原文�Q?a >http://jiangxuwen7515.blog.163.com/blog/static/817523502010730481252/?fromdm&fromSearch&isFromSearchEngine=yes

一�?/span>hibernate抓取�{�略�Q�单端代理的扚w��抓取fetch=select(默认�Q?/span>/join�Q?/span>

��试用例�Q?/span>

Student student = (Student)session.get(Student.class, 1);
System.out.println(student.getName());
System.out.println(student.getClasses().getName());

1�Q�保�?/span>默认�Q�同fetch="select",如：
fetch="select"/>

fetch="select",另外发送一�?/span>select语句抓取当前对象兌��实体或集�?/span>

执行�l�果�Q?/span>2条语�?/span>

Hibernate: select student0_.id as id1_0_, student0_.name as name1_0_, student0_.class_id as class3_1_0_ from student_join student0_ where student0_.id=?
学生1
Hibernate: select classes0_.id as id0_0_, classes0_.name as name0_0_ from classes_join classes0_ where classes0_.id=?
高一(1)�?/span>

======================================

2�Q�设�|?/span>fetch="join",如：
fetch="join"/>

fetch="join",hibernate会通过select语句使用外连接来加蝲其关联实体或集合

此时lazy会失�?/span>

执行�l�果�Q�一�?/span>join语句

Hibernate: select student0_.id as id1_1_, student0_.name as name1_1_, student0_.class_id as class3_1_1_, classes1_.id as id0_0_, classes1_.name as name0_0_ from student_join student0_ left outer join classes_join classes1_ on student0_.class_id=classes1_.id where student0_.id=?
学生1
高一(1)�?/span>

======================================================

二�?/span>hibernate抓取�{�略�Q�集合代理的扚w��抓取�Q?/span>fetch=select�Q�默认）/join/subselect�Q?/span>

��试用例�Q?/span>

Classes c = (Classes) session.load(Classes.class, new Integer(1));
    System.out.println("Class.name=" + c.getName());
    Set stuSet = c.getStudents();
    System.out.println(stuSet.size());
    if(stuSet != null && !stuSet.isEmpty()){
     for(Iterator it = stuSet.iterator(); it.hasNext();){
      Student s = (Student) it.next();
      System.out.println("student.name=" + s.getName());
     }
    }

1�Q�保持默认，�?/span>fetch="select",如：
fetch="select">

fetch="select",另外发送一�?/span>select语句抓取当前对象兌��实体或集�?/span>

��试�l�果�Q?/span>2条独立的查询语句

Hibernate: select classes0_.id as id0_0_, classes0_.name as name0_0_ from classes_join classes0_ where classes0_.id=?
Class.name=高一(1)�?/span>
Hibernate: select students0_.class_id as class3_1_, students0_.id as id1_, students0_.id as id1_0_, students0_.name as name1_0_, students0_.class_id as class3_1_0_ from student_join students0_ where students0_.class_id=?
9
student.name=学生7
student.name=学生3
student.name=学生1
student.name=学生8
student.name=学生2
student.name=学生4
student.name=学生5
student.name=学生9
student.name=学生6

(2)讄��fetch="join",如：
fetch="join">

fetch="join",hibernate会通过select语句使用外连接来加蝲其关联实体或集合

此时lazy会失�?/span>

��试�l�果�Q?/span>1条独立的join查询语句

Hibernate: select classes0_.id as id0_1_, classes0_.name as name0_1_, students1_.class_id as class3_3_, students1_.id as id3_, students1_.id as id1_0_, students1_.name as name1_0_, students1_.class_id as class3_1_0_ from classes_join classes0_ left outer join student_join students1_ on classes0_.id=students1_.class_id where classes0_.id=?
Class.name=高一(1)�?/span>
9
student.name=学生6
student.name=学生4
student.name=学生9
student.name=学生7
student.name=学生2
student.name=学生3
student.name=学生8
student.name=学生1
student.name=学生5

(3)讄��fetch="subselect",如：用在查询语句�?/span>
fetch="subselect">

fetch="subselect",另外发送一�?/span>select语句抓取在前面查询到的所有实体对象的兌��集合

��试用例�Q?/span>

List classList = session.createQuery("from Classes where id in (1,2,3)").list();
    for(Iterator iter = classList.iterator(); iter.hasNext();){
     Classes c = (Classes)iter.next();
     System.out.println("Class.name=" + c.getName());
     Set stuSet = c.getStudents();
     System.out.println(stuSet.size());
     if(stuSet != null && !stuSet.isEmpty()){
      for(Iterator it = stuSet.iterator(); it.hasNext();){
       Student s = (Student) it.next();
       System.out.println("student.name=" + s.getName());
      }
     }
    }

当不�?/span>fetch="subselect" ,卻I��,�l�果如下�Q?/span>

执行�?/span>3条查询语�?/span>

Hibernate: select classes0_.id as id0_, classes0_.name as name0_ from classes_join classes0_ where classes0_.id in (1 , 2 , 3)
Class.name=高一(1)�?/span>
Hibernate: select students0_.class_id as class3_1_, students0_.id as id1_, students0_.id as id1_0_, students0_.name as name1_0_, students0_.class_id as class3_1_0_ from student_join students0_ where students0_.class_id=?
9
student.name=学生8
student.name=学生5
student.name=学生3
student.name=学生9
student.name=学生7
student.name=学生1
student.name=学生4
student.name=学生6
student.name=学生2
Class.name=高一(2)�?/span>
Hibernate: select students0_.class_id as class3_1_, students0_.id as id1_, students0_.id as id1_0_, students0_.name as name1_0_, students0_.class_id as class3_1_0_ from student_join students0_ where students0_.class_id=?
4
student.name=学生3
student.name=学生4
student.name=学生1
student.name=学生2
Class.name=高一(3)�?/span>
Hibernate: select students0_.class_id as class3_1_, students0_.id as id1_, students0_.id as id1_0_, students0_.name as name1_0_, students0_.class_id as class3_1_0_ from student_join students0_ where students0_.class_id=?
0

当不�?/span>fetch="subselect" ,卻I��subselect">,�l�果如下�Q?/span>

执行�?/span>1条查询语句（嵌套子查询）

Hibernate: select classes0_.id as id0_, classes0_.name as name0_ from classes_join classes0_ where classes0_.id in (1 , 2 , 3)
Class.name=高一(1)�?/span>
Hibernate: select students0_.class_id as class3_1_, students0_.id as id1_, students0_.id as id1_0_, students0_.name as name1_0_, students0_.class_id as class3_1_0_ from student_join students0_ where students0_.class_id in (select classes0_.id from classes_join classes0_ where classes0_.id in (1 , 2 , 3))
9
student.name=学生8
student.name=学生4
student.name=学生5
student.name=学生9
student.name=学生6
student.name=学生2
student.name=学生3
student.name=学生1
student.name=学生7
Class.name=高一(2)�?/span>
4
student.name=学生3
student.name=学生4
student.name=学生2
student.name=学生1
Class.name=高一(3)�?/span>
0

... 2011-06-18 15:33 发表评论

[转]Hibernate性能优化要点

... — Sat, 18 Jun 2011 04:27:00 GMT

Robbin�ȝ��的Hibernate性能优化要点�Q?/span>

1.��量使用many-to-one�Q�避免��用单��one-to-many
2.灉|��使用单向one-to-many
3.不用一对一�Q��用多对一代替一对一
4.配置对象�~�存�Q�不使用集合�~�存
5.一对多使用Bag 多对一使用Set
6.�l�承使用昄��多�?nbsp; HQL:from object polymorphism="exlicit" 避免查处所有对�?br />7.消除大表�Q��用二�U�缓�?br />    对于上面�q�些�Q�Robbin�q�行了详�l�的讲解�?br />one-to-many�Q?/strong>
     使用inverse=false(default)�Q�对象的兌��关系是由parent对象来维护的
     而inverse=true的情况下�Q�一般用户双向多对多兌��Q�由子对象维护关联关�p�，增加子对象的时候需要显�C�：child.setParent(child)
     ��Z��提高性能�Q�应该尽量��用双向one-to-many inverse=true�Q�在MVC�l�构中的DAO接口中应该直接用Session持久化对象，避免通过兌��关系�Q�这句话有点不理解）�Q�而在单项关系中正��用二�U�缓存，则可以大�q�提高以查询��Z��的应用�?br />     多对一性能问题比较��，但是要避免经典N+1问题�?br />     通过主键�q�行兌��Q�相当于大表拆分��表。（�q�个是区分面向对象设计和面向�q�程设计的一个关键点�Q?br />list、bag、set的正��运�?/strong>
     one-to-many�Q?br />     A、��用list 需要维护Index Column字段�Q�不能被用于双向兌��Q�而且必须使用inverse=false�Q�需要�}慎��用在某些�E�有场合（基本上是不予考虑使用�Q?br />     B、bag/set在one-to-many中语义基本相同，推荐使用bag
     many-to-one�Q?br />     A、bag和set不同�Q�bag允许重复插入�Q�徏议��用set
在庞大的集合分页中应该��用session.createFilter
    session.createFilter(parent.getChildren(),""),setFirstResult(0),setMaxResult(10))
避免N+1 参考（http://www.iteye.com/post/266972�Q?/strong>
    在多对一的情况下�Q�查询child对象�Q�当在页面上昄��每个子类的父�c�d��象的时候会��D��N+1�ơ查询，需要采用下面的�Ҏ��避免�Q�many-to-one fetch="join|select"�Q�该�Ҏ��可能有问题）
inverse=true 无法�l�护集合�~�存�Q�还不是很理解集合缓存和对象�~�存�Q?/strong>
OLTP�c�d��的web应用�Q�可以群集水�q�x��展，不可避免的出现数据库瓉��
    框架能降低访问数据库的压力，采用�~�存是衡量一个框架是否优�U�的重要标准，从缓存方面看Hibernate
    A、对象缓存，�l�颗�_�度�Q�是针对表的�U�别�Q�透明化访问，因�ؓ有不改变代码的好处，所以是ORM提高性能的法�?br />    B、Hibernate是目前ORM框架中缓存性能最好的框架
    C、查询缓�?br />最后Robbin�q�针对大家经常出现的Hibernate vs iBatis的讨��行了一个�ȝ��Q?br />   对于OLTP应用�Q��用ORM框架而OLEB应用�Q�不��定是什么应用）最好采用JDBC或者其他方法处�?br />   Hibernate們֐�于细颗粒度设计，面向对象�Q�将大表拆分为多个小表，消除冗余字段�Q�通过二��~�存提升性能�?br />   iBatis們֐�于粗颗粒度设计，面向关系�Q�尽量把表合�qӞ��通过Column冗余�Q�消除关联关�p�，但是iBatis没有有效的缓存手�D�c�?/span>

   可以说Robbin的性能�ȝ��对于使用Hibernate的开发�h员有着很重要的�Ҏ��作用。非常感谢他无私奉献自己的经验�?/span>

... 2011-06-18 12:27 发表评论

... — Sat, 18 Jun 2011 04:03:00 GMT
原文: http://www.infoq.com/cn/articles/hibernate_tuning-ii

4.6 HQL调优

4.6.1 索引调优

HQL看�v来和SQL很相伹{��从HQL的WHERE子句中通常可以猜到相应的SQL WHERE子句。WHERE子句中的字段军_��了数据库��选择的烦引�?/p>
大多数Hibernate开发者所常犯的一个错误是无论何时�Q�当需要新WHERE子句的时候都会创��Z��个新的烦引。因为烦引会带来额外的数据更新开销�Q�所以应该争取创建少量烦引来覆盖��可能多的查询�?br />4.1�?/strong>让你使用一个集合来处理所有可能的数据搜烦条�g。如果这不太实际�Q�那么你可以使用后端剖析工具来创��Z��个针对应用程序涉及的所有SQL的集合。基于那些搜索条件的分类�Q�你最�l�会得到一个小的烦引集。与此同�Ӟ��q�可以尝试向WHERE子句中添加额外的谓语来匹配其他WHERE子句�?/p>

范例7

有两个UI搜烦器和一个后端守护进�E�搜索器来搜索名为iso_deals的表。第一个UI搜烦器在unexpectedFlag、dealStatus、tradeDate和isold属性上有谓语�?/p>
�W�二个UI搜烦器基于用户键入的�q��o器，其中包括的内定w��tradeDate和isold以外�q�有其他属性。开始时所有这些过滤器属性都是可选的�?br />后端搜烦器基于isold、participantCode和transactionType属性�?br />�l�过�q�一步业务分析，发现�W�二个UI搜烦器实际是��Z��一些隐式的unexpectedFlag和dealStatus值来选择数据的。我们还让tradeDate成�ؓ�q��o器的必要属性（��Z��使用数据库烦引，每个搜烦�q��o器都应该有必要属性）�?/p>
鉴于�q�一点，我们依次使用unexpectedFlag、dealStatus、tradeDate和isold构造了一个复合烦引。两个UI搜烦器都能共用它。（��序很重要，如果你的谓语以不同的��序指定�q�些属性或在它们前�|�列了其他属性，数据库就不会选择该复合烦引。）

后端搜烦器和UI搜烦器区别太大，因此我们不得不�ؓ它构造另一个复合烦引，依次使用isold、participantCode和transactionType�?/p>

4.6.2�l�定参数 vs.字符串拼�?/h4>
既可以��用绑定参数构造HQL的WHERE子句�Q�也可以使用字符串拼接的�Ҏ��Q�该军_��Ҏ��能会有一定媄响。��用绑定参数的原因是让数据库一�ơ解析SQL�Q�对后箋的重复请求复用生成好的执行计划，�q�样做节省了CPU旉��和内存。然而，��到最优的数据讉K��效率�Q�不同的�l�定值可能需要不同的SQL执行计划�?/p>
例如�Q�一��段数据范围可能只返回数据总量�?%�Q�而一大段数据范围可能�q�回数据总量�?0%。前者��用烦引更好，而后者则最好��用全表扫描�?/p>
��OLTP使用�l�定参数�Q�数据仓库��用字�W�串拼接�Q�因为OLTP通常在一个事务中重复插入和更新数据，只取��量数据�Q�数据仓库通常只有��量SQL查询�Q�有一个确定的执行计划比节省CPU旉��和内存更为重要�?/p>
要是你知道你的OLTP搜烦对不同绑定值应该��用相同执行计划又该怎么办呢�Q?/p>
Oracle 9i及以后版本在�W�一�ơ调用绑定参数�ƈ生成执行计划时能探出参数倹{��后�l�调用不会再探测�Q�而是重用之前的执行计划�?/p>
4.6.3聚合及排�?/h4>
你可以在数据库中�q�行聚合�?#8220;order by”�Q�也可以在应用程序的服务层中事先加蝲所有数据然后做聚合�?#8220;order by”操作。推荐��用前者，因�ؓ数据库在�q�方面通常会比你的应用�E�序做得好。此外，�q�样做还能节省网�l�带宽，�q�也是一�U�拥有跨数据库移植性的做法�?/p>
当你的应用程序对数据聚合和排序有HQL不支持的特定业务规则旉��外�?/p>
4.6.4覆盖抓取�{�略

详见4.7.1�?/strong>�?/p>
4.6.5本地查询

本地查询调优其实�q�不直接与HQL有关。但HQL的确可以让你直接向底层数据库传递本地查询。我们�ƈ不徏议这么做�Q�因为本地查询在数据库间不可�U�L��?/p>
4.7抓取�{�略调优

抓取�{�略军_��了在应用�E�序需要访问关联对象时�Q�Hibernate以何�U�方式以及何时获取关联对象。HRD中的�W?0�?#8220;改善性能”对该主题作了很好的阐�q�ͼ�我们在此��关注它的��用方法�?/p>
4.7.1覆盖抓取�{�略

不同的用户可能会有不同的数据抓取要求。Hibernate允许在两个地方定义数据抓取策略，一处是在映��元数据中，另一处是在HQL或Criteria中覆盖它�?/p>
常见的做法是��Z��主要的抓取用例在映射元数据中定义默认抓取�{�略�Q�针对少数用例在HQL和Criteria中覆盖抓取策略�?/p>
假设pojoA和pojoB是父子关�p�d��例。如果根据业务规则，只是偶尔需要从实体两端加蝲数据�Q�那你可以声明一个�g�q�加载集合或代理抓取�Q�proxy fetching�Q�。当你需要从实体两端获取数据�Ӟ��可以用立��x��取（eager fetching�Q�覆盖默认策略，例如使用HQL或Criteria配置�q�接抓取�Q�join fetching�Q��?/p>
另一斚w��Q�如果业务规则在大多数时候需要从实体两端加蝲数据�Q�那么你可以声明立即抓取�q�在Criteria中设�|��g�q�加载集合或代理抓取来覆盖它�Q�HQL目前�q�不支持�q�样的覆盖）�?/p>
4.7.2 N+1模式或是反模式？

select抓取会导致N+1问题。如果你知道自己��L��需要从兌��中加载数据，那么��p��始终使用�q�接抓取。在下面两个场景中，你可能会把N+1视�ؓ一�U�模式而非反模式�?/p>
�W�一�U�场景，你不知道用户是否会访问关联对象。如果他/�Ҏ��有访问，那么你赢了；否则你仍焉��要额外的N�ơselect SQL语句。这是一�U��o人左右�ؓ隄��局面�?/p>
�W�二�U�场景，pojoA和很多其他POJO有one-to-many兌��Q�例如pojoB和pojoC。��用立即的内连接或外连接抓取会在结果集中将pojoA重复很多�ơ。当pojoA中有很多非空属性时�Q�你不得不将大量数据加蝲到持久层中。这�U�加载需要很多时��_��既有�|�络带宽的原因，如果Hibernate的会话是有状态的�Q�其中也会有会话�~�存的原因（内存消耗和GC暂停�Q��?/p>
如果你有一个很长的one-to-many兌��链，例如从pojoA到pojoB到pojoC以此�c�L��Q�情况也是类似的�?/p>
你也�怼��M��用HQL中的DISTINCT关键字或Cirteria中的distinct功能或是Java的Set接口来消除重复数据。但所有这些都是在Hibernate�Q�在持久层）中实现的�Q�而非数据库中�?/p>
如果��Z��你的�|�络和内存配�|�的��试表明N+1性能更好�Q�那么你可以使用扚w��抓取、subselect抓取或二�U�缓存来做进一步调优�?/p>

范例8

以下是一个��用批量抓取的HBM文�g片段�Q?/p>
<class name="pojoA" table="pojoA"> … <set name="pojoBs" fetch="select" batch-size="10"> <key column="pojoa_id"/> … set> class>

以下是多端pojoB生成的SQL�Q?/p>
select … from pojoB where pojoa_id in(?,?,?,?,?, ?,?,?,?,?);

问号数量与batch-size值相�{�。因此N�ơ额外的关于pojoB的select SQL语句被减��到了N/10�ơ�?/p>
如果��?small>fetch="select"替换�?small>fetch="subselect"�Q�pojoB生成的SQL语句��是�q�样的：
select … from pojoB where pojoa_id in(select id from pojoA where …);

��管N�ơ额外的select减少�?�ơ，但这只在重复�q�行pojoA的查询开销很低时才有好处�?/p>
如果pojoA中的pojoB集合很稳定，或pojoB有pojoA的many-to-one兌��Q�而且pojoA是只��d��用数据，那么你可以��用二�U�缓存来�~�存pojoA以消除N+1问题�Q?strong>4.8.1�?/strong>中有一个例子）�?/p>

4.7.3延迟属性抓�?/h4>
除非有一张拥有很多你不需要的字段的遗留表�Q�否则不应该使用�q�种抓取�{�略�Q�因为它的�g�q�属性分�l�会带来额外的SQL�?/p>
在业务分析和设计�q�程中，你应该将不同数据获取或修改分�l�放��C��同的领域对象实体中，而不是��用这�U�抓取策略�?/p>
如果不能重新设计遗留表，可以使用HQL或Criteria提供的投影功能来获取数据�?/p>
4.8 二��~�存调优

HRD�W?0.2�?“二��~�存”中的描述对大多数开发者来说过于简单，无法做出选择�?.3版及以后版本不再推荐使用��Z��“CacheProvider”的缓存，而用��Z��“RegionFactory”的缓存，�q�也让�h更糊涂了。但是就��是最新的3.5参考文��也没有提及如何使用新缓存方法�?/p>
��Z��下述考虑�Q�我们将�l�箋��x��于老方法：

所有流行的Hibernate二��~�存提供商中只有JBoss Cache 2�?a >Infinispan 4�?a >Ehcache 2支持新方法�?a >OSCache�?a >SwarmCache�?a >Coherence�?a >Gigaspaces XAP-Data Grid只支持老方法�?/li>
两种�Ҏ��q��相同�?lt;cache>配置。例如，它们仍旧使用相同的usage属性�?#8220;transactional|read-write|nonstrict-read-write|read-only”�?/li>
多个cache-region适配器仍然内�|�老方法的支持�Q�理解它能帮助你快速理解新�Ҏ��?

4.8.1 ��Z��CacheProvider的缓存机�?/h4>
理解该机制是做出合理选择的关键。关键的�c?接口是CacheConcurrencyStrategy和它针对4中不同缓存��用的实现�c�，�q�有EntityUpdate/Delete/InsertAction�?/p>
针对�q�发�~�存讉K��Q�有三种实现模式�Q?/p>
针对“read-only”的只��L��式�?/strong>
无论是锁�q�是事务都没影响�Q�因为缓存自数据从数据库加蝲后就不会改变�?/p>
针对“read-write”�?#8220;nonstrict-read-write”的非事务感知�Q�non-transaction-aware�Q�读写模式�?/strong>
对缓存的更新发生在数据库事务完成后。缓存需要支持锁�?/p>
针对“transactional”的事务感知读写�?/strong>
对缓存和数据库的更新被包装在同一个JTA事务中，�q�样�~�存与数据库��L��保持同步的。数据库和缓存都必须支持JTA。尽��缓存事务内部依赖于�~�存锁，但Hibernate不会昑ּ�调用��M��的缓存锁函数�?/p>

以数据库更新��Z��。EntityUpdateAction对于事务感知��d��?#8220;read-write”的非事务感知��d��Q�还�?#8220;nonstrict-read-write”的非事务感知��d��相应有如下调用序列：

在一个JTA事务中更新数据库�Q�在同一个事务中更新�~�存�?/strong>
软锁�~�存�Q�在一个事务中更新数据库；在上一个事务成功完成后更新�~�存�Q�否则释放��Y锁�?/strong>
软锁只是一�U�特定的�~�存值失效表�q�方式，在它获得新数据库值前��L��其他事务��d��~�存。那些事务会转而直接读取数据库�?/p>
�~�存必须支持锁；事务支持则不是必��ȝ��。如果缓存是一个集��，“更新�~�存”的调用会��新值推送给所有副本，�q�通常被称�?#8220;推（push�Q?#8221;更新�{�略�?/p>
在一个事务中更新数据库；在上一个事务完成前��清除缓存；��Z��安全赯��Q�无��Z��务成功与否，在事务完成后再次清除�~�存�?/strong>
既不需要支持缓存锁�Q�也不需要支持事务。如果是�~�存集群�Q?#8220;清除�~�存”调用会让所有副本都失效�Q�这通常被称�?#8220;拉（pull�Q?#8221;更新�{�略�?/p>

对于实体的删除或插入动作�Q�或者集合变��_��调用序列都是�怼�的�?/p>
实际上，最后两个异步调用序列仍能保证数据库和缓存的一致性（基本��是“read committed”的隔��M��U�别�Q�，�q�要归功于第二个序列中的软锁�?#8220;更新数据�?#8221;后的“更新�~�存”�Q�还有最后一个调用序列中的悲�?#8220;清除�~�存”�?/p>
��Z��上述分析�Q�我们的��是：

如果数据是只�ȝ��Q�例如引用数据，那么��L��使用“read-only”�{�略�Q�因为它是最��单、最高效的策略，也是集群安全的策略�?/li>
除非你真的想��缓存更新和数据库更新放在一个JTA事务里，否则不要使用“transactional”�{�略�Q�因为JTA需要�O长的两阶�D�|��交处理，�q�导致它基本是性能最差的�{�略�?
依笔者看来，二��~�存�q��一�U�数据源�Q�因此��用JTA也未必合理。实际上最后两个调用序列在大多数场景下是个不错的替代方案，�q�要归功于它们的数据一致性保障�?/p>
如果你的数据��d��多或者很��有�q�发�~�存讉K��和更斎ͼ�那么可以使用“nonstrict-read-write”�{�略。感谢它的轻量��“�?#8221;更新�{�略�Q�它通常是性能�W�二好的�{�略�?/li>
如果你的数据是又��d��写的�Q�那么��?#8220;read-write”�{�略。这通常是性能倒数�W�二的策略，因�ؓ它要求有�~�存锁，�~�存集群中��用重量��?#8220;�?#8221;更新�{�略�?

范例9

以下是一个ISO收费�c�d��的HBM文�g片段�Q?/p>
<class name="IsoChargeType">    <property name="isoId" column="ISO_ID" not-null="true"/>    <many-to-one name="estimateMethod" fetch="join" lazy="false"/>    <many-to-one name="allocationMethod" fetch="join" lazy="false"/>    <many-to-one name="chargeTypeCategory" fetch="join" lazy="false"/> class>

一些用户只需要ISO收费�c�d��本��n�Q�一些用��h��需要ISO收费�c�d��Q�还需要它的三个关联对象。简单�v见，开发者会立即加蝲所有三个关联对象。如果项目中没�h负责Hibernate调优�Q�这是很常见的�?/p>
4.7.1�?/strong>中讲�q�了最好的�Ҏ��。因为所有的兌��对象都是只读引用数据�Q�另一�U�方法是使用延迟抓取�Q�打开�q�些对象的二�U�缓存以避免N+1问题。实际上前一�U�方法也能从引用数据�~�存中获益�?/p>
因�ؓ大多数项目都有很多被其他数据引用的只��d��用数据，上述两种�Ҏ��都能改善全局�pȝ��性能�?/p>

4.8.2 RegionFactory

下表是新老两�U�方法中对应的主要类/接口�Q?

新方�?/strong>

老方�?/strong>

RegionFactory

CacheProvider

Region

Cache

EntityRegionAccessStrategy

CacheConcurrencyStrategy

CollectionRegionAccessStrategy

CacheConcurrencyStrategy

�W�一个改�q�是RegionFactory构徏了特定的Region�Q�例如EntityRegion和TransactionRegion�Q�而不是��用一个通用的访问Region。第二个改进是对于特定缓存的“usage”属性��|��Region要求构徏自己的访问策略，而不是所有Region都一直��用CacheConcurrencyStrategy�?�U�实现�?/p>
要��用新�Ҏ��Q�应该设�|�factory_class而非provider_class配置属性。以Ehcache 2.0��Z��Q?/p>
        net.sf.ehcache.hibernate.EhCacheRegionFactory

其他相关的Hibernate�~�存配置都和老方法一栗��?/p>
新方法也能向后兼定w��留方法。如果还是只配了CacheProvider�Q�新�Ҏ��中将使用下列自说明（self-explanatory�Q�适配器和桥隐式地调用老的接口/�c�：

RegionFactoryCacheProviderBridge、EntityRegionAdapter、CollectionRegionAdapter、QueryResultsRegionAdapter、EntityAccessStrategyAdapter和CollectionAccessStrategyAdapter

4.8.3 查询�~�存

二��~�存也能�~�存查询�l�果。如果查询开销很大而且要重复运行，�q�也会很有帮助�?/p>
4.9扚w��处理调优

大多数Hibernate的功能都很适合那些每个事务都通常只处理少量数据的OLTP�pȝ��。但是，如果你有一个数据仓库或者事务需要处理大量数据，那么��另当别��Z��?/p>
4.9.1使用有状态会话的非DML风格批处�?/h5>
如果你已�l�在使用常规会话了，那这是最自然的方法。你需要做三�g事：

配置下列3个属性以开启批处理�Ҏ��：
  hibernate.jdbc.batch_size 30   hibernate.jdbc.batch_versioned_data true   hibernate.cache.use_second_level_cache false

batch_size讄��为正��g��开启JDBC2的批量更斎ͼ�Hibernate的徏议值是5�?0。基于我们的��试�Q�极低值和极高值性能都很差。只要取值在合理范围内，区别��只有几�U�而已。如果网�l�够快，�q�个�l�果是一定的�?/p>
�W�二个配�|�设为true�Q�这要求JDBC驱动在executeBatch()�Ҏ��中返回正��的行数。对于Oracle用户而言�Q�批量更新时不能��其设�ؓtrue。请阅读Oracle的《JDBC Developer’s Guide and Reference》中�?#8220;标准批处理的Oracle实现中的更新计数”�Q?a >Update Counts in the Oracle Implementation of Standard Batching�Q�以获得更多详细信息。因为它�Ҏ��量插入来说还是安全的�Q�所以你可以为批量插入创建单独的专用数据源。最后一个配�|�项是可选的�Q�因��Z��可以在会话中昑ּ�关闭二��~�存�?/p>
像如下范例中那样定期��h��Q�flush�Q��ƈ清除一�U�会话缓存：
Session session = sessionFactory.openSession(); Transaction tx = session.beginTransaction();
for ( int i=0; i<100000; i++ ) {
     Customer customer = new Customer(.....);
     //if your hibernate.cache.use_second_level_cache is true, call the following:
     session.setCacheMode(CacheMode.IGNORE);
     session.save(customer);
     if (i % 50 == 0) { //50, same as the JDBC batch size
     //flush a batch of inserts and release memory:
     session.flush();
     session.clear();
     }
}
tx.commit();
session.close();

批处理通常不需要数据缓存，否则你会��内存耗尽�q�大量增加GC开销。如果内存有限，那这�U�情况会很明显�?/p>
��L��批量插入嵌套在事务中�?

每次事务修改的对象数量越��就意味着会有更多数据库提交，正如4.5�?/strong>所�q�每�ơ提交都会带来磁盘相关的开销�?/p>
另一斚w��Q�每�ơ事务修改的对象数量��多��意味着锁定变更旉��长�Q�同时数据库需要更大的redo log�?/p>
4.9.2使用无状态会话的非DML风格批处�?/h4>
无状态会话执行�v来比上一�U�方法更好，因�ؓ它只是JDBC的简单包装，而且可以�l�开很多常规会话要求的操作。例如，它不需要会话缓存，也不和�Q何二�U�缓存或查询�~�存有交互�?br />然而它的用法�ƈ不简单。尤其是它的操作�q�不会��联到所兌��的实例上�Q�你必须自己来处理它们�?/p>
4.9.3 DML风格

使用DML风格的插入、更新或删除�Q�你直接在数据库中操作数据，�q�和前两�U�方法在Hibernate中操作数据的情况有所不同�?/p>
因�ؓ一个DML风格的更新或删除相当于前两种�Ҏ��中的多个单独的更新或删除�Q�所以如果更新或删除中的WHERE子句暗示了恰当的数据库烦引，那么使用DML风格的操作能节省�|�络开销�Q�执行得更好�?/p>
强烈��l�合使用DML风格操作和无状态会话。如果��用有状态会话，不要忘记在执行DML前清除缓存，否则Hibernate��会更新或清除相关缓存（见下面的范例10�Q��?/p>
4.9.4扚w��加蝲

如果你的HQL或Criteria会返回很多数据，那么要注意两件事�Q?/p>
用下列配�|�开启批量抓取特性：
hibernate.jdbc.fetch_size 10

fetch_size讄��为正值将开启JDBC扚w��抓取�Ҏ��。相对快速网�l�，在慢速网�l�中�q�一�Ҏ��为重要。Oracle��的经验值是10。你应该��Z��自己的环境进行测试�?/p>
在��用上�q�C�Q一�Ҏ��旉��要关闭缓存，因�ؓ扚w��加蝲一般是一�ơ性�Q务。受限于内存定w��Q�向�~�存中加载大量数据通常也意味着它们很快会被清除出去�Q�这会增加GC开销�?

范例10

我们有一个后��C�Q务，分段加蝲大量的IsoDeal数据用于后箋处理。我们还会在分段数据交给下游�pȝ��处理前将其更��Cؓ处理中状态。最大的一�D�|��50万行数据。以下是原始代码中截取出来的一�D�：
Query query = session.createQuery("FROM IsoDeal d WHERE chunk-clause"); query.setLockMode("d", LockMode.UPGRADE); //for Inprocess status update List isoDeals = query.list(); for (IsoDeal isoDeal : isoDeals) { //update status to Inprocess    isoDeal.setStatus("Inprocess"); } return isoDeals;

包含上述代码的方法加上了Spring 2.5声明式事务的注解。加载�ƈ更新50万行数据大约�׃��10分钟。我们识别出了以下这些问题：

�׃��会话�~�存和二�U�缓存的原因�Q�系�l�会频繁地内存溢出�?/li>
��q��没有内存溢出�Q�当内存消耗很高时GC的开销也会很大�?/li>
我们�q�未讄��fetch_size�?/li>
��q��我们讄��了batch_size�Q�for循环也创��Z��太多update SQL语句�?

不幸的是Spring 2.5不支持Hibernate无状态会话，所以我们只能关闭二�U�缓存；讄��fetch_size�Q�用DML风格的更新来代替for循环�Q�以此改善性能�?/p>
但是�Q�执行时间还是要6分钟。将Hibernate的日志��别调成trace后，我们发现是更��C��话缓存造成了�g时。通过在DML更新前清除会话缓存，我们��时间羃短到�?分钟�Q�全部都是将数据加蝲��C��话缓存中��p��的时间�?/p>

4.10 SQL生成调优

本节��向你展�C�如何减��SQL生成的数量�?/p>
4.10.1 N+1抓取问题

“select抓取”�{�略会导致N+1问题。如�?#8220;�q�接抓取”�{�略适合你的话，你应该始�l��用该�{�略避免N+1问题�?/p>
但是�Q�如�?#8220;�q�接抓取”�{�略执行效果不理惻I��像4.7.2�?/strong>中那��P��你可以��?#8220;subselect抓取”�?#8220;扚w��抓取”�?#8220;延迟集合抓取”来减��所需的额外SQL语句数�?/p>
4.10.2 Insert+Update问题

范例11

我们的ElectricityDeal与DealCharge有单向one-to-many兌��Q�如下列HBM文�g片段所�C�：
<class name="ElectricityDeal"        select-before-update="true" dynamic-update="true"        dynamic-insert="true">      name="key" column="ID">          class="sequence">              name="sequence">SEQ_ELECTRICITY_DEALS</param>
    …
     name="dealCharges" cascade="all-delete-orphan">         column="DEAL_KEY" not-null="false" update="true"              on-delete="noaction"/>          class="DealCharge"/>

�?#8220;key”元素中，“not-null”�?#8220;update”对应的默认值是false和true�Q�上�q�C��码�ؓ了明��这些取��|��它们写了出来�?/p>
如果你想创徏一个ElectricityDeal和十个DealCharge�Q�会生成如下SQL语句�Q?/p>
1句ElectricityDeal的插入语句；
10句DealCharge的插入语句，其中不包括外�?#8220;DEAL_KEY”�Q?/li>
10句DealCharge字段“DEAL_KEY”的更新语句�?

��Z��消除那额外的10句更新语句，可以在那10句DealCharge插入语句中包�?#8220;DEAL_KEY”�Q�你需要将“not-null”�?#8220;update”分别修改为true和false�?/p>
另一�U�做法是使用双向或many-to-one兌��Q�让DealCharge来管理关联�?/p>
4.10.3 更新前执行select

在范�?1中，我们为ElectricityDeal加上了select-before-update�Q�这会对瞬时�Q�transient�Q�对象或分离�Q�detached�Q�对象��生额外的select语句�Q�但却能避免不必要的数据库更新�?/p>
你应该做��Z��些权衡，如果对象没多��属性，不需要防止不必要的数据库更新�Q�那么就不要使用该特性，因�ؓ你那些有限的数据既没有太多网�l�传输开销�Q�也不会带来太多数据库更新开销�?/p>
如果对象的属性较多，例如是一张大的遗留表�Q�那你应该开启该�Ҏ��，�?#8220;dynamic-update”�l�合使用以避免太多数据库更新开销�?/p>
4.10.4 �U�联删除

在范�?1中，如果你想删除1个ElectricityDeal和它�?00个DealCharge�Q�Hibernate会对DealCharge�?00�ơ删除�?/p>
如果��?#8220;on-delete”修改�?#8220;cascade”�Q�Hibernate不会执行DealCharge的删除动作；而是让数据库�Ҏ��ON CASCADE DELETE�U�束自动删除�?00个DealCharge。不�q�，需要让DBA开启ON CASCADE DELETE�U�束�Q�大多数DBA不愿意这么做�Q�因��Z��们想避免父对象的意外删除�U�联到它的依赖对象上。此外，�q�要注意�Q�该�Ҏ��会�l�过Hibernate对版本数据（versioned data�Q�的常用乐观锁策略�?/p>
4.10.5 增强的序列标识符生成�?/h4>
范例11中��用Oracle的序列作为标识符生成器。假设我们保�?00个ElectricityDeal�Q�Hibernate会将下面的SQL语句执行100�ơ来获取下一个可用的标识�W�：
select SEQ_ELECTRICITY_DEALS.NEXTVAL from dual;

如果�|�络不是很快�Q�那�q�无疑会降低效率�?.2.3及后�l�版本中增加了一个增强的生成�?#8220;SequenceStyleGenerator”�Q�它带了两个优化器：hilo和pooled。尽��HRD�?a >�W?�?#8220;基础O/R映射” 讲到了这两个优化器，不过内容有限。两个优化器都��用了HiLo��法�Q�该��法生成的标识符�{�于Hi值加上Lo��|��其中Hi��g��表组��P��Lo值顺序且重复��C��1�q�代到最大组大小�Q�组号在Lo�?#8220;转回�?#8221;1时加1�?/p>
假设�l�大��是5�Q�可以用max_lo或increment_size参数来表�C�）�Q�下面是个例子：

hilo优化�?
�l�号取自数据库序列的下一个可用��|��Hi值由Hibernate定义�Q�是�l�号乘以increment_size参数倹{�?/p>
pooled优化�?
Hi值直接取自数据库序列的下一个可用倹{��数据库序列的增量应该设�|��ؓincrement_size参数倹{�?/p>

直到内存�l�中的��D��尽后，两个优化器才会去讉K��数据库，上面的例子每5个标识值符讉K��一�ơ数据库。��用hilo优化器时�Q�你的序列不能再被其他应用程序��用，除非它们使用与Hibernate相同的逻辑。��用pooled优化器，在其他应用程序��用同一序列时则相当安全�?/p>
两个优化器都有一个问题，如果Hibernate崩溃�Q�当前组内的一些标识符值就会丢失，然而大多数应用�E�序都不要求拥有�q�箋的标识符��|��如果你的数据库，比方说Oracle�Q�缓存了序列��|��当它崩溃时你也会丢失标识�W��|��?/p>
如果在范�?1中��用pooled优化器，新的id配置如下�Q?/p>
name="key" column="ID"> class="org.hibernate.id.enhance.SequenceStyleGenerator">
name="sequence_name">SEQ_ELECTRICITY_DEALS name="initial_value">0 name="increment_size">100 name="optimizer ">pooled

5 �ȝ��

本文�늛�了大多数你在Hibernate应用�E�序调优时会觉得很有用的调优技巧，其中的大多数旉��都在讨论那些行之有效却缺乏文��的调优主题�Q�例如��承映��、二�U�缓存和增强的序列标识符生成器�?/p>
它还提到了一些Hibernate调优所必需的数据库知识。一些范例中包含了你可能遇到的问题的实际解决�Ҏ��?/p>
除此之外�Q�值得一提的是Hibernate也可以和In-Memory Data Grid�Q�IMDG�Q�一起��用，例如Oracle的Coherance或GigaSpaces IMDG�Q�这能让你的应用�E�序辑ֈ�毫秒�U�别�?/p>
6 资源

[1] Latest Hibernate Reference Documentation on jboss.com

[2] Oracle 9i Performance Tuning Guide and Reference

[3] Performance Engineering on Wikipedia

[4] Program Optimization on Wikipedia

[5] Pareto Principle (the 80/20 rule) on Wikipedia

[6] Premature Optimization on acm.org

[7] Java Performance Tuning by Jack Shirazi

[8] The Law of Leaky Abstractions by Joel Spolsky

[9] Hibernate’s StatisticsService Mbean configuration with Spring

[10] JProbe by Quest Software

[11] Java VisualVM

[12] Column-oriented DBMS on Wikipedia

[13] Apache DBCP BasicDataSource

[14] JDBC Connection Pool by Oracle

[15] Connection Failover by Oracle

[16] Last Resource Commit Optimization (LRCO)

[17] GigaSpaces for Hibernate ORM Users

... 2011-06-18 12:03 发表评论

... — Sat, 18 Jun 2011 03:59:00 GMT
http://www.infoq.com/cn/articles/hibernate_tuning

1.引言

Hibernate是最��行的对象关�p�L��（ORM�Q�引擎之一�Q�它提供了数据持久化和查询服务�?/p>

2.Hibernate性能调优

调优是一个�P代的、持�l�进行的�q�程�Q�涉及��Y件开发生命周期（SDLC�Q�的所有阶�D�c��在一个典型的使用Hibernate�q�行持久化的Java EE应用�E�序中，调优会涉及以下几个方面：

业务规则调优
设计调优
Hibernate调优
Java GC调优
应用�E�序容器调优
底层�pȝ��调优�Q�包括数据库和OS�?

没有一套精心设计的�Ҏ��去�q�行以上调优是非常耗时的，而且很可能收效甚微。好的调优方法的重要部分是�ؓ调优内容划分优先�U�。可以用Pareto定律�Q�又�U?#8220;80/20法则”�Q�来解释�q�一点，即通常80%的应用程序性能改善源自�?0%的性能问题^[5]�?/p>
相比��Z��盘和网�l�的讉K��Q�基于内存和CPU的访问能提供更低的�g�q�和更高的吞吐量。这�U�基于IO的Hibernate调优与底层系�l�IO部分的调优应该优先于��Z��CPU和内存的底层�pȝ��GC、CPU和内存部分的调优�?/p>

范例1

我们调优了一个选择甉|��的HQL查询�Q�把它从30�U�降��C��1�U�以内。如果我们在垃圾回收斚w��下功夫，可能收效甚微——也许只有几毫�U�或者最多几�U�，相比HQL的改�q�，GC斚w��的改善可以忽略不计�?/p>

好的调优�Ҏ��的另一个重要部分是军_��何时优化^[4]�?/p>
�U�极优化的提倡者主张开始时��p��行调优，例如在业务规则和设计阶段�Q�在整个SDLC都持�l�进行优化，因�ؓ他们认�ؓ后期改变业务规则和重新设计代价太大�?/p>
另一�z��h提倡在SDLC末期�q�行调优�Q�因��Z��们抱怨前期调优经�怼�让设计和�~�码变得复杂。他们经常引用Donald Knuth的名�a�“�q�早优化是万恶之�?/em>”^[6]�?/p>
��Z��q��调优和编码需要一些权衡。根据笔者的�l�验�Q�适当的前期调优能带来更明智的设计和细致的�~�码。很多项目就��p�|在应用程序调优上�Q�因��Z��面提到的“�q�早优化”阶段在被引用时脱��M��上下文，而且相应的调优不是被推迟得太晚就是投入资源过��?/p>
但是�Q�要做很多前期调优也不太可能�Q�因为没有经�q�剖析，你�ƈ不能��定应用�E�序的瓶颈究竟在何处�Q�应用程序一般都是这��h��化的�?/p>
�Ҏ��们的多线�E�企业��应用�E�序的剖析也表现出大多数应用�E�序�q�_��只有20-50%的CPU使用率。剩余的CPU开销只是在等待数据库和网�l�相关的IO�?/p>
��Z��上述分析�Q�我们得��样一个结论，�l�合业务规则和设计的Hibernate调优在Pareto定律�?0%的那个部分，相应的它们的优先�U�更高�?/p>
一�U�比较实际的做法是：

识别��Z��要瓶颈，可以预见其中多数是Hibernate、业务规则和设计斚w��的（其数量视你的调优目标而定�Q�但三到五个是不错的开端）�?/li>
修改应用�E�序以便消除�q�些瓉��?/li>
��试应用�E�序�Q�然后重复步�?�Q�直到达��C��的调优目标�ؓ止�?

你能在Jack Shirazi的《Java Performance Tuning�?^[7]一书中扑ֈ�更多关于性能调优阶段的常见徏议�?/p>
下面的章节中�Q�我们会按照调优的大致顺序（列在前面的通常影响最大）去解释一些特定的调优技术�?/p>
3. 监控和剖�?/h2>
没有对Hibernate应用�E�序的有效监控和剖析�Q�你无法得知性能瓉��以及何处需要调优�?/p>
3.1.1 监控SQL生成

��管使用Hibernate的主要目的是��你从直接��用SQL的痛苦中解救出来�Q��ؓ了对应用�E�序�q�行调优�Q�你必须知道Hibernate生成了哪些SQL。JoeSplosky在他的《The Law of Leaky Abstractions》一文中详细描述了这个问题�?/p>
你可以在log4j中将org.hibernate.SQL包的日志�U�别设�ؓDEBUG�Q�这样便能看到生成的所有SQL。你�q�可以将其他包的日志�U�别设�ؓDEBUG�Q�甚至TRACE来定位一些性能问题�?/p>
3.1.2 查看Hibernate�l�计
如果开�?strong>hibernate.generate.statistics�Q�Hibernate会导出实体、集合、会话、二�U�缓存、查询和会话工厂的统计信息，�q�对通过SessionFactory.getStatistics()�q�行的调优很有帮助。�ؓ了简单�v见，Hibernate�q�可以��用MBean“org.hibernate.jmx.StatisticsService”通过JMX来导出统计信息。你可以在这个网站找到配�|�范�?/u> �?/u>

3.1.3 剖析

一个好的剖析工具不仅有利于Hibernate调优�Q�还能�ؓ应用�E�序的其他部分带来好处。然而，大多数商业工��P��例如JProbe ^[10]�Q�都很昂��c��幸�q�的是Sun/Oracle的JDK1.6自带了一个名�?#8220;Java VisualVM” ^[11]的调试接口。虽然比起那些商业竞争对手，它还相当基础�Q�但它提供了很多调试和调优信息�?/p>
4. 调优技�?/h2>
4.1 业务规则与设计调�?/h3>
��管业务规则和设计调优�ƈ不属于Hibernate调优的范��_��但此处的军_��对后面Hibernate的调优有很大影响。因此我们特意指��Z��些与Hibernate调优有关的点�?/p>
在业务需求收集与调优�q�程中，你需要知道：

数据获取�Ҏ��包括引用数据（reference data�Q�、只��L��据、读分组�Q�read group�Q�、读取大��、搜索条件以及数据分�l�和聚合�?/li>
数据修改�Ҏ��包括数据变更、变更组、变更大��、无效修改补�ѝ��数据库�Q�所有变更都在一个数据库中或在多个数据库中）、变更频率和�q�发性，以及变更响应和吞吐量要求�?/li>
数据关系�Q�例如关联（association�Q�、泛化（generalization�Q�、实玎ͼ�realization�Q�和依赖�Q�dependency�Q��?

��Z��业务需求，你会得到一个最优设计，其中军_��了应用程序类型（是OLTP�q�是数据仓库�Q�亦或者与其中某一�U�比较接�q�）和分层结构（��持久层和服务层分离�q�是合�ƈ�Q�，创徏领域对象�Q�通常是POJO�Q�，军_��数据聚合的地方（在数据库中进行聚合能利用强大的数据库功能�Q�节省网�l�带宽；但是除了像COUNT、SUM、AVG、MIN和MAX�q�样的标准聚合，其他的聚合通常不具有移植性。在应用服务器上�q�行聚合允许你应用更复杂的业务逻辑�Q�但你需要先在应用程序中载入详细的数据）�?/p>

范例2

分析员需要查看一个取自大数据表的甉|��ISO�Q�Independent System Operator�Q�聚合列表。最开始他们想要显�C�大多数字段�Q�尽��数据库能在1分钟内做出响应，应用�E�序也要�?0分钟��?百万行数据加载到前端UI。经�q�重新分析，分析员保留了14个字�D�c��因为去掉了很多可选的高聚合度字段�Q�从剩下的字�D�中�q�行聚合分组�q�回的数据要��很多，而且大多数情况下的数据加载时间也�~�小��C��可接受的范围内�?/p>
范例3

�q?4�?#8220;非标�?#8221;�Q�shaped�Q�表�C�每��时都可以有自己的电量和��h��Q�如果所�?4��时的电量和��h��相同�Q�我们称之�ؓ“标准”�Q�小时会修改��时甉|��交易�Q�其中包�?个属性：每小时电量和��h��。�v初我们��用Hibernate�?em>select-before-update�Ҏ��，��是更新24行数据需�?4�ơ选择。因为我们只需�?个属性，而且如果不修改电量或��h��的话也没有业务规则禁止无效修改，我们��关闭了select-before-update�Ҏ��，避免�?4�ơ选择�?/p>

4.2�l�承映射调优

��管�l�承映射是领域对象的一部分�Q�出于它的重要性我们将它单独出来。HRD ^[1]中的�W?�?#8220;�l�承映射”已经说得很清楚了�Q�所以我们将��x��SQL生成和针�Ҏ��个策略的调优��?/p>
以下是HRD中范例的�c�d��Q?/p>

4.2.1 每个�c�d��ơ一张表

只需要一张表�Q�一条多态查询生成的SQL大概是这��L��Q?/p>
select id, payment_type, amount, currency, rtn, credit_card_type from payment

针对具体子类�Q�例如CashPayment�Q�的查询生成的SQL是这��L��Q?/p>
select id, amount, currency from payment where payment_type=’CASH’

�q�样做的优点包括只有一张表、查询简单以及容易与其他表进行关联。第二个查询中不需要包含其他子�c�M��的属性。所有这些特性让该策略的性能调优要比其他�{�略�Ҏ��得多。这�U�方法通常比较适合数据仓库�pȝ��Q�因为所有数据都在一张表里，不需要做表连接�?/p>
主要的缺�Ҏ��个类层次中的所有属性都挤在一张大表里�Q�如果有很多子类�Ҏ��的属性，数据库中��׃��有太多字�D늚�取��gؓnull�Q�这为当前基于行的数据库�Q��用基于列的DBMS的数据仓库处理这个会更好些）的SQL调优增加了难度。除非进行分区，否则唯一的数据表会成为热点，OLTP�pȝ��通常在这斚w��都不太好�?/p>
4.2.2每个子类一张表

需�?张表�Q�多态查询生成的SQL如下�Q?/p>
select id, payment_type, amount, currency, rtn, credit_card type,         case when c.payment_id is not null then 1      when ck.payment_id is not null then 2      when cc.payment_id is not null then 3      when p.id is not null then 0 end as clazz from payment p left join cash_payment c on p.id=c.payment_id left join    cheque_payment ck on p.id=ck.payment_id left join    credit_payment cc on p.id=cc.payment_id;

针对具体子类�Q�例如CashPayment�Q�的查询生成的SQL是这��L��Q?/p>
select id, payment_type, amount, currency from payment p left join cash_payment c on p.id=c.payment_id;

优点包括数据表比较紧凑（没有不需要的可空字段�Q�，数据跨三个子�cȝ��表进行分区，�Ҏ��使用��类的表与其他表�q�行兌��。紧凑的数据表可以针对基于行的数据库做存储块优化�Q�让SQL执行得更好。数据分区增加了数据修改的�ƈ发性（除了��类�Q�没有热点）�Q�OLTP�pȝ��通常会更好些�?/p>
同样的，�W�二个查询不需要包含其他子�cȝ��属性�?/p>
�~�点是在所有策略中它��用的表和表连接最多，SQL语句�E�显复杂�Q�看看Hibernate动态鉴别器的长CASE子句�Q�。相比单张表�Q�数据库要花更多旉��调优数据表连接，数据仓库在��用该�{�略旉��常不太理想�?/p>
因�ؓ不能跨超�c�d��子类的字�D�|��建立复合索引�Q�如果需要按�q�些列进行查询，性能会受影响。�Q何子�c�L��据的修改都涉及两张表�Q�超�cȝ��表和子类的表�?/p>
4.2.3每个具体�c�M��张表

涉及三张或更多的表，多态查询生成的SQL是这��L��Q?/p>
select p.id, p.amount, p.currency, p.rtn, p. credit_card_type, p.clazz from (select id, amount, currency, null as rtn,null as credit_card type, 1 as clazz from cash_payment union all select id, amount, null as currency, rtn,null as credit_card type, 2 as clazz from cheque_payment union all select id, amount, null as currency, null as rtn,credit_card type, 3 as clazz from credit_payment) p;

针对具体子类�Q�例如CashPayment�Q�的查询生成的SQL是这��L��Q?/p>
select id, payment_type, amount, currency from cash_payment;

优点和上面的“每个子类一张表”�{�略�怼�。因��c�通常是抽象的�Q�所以具体的三张表是必须的[开头处说的3张或更多的表是必��ȝ��]�Q��Q何子�cȝ��数据修改只涉及一张表�Q�运行�v来更快�?/p>
�~�点是SQL�Q�from子句和union all子查询）太复杂。但是大多数数据库对此类SQL的调优都很好�?/p>
如果一个类惛_��Payment��类兌��Q�数据库无法使用引用完整性（referential integrity�Q�来实现它；必须使用触发器来实现它。这�Ҏ��据库性能有些影响�?/p>
4.2.4使用隐式多态实现每个具体类一张表

只需要三张表。对于Payment的多态查询生成三条独立的SQL语句�Q�每个对应一个子�c�R��Hibernate引擎通过Java反射扑և�Payment的所有三个子�c�R�?/p>
具体子类的查询只生成该子�cȝ��SQL。这些SQL语句都很��单，�q�里��׃��再阐�q�C��?/p>
它的优点和上节类��|��紧凑数据表、跨三个具体子类的数据分��Z��及对子类��L��数据的修攚w��只涉及一张表�?/p>
�~�点是用三条独立的SQL语句代替了一条联合SQL�Q�这会带来更多网�l�IO。Java反射也需要时间。假讑֦�果你有一大堆领域对象�Q�你从最上层的Object�c�进行隐式选择查询�Q�那该需要多长时间啊�Q?/p>
�Ҏ��你的映射�{�略制定合理的选择查询�q��易事�Q�这需要你仔细调优业务需求，��Z��特定的数据场景制定合理的设计决策�?/p>
以下是一些徏议：

设计�l�粒度的�c�d��ơ和�_�粒度的数据表。细�_�度的数据表意味着更多数据表连接，相应的查询也会更复杂�?/li>
如非必要�Q�不要��用多态查询。正如上文所�C�，对具体类的查询只选择需要的数据�Q�没有不必要的表�q�接和联合�?/li>
“每个�c�d��ơ一张表”�Ҏ��高�ƈ发、简单查询�ƈ且没有共享列的OLTP�pȝ��来说是个不错的选择。如果你想用数据库的引用完整性来做关联，那它也是个合适的选择�?/li>
“每个具体�c�M��张表”�Ҏ��高�ƈ发、复杂查询�ƈ且没有共享列的OLTP�pȝ��来说是个不错的选择。当然你不得不牺牲超�c�M��其他�c�M��间的兌��?/li>
采用混合�{�略�Q�例�?#8220;每个�c�d��ơ一张表”中嵌�?#8220;每个子类一张表”�Q�这样可以利用不同策略的优势。随着你项目的�q�化�Q�如果你要反复重新映��，那你可能也会采用该策略�?/li>
“使用隐式多态实现每个具体类一张表”�q�种做法�q�不推荐�Q�因为其配置�q�于�J�缛、��?#8220;any”元素的复杂关联语法和隐式查询的潜在危险性�?

范例4

下面是一个交易描�q�应用程序的部分领域�c�d��Q?/p>

开始时�Q�项目只有GasDeal和少数用��P��它��?#8220;每个�c�d��ơ一张表”�?/p>
OilDeal和ElectricityDeal是后期��生更多业务需求后加入的。没有改变映��策略。但是ElectricityDeal有太多自��q��属性，因此有很多电相关的可�I�字�D�加入了Deal表。因为用户量也在增长�Q�数据修改变得越来越慢�?/p>
重新设计时我们��用了两张单独的表�Q�分别针�Ҏ��/油和�늛�关的属性。新的映��؜合了“每个�c�d��ơ一张表”�?#8220;每个子类一张表”。我们还重新设计了查询，以便允许针对具体交易子类�q�行选择�Q�消除不必要的列和表�q�接�?/p>

4.3 领域对象调优

��Z��4.1�?/strong>中对业务规则和设计的调优�Q�你得到了一个用POJO来表�C�的领域对象的类图。我们徏议：

4.3.1 POJO调优

从读写数据中��类似引用这��L��只读数据和以��Mؓ�ȝ��数据分离出来�?br />只读数据的二�U�缓存是最有效的，其次是以��Mؓ�ȝ��数据的非严格��d��。将只读POJO标识��Z��可更改的�Q�immutable�Q�也是一个调优点。如果一个服务层�Ҏ��只处理只��L��据，可以��它的事务标为只读，�q�是优化Hibernate和底层JDBC驱动的一个方法�?/li>
�l�粒度的POJO和粗�_�度的数据表�?br />��Z��数据的修改�ƈ发量和频率等内容来分解大的POJO。尽��你可以定义一个粒度非常细的对象模型，但粒度过�l�的表会��D��大量表连接，�q�对数据仓库来说是不能接受的�?/li>
优先使用非final的类�?br />Hibernate只会针对非final的类使用CGLIB代理来实现�g时关联获取。如果被兌��的类是final的，Hibernate会一�ơ加载所有内容，�q�对性能会有影响�?/li>
使用业务键�ؓ分离�Q�detached�Q�实例实现equals()和hashCode()�Ҏ��?br />在多层系�l�中�Q�经常可以在分离对象上��用乐观锁来提升系�l��ƈ发性，辑ֈ�更高的性能�?/li>
定义一个版本或旉��戛_��性�?br />乐观锁需要这个字�D�|��实现长对话（应用�E�序事务�Q�[译注�Q�session译�ؓ会话�Q�conversion译�ؓ对话�Q�以�C�区别]�?/li>
优先使用�l�合POJO�?br />你的前端UI�l�常需要来自多个不同POJO的数据。你应该向UI传递一个组合POJO而不是独立的POJO以获得更好的�|�络性能�?br />有两�U�方式在服务层构建组合POJO。一�U�是在开始时�?.2载所有需要的独立POJO�Q�随后抽取需要的属性放入组合POJO�Q�另一�U�是使用HQL投媄�Q�直接从数据库中选择需要的属性�?br />如果其他地方也要查找�q�些独立POJO�Q�可以把它们放进二��~�存以便�׃�n�Q�这时第一�U�方式更好；其他情况下第二种方式更好�?

4.3.2 POJO之间兌��的调�?/h4>
如果可以用one-to-one、one-to-many或many-to-one的关联，��׃��要��用many-to-many�?/li>
many-to-many兌��需要额外的映射表�?br />��管你的Java代码只需要处理两端的POJO�Q�但查询�Ӟ��数据库需要额外地兌��映射表，修改旉��要额外的删除和插入�?/li>
单向兌��优先于双向关联�?br />�׃��many-to-many的特性，在双向关联的一端加载对象会触发另一端的加蝲�Q�这会进一步触发原始端加蝲更多的数据，�{�等�?br />one-to-many和many-to-one的双向关联也是类似的�Q?a>当你从多端（子实体）定位��C��端（父实体）�?br />�q�样的来回加载很耗时�Q�而且可能也不是你所期望的�?/li>
不要��Z��兌��而定义关联；只在你需要一起加载它们时才这么做�Q�这应该�׃��的业务规则和设计来决定（�?strong>范例5�Q��?br />另外�Q�你要么不定义�Q何关联，要么在子POJO中定义一个值类型的属性来表示父POJO的ID�Q�另一个方向也是类似的�Q��?/li>
集合调优
如果集合排序逻辑能由底层数据库实玎ͼ��׃��?#8220;order-by”属性来代替“sort”�Q�因为通常数据库在�q�方面做得比你好�?br />集合可以是值类型的�Q�元素或�l�合元素�Q�，也可以是实体引用�c�d��的（one-to-many或many-to-many兌��Q�。对引用�c�d��集合的调优主要是调优获取�{�略。对于值类型集合的调优�Q�HRD ^[1]中的20.5�?#8220;理解集合性能”已经做了很好的阐�q��?/li>
获取�{�略调优。请�?strong>4.7节的范例5�?

范例5

我们有一个名为ElectricityDeals的核心POJO用于描述�늚�交易。从业务角度来看�Q�它有很多many-to-one兌��Q�例如和Portfolio、Strategy和Trader�{�的兌��。因为引用数据十分稳定，它们被缓存在前端�Q�能��Z��其ID属性快速定位到它们�?/p>
��Z��有好的加载性能�Q�ElectricityDeal只映��元数据�Q�即那些引用POJO的值类型ID属性，因�ؓ在需要时�Q�可以在前端通过portfolioKey从缓存中快速查找Portfolio�Q?/p>
name="portfolioKey" column="PORTFOLIO_ID" type="integer"/>

�q�种隐式兌��避免了数据库表连接和额外的字�D�选择�Q�降低了数据传输的大��?/p>

4.4 �q�接池调�?/h3>
�׃��创徏物理数据库连接非常耗时�Q�你应该始终使用�q�接池，而且应该始终使用生��U�连接池而非Hibernate内置的基本连接池��法�?/p>
通常会�ؓHibernate提供一个有�q�接池功能的数据源。Apache DBCP的BasicDataSource^[13]是一个流行的开源生产��数据源。大多数数据库厂商也实现了自��q��兼容JDBC 3.0的连接池。�D例来��_��你也可以使用Oracle ReaApplication Cluster ^[15]提供的JDBC�q�接�?sup>[14]以获得连接的负蝲均衡和失败�{�U�R�?/p>
不用多说�Q�你在网上能扑ֈ�很多关于�q�接池调优的技术，因此我们只讨论那些大多数�q�接池所共有的通用调优参数�Q?/p>
最��池大小�Q�连接池中可保持的最��连接数�?/li>
最大池大小�Q�连接池中可以分配的最大连接数�?br />如果应用�E�序有高�q�发�Q�而最大池大小又太��，�q�接池就会经常等待。相反，如果最��池大小太大�Q�又会分配不需要的�q�接�?/li>
最大空闲时��_��q�接池中的连接被物理关闭前能保持�I�闲的最大时间�?/li>
最大等待时��_��q�接池等待连接返回的最大时间。该参数可以预防失控事务�Q�runaway transaction�Q��?/li>
验证查询�Q�在��连接返回给调用方前用于验证�q�接的SQL查询。这是因��Z��些数据库被配�|��ؓ会杀掉长旉��I�闲的连接，�|�络或数据库相关的异�怹�可能会杀死连接。�ؓ了减��此�c�d��销�Q�连接池在空闲时会运行该验证�?

4.5事务和�ƈ发的调优

短数据库事务对�Q何高性能、高可扩展性的应用�E�序来说都是必不可少的。你使用表示对话��h��的会话来处理单个工作单元�Q�以此来处理事务�?/p>
考虑到工作单元的范围和事务边界的划分�Q�有3中模式：

每次操作一个会话�?/strong>每次数据库调用需要一个新会话和事务。因为真实的业务事务通常包含多个此类操作和大量小事务�Q�这一般会引�v更多数据库活动（主要是数据库每次提交需要将变更��h��到磁盘上�Q�，影响应用�E�序性能。这是一�U�反模式�Q�不该��用它�?/li>
使用分离对象�Q�每�ơ请求一个会话�?/strong>每次客户端请求有一个新会话和一个事务，使用Hibernate�?#8220;当前会话”�Ҏ��将两者关联�v来�?br />在一个多层系�l�中�Q�用户通常会发起长对话�Q�或应用�E�序事务�Q�。大多数旉��我们使用Hibernate的自动版本和分离对象来实��C��观�ƈ发控制和高性能�?/li>
带扩展（或长�Q�会话的每次对话一会话�?/strong>在一个也�怼�跨多个事务的长对话中保持会话开启。尽��这能把你从重新兌��中解脱出来，但会话可能会内存溢出�Q�在高�ƈ发系�l�中可能会有旧数据�?

你还应该注意以下几点�?nbsp;

如果不需要JTA��q��本地事务�Q�因为JTA需要更多资源，比本��C��务更慢。就��你有多个数据源�Q�除非有跨多个数据库的事务，否则也不需要JTA。在最后的一个场景下�Q�可以考虑在每个数据源中��用本��C��务，使用一�U�类�?#8220;Last Resource Commit Optimization”^[16]的技术（见下面的范例6�Q��?/li>
如果不涉及数据变��_��事务标��Cؓ只读的，��像4.3.1�?/strong>提到的那栗��?/li>
��L��讄��默认事务��时。保证在没有响应�q�回�l�用��h��Q�没有行��Z��当的事务会完全占有资源。这�Ҏ��C��务也同样有效�?/li>
如果Hibernate不是独占数据库用��P��乐观锁会失效�Q�除非创建数据库触发器�ؓ其他应用�E�序对相同数据的变更增加版本字段倹{�?

范例6

我们的应用程序有多个在大多数情况下只和数据库“A”打交道的服务层方法；它们偶尔也会从数据库“B”中获取只��L��据。因为数据库“B”只提供只��L��据，我们对这些方法在�q�两个数据库上仍然��用本��C��务�?/p>
服务层上有一个方法设计在两个数据库上执行数据变更。以下是伪代码：
//Make sure a local transaction on database A exists @Transactional (readOnly=false, propagation=Propagation.REQUIRED) public void saveIsoBids() { //it participates in the above annotated local transaction insertBidsInDatabaseA(); //it runs in its own local transaction on database B insertBidRequestsInDatabaseB(); //must be the last operation

因�ؓinsertBidRequestsInDatabaseB()是saveIsoBids ()中的最后一个方法，所以只有下面的场景会造成数据不一��_��

在saveIsoBids()执行�q�回�Ӟ��数据�?#8220;A”的本��C��务提交失败�?/p>
但是�Q�就��saveIsoBids()使用JTA�Q�在两阶�D�|��交（2PC�Q�的�W�二个提交阶�D�失败的时候，你还是会��到数据不一致。因此如果你能处理好上述的数据不一致性，而且不想��Z��一个或��数几个�Ҏ��引入JTA的复杂性，你应该��用本��C��务�?/p>

�Q�未完待�l�）

... 2011-06-18 11:59 发表评论

[转]Spring3.05��单集成MyBatis3.03

... — Sat, 18 Jun 2011 03:42:00 GMT
     摘要: 原文: http://blog.csdn.net/sustbeckham/archive/2010/12/17/6082677.aspxmybatis一直没有发布release版本。所以spring也坐着看。但是spring�q�是必须用啊�?1. Pojo & mapper配置 view plaincopy to clipboardprint? package&...  阅读全文

... 2011-06-18 11:42 发表评论

获取textarea选中文本

... — Wed, 16 Mar 2011 13:34:00 GMT

1code_area.text.substr(code_area.selectionBeginIndex, code_area.selectionEndIndex - code_area.selectionBeginIndex);

... 2011-03-16 21:34 发表评论

新方�?/strong>	老方�?/strong>
RegionFactory	CacheProvider
Region	Cache
EntityRegionAccessStrategy	CacheConcurrencyStrategy
CollectionRegionAccessStrategy	CacheConcurrencyStrategy

99久久精品久久久久久ai换脸,亚洲一区二区三区在线视频 ,青青草视频免费在线观看

[转]你是否懂得Oracle UNION ALL

[转]hibernate抓取�{�略

[转]Hibernate性能优化要点

4.6 HQL调优

4.6.1 索引调优

4.6.4覆盖抓取�{�略

4.6.5本地查询

4.7抓取�{�略调优

4.7.1覆盖抓取�{�略

4.7.2 N+1模式或是反模式？

4.8 二��~�存调优

4.8.2 RegionFactory

4.8.3 查询�~�存

4.9扚w��处理调优

4.9.3 DML风格

4.9.4扚w��加蝲

4.10 SQL生成调优

4.10.1 N+1抓取问题

4.10.2 Insert+Update问题

4.10.3 更新前执行select

4.10.4 �U�联删除

5 �ȝ��

6 资源

1.引言

3. 监控和剖�?/h2> 没有对Hibernate应用�E�序的有效监控和剖析�Q�你无法得知性能瓉���以及何处需要调优�?/p>

3.1.1 监控SQL生成

3.1.2 查看Hibernate�l�计

3.1.3 剖析

4. 调优技�?/h2>

4.2�l�承映射调优

4.2.1 每个�c�d���ơ一张表

4.2.2每个子类一张表

4.2.3每个具体�c�M��张表

4.2.4使用隐式多态实现每个具体类一张表

4.3 领域对象调优

4.3.1 POJO调优

4.5事务和�ƈ发的调优

[转]Spring3.05���单集成MyBatis3.03

获取textarea选中文本

3. 监控和剖�?/h2>
没有对Hibernate应用�E�序的有效监控和剖析�Q�你无法得知性能瓉��以及何处需要调优�?/p>

4.2.1 每个�c�d��ơ一张表

[转]Spring3.05��单集成MyBatis3.03