select * from
(select t.*, romnum rn from
(select * from user
where score > #score#
order by $orderby$
) t
where rownum <= #start# + #size# )
where rn > #start#
在数据量较少Ӟ以上语句没有问题Q但是在辑ֈ500w+数据量时Q就会发生急剧的性能下降Q经q测试，发现应该改ؓ以下的语句，可以避免，在千万数据以上仍可以在百毫秒得出l果(select t.*, romnum rn from
(select * from user
where score > #score#
order by $orderby$
) t
where rownum <= #start# + #size# )
where rn > #start#
select * from
(select t.*, romnum rn from
(select * from user
where score > #score#
order by $orderby$
) t
where rownum <= $start$ + $end$ )
where rn > #start#
(select t.*, romnum rn from
(select * from user
where score > #score#
order by $orderby$
) t
where rownum <= $start$ + $end$ )
where rn > #start#
因ؓibatis会将#xxx#参数解析为PreparedStatement中的Q，但是如果使用#start#+#size#Q会产生?+?的语句，影响oracle语句动态解析，实际上这个参数在执行时完全可以先计算和，再作Z个g入语句，采用$start$+$size$正是做到了这点，大大加快了执行速度
]]>
number数据cd
numbercd的语法很单：number(p,s)Q?br /> pQ精度位QprecisionQ是L效数据位敎ͼ取D围是38Q默认是38Q可以用字符*表示38?br /> sQ小CQscaleQ是数点右边的位数Q取D围是-84~127Q默认值取决于pQ如果没有指定pQ那么s是最大范_如果指定了pQ那么s=0?br /> pQis the precision,or the total number of digits. Oracle guarantees the portability of numbers with precision ranging from 1 to 38.
sQis the scale, or the number of digits to the right of the decimal point. The scale can range from -84 to 127.
numbercd的p和sQ与其底层存储完全没有关p，Ҏ(gu)不会影响数据在磁盘上如何存储Q它只会影响允许哪些g及数值如何舍入，你可以认为其是对数据?#8220;~辑”。简单的__ֺ位p表示数值最多能有多个有效数字Q而小Cs表示最多能有多位数。换句话_p表示一共有多少位有效数字（卛_数点左边最多有p-s位有效数字）Qs表示数点右Ҏ(gu)s位有效数字。如number(5,2)cd的数据，pC小数点左边最多有3位有效数字，双最多有2位有效数字，加v来就是最多有5位有效数字，过q个范围的数字就不能正确的存储下来，注意q里说的是不能正存储，但ƈ不是不能存储?br />
最高整C敎ͼp-s
s正数Q小数点双指定位置开始四舍五?
s负数Q小数点左边指定位置开始四舍五?
s?或者未指定Q四舍五入到最q整?
当p于s时候，表示数字是绝对值小?的数字，且从数点右边开始的前s-p位必L0Q保留s位小数?
p>0Q对s?U情况：
1. s>0
_到小数点双s位，q四舍五入。然后检验有效数位是?lt;=pQ如果s>pQ小数点双臛_有s-p?填充?
2. s<0
_到小数点左边s位，q四舍五入。然后检验有效数位是?lt;=p+|s|
具体数据可参考下?br />
|
Value |
Datatype |
Stored Value |
|
123.2564 |
NUMBER |
123.2564 |
|
1234.9876 |
NUMBER(6,2) |
1234.99 |
|
12345.12345 |
NUMBER(6,2) |
Error |
|
1234.9876 |
NUMBER(6) |
1235 |
|
12345.345 |
NUMBER(5,-2) |
12300 |
|
1234567 |
NUMBER(5,-2) |
1234600 |
|
12345678 |
NUMBER(5,-2) |
Error |
|
123456789 |
NUMBER(5,-4) |
123460000 |
|
1234567890 |
NUMBER(5,-4) |
Error |
|
12345.58 |
NUMBER(*, 1) |
12345.6 |
|
0.1 |
NUMBER(4,5) |
Error |
|
0.01234567 |
NUMBER(4,5) |
0.01235 |
|
0.09999 |
NUMBER(4,5) |
0.09999 |
|
0.099996 |
NUMBER(4,5) |
Error |
里面发生错误的行有的是因为源数据过了可以表C的范围Q有的是因ؓq行数四舍五入后超q了可以表示的范围?br />
以下是一些例?br />
1. s>0
_到小数点双s位，q四舍五入。然后检验有效数位是?lt;=pQ?
ZWF.YUDONG>create table t_n(id number(5,2));
Table created.
ZWF.YUDONG>insert into t_n values(123.45);
1 row created.
ZWF.YUDONG>insert into t_n values(123.455);
1 row created.
ZWF.YUDONG>select * from t_n;
ID
----------
123.45
123.46
2 rows selected.
ZWF.YUDONG>insert into t_n values(1.234);
1 row created.
ZWF.YUDONG>select * from t_n;
ID
----------
123.45
123.46
1.23
3 rows selected.
ZWF.YUDONG>insert into t_n values(.001);
1 row created.
ZWF.YUDONG>select * from t_n;
ID
----------
123.45
123.46
1.23
0
4 rows selected.
ZWF.YUDONG>insert into t_n values(1234.56);
insert into t_n values(1234.56)
*
ERROR at line 1:
ORA-01438: value larger than specified precision allowed for this column
如果s>pQ小数点双臛_有s-p?填充?
ZWF.YUDONG>create table t_n(id number(4,5));
Table created.
ZWF.YUDONG>insert into t_n values(1);
insert into t_n values(1)
*
ERROR at line 1:
ORA-01438: value larger than specified precision allowed for this column
ZWF.YUDONG>insert into t_n values(.1);
insert into t_n values(.1)
*
ERROR at line 1:
ORA-01438: value larger than specified precision allowed for this column
ZWF.YUDONG>insert into t_n values(.01);
1 row created.
ZWF.YUDONG>commit;
Commit complete.
ZWF.YUDONG>select * from t_n;
ID
----------
.01
1 row selected.
ZWF.YUDONG>insert into t_n values(.001);
1 row created.
ZWF.YUDONG>insert into t_n values(.0001);
1 row created.
ZWF.YUDONG>insert into t_n values(.00001);
1 row created.
ZWF.YUDONG>insert into t_n values(.000001); --过d存储0
1 row created.
ZWF.YUDONG>select * from t_n;
ID
----------
.01
.001
.0001
.00001
0
10 rows selected.
ZWF.YUDONG>col dp for a50
ZWF.YUDONG>select id,dump(id) dp,length(id),vsize(id) from t_n; --vsize和dump的是字节敎ͼlength是数值实际位敎ͼ含小数点Q?
ID DP LENGTH(ID) VSIZE(ID)
---------- -------------------------------------------------- ---------- ----------
.01 Typ=2 Len=2: 192,2 3 2
.001 Typ=2 Len=2: 191,11 4 2
.0001 Typ=2 Len=2: 191,2 5 2
.00001 Typ=2 Len=2: 190,11 6 2
0 Typ=2 Len=1: 128 1 1
5 rows selected.
2. s<0
_到小数点左边s位，q四舍五入。然后检验有效数位是?lt;=p+|s|
ZWF.YUDONG>create table t_n(id number(5,-2));
Table created.
ZWF.YUDONG>insert into t_n values(12345);
1 row created.
ZWF.YUDONG>select * from t_n;
ID
----------
12300
1 row selected.
ZWF.YUDONG>insert into t_n values(123456);
1 row created.
ZWF.YUDONG>insert into t_n values(1234567);
1 row created.
ZWF.YUDONG>select * from t_n;
ID
----------
12300
123500
1234600
3 rows selected.
ZWF.YUDONG>insert into t_n values(12345678);
insert into t_n values(12345678)
*
ERROR at line 1:
ORA-01438: value larger than specified precision allowed for this column
oracle的numbercd存储l构
oracle采用变长存储number数据cdQ按一定规则进行{换成2q制~码格式存储Q?
oracle数据库中存储的numbercd包含3个部? HEAD部分, DATA部分, W号位?
Ҏ(gu)数来? W号位省? ?来说, oracle存储的是X80Q?28Q?
ZWF.YUDONG>select dump(0) from dual;
DUMP(0)
----------------
Typ=2 Len=1: 128
1 row selected.
ZWF.YUDONG>select dump(1) from dual;
DUMP(1)
------------------
Typ=2 Len=2: 193,2
1 row selected.
ZWF.YUDONG>select dump(-1) from dual;
DUMP(-1)
-----------------------
Typ=2 Len=3: 62,100,102
1 row selected.
HEAD部分Z个字?? 是前面看到?28, 193Q?2。由该部分我们可以看出numbercd的基本信息，因ؓ设计q种存储格式的时? oracle希望以十六进?0-FF来表C所?
的number, 所以ؓ了编码的对称, 首先number分ؓ正负, 所以以00-FF的中间位|?0, 也就是十q制?28来表C?, HEAD部分于80,即ؓ负数,大于80即ؓ正数。ORACLE再次?
00-80, 80-FFq行对分Q?
00-3E 表示: number <= -1
3F-7F 表示: -1 < number < 0
81-C0 表示: 0 < number < 1
C1-FF 表示Qnumber >= 1
从HEAD部分我们可以也看出数据的位数信息Q是否含有小敎ͼ可以Ҏ(gu)HEAD的信息判断小数点的位|。由于数据部分低?的nơ方位个0是不被存储的Q数据展现的时候oracle
Ҏ(gu)HEAD的信息给补充末位??
ZWF.YUDONG>select dump(123456789) from dual;
DUMP(123456789)
------------------------------
Typ=2 Len=6: 197,2,24,46,68,90 --197QC5Q的含义Q表C数?23456789大于1Q?97-193(数字1占用2个字节该gؓ193) = 4 Q所以该数字占用6Q?+4Q个字节?
1 row selected.
然后,我们再来看数据部? ORACLE对十q制的数?整数部分,数部分正好相反)是两位两位进行存储的(从右往左的序), 例如?234, ORACLE会分别对12, 34q行存储.
所以只需要对(+-)1-99q行~码
1 --- 99 分别用十六进?-64表示Q就?-100,
-1--- -99 用十六进?4-2表示Q就?00-2
ZWF.YUDONG>select dump(12345) from dual;
DUMP(12345)
------------------------
Typ=2 Len=4: 195,2,24,46 --数据部分2,24,46 表示 Q?-1=1Q?4-1=23Q?6-1=45Q；HEAD部分表示12345 >= 1,占用195-193+2=4字节?
1 row selected.
SYS.YUDONG>select dump(1100) from dual;
DUMP(1100)
-------------------
Typ=2 Len=2: 194,12 --如果从右边vQ连l?的nơ方位ؓ0Qoracle一ơ排触（不存储）只是位数?。可以对比dump(11)的情늜看?
1 row selected.
SYS.YUDONG>select dump(11) from dual;
DUMP(11)
-------------------
Typ=2 Len=2: 193,12 --q里数据部分?100是一LQ末位的2?没有实际存储Q长?93?94??
1 row selected.
--对于含小?负数、整?U情?的情况：
1、负?
SYS.YUDONG>select dump(-1.2) from dual;
DUMP(-1.2)
--------------------------
Typ=2 Len=4: 62,100,81,102 --HEAD=62Q?EQ表C数值小于等?1;数据部分Q整数部分的-1存储?00Q小数部分从左往?位一l合Q不?位后边补一??
对应关系变ؓ9Q?...1表示1Q?...9Q看下面几个例子Q如果2位，q是按照上边说的规律Q?1--- -99 用十六进?4-2表示Q就?00-2Q?
1 row selected.
ZWF.YUDONG>select dump(-2.1) from dual;
DUMP(-2.1)
-------------------------
Typ=2 Len=4: 62,99,91,102
1 row selected.
ZWF.YUDONG>select dump(-2.2) from dual;
DUMP(-2.2)
-------------------------
Typ=2 Len=4: 62,99,81,102
1 row selected.
ZWF.YUDONG>select dump(-2.9) from dual;
DUMP(-2.9)
-------------------------
Typ=2 Len=4: 62,99,11,102
1 row selected.
ZWF.YUDONG>select dump(-2.12) from dual;
DUMP(-2.12)
-------------------------
Typ=2 Len=4: 62,99,89,102
1 row selected.
ZWF.YUDONG>select dump(-2.13) from dual;
DUMP(-2.13)
-------------------------
Typ=2 Len=4: 62,99,88,102
1 row selected.
ZWF.YUDONG>select dump(-2.123) from dual;
DUMP(-2.123)
----------------------------
Typ=2 Len=5: 62,99,89,71,102
1 row selected.
2、正?
SYS.YUDONG>select dump(1.222) from dual;
DUMP(1.222)
------------------------
Typ=2 Len=4: 193,2,23,21 --HEAD=193(C1)表示该数字大于等?;数据部分:整数部分存储2(2-1=1),数部分从左往?位一l合,23(23-1=22)表示22,后边q剩下一?,
不2位的末尾补充一?,也就是等?.2220
1 row selected.
ZWF.YUDONG>select dump(1.2220) from dual;
DUMP(1.2220)
------------------------
Typ=2 Len=4: 193,2,23,21
1 row selected.
W号位： 用的?+-)1-99都不可能用到的编?6(102)来表C，有资料说Z处理排序问题Q未加考证Q。根据HEAD部分可以做初步判断，Ҏ(gu)我们说的HEAD部分的四个范_
如果2个数g在一个范_立即可以看出大小Q如果在一个范围其实也可以Ҏ(gu)其正?l对值来q行排序了，正数l对值大的就大，负数则相反，Zq要用到q个W号位？
本地点cd
另外再说一下两个数值类型本地QҎ(gu)据类型（binary_float与binary_doubleQ?br />
本地点数据cd最大的特点是比NUMBERcd效率更高
gq算/数学q算?5– 10 ?br /> 占用更少的内?盘I间Q?/9 字节?1 – 22 字节Q?br /> BINARY_DOUBLE D围更大（e308 ?e125Q?br /> 无需cd转换Q用与字节序无关的存储格式）
下面E序是用欧拉数计圆周率∏:
∏ = sqrt ( 6 * ( 1 + 1/2*2 + 1/3*2 + ... ) )
Ҏ(gu)一Q用NUMBERcd
create or replace procedure Euler_Pi_Number is
subtype My_Number is number;
zero constant My_Number := 0.0;
one constant My_Number := 1.0;
two constant My_Number := 2.0;
six constant My_Number := 6.0;
toler constant My_Number := 0.00000000001;
root_toler constant My_Number := toler/1000.0;
root My_Number;
prev_root My_Number;
prod_over_six My_Number;
prod My_Number;
pi My_Number;
prev_pi My_Number;
step My_Number;
begin
pi := one;
prev_pi := zero;
prod_over_six := zero;
step := zero;
while pi - prev_pi > toler
loop
prev_pi := pi;
step := step + one;
prod_over_six := prod_over_six + one/(step*step);
prod := six*prod_over_six;
prev_root := prod;
root := prod/two;
while Abs(root - prev_root) > root_toler
loop
prev_root := root;
root := (root + prod/root)/two;
end loop;
pi := root;
end loop;
end Euler_Pi_Number;
/
Ҏ(gu)二：使用BINARY_DOUBLEcd
create or replace procedure Euler_Pi_Binary is
subtype My_Number is binary_double;
zero constant My_Number := 0.0d;
one constant My_Number := 1.0d;
two constant My_Number := 2.0d;
six constant My_Number := 6.0d;
toler constant My_Number := 0.00000000001d;
root_toler constant My_Number := toler/1000.0d;
root My_Number;
prev_root My_Number;
prod_over_six My_Number;
prod My_Number;
pi My_Number;
prev_pi My_Number;
step My_Number;
begin
pi := one;
prev_pi := zero;
prod_over_six := zero;
step := zero;
while pi - prev_pi > toler
loop
prev_pi := pi;
step := step + one;
prod_over_six := prod_over_six + one/(step*step);
prod := six*prod_over_six;
prev_root := prod;
root := prod/two;
while Abs(root - prev_root) > root_toler
loop
prev_root := root;
root := (root + prod/root)/two;
end loop;
pi := root;
end loop;
end Euler_Pi_Binary;
/
SQL> set timing on
SQL> exec Euler_Pi_Number;
PL/SQL q程已成功完成?br />
已用旉: 00: 00: 11.59
SQL> exec Euler_Pi_Binary;
PL/SQL q程已成功完成?br />
已用旉: 00: 00: 02.09
上面例子中近?00,000ơP代计?NUMBERcdp11.59U?BINARY_DOUBLEcdpU?.09U?性能提高大约5.5?
l论Q在版本10g之后写一些偏数字U学q行量巨大的存储q程、函数时,对于点数字cd要优先考虑使用本地点数据cd
相关链接
http://it.chinawin.net/database/article-4193.html
http://ilinux.javaeye.com/blog/289550
http://yaanzy.itpub.net/post/1263/200971
]]>
脏读Q就是指当一个事务正在访问数据，q且Ҏ(gu)据进行了修改Q而这U修改还没有提交到数据库中，q时Q另外一个事务也讉Kq个数据Q然后用了q个数据。因个数据是q没有提交的数据Q那么另外一个事务读到的q个数据是脏数据Q依据脏数据所做的操作可能是不正确的?br />
不可重复读，是指在一个事务内Q多ơ读同一数据。在q个事务q没有结束时Q另外一个事务也讉K该同一数据。那么，在第一个事务中的两ơ读数据之间Q由于第二个事务的修改，那么W一个事务两ơ读到的的数据可能是不一L。这样就发生了在一个事务内两次d的数据是不一LQ因此称为是不可重复诅R?br />
q读Q是指当事务不是独立执行时发生的一U现象，例如W一个事务对一个表中的数据q行了修改，q种修改涉及到表中的全部数据行。同ӞW二个事务也修改q个表中的数据，q种修改是向表中插入一行新数据。那么，以后׃发生操作W一个事务的用户发现表中q有没有修改的数据行Q就好象发生了觉一栗?br />
ANSI SQL中定义的4个隔ȝ实际上是用对锁的操作来定义的Q?br />
Read Uncommitted(未提交读取，也叫脏读): L据时不加锁。允许脏诅R不可重复读、觉读?br /> Read Committed(提交d): 在读数据之前加一个读锁，d之后释放锁。允怸可重复读、觉读?br /> Repeatable Read(可重复读?: 在读数据之前加一个读锁，d之后不释NQ直C务rollback或者commit后才释放锁。允许觉读?br /> Serializable(串行化读?: 在读数据之前在读取的条g上加锁（UCؓ条g锁）Q读完之后不释放锁，直到事务rollback或者commit后才释放锁。不允许脏读、不可重复读、诅R?br />
以下是对照表
| 隔离U别 | 脏读QDirty ReadQ? | 不可重复读（NonRepeatable ReadQ? | q读QPhantom ReadQ? |
|---|---|---|---|
| L提交QRead uncommittedQ? | 可能 | 可能 | 可能 |
| d提交QRead committedQ? | 不可? | 可能 | 可能 |
| 可重复读QRepeatable readQ? | 不可? | 不可? | 可能 |
| 可串行化QSerializable Q? | 不可? | 不可? | 不可? |
]]>