--查询表空间、表空间大小及表空间对应物理路径

select a.tablespace_name,b.file_name,a.block_size,a.block_size,b.bytes/1024

/1024 "Sum MB" from dba_tablespaces a,dba_data_files b where a.tablespace_name=b.tablespace_name;

--查询表空间使用情况

　　SELECT UPPER(F.TABLESPACE_NAME) "表空间名",

　　D.TOT_GROOTTE_MB "表空间大小(M)",

　　D.TOT_GROOTTE_MB - F.TOTAL_BYTES "已使用空间(M)",

　　TO_CHAR(ROUND((D.TOT_GROOTTE_MB - F.TOTAL_BYTES) / D.TOT_GROOTTE_MB * 100,2),'990.99') || '%' "使用比",

　　F.TOTAL_BYTES "空闲空间(M)",

　　F.MAX_BYTES "最大块(M)"

　　FROM (SELECT TABLESPACE_NAME,

　　ROUND(SUM(BYTES) / (1024 * 1024), 2) TOTAL_BYTES,

　　ROUND(MAX(BYTES) / (1024 * 1024), 2) MAX_BYTES

　　FROM SYS.DBA_FREE_SPACE

　　GROUP BY TABLESPACE_NAME) F,

　　(SELECT DD.TABLESPACE_NAME,

　　 ROUND(SUM(DD.BYTES) / (1024 * 1024), 2) TOT_GROOTTE_MB

　　FROM SYS.DBA_DATA_FILES DD

　　GROUP BY DD.TABLESPACE_NAME) D

　　WHERE D.TABLESPACE_NAME = F.TABLESPACE_NAME

　　ORDER BY 1;

--查询表空间的free space

　　select tablespace_name,

　　count(*) as extends,

　　round(sum(bytes) / 1024 / 1024, 2) as MB,

　　sum(blocks) as blocks

　　from dba_free_space

group by tablespace_name;

--查询表空间的总容量

　　select tablespace_name, sum(bytes) / 1024 / 1024 as MB

　　from dba_data_files

　　group by tablespace_name;

--查询表空间使用率

　　select total.tablespace_name,

　　round(total.MB, 2) as Total_MB,考试大论坛

　　round(total.MB - free.MB, 2) as Used_MB,

　　round((1 - free.MB / total.MB) * 100, 2) || '%' as Used_Pct

　　from (select tablespace_name, sum(bytes) / 1024 / 1024 as MB

　　from dba_free_space

　　group by tablespace_name) free,

　　(select tablespace_name, sum(bytes) / 1024 / 1024 as MB

　　from dba_data_files

　　group by tablespace_name) total

　　where free.tablespace_name = total.tablespace_name;

1.查找当前表级锁的SQL如下：

select sess.sid,

    sess.serial#,

    lo.oracle_username,

    lo.os_user_name,

    ao.object_name,

    lo.locked_mode

    from v$locked_object lo,

    dba_objects ao,

    v$session sess

where ao.object_id = lo.object_id and lo.session_id = sess.sid;

2.杀掉锁表进程：

alter system kill session '436,35123';

3.RAC环境中锁查找：

SELECT inst_id,DECODE(request,0,'Holder: ','Waiter: ')||sid sess,

        id1, id2, lmode, request, type,block,ctime

FROM GV$LOCK

WHERE (id1, id2, type) IN

       (SELECT id1, id2, type FROM GV$LOCK WHERE request>0)

ORDER BY id1, request;

4.监控当前数据库谁在运行什么SQL语句

select osuser, username, sql_text 

from  v$session a, v$sqltext b

where  a.sql_address =b.address order by address, piece;

5.找使用CPU多的用户session

select a.sid,spid,status,substr(a.program,1,40) prog, a.terminal,osuser,value/60/100 value

from  v$session a,v$process b,v$sesstat c

where  c.statistic#=12 and 

       c.sid=a.sid and 

       a.paddr=b.addr 

       order by value desc;

6.查看死锁信息

SELECT (SELECT username

          FROM v$session

         WHERE SID = a.SID) blocker, a.SID, 'is blocking',

       (SELECT username

          FROM v$session

         WHERE SID = b.SID) blockee, b.SID

  FROM v$lock a, v$lock b

 WHERE a.BLOCK = 1 AND b.request > 0 AND a.id1 = b.id1 AND a.id2 = b.id2;

7.具有最高等待的对象

SELECT   o.OWNER,o.object_name, o.object_type, a.event,

         SUM (a.wait_time + a.time_waited) total_wait_time

    FROM v$active_session_history a, dba_objects o

   WHERE a.sample_time BETWEEN SYSDATE - 30 / 2880 AND SYSDATE

     AND a.current_obj# = o.object_id

GROUP BY o.OWNER,o.object_name, o.object_type, a.event

ORDER BY total_wait_time DESC;

SELECT   a.session_id, s.osuser, s.machine, s.program, o.owner, o.object_name,

         o.object_type, a.event,

         SUM (a.wait_time + a.time_waited) total_wait_time

    FROM v$active_session_history a, dba_objects o, v$session s

   WHERE a.sample_time BETWEEN SYSDATE - 30 / 2880 AND SYSDATE

     AND a.current_obj# = o.object_id

     AND a.session_id = s.SID

GROUP BY o.owner,

         o.object_name,

         o.object_type,

         a.event,

         a.session_id,

         s.program,

         s.machine,

         s.osuser

ORDER BY total_wait_time DESC;

8.查询当前连接会话数

select s.value,s.sid,a.username

from

v$sesstat S,v$statname N,v$session A

where

n.statistic#=s.statistic# and

name='session pga memory'

and s.sid=a.sid

order by s.value;

9.等待最多的用户

SELECT   s.SID, s.username, SUM (a.wait_time + a.time_waited) total_wait_time

    FROM v$active_session_history a, v$session s

   WHERE a.sample_time BETWEEN SYSDATE - 30 / 2880 AND SYSDATE

GROUP BY s.SID, s.username

ORDER BY total_wait_time DESC;

10.等待最多的SQL

SELECT   a.program, a.session_id, a.user_id, d.username, s.sql_text,

         SUM (a.wait_time + a.time_waited) total_wait_time

    FROM v$active_session_history a, v$sqlarea s, dba_users d

   WHERE a.sample_time BETWEEN SYSDATE - 30 / 2880 AND SYSDATE

     AND a.sql_id = s.sql_id

     AND a.user_id = d.user_id

GROUP BY a.program, a.session_id, a.user_id, s.sql_text, d.username;

11.查看消耗资源最多的SQL

SELECT hash_value, executions, buffer_gets, disk_reads, parse_calls

FROM V$SQLAREA

WHERE buffer_gets > 10000000 OR disk_reads > 1000000

ORDER BY buffer_gets + 100 * disk_reads DESC;

12.查看某条SQL语句的资源消耗

SELECT hash_value, buffer_gets, disk_reads, executions, parse_calls

FROM V$SQLAREA

WHERE hash_Value = 228801498 AND address = hextoraw('CBD8E4B0');

13.查询会话执行的实际SQL

SELECT   a.SID, a.username, s.sql_text

    FROM v$session a, v$sqltext s

   WHERE a.sql_address = s.address

     AND a.sql_hash_value = s.hash_value

     AND a.status = 'ACTIVE'

ORDER BY a.username, a.SID, s.piece;

14.显示正在等待锁的所有会话

SELECT * FROM DBA_WAITERS;

DDL

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

/*注意点：

1.如果在PL/SQL 等工具里打开的话，直接修改下面的代码中[斜体加粗部分]执行

2.确保路径存在，比如【D:\oracle\oradata\Oracle9i\】也就是你要保存文件的路径存在

/*分为四步 */

/*第1步：创建临时表空间  */

create temporary tablespace user_temp 

tempfile 'D:\oracle\oradata\Oracle9i\user_temp.dbf'

size 50m 

autoextend on 

next 50m maxsize 20480m 

extent management local; 

/*第2步：创建数据表空间  */

create tablespace user_data 

logging 

datafile 'D:\oracle\oradata\Oracle9i\user_data.dbf'

size 50m 

autoextend on 

next 50m maxsize 20480m 

extent management local; 

/*第3步：创建用户并指定表空间  */

create user username identified by password 

default tablespace user_data 

temporary tablespace user_temp; 

/*第4步：给用户授予权限  */

grant connect,resource,dba to username; 

 1<!DOCTYPE html>
 2<html>
 3
 4<SCRIPT LANGUAGE="JavaScript">
 5function method1(){
 6    alert("method1");
 7}
 8function method2(){
 9    alert("method2");
10}
11function method3(){
12    alert("method3");
13}
14</SCRIPT>
15<body>
16<input type="button"  value="dom 元素事件属性绑定的按钮" id="button1"/>
17<input type="button"  value="IE浏览器: attachEvent进行事件绑定的按钮" id="btn1"/>
18<input type="button"  value="火狐浏览器: addEventListener进行事件绑定的按钮" id="btn2"/>
19
20<SCRIPT LANGUAGE="JavaScript">
21     /**//**方法一: 使用元素的事件属性. [这种方式事件只可绑定一次,最后绑定的执行]**/
22     button1.onclick = function() { alert("1-1"); };
23     button1.onclick = function() { alert("1-2"); };
24     /**//**方法二: 使用attachEvent注册事件. 格式如下object.attachEvent(event,function);**/
25   var btn1Obj = document.getElementById("btn1");
26    btn1Obj.attachEvent("onclick", method1);
27   btn1Obj.attachEvent("onclick", method2);
28    btn1Obj.attachEvent("onclick", method3);
29     /**//**方法三: addEventListener. 格式如下element.addEventListener(type,listener,useCapture);**/
30    var btn2Obj = document.getElementById("btn2");
31    btn2Obj.addEventListener("click",method1,false);
32    btn2Obj.addEventListener("click",method2,false);
33    btn2Obj.addEventListener("click",method3,false);
34    //执行顺序为method1->method2->method3
35</SCRIPT>
36<br/>attachEvent按照注册倒叙执行:    执行顺序为method3->method2->method1 
37<br/>addEventListener按照注册顺序执行:    执行顺序为method1->method2->method3 
38</body>
39</html>

JavaScript欲速则不达——基本处理事件详解和阻止事件传播

如何修改mysql root密码
  忘记MySQL ROOT密码是在MySQ使用中很常见的问题，可是有很多朋友并不会重置ROOT密码，那叫苦啊，特写此文章与大家交流：

1、编辑MySQL的配置文件：my.ini
一般在MySQL安装目录下有my.ini即MySQL的配置文件。
在此配置文件的最后添加如下一行：
skip-grant-tables
保存退出编辑。

2、然后重启MySQL服务
在命令行下执行：
net stop MySQL
net start MySQL

3、设置新的ROOT密码
然后用命令提示符cd到对应安装目录的bin下执行：
MySQL -u root -p MySQL或mysql -u root -p
直接回车无需密码即可进入数据库了。
此时,在命令行下执行 use mysql;
现在我们执行如下语句把root密码更新为：
update user set password=PASSWORD("root") where user='root';
(注意:此时不用使用mysqladmin -u root -p password '你的新密码'这条命令修改密码,因为'skip-grant-tables'配置,
不信的话,你可以试用一下,它肯定会报如下所示的错误:
F:\Documents and Settings\long>mysqladmin -u root -p password 'root'
Enter password:
Warning: single quotes were not trimmed from the password by your command
line client, as you might have expected.
mysqladmin:
You cannot use 'password' command as mysqld runs
 with grant tables disabled (was started with --skip-grant-tables).
Use: "mysqladmin flush-privileges password '*'" instead)
exit 退出MySQL。

4、还原配置文件并重启服务

然后修改MySQL配置文件把刚才添加的那一行'skip-grant-tables'删除。
再次重起MySQL服务，密码修改完毕。
用新密码root试一下吧，又能登入重新进入mysql了？



附mysql修改密码的一些方法:
1. 用MYSQL的grant语句，例如
mysql -h hostname –u root 命令登录到mysqld server 用grant 命令改变口令:
mysql -h 192.168.1.101 -u root
上边的192.168.1.101 是偶的mysqld 运行机器，你换成自己的，这样登录上去，就可以修改密码了,
其实没必要这么麻烦,直接mysql -u root就可以了。
GRANT ALL ON *.* TO 'root'@'localhost' IDENTIFIED BY 'root' WITH GRANT OPTION

2. mysqladmin -u 用户名 -p 旧密码 password 新密码
例1：给root 加个密码root。首先进入cmd中，然后键入
以下命令,至于在CMD下能否使用mysqladmin，
就要看你的Windows环境变量PATH中是否添加“E:\Program Files\MySQL\MySQL Server 5.1\bin;”（请改为你自己的安装路径）了。)
mysqladmin -u root password root
注：因为开始时root 没有密码，所以-p 旧密码一项就可以省略了。
例2：再将root 的密码改为admin。
mysqladmin –u root -proot password admin(注意-p 不要和后面的密码分
开写，要写在一起,不然会出错,错误如下所示:
F:\Documents and Settings\long>mysqladmin -u root -p root password admin
Enter password: ****
mysqladmin: Unknown command: 'root')
当然你也可以这样写:mysqladmin –u root -p password admin回车,
然后再输入你的旧密码,这样也是完全也可以的,看你的爱好了.
例3:再将root用户的密码去掉.
F:\Documents and Settings\long>mysqladmin -u root -p password  ;
Enter password: root
此时,root用户又没有密码了.可以通过下面的方法设置:
F:\Documents and Settings\long>mysql -u root
mysql>set password for 'root'@'localhost'=password('root');(语法:SET PASSWORD FOR '用户名'@'主机' = PASSWORD('密码'))
mysql>set password for 'root'@'%'=password('root');
//本条可选,这是在配置mysql数据库,如果你选择了允许root通过远程登录进来时,你在mysql数据库下的user表中,
use mysql;
select * from user;可以看到有两条记录,如果你没有配置这一项的话,只会第一条记录!
Host                    User     Password
'localhost', 'root', '*9C9F4927129ECC3209D8550DC8B67156FDBF9418', ...
'%', 'root', '*81F5E21E35407D884A6CD4A731AEBFB6AF209E1B', ...
通过以上设置,root的密码将变为root这样就完成了根用户root密码的设置工作。

3. use mysql;
 update user set password =password('yourpass') where user='root'

(注:下面的这些方法我本人没有试过,不知对不对,我只是转载了一下:)
下面的方法都在mysql提示符下使用，且必须有mysql的root权限：
方法4
mysql> INSERT INTO mysql.user (Host,User,Password)
VALUES('%','jeffrey',PASSWORD('biscuit'));
mysql> FLUSH PRIVILEGES
确切地说这是在增加一个用户，用户名为jeffrey，密码为biscuit。
在《mysql中文参考手册》里有这个例子，所以我也就写出来了。
注意要使用PASSWORD函数，然后还要使用FLUSH PRIVILEGES。

方法5
和方法三一样，只是使用了REPLACE语句
mysql> REPLACE INTO mysql.user (Host,User,Password)
VALUES('%','jeffrey',PASSWORD('biscuit'));
mysql> FLUSH PRIVILEGES

方法6
使用SET PASSWORD语句，
mysql> SET PASSWORD FOR jeffrey@"%" = PASSWORD('biscuit');
你也必须使用PASSWORD()函数，
但是不需要使用FLUSH PRIVILEGES。


方法7
使用GRANT ... IDENTIFIED BY语句
mysql> GRANT USAGE ON *.* TO jeffrey@"%" IDENTIFIED BY 'biscuit';
这里PASSWORD()函数是不必要的，也不需要使用FLUSH PRIVILEGES。

注:mysql 新设置用户或更改密码后需用flush privileges刷新MySQL的系统权限相关表，
否则会出现拒绝访问，还有一种方法，就是重新启动mysql服务器，来使新设置生效。

怎么查看端口占用情况?

       开始--运行--cmd 进入命令提示符 输入netstat -ano 即可看到所有连接的PID 之后在任务管理器中找到这个PID所对应的程序如果任务管理器中没有PID这一项,可以在任务管理器中选"查看"-"选择列"

        经常，我们在启动应用的时候发现系统需要的端口被别的程序占用，如何知道谁占有了我们需要的端口，很多人都比较头疼，下面就介绍一种非常简单的方法，希望对大家有用

假如我们需要确定谁占用了我们的9050端口

1、Windows平台
在windows命令行窗口下执行：

C:\>netstat -aon|findstr "9050"

TCP    127.0.0.1:9050         0.0.0.0:0              LISTENING       2016

看到了吗，端口被进程号为2016的进程占用，继续执行下面命令：

C:\>tasklist|findstr "2016"

tor.exe                     2016 Console                 0     16,064 K

很清楚吧，tor占用了你的端口。

JSON 数据格式解析

和 XML 一样，JSON 也是基于纯文本的数据格式。由于 JSON 天生是为 JavaScript 准备的，因此，JSON 的数据格式非常简单，您可以用 JSON 传输一个简单的 String，Number，Boolean，也可以传输一个数组，或者一个复杂的 Object 对象。

String，Number 和 Boolean 用 JSON 表示非常简单。例如，用 JSON 表示一个简单的 String “ abc ”，其格式为：

"abc"

这与绝大多数编程语言的表示方法一致，例如：

12345（整数）
 -3.9e10（浮点数）

Boolean 类型表示为 true 或 false 。此外，JavaScript 中的 null 被表示为 null，注意，true、false 和 null 都没有双引号，否则将被视为一个 String 。

JSON 还可以表示一个数组对象，使用 [] 包含所有元素，每个元素用逗号分隔，元素可以是任意的 Value，例如，以下数组包含了一个 String，Number，Boolean 和一个 null：

["abc",12345,false,null]

Object 对象在 JSON 中是用 {} 包含一系列无序的 Key-Value 键值对表示的，实际上此处的 Object 相当于 Java 中的 Map<String, Object>，而不是 Java 的 Class 。注意 Key 只能用 String 表示。

例如，一个 Address 对象包含如下 Key-Value：

city:Beijing 
 street:Chaoyang Road 
 postcode:100025（整数）

用 JSON 表示如下：

{"city":"Beijing","street":" Chaoyang Road ","postcode":100025}

其中 Value 也可以是另一个 Object 或者数组，因此，复杂的 Object 可以嵌套表示，例如，一个 Person 对象包含 name 和 address 对象，可以表示如下：

{"name":"Michael","address":
    {"city":"Beijing","street":" Chaoyang Road ","postcode":100025}
}

JavaScript 处理 JSON 数据

上面介绍了如何用 JSON 表示数据，接下来，我们还要解决如何在服务器端生成 JSON 格式的数据以便发送到客户端，以及客户端如何使用 JavaScript 处理 JSON 格式的数据。

我们先讨论如何在 Web 页面中用 JavaScript 处理 JSON 数据。我们通过一个简单的 JavaScript 方法就能看到客户端如何将 JSON 数据表示给用户：

function handleJson() { 
  var j={"name":"Michael","address":
      {"city":"Beijing","street":" Chaoyang Road ","postcode":100025}
  }; 
  document.write(j.name); 
  document.write(j.address.city); 
 }

假定服务器返回的 JSON 数据是上文的：

{"name":"Michael","address":
    {"city":"Beijing","street":" Chaoyang Road ","postcode":100025}
}

只需将其赋值给一个 JavaScript 变量，就可以立刻使用该变量并更新页面中的信息了，相比 XML 需要从 DOM 中读取各种节点而言，JSON 的使用非常容易。我们需要做的仅仅是发送一个 Ajax 请求，然后将服务器返回的 JSON 数据赋值给一个变量即可。有许多 Ajax 框架早已包含了处理 JSON 数据的能力，例如 Prototype（一个流行的 JavaScript 库：http://prototypejs.org）提供了 evalJSON() 方法，能直接将服务器返回的 JSON 文本变成一个 JavaScript 变量：

new Ajax.Request("http://url", { 
  method: "get", 
  onSuccess: function(transport) { 
    var json = transport.responseText.evalJSON(); 
    // TODO: document.write(json.xxx); 
  } 
 });

服务器端输出 JSON 格式数据

下面我们讨论如何在服务器端输出 JSON 格式的数据。以 Java 为例，我们将演示将一个 Java 对象编码为 JSON 格式的文本。

将 String 对象编码为 JSON 格式时，只需处理好特殊字符即可。另外，必须用 (") 而非 (') 表示字符串：

 static String string2Json(String s) { 
    StringBuilder sb = new StringBuilder(s.length()+20); 
    sb.append('\"'); 
    for (int i=0; i<s.length(); i++) { 
        char c = s.charAt(i); 
        switch (c) { 
        case '\"': 
            sb.append("\\\""); 
            break; 
        case '\\': 
            sb.append("\\\\"); 
            break; 
        case '/': 
            sb.append("\\/"); 
            break; 
        case '\b': 
            sb.append("\\b"); 
            break; 
        case '\f': 
            sb.append("\\f"); 
            break; 
        case '\n': 
            sb.append("\\n"); 
            break; 
        case '\r': 
            sb.append("\\r"); 
            break; 
        case '\t': 
            sb.append("\\t"); 
            break; 
        default: 
            sb.append(c); 
        } 
    } 
    sb.append('\"'); 
    return sb.toString(); 
 }

将 Number 表示为 JSON 就容易得多，利用 Java 的多态，我们可以处理 Integer，Long，Float 等多种 Number 格式：

 static String number2Json(Number number) { 
    return number.toString(); 
 }

Boolean 类型也可以直接通过 toString() 方法得到 JSON 的表示：

 static String boolean2Json(Boolean bool) { 
    return bool.toString(); 
 }

要将数组编码为 JSON 格式，可以通过循环将每一个元素编码出来：

 static String array2Json(Object[] array) { 
    if (array.length==0) 
        return "[]"; 
    StringBuilder sb = new StringBuilder(array.length << 4); 
    sb.append('['); 
    for (Object o : array) { 
        sb.append(toJson(o)); 
        sb.append(','); 
    } 
    // 将最后添加的 ',' 变为 ']': 
    sb.setCharAt(sb.length()-1, ']'); 
    return sb.toString(); 
 }

最后，我们需要将 Map<String, Object> 编码为 JSON 格式，因为 JavaScript 的 Object 实际上对应的是 Java 的 Map<String, Object> 。该方法如下：

 static String map2Json(Map<String, Object> map) { 
    if (map.isEmpty()) 
        return "{}"; 
    StringBuilder sb = new StringBuilder(map.size() << 4); 
    sb.append('{'); 
    Set<String> keys = map.keySet(); 
    for (String key : keys) { 
        Object value = map.get(key); 
        sb.append('\"'); 
        sb.append(key); 
        sb.append('\"'); 
        sb.append(':'); 
        sb.append(toJson(value)); 
        sb.append(','); 
    } 
    // 将最后的 ',' 变为 '}': 
    sb.setCharAt(sb.length()-1, '}'); 
    return sb.toString(); 
 }

为了统一处理任意的 Java 对象，我们编写一个入口方法 toJson(Object)，能够将任意的 Java 对象编码为 JSON 格式：

 public static String toJson(Object o) { 
    if (o==null) 
        return "null"; 
    if (o instanceof String) 
        return string2Json((String)o); 
    if (o instanceof Boolean) 
        return boolean2Json((Boolean)o); 
    if (o instanceof Number) 
        return number2Json((Number)o); 
    if (o instanceof Map) 
        return map2Json((Map<String, Object>)o); 
    if (o instanceof Object[]) 
        return array2Json((Object[])o); 
    throw new RuntimeException("Unsupported type: " + o.getClass().getName()); 
 }

我们并未对 Java 对象作严格的检查。不被支持的对象（例如 List）将直接抛出 RuntimeException 。此外，为了保证输出的 JSON 是有效的，Map<String, Object> 对象的 Key 也不能包含特殊字符。细心的读者可能还会发现循环引用的对象会引发无限递归，例如，精心构造一个循环引用的 Map，就可以检测到 StackOverflowException：

 @Test(expected=StackOverflowError.class) 
 public void testRecurrsiveMap2Json() { 
    Map<String, Object> map = new HashMap<String, Object>(); 
    map.put("key", map); 
    JsonUtil.map2Json(map); 
 }

好在服务器处理的 JSON 数据最终都应该转化为简单的 JavaScript 对象，因此，递归引用的可能性很小。

最后，通过 Servlet 或 MVC 框架输出 JSON 时，需要设置正确的 MIME 类型（application/json）和字符编码。假定服务器使用 UTF-8 编码，则可以使用以下代码输出编码后的 JSON 文本：

 response.setContentType("application/json;charset=UTF-8"); 
 response.setCharacterEncoding("UTF-8"); 
 PrintWriter pw = response.getWriter(); 
 pw.write(JsonUtil.toJson(obj)); 
 pw.flush();

小结

JSON 已经是 JavaScript 标准的一部分。目前，主流的浏览器对 JSON 支持都非常完善。应用 JSON，我们可以从 XML 的解析中摆脱出来，对那些应用 Ajax 的 Web 2.0 网站来说，JSON 确实是目前最灵活的轻量级方案。

在Oracle中，要按特定条件查询前N条记录，用个rownum就搞定了。
select * from emp where rownum <= 5
结果只查询5条记录, oracle会自动展现一个rownum的属性表示记录排序号

而select * from emp where rownum > 5 ;则是失败的。
因为:rownum是oracle预处理字段，默认标序是1，只有记录集已经满足条件后才会进行后续编号。由于第一条记录rownum默认是1，而你的条件是rownum>=6 对第一条记录比较它的rownum肯定不大于6 所以不满足条件 oracle舍弃第一条记录将数据库第二条记录标序为1再进行比较  肯定都不满足rownum>=6  这样循环也就是说由于没有记录满足rownum>=6所以记录一直被舍弃，rownum一直是1 。

解决方案: 利用查询时,自动生成的rownum属性.
排序方法：
  select * from (
       select a1.*, rownum rwn  from emp a1   where rownum <=10
    ) where rwn >= 6;
  或者
  select * from (
    select qx.*,row_number() over(order by qx.empno) rwn from emp qx
  ) where rwn between 6 and 10
-------------------------------------------------------------------------
使用注意:

1排序导致数据重复:


table1中表有字段（其余字段省）
ID  主键
DATA_UPDATE_TIME 数据更新时间（只存储了年月日）

分页查询的语句如下
select *
   from (
        select row_.*, rownum rownum_
           from ( select  p.id from table1 p
             order by  p.DATA_UPDATE_TIME desc )
   row_ where rownum <= )
where rownum_ >

以每页显示１０条为例
第一次　　rownum <= 10) 　 where rownum_ > 0
第二次　　rownum <= 20) 　 where rownum_ > 10

发现有一条记录在两次查询结果中重复出现，不知道问题出在哪里，请忙帮看看。

另：
DATA_UPDATE_TIME 的值有重复，不知道跟它有没有关系。
如果按ID排的话就不会出现这个问题


解答:
如果order by 不能唯一确定记录的顺序就会出现这个问题。
解决的方法是把分页部分全部拿到最外层进行。

Java代码  

1. select * from (    
2.   select row_.*, rownum rownum_    
3.   from (   
4.     select p.id from table1 p    
5.     order by p.DATA_UPDATE_TIME desc    
6.   ) row_   
7. )    
8. where rownum_ > ? and rownum_ <= ?   

2 排序的id顺序:
Oracle中的rownum的是在取数据的时候产生的序号，所以想对指定排序的数据去指定的rowmun行数据就必须注意了。
SQL> select rownum ,id,name from student order by name;
    ROWNUM ID     NAME
---------- ------ ---------------------------------------------------
         3 200003 李三
         2 200002 王二
         1 200001 张一
         4 200004 赵四
可以看出，rownum并不是按照name列来生成的序号。系统是按照记录插入时的顺序给记录排的号，rowid也是顺序分配的。为了解决这个问题，必须使用子查询
SQL> select rownum ,id,name from (select * from student order by name);
    ROWNUM ID     NAME
---------- ------ ---------------------------------------------------
         1 200003 李三
         2 200002 王二
         3 200001 张一
         4 200004 赵四
这样就成了按name排序，并且用rownum标出正确序号（有小到大）


------------
参考Oracle的rownum原理和使用  http://tenn.iteye.com/blog/99339

AOP术语介绍

1. 正常的编程为从上到下的调用,执行

2. 加入了安全性检查,日志这样的代码. 这是一个横切的问题,其于正常的业务毫无关系.

横切的问题会散布在代码的各个角落
.

3.这个横切就是横切性的关注点: Cross cutting concern

4. 将横切的关注点都放在一个类中(如动态代理项目中的SecurityHandler.java).这个类就叫做切面.

   对横切关注点进行模块化,这个模块化的类就叫做切面类(Aspect对应的类) ,

5. 在切面类中对某个问题如日志或安全性检查的具体实现方法,叫做横切关注点的具体实现(称为Advice).

6. 这个Advice可以进行分类. :在业务方法执行之前,之后.异常时候……

7. Advice应用的目标方法范围(那些方法之前,之后,异常….)这个过滤范围叫做切入点Pointcut()

8 .植入

Advice应用的目标方法的过程叫做植入(Weave)

Spring只支持针对业务方法执行前,执行后进行植入. 即只支持方法级别的植入

植入的地方就叫做连接点.

Spring的Aop是使用代理模式.

横切问题的处理思路:

发现横切性的问题,将其模块化(切片).然后形成切片类,在其中实现这些横切性的功能.

1. 触发器使用教程和命名规范  
2.   
3.   
4. 目  录  
5. 触发器使用教程和命名规范    1  
6. 1，触发器简介 1  
7. 2，触发器示例 2  
8. 3，触发器语法和功能  3  
9. 4，例一：行级触发器之一    4  
10. 5，例二：行级触发器之二    4  
11. 6，例三：INSTEAD OF触发器  6  
12. 7，例四：语句级触发器之一   8  
13. 8，例五：语句级触发器之二   9  
14. 9，例六：用包封装触发器代码  10  
15. 10，触发器命名规范  11  
16.   
17. 1，触发器简介  
18. 触发器（Trigger）是数据库对象的一种，编码方式类似存储过程，与某张表（Table）相关联，当有DML语句对表进行操作时，可以引起触发器的执行，达到对插入记录一致性，正确性和规范性控制的目的。在当年C/S时代盛行的时候，由于客户端直接连接数据库，能保证数据库一致性的只有数据库本身，此时主键（Primary Key），外键（Foreign Key），约束（Constraint）和触发器成为必要的控制机制。而触发器的实现比较灵活，可编程性强，自然成为了最流行的控制机制。到了B/S时代，发展成4层架构，客户端不再能直接访问数据库，只有中间件才可以访问数据库。要控制数据库的一致性，既可以在中间件里控制，也可以在数据库端控制。很多的青睐Java的开发者，随之将数据库当成一个黑盒，把大多数的数据控制工作放在了Servlet中执行。这样做，不需要了解太多的数据库知识，也减少了数据库编程的复杂性，但同时增加了Servlet编程的工作量。从架构设计来看，中间件的功能是检查业务正确性和执行业务逻辑，如果把数据的一致性检查放到中间件去做，需要在所有涉及到数据写入的地方进行数据一致性检查。由于数据库访问相对于中间件来说是远程调用，要编写统一的数据一致性检查代码并非易事，一般采用在多个地方的增加类似的检查步骤。一旦一致性检查过程发生调整，势必导致多个地方的修改，不仅增加工作量，而且无法保证每个检查步骤的正确性。触发器的应用，应该放在关键的，多方发起的，高频访问的数据表上，过多使用触发器，会增加数据库负担，降低数据库性能。而放弃使用触发器，则会导致系统架构设计上的问题，影响系统的稳定性。  
19.   
20.   
21. 2，触发器示例  
22. 触发器代码类似存储过程，以PL/SQL脚本编写。下面是一个触发器的示例：  
23. 新建员工工资表salary  
24. create table SALARY  
25. (  
26.   EMPLOYEE_ID NUMBER, --员工ID  
27.   MONTH       VARCHAR2(6), --工资月份  
28.   AMOUNT      NUMBER --工资金额  
29. )  
30.   
31. 创建与salary关联的触发器salary_trg_rai  
32. 1   Create or replace trigger salary_trg_rai  
33. 2   After insert on salary  
34. 3   For each row  
35. 4   declare  
36. 5   Begin  
37. 6     Dbms_output.put_line(‘员工ID：’ || :new.employee_id);  
38. 7     Dbms_output.put_line(‘工资月份：’ || :new.month);  
39. 8     Dbms_output.put_line(‘工资：’ || :new.amount);  
40. 9     Dbms_output.put_line(‘触发器已被执行’);  
41. 10   End;  
42. 打开一个SQL Window窗口（使用PL/SQL Developer工具），或在sqlplus中输入：  
43. Insert into salary(employee_id, month, amount) values(1, ‘200606’, 10000);  
44. 执行后可以在sqlplus中，或在SQL Window窗口的Output中见到  
45. 员工ID：1  
46. 工资月份：200606  
47. 工资：10000  
48. 触发器已执行  
49.   
50. 在代码的第一行，定义了数据库对象的类型是trigger，定义触发器的名称是salary_trg_rai  
51. 第二行说明了这是一个after触发器，在DML操作实施之后执行。紧接着的insert说明了这是一个针对insert操作的触发器，每个对该表进行的insert操作都会执行这个触发器。  
52. 第三行说明了这是一个针对行级的触发器，当插入的记录有n条时，在每一条插入操作时都会执行该触发器，总共执行n次。  
53. Declare后面跟的是本地变量定义部分，如果没有本地变量定义，此部分可以为空  
54. Begin和end括起来的代码，是触发器的执行部分，一般会对插入记录进行一致性检查，在本例中打印了插入的记录和“触发器已执行”。  
55. 其中:new对象表示了插入的记录，可以通过:new.column_name来引用记录的每个字段值  
56.   
57.   
58. 3，触发器语法和功能  
59. 触发器的语法如下  
60. CREATE OR REPLACE TRIGGER trigger_name  
61. <before | after | instead of> <insert | update | delete> ON table_name  
62. [FOR EACH ROW]  
63. WHEN (condition)  
64. DECLARE  
65. BEGIN  
66.     --触发器代码  
67. END;  
68.   
69. Trigger_name 是触发器的名称。<before | after | instead of>可以选择before或者after或instead of。 Before表示在DML语句实施前执行触发器，而after表示在在dml语句实施之后执行触发器，instead of触发器用在对视图的更新上。<insert | update | delete>可以选择一个或多个DML语句，如果选择多个，则用or分开，如：insert or update。Table_name是触发器关联的表名。  
70. [FOR EACH ROW]为可选项，如果注明了FOR EACH ROW，则说明了该触发器是一个行级的触发器，DML语句处理每条记录都会执行触发器；否则是一个语句级的触发器，每个DML语句触发一次。  
71. WHEN后跟的condition是触发器的响应条件，只对行级触发器有效，当操作的记录满足condition时，触发器才被执行，否则不执行。Condition中可以通过new对象和old对象（注意区别于前面的:new和:old，在代码中引用需要加上冒号）来引用操作的记录。  
72. 触发器代码可以包括三种类型：未涉及数据库事务代码，涉及关联表（上文语法中的table_name）数据库事务代码，涉及除关联表之外数据库事务代码。其中第一种类型代码只对数据进行简单运算和判断，没有DML语句，这种类型代码可以在所有的触发器中执行。第二种类型代码涉及到对关联表的数据操作，比如查询关联表的总记录数或者往关联表中插入一条记录，该类型代码只能在语句级触发器中使用，如果在行级触发器中使用，将会报ORA-04091错误。第三种类型代码涉及到除关联表之外的数据库事务，这种代码可以在所有触发器中使用。  
73.   
74. 从触发器的功能上来看，可以分成3类：  
75.    重写列（仅限于before触发器）  
76.    采取行动（任何触发器）  
77.    拒绝事务（任何触发器）  
78. “重写列”用于对表字段的校验，当插入值为空或者插入值不符合要求，则触发器用缺省值或另外的值代替，在多数情况下与字段的default属性相同。这种功能只能在行级before触发器中执行。“采取行动”针对当前事务的特点，对相关表进行操作，比如根据当前表插入的记录更新其他表，银行中的总帐和分户帐间的总分关系就可以通过这种触发器功能来维护。“拒绝事务”用在对数据的合法性检验上，当更新的数据不满足表或系统的一致性要求，则通过抛出异常的方式拒绝事务，在其上层的代码可以捕获这个异常并进行相应操作。  
79.   
80. 下面将通过举例说明，在例子中将触发器主体的语法一一介绍，读者可以在例子中体会触发器的功能。  
81.   
82. 4，例一：行级触发器之一  
83. CREATE OR REPLACE TRIGGER salary_raiu  
84. AFTER INSERT OR UPDATE OF amount ON salary  
85. FOR EACH ROW  
86. BEGIN  
87.     IF inserting THEN  
88.         dbms_output.put_line(‘插入’);  
89.     ELSIF updating THEN  
90. dbms_output.put_line(‘更新amount列’);  
91.     END IF；  
92. END;  
93. 以上是一个after insert和after update的行级触发器。在第二行中of amount on salary的意思是只有当amount列被更新时，update触发器才会有效。所以，以下语句将不会执行触发器：  
94. Update salary set month = ‘200601’ where month = ‘200606’;  
95. 在触发器主体的if语句表达式中，inserting, updating和deleting可以用来区分当前是在做哪一种DML操作，可以作为把多个类似触发器合并在一个触发器中判别触发事件的属性。  
96.   
97. 5，例二：行级触发器之二  
98. 新建员工表employment  
99. CREATE TABLE EMPLOYMENT  
100. (  
101.   EMPLOYEE_ID NUMBER, --员工ID  
102.   MAXSALARY   NUMBER --工资上限  
103. )  
104. 插入两条记录  
105. Insert into employment values(1, 1000);  
106. Insert into employment values(2, 2000);  
107.   
108. CREATE OR REPLACE TRIGGER salary_raiu  
109. AFTER INSERT OR UPDATE OF amount ON salary  
110. FOR EACH ROW  
111. WHEN ( NEW.amount >= 1000 AND (old.amount IS NULL OR OLD.amount <= 500))  
112. DECLARE  
113.     v_maxsalary NUMBER;  
114. BEGIN  
115.     SELECT maxsalary  
116.         INTO v_maxsalary  
117.         FROM employment  
118.      WHERE employee_id = :NEW.employee_id;  
119.     IF :NEW.amount > v_maxsalary THEN  
120.         raise_application_error(-20000, '工资超限');  
121.     END IF;  
122. END;  
123.   
124. 以上的例子引入了一个新的表employment，表中的maxsalary字段代表该员工每月所能分配的最高工资。下面的触发器根据插入或修改记录的 employee_id，在employment表中查到该员工的每月最高工资，如果插入或修改后的amount超过这个值，则报错误。  
125. 代码中的when子句表明了该触发器只针对修改或插入后的amount值超过1000，而修改前的amount值小于500的记录。New对象和old对象分别表示了操作前和操作后的记录对象。对于insert操作，由于当前操作记录无历史对象，所以old对象中所有属性是null；对于delete操作，由于当前操作记录没有更新对象，所以new对象中所有属性也是null。但在这两种情况下，并不影响old和new对象的引用和在触发器主体中的使用，和普通的空值作同样的处理。  
126. 在触发器主体中，先通过:new.employee_id，得到该员工的工资上限，然后在if语句中判断更新后的员工工资是否超限，如果超限则错误代码为-20000，错误信息为“工资超限”的自定义错误。其中的raise_application_error包含两个参数，前一个是自定义错误代码，后一个是自定义错误代码信息。其中自定义错误代码必须小于或等于-20000。执行完该语句后，一个异常被抛出，如果在上一层有exception子句，该异常将被捕获。如下面代码：  
127. DECLARE  
128.     code NUMBER;  
129.     msg  VARCHAR2(500);  
130. BEGIN  
131.     INSERT INTO salary (employee_id, amount) VALUES (2, 5000);  
132. EXCEPTION  
133.     WHEN OTHERS THEN  
134.         code := SQLCODE;  
135.         msg  := substr(SQLERRM, 1, 500);  
136.         dbms_output.put_line(code);  
137.         dbms_output.put_line(msg);  
138. END;  
139. 执行后，将在output中或者sqlplus窗口中见着以下信息：  
140. -20000  
141. ORA-20000: 工资超出限制  
142. ORA-06512: 在"SCOTT.SALARY_RAI", line 9  
143. ORA-04088: 触发器 'SCOTT.SALARY_RAI' 执行过程中出错  
144.   
145. 这里的raise_application_error相当于拒绝了插入或者修改事务，当上层代码接受到这个异常后，判断该异常代码等于-20000，可以作出回滚事务或者继续其他事务的处理。  
146.   
147. 以上两个例子中用到的inserting, updating, deleting和raise_application_error都是dbms_standard包中的函数，具体的说明可以参照Oracle的帮助文档。  
148. create or replace package sys.dbms_standard is  
149.   procedure raise_application_error(num binary_integer, msg varchar2,  
150.   function inserting return boolean;  
151.   function deleting  return boolean;  
152.   function updating  return boolean;  
153.   function updating (colnam varchar2) return boolean;  
154. end;  
155.   
156. 对于before和after行级触发器，:new和:old对象的属性值都是一样的，主要是对于在Oracle约束（Constraint）之前或之后的执行触发器的选择。需要注意的是，可以在before行触发器中更改:new对象中的值，但是在after行触发器就不行。  
157.   
158. 下面介绍一种instead of触发器，该触发器主要使用在对视图的更新上，以下是instead of触发器的语法：  
159. CREATE OR REPLACE TRIGGER trigger_name  
160. INSTEAD OF <insert | update | delete> ON view_name  
161. [FOR EACH ROW]  
162. WHEN (condition)  
163. DECLARE  
164. BEGIN  
165.     --触发器代码  
166. END;  
167.   
168. 其他部分语法同前面所述的before和after语法是一样的，唯一不同的是在第二行用上了instead of关键字。对于普通的视图来说，进行 insert等操作是被禁止的，因为Oracle无法知道操作的字段具体是哪个表中的字段。但我们可以通过建立instead of触发器，在触发器主体中告诉Oracle应该更新，删除或者修改哪些表的哪部分字段。如：  
169.   
170. 6，例三：instead of触发器  
171. 新建视图  
172. CREATE VIEW employee_salary(employee_id, maxsalary, MONTH, amount) AS   
173. SELECT a.employee_id, a.maxsalary, b.MONTH, b.amount  
174. FROM employment a, salary b  
175. WHERE a.employee_id = b.employee_id  
176.   
177. 如果执行插入语句  
178. INSERT INTO employee_salary(employee_id, maxsalary, MONTH, amount)  
179. VALUES(10, 100000, '200606', 10000);  
180. 系统会报错：  
181. ORA-01779：无法修改与非键值保存表对应的列  
182.   
183. 我们可以通过建立以下的instead of存储过程，将插入视图的值分别插入到两个表中：  
184. create or replace trigger employee_salary_rii  
185.   instead of insert on employee_salary    
186.   for each ROW  
187. DECLARE  
188.     v_cnt NUMBER;  
189. BEGIN  
190.   --检查是否存在该员工信息  
191.     SELECT COUNT(*)  
192.         INTO v_cnt  
193.         FROM employment  
194.      WHERE employee_id = :NEW.employee_id;  
195.     IF v_cnt = 0 THEN  
196.         INSERT INTO employment  
197.             (employee_id, maxsalary)  
198.         VALUES  
199.             (:NEW.employee_id, :NEW.maxsalary);  
200.     END IF;  
201.   --检查是否存在该员工的工资信息  
202.     SELECT COUNT(*)  
203.         INTO v_cnt  
204.         FROM salary  
205.      WHERE employee_id = :NEW.employee_id  
206.          AND MONTH = :NEW.MONTH;  
207.     IF v_cnt = 0 THEN  
208.         INSERT INTO salary  
209.             (employee_id, MONTH, amount)  
210.         VALUES  
211.             (:NEW.employee_id, :NEW.MONTH, :NEW.amount);  
212.     END IF;  
213. END employee_salary_rii;  
214.   
215. 该触发器被建立后，执行上述insert操作，系统就会提示成功插入一条记录。  
216. 但需要注意的是，这里的“成功插入一条记录”，只是Oracle并未发现触发器中有异常抛出，而根据insert语句中涉及的记录数作出一个判断。若触发器的主体什么都没有，只是一个空语句，Oracle也会报“成功插入一条记录”。同样道理，即使在触发器主体里往多个表中插入十条记录，Oracle的返回也是“成功插入一条记录”。  
217.   
218.   
219.   
220.   
221. 行级触发器可以解决大部分的问题，但是如果需要对本表进行扫描检查，比如要检查总的工资是否超限了，用行级触发器是不行的，因为行级触发器主体中不能有涉及到关联表的事务，这时就需要用到语句级触发器。以下是语句级触发器的语法：  
222. CREATE OR REPLACE TRIGGER trigger_name  
223. <before | after | instead of ><insert | update | delete > ON table_name  
224. DECLARE  
225. BEGIN  
226.     --触发器主体  
227. END;  
228.   
229. 从语法定义上来看，行级触发器少了for each row，也不能使用when子句来限定入口条件，其他部分都是一样的，包括insert, update, delete和instead of都可以使用。  
230.   
231.   
232. 7，例四：语句级触发器之一  
233. CREATE OR REPLACE TRIGGER salary_saiu  
234. AFTER INSERT OR UPDATE OF amount ON salary  
235. DECLARE  
236.     v_sumsalary NUMBER;  
237. BEGIN  
238.   SELECT SUM(amount) INTO v_sumsalary FROM salary;  
239.     IF v_sumsalary > 500000 THEN  
240.         raise_application_error(-20001, '总工资超过500000');  
241.     END IF;  
242. END;  
243.   
244. 以上代码定义了一个语句级触发器，该触发器检查在insert和update了amount字段后操作后，工资表中所有工资记录累加起来是否超过500000，如果超过则抛出异常。从这个例子可以看出，语句级触发器可以对关联表表进行扫描，扫描得到的结果可以用来作为判断一致性的标志。需要注意的是，在 before语句触发器主体和after语句触发器主体中对关联表进行扫描，结果是不一样的。在before语句触发器主体中扫描，扫描结果将不包括新插入和更新的记录，也就是说当以上代码换成 before触发器后，以下语句将不报错：  
245. INSERT INTO salary(employee_id, month, amount) VALUEs(2, '200601', 600000)  
246. 这是因为在主体中得到的v_sumsalary并不包括新插入的600000工资。  
247. 另外，在语句级触发器中不能使用:new和:old对象，这一点和行级触发器是显著不同的。如果需要检查插入或更新后的记录，可以采用临时表技术。  
248. 临时表是一种Oracle数据库对象，其特点是当创建数据的进程结束后，进程所创建的数据也随之清除。进程与进程不可以互相访问同一临时表中对方的数据，而且对临时表进行操作也不产生undo日志，减少了数据库的消耗。具体有关临时表的知识，可以参看有关书籍。  
249. 为了在语句级触发器中访问新插入后修改后的记录，可以增加行级触发器，将更新的记录插入临时表中，然后在语句级触发器中扫描临时表，获得修改后的记录。临时表的表结构一般与关联表的结构一致。  
250.   
251.   
252. 8，例五：语句级触发器之二  
253. 目的：限制每个员工的总工资不能超过50000，否则停止对该表操作。  
254. 创建临时表  
255. create global temporary table SALARY_TMP  
256. (  
257.   EMPLOYEE_ID NUMBER,  
258.   MONTH       VARCHAR2(6),  
259.   AMOUNT      NUMBER  
260. )  
261. on commit delete rows;  
262.   
263. 为了把操作记录插入到临时表中，创建行级触发器：  
264. CREATE OR REPLACE TRIGGER salary_raiu  
265. AFTER INSERT OR UPDATE OF amount ON salary  
266. FOR EACH ROW  
267. BEGIN  
268.   INSERT INTO salary_tmp(employee_id, month, amount)  
269.   VALUES(:NEW.employee_id, :NEW.MONTH, :NEW.amount);  
270. END;  
271. 该触发器的作用是把更新后的记录信息插入到临时表中，如果更新了多条记录，则每条记录都会保存在临时表中。  
272.   
273. 创建语句级触发器：  
274. CREATE OR REPLACE TRIGGER salary_sai  
275. AFTER INSERT OR UPDATE OF amount ON salary  
276. DECLARE  
277.     v_sumsalary NUMBER;  
278. BEGIN  
279.     FOR cur IN (SELECT * FROM salary_tmp) LOOP  
280.         SELECT SUM(amount)  
281.             INTO v_sumsalary  
282.             FROM salary  
283.          WHERE employee_id = cur.employee_id;  
284.         IF v_sumsalary > 50000 THEN  
285.             raise_application_error(-20002, '员工累计工资超过50000');  
286.         END IF;  
287.     DELETE FROM salary_tmp;  
288.     END LOOP;  
289. END;  
290.   
291. 该触发器首先用游标从salary_tmp临时表中逐条读取更新或插入的记录，取employee_id，在关联表salary中查找所有相同员工的工资记录，并求和。若某员工工资总和超过50000，则抛出异常。如果检查通过，则清空临时表，避免下次检查相同的记录。  
292. 执行以下语句：  
293. INSERT INTO salary(employee_id, month, amount) VALUEs(7, '200601', 20000);  
294. INSERT INTO salary(employee_id, month, amount) VALUEs(7, '200602', 20000);  
295. INSERT INTO salary(employee_id, month, amount) VALUEs(7, '200603', 20000);  
296. 在执行第三句时系统报错：  
297. ORA-20002：员工累计工资超过50000  
298. 查询salary表，发现前两条记录正常插入了，第三条记录没有插入。  
299.   
300.   
301. 如果系统结构比较复杂，而且触发器的代码比较多，在触发器主体中写过多的代码，对于维护来说是一个困难。这时可以将所有触发器的代码写到同一个包中，不同的触发器代码以不同的存储过程封装，然后触发器主体中调用这部分代码。  
302.   
303. 9，例六：用包封装触发器代码  
304. 目的：改写例五，封装触发器主体代码  
305. 创建代码包：  
306. CREATE OR REPLACE PACKAGE BODY salary_trigger_pck IS  
307.   
308.     PROCEDURE load_salary_tmp(i_employee_id IN NUMBER,  
309.                             i_month       IN VARCHAR2,  
310.                             i_amount      IN NUMBER) IS  
311.     BEGIN  
312.         INSERT INTO salary_tmp VALUES (i_employee_id, i_month, i_amount);  
313.     END load_salary_tmp;  
314.   
315.     PROCEDURE check_salary IS  
316.         v_sumsalary NUMBER;  
317.     BEGIN  
318.         FOR cur IN (SELECT * FROM salary_tmp) LOOP  
319.             SELECT SUM(amount)  
320.                 INTO v_sumsalary  
321.                 FROM salary  
322.              WHERE employee_id = cur.employee_id;  
323.             IF v_sumsalary > 50000 THEN  
324.                 raise_application_error(-20002, '员工累计工资超过50000');  
325.             END IF;  
326.             DELETE FROM salary_tmp;  
327.         END LOOP;  
328.     END check_salary;  
329. END salary_trigger_pck;  
330. 包salary_trigger_pck中有两个存储过程，load_salary_tmp用于在行级触发器中调用，往salary_tmp临时表中装载更新或插入记录。而check_salary用于在语句级触发器中检查员工累计工资是否超限。  
331.   
332. 修改行级触发器和语句级触发器：  
333. CREATE OR REPLACE TRIGGER salary_raiu  
334.     AFTER INSERT OR UPDATE OF amount ON salary  
335.     FOR EACH ROW  
336. BEGIN  
337.     salary_trigger_pck.load_salary_tmp(:NEW.employee_id,     :NEW.MONTH, :NEW.amount);  
338. END;  
339.   
340. CREATE OR REPLACE TRIGGER salary_sai  
341. AFTER INSERT OR UPDATE OF amount ON salary  
342. BEGIN  
343.     salary_trigger_pck.check_salary;  
344. END;  
345.   
346. 这样主要代码就集中到了salary_trigger_pck中，触发器主体中只实现了一个调用功能。  
347.   
348. 10，触发器命名规范  
349. 为了方便对触发器命名和根据触发器名称了解触发器含义，需要定义触发器的命名规范：  
350. Trigger_name = table_name_trg_<R|S><A|B|I><I|U|D>  
351.   
352. 触发器名限于30个字符。必须缩写表名，以便附加触发器属性信息。  
353. <R|S>基于行级（row）还是语句级（statement）的触发器  
354. <A|B|I>after, before或者是instead of触发器  
355. <I|U|D>触发事件是insert，update还是delete。如果有多个触发事件则连着写  
356.   
357. 例如：  
358. Salary_rai      salary表的行级after触发器，触发事件是insert  
359. Employee_sbiud  employee表的语句级before触发器，触发事件是insert,update和delete  

       Before| after   insert|delete|(update of 列名)

On 表名

[for each row]

When 条件

PL/SQL块

说明：

For each row的意义是：在一次操作表的语句中，每操作成功一行就会触发一 次；不写的话，表示是表级触发器，则无论操作多少行，都只触发一次；

When条件的出现说明了，在DML操作的时候也许一定会触发触发器，但是触发器不一定会做实际的工作，比如when 后的条件不为真的时候，触发器只是简单地跳过了PL/SQL块；

例子：

关键字：

:NEW 和:OLD使用方法和意义，new 只出现在insert和update时，old只出现在update和delete时。在insert时new表示新插入的行数据，update时new 表示要替换的新数据、old表示要被更改的原来的数据行，delete时old表示要被删除的数据。

注意：

在触发器中不能使用commit。