?0g 环境中，ORACLE 使用Scheduler 替换普通的jobQ来理d的执行。其实，Scheduler 描述成管理job 的工具已l太q片面了(jin)Q?0G版本中新增的Scheduler l不仅仅是创ZQ务这么简?
一Q?使用Jobs
所谓JOBSQ其实就是Scheduler 理的一?或多?d的执行调度?/p>
1.1 创徏Jobs
通过DBMS_SCHEDULER 包来创徏JobsQ是使用其CREATE_JOB q程。在创徏Job Ӟ用户可以指定要执行的dQ调度信?啥时候执行，执行周期Q终止日期等)以及(qing)其它一些Q务相关的属性。CREATE_JOB q程调用q是比较单的Q例如：(x)
create table TEST (id number);
CREATE OR REPLACE PROCEDURE IT
AS
BEGIN
insert into TEST VALUES(1);
END;
SQL> BEGIN
DBMS_SCHEDULER.CREATE_JOB (
job_name => 'JobTest',
job_type => 'STORED_PROCEDURE',
job_action => 'SYSTEM.IT',
start_date => sysdate,
repeat_interval => 'FREQ=MINUTELY;INTERVAL=10');
END;
/
PL/SQL q程已成功完成?/p>
事实上，有权限的话，用户也可以创建其它SCHEMA 下的JOBQ只需要在指定JOB_NAME Ӟ按照schema.job_name 的格式即可。注意哟Q这U情况下创徏的JOBQ其CREATED 与OWNER 有可能ƈ不相同的哟?/p>
当用CREATE_JOB q程创徏JOB Ӟ可指定的参数值很多，只不q多数情况下用户仅指定部分参数即可满需求?/p>
其中Q上例中指定的参敎ͼ分别代表的含义如下：(x)
JOB_NAMEQ指定Q务的名称Q必选|注意要确保指定的名称唯一?/p>
JOB_TYPEQQ务执行的操作cdQ必选|有下列几个可选|(x)
PLSQL_BLOCKQ表CZQ务执行的是一个PL/SQL 匿名块?/p>
STORED_PROCEDUREQ表CZQ务执行的是ORACLE q程(含PL/SQL PROCEDURE 和JAVA
PROCEDURE)Q本例中正是指定q一参数倹{?/p>
EXECUTABLEQ表CZQ务执行的是一个外部程序，比如说操作系l命令?/p>
CHAINQ表CZQ务执行的是一个CHAIN?/p>
JOB_ACTIONQQ务执行的操作Q必选|应与JOB_TYPE cd中指定的参数相匹配?/p>
比如说对于PL/SQL 匿名块，此处可以放|PL/SQL 块的具体代表Q类似DECLARE .. BEGIN ..ENDq类Q如果是ORACLE q程Q那么此处应该指定具体的q程名，注意׃d执行Q即使过E中有OUT之类参数Q实际执行时也不?x)有输出的?/p>
START_DATEQ指定Q务初ơ执行的旉Q本参数可ؓ(f)I，当ؓ(f)I时Q表CZQ务立L行，效果{同于指定该参数gؓ(f)SYSDATE?/p>
REPEAT_INTERVALQ指定Q务执行的频率Q比如多长时间会(x)被触发再ơ执行。本参数也可以ؓ(f)I，如果为空的话Q就表示当前讑֮的Q务只执行一ơ。REPEAT_INTERVAL 参数需要好好说_(d)因ؓ(f)q一参数与标准JOB 中的INTERVAL 参数有很大区别，相比之下QREPEAT_INTERVAL 参数的语法结构要复杂的多。其中最重要的是FREQ 和INTERVAL 两个关键字?/p>
FREQ 关键字用来指定间隔的旉周期Q可选参数有QYEARLY, MONTHLY, WEEKLY, DAILY,HOURLY, MINUTELY, and SECONDLYQ分别表C年、月、周、日、时、分、秒{单位?/p>
INTERVAL 关键字用来指定间隔的频繁Q可指定的值的范围?-99?/p>
例如QREPEAT_INTERVAL=>'FREQ=DAILY;INTERVAL=1';表示每天执行一ơ，如果INTERVAL 改ؓ(f)7 pC每7 天执行一ơ，效果{同于FREQ=WEEKLY;INTERVAL=1?/p>
一般来_(d)使用DBMS_SCHEDULER.CREATE_JOB 创徏一个JOBQ至需要指定上q参C的前3 V除此之外，q可以在CREATE_JOB Ӟ指定下列参数Q?/p>
NUMBER_OF_ARGUMENTSQ指定该JOB 执行旉要附带的参数的数量，默认gؓ(f)0Q注意当JOB_TYPE 列gؓ(f)PLSQL_BLOCK 或CHAIN Ӟ本参数必设|ؓ(f)0Q因ZqCU情况下不支持附带参数?/p>
END_DATEQ指定Q务的q期旉Q默认gؓ(f)NULL。Q务过期后QQ务的STATE 自动被修改为COMPLETEDQENABLED 被置为FALSE。如果该参数讄为空的话Q表Cd怸q期Q将一直按?/p>
REPEAT_INTERVAL 参数讄的周期重复执行，直到辑ֈ讄的MAX_RUNS 或MAX_FAILURES 倹{?/p>
JOB_CLASSQ指定Q务关联的CLASSQ默认gؓ(f)DEFAULT_JOB_CLASS?/p>
ENABLEDQ指定Q务是否启用，默认gؓ(f)FALSE。FALSE 状态表Cdq不?x)被执行Q除非被用户手动调用Q或者用户将该Q务的状态修改ؓ(f)TRUE?/p>
AUTO_DROPQ当该标志被|ؓ(f)TRUE ӞORACLE ?x)在满条g时自动删除创建的d
d已过期；
d最大运行次数已达MAX_RUNS 的设||
d未指定REPEAT_INTERVAL 参数Q仅q行一ơ；
该参数的默认值即为TRUE。用户在执行CREATE_JOB q程时可以手动将该标志指定ؓ(f)FALSEQ当参数D|ؓ(f)FALSE Ӟ即满上述提到的条件Q务也不会(x)被自动删除，q种情况下，唯一能够Dd被删除的情况Q就是用户主动调用DROP_JOB q程?/p>
COMMENTSQ设|Q务的注释信息Q默认gؓ(f)NULL?/p>
上面的例子创Z(jin)一个新的JOBQ不q这个JOB 与普通JOB 不同哟，此时查询USER_JOBS 视图是查不到刚刚创徏的JOB 的信息，因ؓ(f)q个JOB 是SCHEDULER 理的JOB。要查询SCHEDULER 理的JOSQ应该通过USER_SCHEDULER_JOBS(当然ALL_SCHEDULER_JOBS 和DBA_SCHEDULER_JOBS 也可?Q?例如Q?/p>
SQL> select job_name,job_type,job_action,to_char(start_date,'yyyy-mm-dd
hh24:mi:ss') TM,repeat_interval,enabled,state from user_scheduler_jobs;
JOB_NAME JOB_TYPE JOB_ACTION TM REPEAT_INTERVAL ENABL STATE
---------- ---------------- ---------- ---------- ------------------------- ------ ------
JOBTEST STORED_PROCEDURE SYSTEM.IT 2009-09-25 FREQ=MINUTELY;INTERVAL=10 FALSE DISABLED
不过Q细?j)的盆友可能会(x)发玎ͼJOB 虽然成功创徏?jin)，但却q未执行.原因ENABLED 参数当不昑ּ指定Ӟ该参数的默认gؓ(f)falseQJOB自然不会(x)q行?jin)?/p>
1.2 理Jobs
1.2.1 启用Jobs
前面创徏JOB Ӟ׃未显式的指定ENABLED 参数Q因此即使指定了(jin)START_DATEQ不q默认情况下JOB
不会(x)自动执行。对于这U情况，DBMS_SCHEDULER 包中提供?jin)一个过EENABLEQ可以用来修改JOB 的启
用状态，调用方式非常单，例如Q?/p>
SQL> exec dbms_scheduler.enable('JOBTEST');
PL/SQL procedure successfully completed.
1.2.2 用Jobs
DBMS_SCHEDULER.ENABLE 仅用来将JOB(其实不仅仅对JOB 有效Q对于CHAIN、PROGRAM {也有效)的启用状态置为TRUE。如果想其启用状态置为FALSEQ简单，q有一个与该功能对应的q程Q?/p>
DBMS_SCHEDULER.DISABLEQ例如：(x)
JSSWEB> exec dbms_scheduler.disable('JOBTEST');
PL/SQL procedure successfully completed.
q两个过E仅用来重置对象的状态，因此均可以无限次执行Q即使执行时对象已经被置指定的状态?/p>
1.2.3 修改Jobs
׃JOB 的属性众多，隑օ时不时的可能?x)遇到需要修改的情况Q比如说前面创徏JOB 时不心(j)Q指定要
执行的过E名输入错误(完全有可能，CREATE_JOB 在创建时不会(x)自动(g)查指定的q程是否有效Q从q方面考虑Q?/p>
SCHEDULER 不如普通JOB 严}?Q这U情况下必然涉?qing)到对JOB 的修?或者说重定?Q没问题Q?/p>
DBMS_SCHEDULER 包中专门提供?jin)一个过ESET_ATTRIBUTEQ可以用来修改Q务的属性倹{?/p>
例如Q修改刚刚创建的JOBQINSERT_TEST_TBL 执行的过E，执行语句如下Q?/p>
JSSWEB> exec dbms_scheduler.set_attribute('JobTest','JOB_ACTION','SYSTEM.IT');
PL/SQL procedure successfully completed
当然啦，我们q里执行的这条语句，执行跟没执行没有区别Q此处仅做示例，大家表深I?/p>
SET_ATTRIBUTE q程虽然仅有三个参数Q不q能够修改的属性值可是不，以下列D几个较常用到的：(x)
LOGGING_LEVELQ指定对jobs 执行情况记录的日志信息别?/p>
SCHEDULER 理的JOB 对Q务的执行情况专门q行?jin)记录，同时用户q可以选择日志中记录信息的U别Q有下列三种选择Q?/p>
DBMS_SCHEDULER.LOGGING_OFFQ关闭日志记录功能；
DBMS_SCHEDULER.LOGGING_RUNSQ对d的运行信息进行记录；
DBMS_SCHEDULER.LOGGING_FULLQ记录Q务所有相关信息，不仅有Q务的q行情况Q甚臌d的创建、修改等也均记入日志?/p>
提示Q?查看SCHEDULER 理的JOB Q?可以通过USER_SCHEDULER_JOB_LOG 和USER_SCHEDULER_JOB_RUN_DETAILS 两个视图中查?/p>
RESTARTABLEQ指定jobs q行出错后，是否能够适时重启创徏d时如未明指定，本参数默认情况下讄为FALSEQ如果设|ؓ(f)TRUEQ就表示当Q务运行时出错Q下ơ运行时间点到达时仍?x)启动，q且如果q行仍然出错Q会(x)l箋重新q行Q不q如果连接出错达? ơ，该job ׃(x)停止?/p>
MAX_FAILURESQ指定jobs 最大连l出错次数该参数值可指定的范围从1-1000000Q默认情况下该参数设|ؓ(f)NULLQ表C无限制。达到指定出错次数后Q该job ?x)被自动disable?/p>
MAX_RUNSQ指定jobs 最大运行次?/p>
该参数值可指定的范围从1-1000000Q默认情况下该参数设|ؓ(f)NULLQ表C无限制(只是q行ơ数无限Ӟ实际job ?x)否l箋q行Q仍受制于end_date 以及(qing)max_failures {参数的讄)。达到指定运行次数后Q该job 也将被自动disableQƈ且状态会(x)被置为COMPLETED?/p>
JOB_TYPEQ指定job 执行的Q务的cd
有四个可选|(x)'PLSQL_BLOCK', 'STORED_PROCEDURE', 'EXECUTABLE', and 'CHAIN'?/p>
JOB_ACTIONQ指定job 执行的Q?q一参数所指定的g赖于JOB_TYPE 参数中的| 比如说JOB_TYPE 讄?/p>
'STORED_PROCEDURE'Q那么本参数g指定的一定是ORACLE 中的q程名?/p>
START_DATEQ指定job 初次启动的时?/p>
END_DATEQ指定job 停止q行的时?/p>
本参数又与AUTO_DROP 相关联，如果AUTO_DROP 讄为TRUE 的话Q那么一旦job 到达停止q行的时_(d)该job ׃(x)被自动删除，否则的话job M存在Q不q状态被修改为COMPLETED?/p>
除此之外Q?其它q包括MAX_RUN_DURATION Q?JOB_WEIGHT Q?INSTANCE_STICKINESS QSTOP_ON_WINDOW_CLOSE Q?JOB_PRIORITY Q?SCHEDULE_LIMIT Q?PROGRAM_NAME QNUMBER_OF_ARGUMENTS Q?SCHEDULE_NAME Q?REPEAT_INTERVAL Q?JOB_CLASS Q?COMMENTS QAUTO_DROPQEVENT_SPECQRAISE_EVENTS {等Q这些参数所代表的意义此处不一一详述Q感兴趣的朋?/p>
仅从q些可设|属性就可以看出QScheduler 理的job 实非常灉|Q上q提C(jin)q些参数Q均可以使用
DBMS_SCHEDULER.SET_ATTRIBUTE q程q行讄?/p>
另外需要注意一点，除了(jin)用户手动创徏的jobs 之外Q数据库在运行过E中也有可能自动创徏jobs。对于这
cjobs 除非必要Q否则不q行修改。至于如何区分jobs 是用户创建，q是数据库自动创建，可以通过
*_SCHEDULER_JOBS 视图的SYSTEM 列来定Q如果该列显CZؓ(f)TRUEQ则表示ql创?/p>
1.2.4 执行Jobs
虽然说jobs 大多都应该是自动执行Q不q经q前面的CZQ大家想必也认识C(jin)Qƈ不是说创Z(jin)jobs ?/p>
׃(x)自动执行Q是否能够真正自动执行ƈ不是׃的主观意愿就能直接决定，而是由jobs 自n的多个相兛_?/p>
军_?/p>
关于jobs 自动执行的话题相信看完前面的内容后，应该都知道如何设|，下面主要演示Q如何手动调用jobs
q执行，q其中，当然不?jin)DBMS_SCHEDULER 包。例如，手动执行前面刚刚创徏的job:JOBTESTQ?/p>
JSSWEB> exec dbms_scheduler.run_job('JOBTEST');
PL/SQL procedure successfully completed
Jobs 每执行一ơ，无论成功或失败，均会(x)?_SCHEDULER_JOB_LOG 中生成一条对应的记录(前提是LOGGING_LEVEL 属性值未讄为DBMS_SCHEDULER.LOGGING_OFF) Q?同时Q?用户也可以通过*_SCHEDULER_JOB_RUN_DETAILS 视图查询job 执行的详l信息?/p>
1.2.5 停止Jobs
停止job 可以使用DMBS_SCHEDULER.STOP_JOB q程Q例如：(x)
JSSWEB> exec dbms_scheduler.stop_job('JOBTEST');
PL/SQL procedure successfully completed
注意QSTOP_JOB q程不仅仅是更新job 的状态，而是停止当前正在执行的Q务，如果你处理的d当前未在q行的话Q那么执行STOP_JOB q程Q会(x)触发ORA-27366 错误?/p>
停止Jobs 也会(x)触发一条Q务的日志信息Q对于执行停止操作的jobQ其*_SCHEDULER_JOB_LOG 视图的OPERATION ?x)记录?f)'STOPPED'QADDITIONAL_INFO 列中记录的信息类?REASON="Stop job called by user:username"'?/p>
1.2.6 删除Jobs
删除创徏的job 比较简单了(jin)Q直接执行DBMS_SCHEDULER.DROP_JOB q程卛_Q例如：(x)
JSSWEB> exec dbms_scheduler.drop_job('JOBTEST');
PL/SQL procedure successfully completed
删除jobs q不是修改该job 中某个字D늚标记|而是直接删除其在数据字典中的字义Q因此被删除的job
如果未来发现仍然需要，只能重徏Q而无法通过其它方式快速恢复。不q，删除jobs 的操作，q不?x)联删?/p>
q些job 曄执行q的日志信息?/p>
二、用Programs
q入10g 版本之后Q可以在ORACLE 中执行操作系l命令，或是ORACLE 数据库外的应用，因ؓ(f)有了(jin)DBMS_SCHEDULERQ因为有?jin)PROGRAM?/p>
2.1 创徏Programs
Scheduler 中的Program 对象q不是常规意义上?E序"?应用"Q而就是一?对象"Q由DBA 定义的，?/p>
有执行某功能的Ҏ(gu)对象。Program 中实际执行的操作可以分ؓ(f)下列三种cdQ?/p>
PL/SQL BLOCKQ标准的pl/sql 代码块；
STORED PROCEDUREQ编译好的PL/SQL 存储q程Q或者Java 存储q程Q以?qing)外部的子程序?/p>
EXECUTEABLEQORACLE 数据库之外的应用Q比如操作系l命令等{?/p>
创徏Programs 使用DBMS_SCHEDULER.CREATE_PROGRAM q程Q该q程支持的参数如下：(x)
SQL> desc dbms_scheduler.create_program;
Parameter Type Mode Default
------------------- -------------- ---- --------
PROGRAM_NAME VARCHAR2 IN
PROGRAM_TYPE VARCHAR2 IN
PROGRAM_ACTION VARCHAR2 IN
NUMBER_OF_ARGUMENTS BINARY_INTEGER IN Y
ENABLED BOOLEAN IN Y
COMMENTS VARCHAR2 IN Y
如上所C，前三ؓ(f)必选参敎ͼ各参数实际代表的意义如下Q?/p>
PROGRAM_NAMEQ指定一个program 名称Q?/p>
PROGRAM_TYPEQProgram 的类型，如前文中所qͼProgram 支持三种cdQ?/p>
PROGRAM_ACTIONQ实际执行的操作Q应与前面PROGRAM_TYPE 参数兌使用。比如说前面指定
?jin)PROGRAM_TYPE ?PLSQL_BLOCK"Q那么此处要执行的action 应当是一D|准的pl/sql 代码。如果前
面指定PROGRAM_TYPE ?STORED_PROCEDURE"Q那么此处要执行的action 应当是ORACLE 中定义好
的存储过E?含Java 存储q程)Q如果前面指定PROGRAM_TYPE ?EXECUTABLE"Q那么此处就应该指定?/p>
部命令的命o(h)行信?含\径信?Q?/p>
NUMBER_OF_ARGUMENTSQ指定支持的参数个数Q默认gؓ(f)0 x有参数。每个program 最多能?/p>
支持255 个参敎ͼ注意如果PROGRAM_TYPE 讄为PLSQL_BLOCKQ那么本参数自动忽略Q?/p>
ENABLEDQ指定是否将创徏的program |ؓ(f)有效状态，默认情况下ؓ(f)false?/p>
COMMENTSQ这个不用再说了(jin)吧，注释信息?/p>
下面实际操作一下看看，PL/SQL 或PROCEDURE 没有挑战(ORACLE 中直接即可调?Q咱们创Z?/p>
programQ直接调用操作系l中的ls 命o(h)Q操作如下：(x)
SQL> BEGIN
DBMS_SCHEDULER.CREATE_PROGRAM (
program_name => 'IPCONFIG',
program_action => 'C:\WINDOWS\system32\ipconfig.exe',
program_type => 'EXECUTABLE',
enabled => TRUE);
END;
/
PL/SQL procedure successfully completed.
2.2 理Programs
CREATE_PROGRAMq程的参数时提到Q每个program最多支?55 个参敎ͼ要ؓ(f)program d参数Q可以通过DEFINE_PROGRAM_ARGUMENT q程。不q在为其d参数前，要注意program 的NUMBER_OF_ARGUMENTS 指定的数量，如果该gؓ(f)0Q那么ؓ(f)其添加参数时׃(x)报错?/p>
查询创徏的program 的信息，可以通过USER_SCHEDULER_PROGRAMS 视图Q例如：(x)
SQL> select program_name,program_type,program_action,number_of_arguments,enabled
from user_scheduler_programs;
׃前面创徏program 時並未指定NUMBER_OF_ARGUMENTS 的|因此我们q里需要首先修改该gؓ(f)
一个非0 |操作如下Q?/p>
SQL> exec dbms_scheduler.set_attribute('IPCONFIG','NUMBER_OF_ARGUMENTS',1);
PL/SQL procedure successfully completed.
没错Q?操作q是使用DBMS_SCHEDULER.SET_ATTRIBUTE q程。另外需要注意， program 的NUMBER_OF_ARGUMENTS 参数可是说想改就能改的，正常情况下该处理必须是在program 处于enabled 之前认完毕Q否则会(x)触发ORA-27465 错误Q因此要修改program 的参C前，必须首先保要修改program 的enabled 状态ؓ(f)false?/p>
那么对于已经处于enabled 状态的programQ如何修改其状态属性呢Q其实很单，前面操作jobs 时用的
DBMS_SCHEDULER.DISABLE q程q记的吗Q没错，该过E对于program 同样好Qƈ且调用方式也完全一
P例如Q?/p>
SQL> exec dbms_scheduler.disable('IPCONFIG');
PL/SQL procedure successfully completed.
另外Q如果希望将program |ؓ(f)enabled 状态，执行DBMS_SCHEDULER.ENABLE q程卛_Q这里不再例举?/p>
接下来，可以ؓ(f)刚刚创徏的IPCONFIGd路径参数Q操作如下：(x)
SQL> BEGIN
DBMS_SCHEDULER.DEFINE_PROGRAM_ARGUMENT (
program_name => 'IPCONFIG',
argument_position => 1,
argument_name => 'dirpath',
argument_type => 'VARCHAR2',
default_value => 'C:\');
END;
/
PL/SQL procedure successfully completed.
exec DBMS_SCHEDULER.ENABLE('IPCONFIG');
查询为program 定义的参敎ͼ可以通过USER_SCHEDULER_PROGRAM_ARGS 视图Q例如：(x)
SQL> select program_name,argument_name,argument_position,argument_type
default_value from user_scheduler_program_args;
删除program 的argument 操作也很单，使用DROP_PROGRAM_ARGUMENT q程卛_Q例如：(x)
SQL> exec dbms_scheduler.drop_program_argument('IPCONFIG','dirpath');
PL/SQL procedure successfully completed.
该过E第一个参数指定program 名称Q第二个参数指定定义的argument 名称Q当然此处也可以指定argument
的位|，卛_例视图返回结果中的ARGUMENT_POSITION 列倹{?/p>
要删除program 的话更单了(jin)Q用DROP_PROGRAM q程卛_Q例如：(x)
SQL> exec dbms_scheduler.drop_program('IPCONFIG');
PL/SQL procedure successfully completed.
当然啦，删除program 的同Ӟ也会(x)删除该program 对应的所有arguments?/p>
实际上SCHEDULER 中创建job Ӟ也可以指定执行外部的E序。SCHEDULER 中的Job 更像是之前版?/p>
l承q来的JOBSQ只不过10g 中SCHEDULER 理的JOBS 功能更加强大。Programs 与Jobs 不同的是QJobs
是定义好的，定时执行的Q务，而Programs 则是定义好的Q等待被执行的对象?/p>
三、用Schedules
10g 中新推出的SCHEDULER 可能实?x)让很多初接触的朋友感觉晕头晕脑Q相比之前的jobsQ?/p>
SCHEDULER 中新增的概念太多。比如说jobsQ仍然可以理解成之前版本中的jobsQ不q功能更加强大，比如说programQ指的是q行的程?把要做什么单提出来了(jin))Q比如说scheduleQ我其译度，定义执行?/p>
频率或者说周期?/p>
3.1 创徏和管理Schedules
ScheduleQ中文直译的话应该理解成调度Q从名字来看Q它是一个逻辑实体Q就是说当创Z(jin)schedule 之后Q数据库中就肯定存在q一对象Q只不过q一对象是用来描qjob 的执行周期?/p>
创徏schedule 可以通过DBMS_SCHEDULER.CREATE_SCHEDULE q程Q该q程支持的参数如下：(x)
SQL>desc dbms_scheduler
SQL>desc dbms_scheduler.create_schedule;
Parameter Type Mode Default?
--------------- ------------------------ ---- --------
SCHEDULE_NAME VARCHAR2 IN
START_DATE TIMESTAMP WITH TIME ZONE IN Y
REPEAT_INTERVAL VARCHAR2 IN
END_DATE TIMESTAMP WITH TIME ZONE IN Y
COMMENTS VARCHAR2 IN Y
各参数分别代表含意如下：(x)
SCHEDULE_NAMEQ指定schedule 名称Q注意名UC能重复?/p>
START_DATEQ指定该调度的开始时_(d)可ؓ(f)I，当ؓ(f)I时表示该调度暂不v用?/p>
REPEAT_INTERVALQ指定调度的执行频率或周期?/p>
END_DATEQ指定调度的l束旉Q可为空Qؓ(f)I时pC调度一直进行?/p>
COMMENTSQ注释信息?/p>
q其中，比较有技术含量的是REPEAT_INTERVAL 参数Q对于这个参数大家应该不?x)太陌生Q因为前面介
lJobsQ也曄提到q同名的参数QSchedules 中的REPEAT_INTERVAL 参数和Jobs 中的REPEAT_INTERVAL
参数功能完全相同Q甚臛_数格式也一模一栗?/p>
REPEAT_INTERVAL 参数的语法结构要复杂的多。其中最重要的是FREQ 和INTERVAL 两个关键字?/p>
FREQ 关键字用来指定间隔的旉周期Q可选参数有QYEARLY, MONTHLY, WEEKLY, DAILY,
HOURLY, MINUTELY, and SECONDLYQ分别表C年、月、周、日、时、分、秒{单位?/p>
INTERVAL 关键字用来指定间隔的频繁Q可指定的值的范围?-99?/p>
比如_(d) 当指定REPEAT_INTERVAL=>'FREQ=DAILY;INTERVAL=1';pC每天执行一ơ， 如果?/p>
INTERVAL 改ؓ(f)7 pC每7 天执行一ơ，效果{同于FREQ=WEEKLY;INTERVAL=1?/p>
下面Q创Z个scheduleQ指定调度ؓ(f)每周一ơ的频率Q执行脚本如下：(x)
SQL> BEGIN
DBMS_SCHEDULER.CREATE_SCHEDULE (
schedule_name => 'MySchedule',
start_date => SYSDATE,
repeat_interval => 'FREQ=WEEKLY; INTERVAL=1',
comments => 'Every 1 weeks');
END;
/
PL/SQL procedure successfully completed.
查询当前已经创徏的schedulesQ可以通过*_SCHEDULER_SCHEDULES 视图(含DBA_,ALL_,USER_)Q例如，查看当前用户拥有的schedulesQ执行语句如下：(x)
SQL> select schedule_name,repeat_interval from user_scheduler_schedules;
如果要修改schedule 属性的话，也是使用DBMS_SCHEDULER.SET_ATTRIBUTE q程Q该q程的调用方式前面已l多ơ演CQ这里就不再重复举例?jin)，仅说明一点，对于schedule 来说Q能够修改的属性包括：(x)
REPEAT_INTERVAL、COMMENTS、END_DATE、START_DATE 以及(qing)EVENT_SPEC?/p>
至于删除scheduleQ再单不q，执行DBMS_SCHEDULER.DROP_SCHEDULE q程卛_Q例如：(x)
SQL> EXEC DBMS_SCHEDULER.DROP_SCHEDULE('MY_FIRST_SCHEDULE');
PL/SQL procedure successfully completed.
3.2 Schedules调度Programs执行的Jobs
通过schedule 调度program 的执行的job?0g 版本中SCHEDULER JOB分成?jin)多个部分，program 负责做什么，schedule 负责啥时候做Qjob q单了(jin)Q一个字Q做?/p>
前面几个节Q已l分别演CZ(jin)创徏理JobsQ创建管理Programs 以及(qing)创徏和管理SchedulesQ下面我
们通过实例来演C，如何创徏通过schedule 调度program 的执行的job 吧?/p>
1. 我们用前面创建的ProgramQ?IPCONFIGQ执行操作系l命令ipconfig?/p>
2. 用我们刚创徏的scheduleQMySchedule
3. 创徏jobQ按照指定的scheduleQ执行programQ操作如下：(x)
SQL> BEGIN
DBMS_SCHEDULER.CREATE_JOB (
job_name => 'ExecCmd',
program_name => 'IPCONFIG',
schedule_name => 'MySchedule',
enabled => true);
END;
/
PL/SQL procedure successfully completed.
创徏job Ӟstart_date,repeat_interval,job_action {均无须指定Q因些参数将由program 和schedule 来控
制?/p>
q样Q操作完成后QORACLE ׃(x)自动定时(当前讄为每周执行一?program 中定义的操作?/p>
要查看当前的执行情况Q通过*_scheduler_job_run_details 卛_查询(*_scheduler_job_log 也可以，不过该视
图中信息不如detail 中全?。例如，查看刚刚创徏?ExecCmd"d的执行情况，执行命o(h)如下Q?/p>
SQL> select log_id,log_date,status,additional_info from user_scheduler_job_run_details where job_name = 'ExecCmd';
3.3 讄Repeat Interval
Job 和Schedule 中REPEAT_INTERVAL 参数都是用来控制执行的频率或周期Q虽然说周期是一个时间性概念，不过REPEAT_INTERVAL 指定的时候ƈ不是一个时间|而是׃l关键字描述的时间?/p>
除了(jin)前面介绍Job 和Schedule 的REPEAT_INTERVAL 参数Ӟ提到该参数拥有FREQ 以及(qing)INTERVAL 两个关键字，其实除此之外Q还有如BYMONTH、BYWEEKNO、BYYEARDAY、BYDATE {等参数Q可以用来进行更_的定义，比如通过BYMONTH 关键字指定调度运行的月䆾QBYDAY 指定调度在哪天运行等{?/p>
REPEAT_INTERVAL 参数的详l语法如下：(x)
repeat_interval = regular_schedule | combined_schedule
Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝
regular_schedule = frequency_clause
[";" interval_clause] [";" bymonth_clause] [";" byweekno_clause]
[";" byyearday_clause] [";" bydate_clause] [";" bymonthday_clause]
[";" byday_clause] [";" byhour_clause] [";" byminute_clause]
[";" bysecond_clause] [";" bysetpos_clause] [";" include_clause]
[";" exclude_clause] [";" intersect_clause][";" periods_clause]
[";" byperiod_clause]
Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝
combined_schedule = schedule_list [";" include_clause]
[";" exclude_clause] [";" intersect_clause]
frequency_clause = "FREQ" "=" ( predefined_frequency | user_defined_frequency )
predefined_frequency = "YEARLY" | "MONTHLY" | "WEEKLY" | "DAILY" |
"HOURLY" | "MINUTELY" | "SECONDLY"
user_defined_frequency = named_schedule
Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝
interval_clause = "INTERVAL" "=" intervalnum
intervalnum = 1 through 99
bymonth_clause = "BYMONTH" "=" monthlist
monthlist = monthday ( "," monthday)*
month = numeric_month | char_month
numeric_month = 1 | 2 | 3 ... 12
char_month = "JAN" | "FEB" | "MAR" | "APR" | "MAY" | "JUN" |
"JUL" | "AUG" | "SEP" | "OCT" | "NOV" | "DEC"
byweekno_clause = "BYWEEKNO" "=" weeknumber_list
weeknumber_list = weeknumber ( "," weeknumber)*
weeknumber = [minus] weekno
weekno = 1 through 53
byyearday_clause = "BYYEARDAY" "=" yearday_list
yearday_list = yearday ( "," yearday)*
yearday = [minus] yeardaynum
yeardaynum = 1 through 366
bydate_clause = "BYDATE" "=" date_list
date_list = date ( "," date)*
date = [YYYY]MMDD [ offset | span ]
bymonthday_clause = "BYMONTHDAY" "=" monthday_list
monthday_list = monthday ( "," monthday)*
monthday = [minus] monthdaynum
monthdaynum = 1 through 31
byday_clause = "BYDAY" "=" byday_list
byday_list = byday ( "," byday)*
byday = [weekdaynum] day
weekdaynum = [minus] daynum
daynum = 1 through 53 /* if frequency is yearly */
daynum = 1 through 5 /* if frequency is monthly */
day = "MON" | "TUE" | "WED" | "THU" | "FRI" | "SAT" | "SUN"
byhour_clause = "BYHOUR" "=" hour_list
hour_list = hour ( "," hour)*
hour = 0 through 23
byminute_clause = "BYMINUTE" "=" minute_list
minute_list = minute ( "," minute)*
minute = 0 through 59
bysecond_clause = "BYSECOND" "=" second_list
second_list = second ( "," second)*
second = 0 through 59
bysetpos_clause = "BYSETPOS" "=" setpos_list
setpos_list = setpos ("," setpos)*
setpos = [minus] setpos_num
setpos_num = 1 through 9999
Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝
include_clause = "INCLUDE" "=" schedule_list
exclude_clause = "EXCLUDE" "=" schedule_list
intersect_clause = "INTERSECT" "=" schedule_list
schedule_list = schedule_clause ("," schedule_clause)*
schedule_clause = named_schedule [ offset ]
named_schedule = [schema "."] schedule
periods_clause = "PERIODS" "=" periodnum
byperiod_clause = "BYPERIOD" "=" period_list
period_list = periodnum ("," periodnum)*
periodnum = 1 through 100
Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝
offset = ("+" | "-") ["OFFSET:"] duration_val
span = ("+" | "-" | "^") "SPAN:" duration_val
duration_val = dur-weeks | dur_days
dur_weeks = numofweeks "W"
dur_days = numofdays "D"
numofweeks = 1 through 53
numofdays = 1 through 376
minus = "-"
q个语法形式看v来复杂无比，其实实用h很简单，之所以看h复杂Q是因ؓ(f)其功能太q灵zR?/p>
例如Q设|Q务仅在周5 的时候运行：(x)
REPEAT_INTERVAL => 'FREQ=DAILY; BYDAY=FRI';
REPEAT_INTERVAL => 'FREQ=WEEKLY; BYDAY=FRI';
REPEAT_INTERVAL => 'FREQ=YEARLY; BYDAY=FRI';
上述三条语句虽然指定的关键字有差异Q不q功能相同?/p>
讄d隔一周运行一ơ，q且仅在? q行Q?/p>
REPEAT_INTERVAL => 'FREQ=WEEKLY; INTERVAL=2; BYDAY=FRI';
讄d在当月最后一天运行：(x)
REPEAT_INTERVAL => 'FREQ=MONTHLY; BYMONTHDAY=-1';
讄d? ?0 日运行：(x)
REPEAT_INTERVAL => 'FREQ=YEARLY; BYMONTH=MAR; BYMONTHDAY=10';
REPEAT_INTERVAL => 'FREQ=YEARLY; BYDATE=0310';
上述两条语句功能相同?/p>
讄d?0 隔天q行Q?/p>
REPEAT_INTERVAL => 'FREQ=DAILY; INTERVAL=10';
讄d在每天的下午4?? Ҏ(gu)q行Q?/p>
REPEAT_INTERVAL => 'FREQ=DAILY; BYHOUR=16,17,18';
讄d在每?9 日运行：(x)
REPEAT_INTERVAL => 'FREQ=MONTHLY; BYMONTHDAY=29';
讄d在每q的最后一个周5 q行Q?/p>
REPEAT_INTERVAL => 'FREQ=YEARLY; BYDAY=-1FRI';
讄d每隔50 个小时运行：(x)
REPEAT_INTERVAL => 'FREQ=HOURLY; INTERVAL=50';
另外Q你是否在怀念常规job 中设|interval 的简便，虽然功能较弱Q但是设|操作非常简单，无须懊恼Q?/p>
其实SCHEDULER 中的REPEAT_INTERVAL 也完全可以按照那U方式设|，前面都说?jin)，REPEAT_INTERVAL
实际上是指定周期Q直接指定一个时间|当然也是周期喽?/p>
比如_(d)讄d每天执行一ơ，也可以设|REPEAT_INTERVAL 参数值如下：(x)
REPEAT_INTERVAL => 'trunc(sysdate)+1'
又比如设|Q务每周执行一ơ：(x)
REPEAT_INTERVAL => 'trunc(sysdate)+7'?/p>
不过需要注意，q种方式仅用于创建SCHEDULER 中jobs 时用，不能用于schedule?/p>
四、用Events
Event 直译对应的中文解释是指事Ӟ不过单纯讲事件毕竟太抽象?jin)，举个CZ来Ş容吧。A(对应某个应用
E序Q或者是ORACLE 中的q程)在干zLH然眉头一p道，不好Q前Ҏ(gu)情况Q这可怎么办！q时Q只?/p>
它认真想?jin)想Q过?jin)一?x)儿怸一喜说道：(x)有了(jin)Q俗话说早请C啊晚汇报，出现情况要找领导Q赶紧给领导?/p>
消息呗！于是B(也是对应某个应用或ORACLE q程)收C(jin)一条A 发过来的"前方有XX 情况"的消息，q个
q程叫EVENT(含A 发消息以?qing)B 接收消息)?/p>
SCHEDULER 中有两种触发EVENT 的情况：(x)
Scheduler 触发的Events
Scheduler 中触发的EventsQ一般是说当前schduler 中job 的状态发生修改，cMjob 启动Q或者运行结束，或者达到运行时间等诸如此类的动作，都能够抛Z个EVENTQ接收到EVENT 的applicate 可以根据这些信息进行适当的处理?/p>
比如_(d)׃pȝ太过于繁忙，出job 启动旉?0 分钟Qjob 仍然没能利启动Q那么这个时候，Scheduler 可以抛Z条EVENT l外部的应用Q以便外部应用能够及(qing)旉知DBAQ进行处理?/p>
application 触发的Events
外部的应用也可以触发EventsQƈ且由Scheduler 来接收ƈ处理q一cd的Events。所谓Scheduler 处理EVENT 是指Scheduler 启动相应的job 来执行相x作，q类job 在创建时专门声明?jin)event 的处理，q样当接收到EVENT Ӟq类job ׃(x)启动?/p>
Scheduler 使用Oracle 高队列来抛Z?qing)销毁Events。当抛出Schduler 触发的Events ӞScheduler 消息入队到默认的event 队列Qapplication 则通过(g)查该队列来处理Events。当抛出application 触发的Events Ӟapplication 消息入队到处理job 对应的队列中?/p>
下面我们也按照这两个cd来介lScheduler 中的Events?/p>
4.1 Scheduler抛出的Events
前面说了(jin)QScheduler 抛出的Events 一般是指job 状态改变时触发的，那么是不是说只要job 状态发生了(jin)改变Q就?x)触发EventsQ其实ƈ非如此，因ؓ(f)默认情况下，job 是不触发Events 的?/p>
Scheduler 中的job 有一个属性叫raise_eventsQ专门用来设|job 触发Events 的条Ӟ该属性在CREATE_JOB时不能执行，因此默认情况下该属性不?x)赋|自然也就不会(x)触发EVENT。要讄raise_events 属性，只能是在job 创徏完成后，通过SET_ATTRIBUTE q程修改job 的raise_events 属性?/p>
例如Q修改前面创建的job-Q启用raise_events 属性，执行语句如下Q?/p>
SQL> BEGIN
DBMS_SCHEDULER.SET_ATTRIBUTE('JOBTEST', 'raise_events',DBMS_SCHEDULER.JOB_ALL_EVENTS);
END;
/
PL/SQL procedure successfully completed.
上述CZ中指定的raise_events 属性的属性值DBMS_SCHEDULER.JOB_ALL_EVENTSQ就是抛出Events的触发条件?/p>
触发Events 的有下列的类型，分别代表不同的操作：(x)
job_startedQJOB 启动Q?/p>
job_succeededQJOB 成功l束Q?/p>
job_failedQJOB 执行p|Q?/p>
job_brokenQJOB 被置为BROKEN 状态；
job_completedQJOB 辑ֈ最大运行次敎ͼ或者运行的l束日期Q?/p>
job_stoppedQJOB 被STOP_JOB q程|ؓ(f)停止执行的状态；
job_sch_lim_reachedQJob 的schedule 辑ֈ限定|
job_disabledQJOB 被置于DISABLE 状态；
job_chain_stalledQ运行于chain 的JOB 被置于CHAIN_STALLED 状态；
job_all_eventsQ含上述提到的所有类型；
job_run_completedQ由于Job q行出错、成功结束或被手动停止?/p>
L(fng)raise_events 后，Scheduler ׃(x)按照讑֮的触发条Ӟ当达到触发条件时Q即?x)抛Z件信息到SYS.SCHEDULER$_EVENT_QUEUE 队列?/p>
例如Q手动执行一ơJOBTESTQ看看是否向队列中记录信息，操作如下Q?/p>
SQL> exec dbms_scheduler.run_job('JOBTEST');
PL/SQL procedure successfully completed.
执行下列脚本Q出队数据：(x)
SQL> set serveroutput on
SQL> DECLARE
l_dequeue_options DBMS_AQ.dequeue_options_t;
l_message_properties DBMS_AQ.message_properties_t;
l_message_handle RAW(16);
l_queue_msg sys.scheduler$_event_info;
BEGIN
l_dequeue_options.consumer_name := 'TEST';
DBMS_AQ.dequeue(queue_name => 'SYS.SCHEDULER$_EVENT_QUEUE',
dequeue_options => l_dequeue_options,
message_properties => l_message_properties,
payload => l_queue_msg,
msgid => l_message_handle);
COMMIT;
DBMS_OUTPUT.put_line('event_type : ' || l_queue_msg.event_type);
DBMS_OUTPUT.put_line('object_owner : ' || l_queue_msg.object_owner);
DBMS_OUTPUT.put_line('object_name : ' || l_queue_msg.object_name);
DBMS_OUTPUT.put_line('event_timestamp: ' || l_queue_msg.event_timestamp);
DBMS_OUTPUT.put_line('error_code : ' || l_queue_msg.error_code);
DBMS_OUTPUT.put_line('event_status : ' || l_queue_msg.event_status);
DBMS_OUTPUT.put_line('log_id : ' || l_queue_msg.log_id);
DBMS_OUTPUT.put_line('run_count : ' || l_queue_msg.run_count);
DBMS_OUTPUT.put_line('failure_count : ' || l_queue_msg.failure_count);
DBMS_OUTPUT.put_line('retry_count : ' || l_queue_msg.retry_count);
END;
/
event_type : JOB_STARTED
object_owner : TEST
object_name : INSERT_TEST_TBL
event_timestamp: 25-AUG-09 12.49.29.558758 PM +08:00
error_code : 0
event_status : 1
log_id :
run_count : 1
failure_count : 0
retry_count : 0
PL/SQL procedure successfully completed.
从返回的信息可以看到Qevent 的类型ؓ(f)JOB_STARTEDQ表CJOB 启动。实际上job:JOBTEST执行一ơ至会(x)向队列中插入两条event 信息Q一条ؓ(f)JOB_STARTEDQ一条则为JOB_SUCCEEDED(也可能是JOB_FAILED)Q这里不详细演示Q感兴趣的朋友不妨自行测试?/p>
提示QSYS.SCHEDULER$_EVENT_QUEUE 队列ZSYS.SCHEDULER$_EVENT_QTAB 队列表，因此查询
SYS.SCHEDULER$_EVENT_QTAB 也可以获取上q的信息?/p>
SYS.SCHEDULER$_EVENT_QUEUE 是一个固定队列，实际应用的过E中QDBA 应该Ҏ(gu)实际情况Q将该表讉K权限授予相关用户Q以侉K利出队该队列中的events 信息?/p>
另外Q友情提醒，默认情况下Scheduler 仅保留最q?4 时的Events 信息Q如果希望修改该讄的话Q可
以通过SET_SCHEDULER_ATTRIBUTE q程Q修改scheduler 的event_expiry_time 属性，该项属性的属性g
Uؓ(f)单位?/p>
4.2 Application抛出的Events
首先要说明，q里所说的Application 是个代词Q即可以表示ORACLE 数据库之外的应用E序Q也可以是ORACLE 数据库中的PROCEDURE {对象，M你就其理解成用戯己创建的对象好?jin)?/p>
Scheduler 能够抛出Events 让外部应用处理，外部的应用也可以抛出Events 让Scheduler 启动job 处理Q不qƈ不是Mjob 都能够对外部应用抛出的Events 做出响应Q必d创徏jobs 时明指定响应的事g。那么如何指定呢Q依靠下列两个附加的参数Q?/p>
queue_specQ指定外部应用抛出的events 消息入队的队列名Q?/p>
event_conditionQ指定触发job 启动的条Ӟq一参数的参数值在讄时应当基于事件消息的自n属性，因ؓ(f)事g消息在入队时Q消息的属性都是由application 定义的，因此在设|触发条件时Q也应该Ҏ(gu)q些属性值就行设|?/p>
下面Q我们就演示创徏一个由event 触发启动的jobQ在此之前，首先需要进行一些准备工P比如创徏队列Q由于队列需要基于一个队列表Q因此在创徏队列之前Q首先要创徏一个队列表Q考虑到队列表需要依赖一个对象类型，因此在创建队列表之前Q先得创Z个type.......复杂Q具体的操作步骤如下Q?/p>
SQL> create or replace type Test_type1 as object
2 (
3 event_type VARCHAR2(10),
4 object_owner VARCHAR2(30),
5 object_name VARCHAR2(30)
6 );
7 /
Type created.
SQL> begin
2 dbms_aqadm.create_queue_table(
3 queue_table => 'my_queue_tbl1',
4 queue_payload_type => 'Test_type1',
5 multiple_consumers => true);
6 end;
7 /
PL/SQL procedure successfully completed.
SQL> begin
2 dbms_aqadm.create_queue(
3 queue_name => 'event_t1',
4 queue_table => 'my_queue_tbl1');
5 end;
6 /
PL/SQL procedure successfully completed.
OK,准备工作完成Q下面就来创Z个event 触发启动的jobQ创本如下：(x)
SQL> BEGIN
2 DBMS_SCHEDULER.CREATE_JOB (
3 job_name => 'EVENT_JOB_T1',
4 job_type => 'STORED_PROCEDURE',
5 job_action => 'SYSTEM.IT',
6 event_condition => 'tab.user_data.event_type = ''OP_INSERT''',
7 queue_spec => 'EVENT_T1',
8 enabled => TRUE);
9 END;
10 /
PL/SQL procedure successfully completed.
上述脚本仅做演示Q因此创建的job 仍然执行IT q程?/p>
通过pl/sql 直接向event_t1 队列中添加消息的方式Q触发job 的启动，具体操作如下?/p>
首先要执行DBMS_AQADM.START_QUEUE q程Q将event_t1 |于允许入队和出队状?默认情况下创建的队列是不允许出队和入队操作的)Q脚本如下：(x)
SQL> exec dbms_aqadm.start_queue(queue_name => 'event_t1',enqueue => true,dequeue => true);
PL/SQL procedure successfully completed.
执行入队操作Q?/p>
SQL> declare
v_Message Test_type1;
v_EnqueueOptions dbms_aq.enqueue_options_t;
v_MessageProperties dbms_aq.message_properties_t;
v_msg_handle raw(16);
begin
v_message := jss_type1('OP_SELECT', user, 'tmpObj');
dbms_aq.enqueue(queue_name => 'event_t1',
enqueue_options => v_enqueueOptions,
message_properties => v_messageproperties,
payload => v_message,
msgid => v_msg_handle);
commit;
end;
/
PL/SQL procedure successfully completed.
查询队列表中的数据：(x)
SQL> select user_data from my_queue_tbl1;
USER_DATA(EVENT_TYPE, OBJECT_OWNER, OBJECT_NAME)
---------------------------------------------------------
JSS_TYPE1('OP_SELECT', 'TEST', 'tmpObj')
然后查询job
SQL> select to_char(created,'yyyy-mm-dd hh24:mi:ss') from jss_1;
TO_CHAR(CREATED,'YY
-------------------
2009-08-25 12:49:29
看v来jss_1 表中q未有新增加记录Q似乎job 没有执行啊。这很正常，q记得咱们创建job 时指定的event_condition 条g吗：(x)
6 event_condition => 'tab.user_data.event_type = ''OP_INSERT''',
没错Q只有当event_type ?OP_INSERT'时才?x)触发job 的执行，前面入队时指定的是OP_SELECTQ当?/p>
没有触发job 中指定的procedure 啦，下面再次执行入队操作Q?/p>
SQL> declare
v_Message jss_type1;
v_EnqueueOptions dbms_aq.enqueue_options_t;
v_MessageProperties dbms_aq.message_properties_t;
v_msg_handle raw(16);
begin
v_message := jss_type1('OP_INSERT', user, 'tmpObj');
dbms_aq.enqueue(queue_name => 'event_t1',
enqueue_options => v_enqueueOptions,
message_properties => v_messageproperties,
payload => v_message,
msgid => v_msg_handle);
commit;
end;
/
再次查看jss_1 表看看：(x)
SQL> select to_char(created,'yyyy-mm-dd hh24:mi:ss') from jss_1;
TO_CHAR(CREATED,'YY
-------------------
2009-08-25 12:49:29
2009-08-25 13:21:21
多了(jin)一条记录，说明job 已经被自动触发?/p>
最后再补充一句，Zevent 的job 不能通过DBMS_SCHEDULER.RUN_JOB q程执行Q否则会(x)触发ORA-00942: table or view does not exist 错误?/p>
五、用Chains
CHAIN(注意不要敲成CHINA) 可以被视做一lPrograms 的复合，举个单的例子Q运行PROGRAM:A 以及(qing)PROGRAM:BQ如果成功的话l运行PROGRAM:CQ否则的话运行PROGRAM:D。Programs:A、B、C、D 以及(qing)执行的逻辑关系构成了(jin)一个最单的CHAIN?/p>
关于CHAIN 的管理操作比较多Q比如创?删除/修改ChainsQ添?修改/删除Chain Steps {等?/p>
5.1 创徏Chains
5.1.1 创徏CHAIN对象
创徏CHAIN 使用DBMS_SCHEDULER.CREATE_CHAIN q程Q这个过E调用非常简单，因ؓ(f)需要指定的
参数极少Q该q程的定义如下：(x)
SQL> desc dbms_scheduler.create_chain;
Parameter Type Mode Default?
------------------- ---------------------- ---- --------
CHAIN_NAME VARCHAR2 IN
RULE_SET_NAME VARCHAR2 IN Y
EVALUATION_INTERVAL INTERVAL DAY TO SECOND IN Y
COMMENTS VARCHAR2 IN Y
在创建时Q甚臛_以简单到只指定一个CHAIN 的名Uͼ其它均ؓ(f)I即可，例如Q?/p>
SQL> exec dbms_scheduler.create_chain('my_chain1');
PL/SQL procedure successfully completed.
定义好的ChainsQ可以通过*_SCHEDULER_CHAINS 视图查看Q例如：(x)
SQL> select chain_name from user_scheduler_chains;
CHAIN_NAME
------------------------------
MY_CHAIN1
注意Q不是说创徏?jin)CHAIN 齐z，只有一个CHAIN 对象ORACLE q是啥也q不?当然啦，怿从上面执行的创徏语句大家也看出来?QCHAIN 对象创徏之后Q要做的工作其实才刚刚开始。其后，q需要定义ChainSteps 以及(qing)Chain rules?/p>
5.1.2 创徏Chain Step
Chain Steps 是用来指定CHAIN 执行的操作及(qing)执行步骤Q?创徏CHAIN STEP 是通过
DBMS_SCHEDULER.DEFINE_CHAIN_STEP q程q行Q例如，为刚刚创建的my_chain1 d一个stepQ执行操作如下：(x)
SQL> begin
DBMS_SCHEDULER.DEFINE_CHAIN_STEP (
chain_name => 'my_chain1',
step_name => 'my_step1',
program_name => 'p_p1');
end;
/
PL/SQL procedure successfully completed.
Chain Steps 卛_以调用PROGRAM(注意是programQ不是procedureQ当然program 中可以定义执行procedure)Q也可以调用EVENTQ甚臌用其它CHAIN(q就叫嵌套CHAIN)?/p>
下面接着为my_chain1 d两个stepQ操作如下：(x)
SQL> begin
DBMS_SCHEDULER.DEFINE_CHAIN_STEP (
chain_name => 'my_chain1',
step_name => 'my_step2',
program_name => 'p_p2');
DBMS_SCHEDULER.DEFINE_CHAIN_STEP (
chain_name => 'my_chain1',
step_name => 'my_step3',
program_name => 'p_p3');
end;
/
PL/SQL procedure successfully completed.
要查询定义的Chain StepsQ则是通过*_SCHEDULER_CHAIN_STEPS 视图Q例如：(x)
SQL> select chain_name,step_name,program_name from user_scheduler_chain_steps;
CHAIN_NAME STEP_NAME PROGRAM_NAME
-------------------- -------------------- --------------------
MY_CHAIN1 MY_STEP1 P_P1
MY_CHAIN1 MY_STEP2 P_P2
MY_CHAIN1 MY_STEP3 P_P3
5.1.3 创徏Chain Rule
接下来，要ؓ(f)CHAIN 的运行定义规则。定义规则是使用DBMS_SCHEDULER.DEFINE_CHAIN_RULE q程QChain Rules 依赖于Chain StepsQ每个CHAIN RULE 都拥有condition 和action 属性，当满condition 时则执行action 中指定的step?/p>
DBMS_SCHEDULER.DEFINE_CHAIN_RULE q程的语法如下：(x)
SQL> desc dbms_scheduler.define_chain_rule;
Parameter Type Mode Default?
---------- -------- ---- --------
CHAIN_NAME VARCHAR2 IN
CONDITION VARCHAR2 IN
ACTION VARCHAR2 IN
RULE_NAME VARCHAR2 IN Y
COMMENTS VARCHAR2 IN Y
CHAIN_NAME ׃说了(jin)Q需要注意的是CONDITION 和ACTION 两个参数。在为condition 参数指定值时Q其语法看v来稍E复杂一些，或者说是灵z，condition 参数值支持下列的语法形式Q?/p>
TRUE
FALSE
stepname [NOT] SUCCEEDED
stepname [NOT] FAILED
stepname [NOT] STOPPED
stepname [NOT] COMPLETED
stepname ERROR_CODE IN (integer, integer, integer ...)
stepname ERROR_CODE NOT IN (integer, integer, integer ...)
stepname ERROR_CODE = integer
stepname ERROR_CODE != integer
stepname ERROR_CODE <> integer
stepname ERROR_CODE > integer
stepname ERROR_CODE >= integer
stepname ERROR_CODE < integer
stepname ERROR_CODE <= integer
甚至于，q可以制定成下列逻辑语法Q?/p>
expression AND expression
expression OR expression
NOT (expression)
比如_(d)我们希望条g为step1 成功q行Q那么可以指定condition 参数值如下：(x)
'step1 completed'
Action 参数相对单一些，q个参数用来指定当满condition 参数ӞCHAIN 执行的操作?/p>
例如Q创建CHAIN RULEQ首先执行my_step1Q如果my_step1 成功执行的话Q就l箋执行my_step2Q如
果my_step2 也成功执行的话，则结束该CHAINQ创本如下：(x)
SQL> BEGIN
DBMS_SCHEDULER.DEFINE_CHAIN_RULE (
chain_name => 'my_chain1',
condition => 'TRUE',
action => 'START my_step1',
rule_name => 'my_rule1');
DBMS_SCHEDULER.DEFINE_CHAIN_RULE (
chain_name => 'my_chain1',
condition => 'my_step1 completed',
action => 'START my_step2',
rule_name => 'my_rule2');
DBMS_SCHEDULER.DEFINE_CHAIN_RULE (
chain_name => 'my_chain1',
condition => 'my_step2 completed',
action => 'end 0',
rule_name => 'my_rule3');
END;
/
PL/SQL procedure successfully completed.
5.1.4 q行Chains
最后，来运行一下创建的my_chain1 吧，手动q行CHAIN 是通过DBMS_SCHEDULER.RUN_CHAIN q程Q?/p>
例如Q?/p>
SQL> BEGIN
DBMS_SCHEDULER.RUN_CHAIN (
chain_name => 'my_chain1',
start_steps => 'my_step1');
END;
/
PL/SQL procedure successfully completed.
语句执行成功Q下面需要查看一下执行的l果。我们之前定义的p_p1 {program 对象Q实际上是调用procedureQ向一个指定表jss_t2 中插入记录，q里直接查询一下该表，q道执行情况了(jin)(在此之前Qjss_t2 表ؓ(f)I?Q?/p>
SQL> select * from jss_t2;
TP DT
------------------------------ ------------
p_p1 inserted 03-SEP-09
p_p2 inserted 03-SEP-09
你看Qjss_t2 表中有了(jin)两条记录Q对应前面设|的CHAIN RULEQ说明my_step1 和my_step2 均已正确执行。提C：(x)Chains 在执行前Q必被|于enabled 状态，默认情况下刚刚创建的CHAIN 都是disabled 状态，要修改Chains 的状态，q是通过DBMS_SCHEDULER.ENABLE 和DBMS_SCHEDULER.DISABLE 两过E，q里׃演示?jin)。手动执行的CHAIN 的话没有pȝU的日志记录Q因此如果希望看到详l执行情늚话，创徏job 来执行CHAINQ例如：(x)
SQL> BEGIN
DBMS_SCHEDULER.CREATE_JOB (
job_name => 'chain_job_1',
job_type => 'CHAIN',
job_action => 'my_chain1',
repeat_interval => 'freq=daily;interval=1',
enabled => TRUE);
END;
/
PL/SQL procedure successfully completed.
然后Qdba 可以通过定期观察*_scheduler_job_run_details 视图来确认chain 的执行情况了(jin)?/p>
5.2 理Chains
5.2.1 修改Chains属?/p>
基本上碰C改CHAIN 属性的机率不会(x)太大Q因此确实没啥可修改的，对于CHAIN 对象来说Q能够修改的属性只有两个：(x)evaluation_interval 和commentsQ这两个参数一般情况下甚至都不?x)进行设|。如果你到?jin)确实需要修改的情况Q没问题QDBMS_SCHEDULER.SET_ATTRIBUTE q程q记的吧Q没错，修改CHAIN 也是用它。例如：(x)
SQL> select chain_name,comments from user_scheduler_chains;
CHAIN_NAME COMMENTS
-------------------- --------------------------
MY_CHAIN1
SQL> exec dbms_scheduler.set_attribute('my_chain1','comments','change it for a test!');
PL/SQL procedure successfully completed.
SQL> select chain_name,comments from user_scheduler_chains;
CHAIN_NAME COMMENTS
-------------------- --------------------------
MY_CHAIN1 change it for a test !
5.2.2 讄Chain Stepq行属?/p>
修改Chain Step 的运行属性就不能使用DBMS_SCHEDULER.SET_ATTRIBUTE ?jin)，而是有专门的q程
DBMS_SCHEDULER.ALTER_CHAIN 处理Q该q程的定义如下：(x)
SQL> desc dbms_scheduler.alter_chain;
Parameter Type Mode Default?
---------- -------- ---- --------
CHAIN_NAME VARCHAR2 IN
STEP_NAME VARCHAR2 IN
ATTRIBUTE VARCHAR2 IN
VALUE BOOLEAN IN
前两个参数就不说?jin)，ATTRIBUTE 参数用来指定STEP 的属性|可设定的属性值有3 个，每个属性值都
有TRUE 和FALSE 两个选项Q由VALUE 参数指定Q?/p>
PAUSEQ设|该参数gؓ(f)TRUE Ӟ当step q行Ӟ其运行状态就?x)变更?f)PAUSEDQ?/p>
SKIPQ设|该参数gؓ(f)TRUE Ӟ当step 满q行条gӞq不是执行step 中的programQ而是直接跌Q注意当SKIP 参数D|ؓ(f)TRUEQƈ且PAUSE 参数g被设|ؓ(f)TRUEQ那么将?x)以PAUSE 的状态优先；
RESTART_ON_RECOVERYQ设|该参数gؓ(f)TRUE Ӟ如果׃数据库shutdown Dstep 被停止，那么当下ơ数据库启动Ӟstep ?x)自动重新运行?/p>
DBMS_SCHEDULER.ALTER_CHAIN q程修改Chain Step 属性后Q只有当下次q行时才?x)生效，如果要修改当前运行中Chain Step 的属性，也有一个专门的q程DBMS_SCHEDULER.ALTER_RUNNING_CHAIN q行处理Q该q程语法与DBMS_SCHEDULER.ALTER_CHAIN 一模一Pq里׃详细介绍?jin)?/p>
5.2.3 删除Chain Rules
Chain Rules 没有对应的修Ҏ(gu)法，如果要修Ҏ(gu)个Chain 的ruleQ只能首先删除不适当的ruleQ然后重新添加新rule(所谓添加，其实是再重新定义一个rule)?/p>
删除Chain Rule 有专门的q程DBMS_SCHEDULER.DROP_CHAIN_RULEQ该q程语法如下Q?/p>
SQL> desc dbms_scheduler.drop_chain_rule;
Parameter Type Mode Default?
---------- -------- ---- --------
CHAIN_NAME VARCHAR2 IN
RULE_NAME VARCHAR2 IN
FORCE BOOLEAN IN Y
举个单的CZQ比如删除前面定义的my_rule3Q执行过E如下：(x)
SQL> exec dbms_scheduler.drop_chain_rule('my_chain1','my_rule3',true);
PL/SQL procedure successfully completed.
5.2.4 删除Chain Steps
删除Chain Step 也有专门的过EDBMS_SCHEDULER.DROP_CHAIN_STEP q行处理Q该q程语法如下Q?/p>
SQL> desc dbms_scheduler.drop_chain_step;
Parameter Type Mode Default?
---------- -------- ---- --------
CHAIN_NAME VARCHAR2 IN
STEP_NAME VARCHAR2 IN
FORCE BOOLEAN IN Y
看着有点儿眼熟是吧，没错Q与drop_chain_rule 的相似度高达90%以上。例如，删除之前定义的my_step3Q?/p>
执行q程如下Q?/p>
SQL> exec dbms_scheduler.drop_chain_step('my_chain1','my_step3',true);
PL/SQL procedure successfully completed.
5.2.5 删除Chains
如果要删除Chain 那就更简单了(jin)Q执行dbms_scheduler.drop_chain q程卛_Q例如：(x)
SQL> exec dbms_scheduler.drop_chain('my_chain1',true);
PL/SQL procedure successfully completed.
注意Q执行drop_chain Ӟ如果不指定force 参数为TRUEQ那么默认情况下ORACLE ?x)首先检查要删除的CHAIN 是否q有被依赖的对象Q如果存在的话，?x)报ORA-27479 错误Q提CZ然有依赖的对?所谓依赖的对象是指，该chain 仍然存在chain_step 或chain_rule 之类)Q因此无法直接删除。这U情况下解决Ҏ(gu)有两U：(x)
一是手动删除所有相关的chain_step 和chain_ruleQ然后再执行chain 的删除，再就是附加force 参数q指定参?/p>
gؓ(f)trueQ这样ORACLE ׃(x)自动替你清除所有依赖的对象?jin)?/p>
六、用Job Classes
Job Classes 相当于创Z(jin)一个job l，DBA 可以那些具有相同特性的jobQ统l放到相同的Job Classes中，然后通过对Job Class 应用ORACLE 中的"资源使用计划"Ҏ(gu)，可以对q些job 执行q程中所需要的资源分配情况q行理?/p>
1、创建Job Classes
使用DBMS_SCHEDULER 包的CREATE_JOB_CLASS q程创徏Job ClassesQ该q程支持的参数如下：(x)
SQL> desc dbms_scheduler.create_job_class;
Parameter Type Mode Default?
----------------------- -------------- ---- --------
JOB_CLASS_NAME VARCHAR2 IN
RESOURCE_CONSUMER_GROUP VARCHAR2 IN Y
SERVICE VARCHAR2 IN Y
LOGGING_LEVEL BINARY_INTEGER IN Y
LOG_HISTORY BINARY_INTEGER IN Y
COMMENTS VARCHAR2 IN Y
其中Q?/p>
JOB_CLASS_NAMEQ要创徏的Job Class 的名Uͼ注意指定的长度不要超q?0 个字W，也不要与现有Job Class 同名Q?/p>
RESOURCE_CONSUMER_GROUPQ指定创建的Job Class 所在的RCGQ?/p>
提示Q啥是Resource Consumer Group
你可以将其理解成一个资源分配的方式Q处于相同RCG l中的用戗会(x)话、或者对象共用一l资源，q组资源中可供分配的资源按照DBA 指定的方式分配给RCG。如果设计合理，通过q种方式Q可以更有效的利用服务器的资源?/p>
SERVICEQ指定创建的Job Class 所在ServiceQ本选项常见于RAC 环境Q我们都知道RAC 环境由多实例+数据库组成，此处所指定的Service 实际是指Job Class ?x)在哪个实例上运行?/p>
注意Q本参数与RESOURCE_CONSUMER_GROUP 参数怺冲突Q同一个Job Class 只同讄两个参数中的一个倹{?/p>
LOGGING_LEVELQ指定日志记录的U别Q有下列三种U别Q?/p>
DBMS_SCHEDULER.LOGGING_OFFQ关闭日志记录功能；
DBMS_SCHEDULER.LOGGING_RUNSQ对该Job Class 下所有Q务的q行信息q行记录Q?/p>
DBMS_SCHEDULER.LOGGING_FULLQ记录该Job Class 下Q务的所有相关信息，不仅有Q务的q行情况Q甚臌d的创建、修改等也均记入日志?/p>
LOG_HISTORYQ指定日志记录的旉Q以天ؓ(f)单位Q比如指定LOG_HISTORY 参数gؓ(f)90Q就表示日志信息保留最q?0 天的内容?/p>
COMMENTSQ指定注释信息?/p>
上述各个参数Q除?jin)LOG_CLASS_NAME 参数为必选参外，其它均ؓ(f)可选参敎ͼ例如Q?/p>
SQL> EXEC DBMS_SCHEDULER.CREATE_JOB_CLASS('my_first_jc');
PL/SQL procedure successfully completed
查询pȝ中已l存在的Job Classes .可以通过DBA_SCHEDULER_JOB_CLASSES视图( 或ALL_SCHEDULER_JOB_CLASS 视图)
当创建Jobs Ӟ可以通过JOB_CLASS 参数来指定job 所在的Job ClassQ如果不指定的话Q创建的job 默认属于DEFAULT_JOB_CLASS 。至于说如何查询创徏的jobs 属于哪个Job Class Q?q用说吗Q?_SCHEDULER_JOBS 视图中的JOB_CLASS 列呗?/p>
2、管理Job Classes
DBMS_SCHEDULER.SET_ATTRIBUTE q程大家应当q记的，前面的小节中演示中用该q程Q修改job的属性，实际上SET_ATTRIBUTE 也同样可以用来修改Job Class 的属性，操作Ҏ(gu)与修改job 属性完全相同，只不q作用函概的范围更广Q修改Job Class 后，该Job Class 下属的所有job 属性都?x)被U联修改(当前正运行的不会(x)立刻生效Q将{到下次q行时生??/p>
例如Q修改刚刚创建的MY_FIRST_JC 的日志保存时_(d)(x)
SQL> EXEC DBMS_SCHEDULER.SET_ATTRIBUTE('SYS.MY_FIRST_JC','LOG_HISTORY','30');
PL/SQL procedure successfully completed.
提示QJob Class 可被修改的属性，卛_建时可选择指定的那5 个属性?/p>
3、删除Job Classes
DBMS_SCHEDULER 包提供了(jin)DROP_JOB_CLASS q程Q用来删除Job Classes。该q程调用非常单，?/p>
如，删除刚刚创徏的MY_FIRST_JCQ执行命令如下：(x)
JSSWEB> EXEC DBMS_SCHEDULER.DROP_JOB_CLASS('MY_FIRST_JC');
PL/SQL procedure successfully completed.
如果有多个Job Classes 需要删除，q不需要多ơ执行DROP_JOB_CLASSQ只需要在q程指定值时Q参数值间以逗号分隔卛_?/p>
七、用Windows
此Windows 非彼WindowsQ通常说的Windows 是指盖首富的操作pȝQ而此处所说的WindowsQ是指SCHEDULER Ҏ(gu)中的一个子V在SCHEDULER 中，W(xu)INDOW 对应的是一个时间窗口的概念。我们知道普通的jobs 是没有运行时间管理地概念的，是说一个job 启动之后Q用户只能被动地{待其执行，一直到其执行地d完成(或DBA 手动kill 对应q程)Q在此期_(d)执行的job 与其它zd的进E共同竞争当前系l中的资源。对于大型数据库pȝQ系l资源那可是相当宝贵的无形资产哪Q企能谁说用q、想什么时候用׃么时候用Q没点儿计划没点儿节制这q了(jin)得。你q别_(d)?i 之前Q还真就是这么回事儿Q谁想用qQ谁也管不了(jin)Q其中表C最甚的是job。你是否惌v?jin)Job ClassesQ没错定义Job Classes 实可以控制job 能够使用的资源，不过单单使用Job Classes q不能灵zȝ控制job 在合适的旉使用适当的资源。进?0g之后QSCHEDULER 中提供了(jin)WINDOWQ事情终于有?jin)缓解。WINDOW 可以指定一个时间窗口，在此期间Q通过与Job Classes 的搭配组合，能够有效控制job 执行时支?使用)的资源。比如说job 通常是在凌晨服务器负载较低时执行Q那么就可以通过WINDOW 讄在此期间Q允许jobs 使用更多的系l资源，而到?jin)工作时间后Q如果job 仍未执行完成Qؓ(f)其分配另一个有限的资源Q以可能降低job 执行占用的资源对其它业务的媄(jing)响?/p>
Q、创建Window
创徏Window 有一个专门的q程QDBMS_SCHEDULER.CREATE_WINDOW q行处理Q该q程有两U调用方式，如下Q?/p>
--ZSCHEDULE
DBMS_SCHEDULER.CREATE_WINDOW (
window_name IN VARCHAR2,
resource_plan IN VARCHAR2,
schedule_name IN VARCHAR2,
duration IN INTERVAL DAY TO SECOND,
window_priority IN VARCHAR2 DEFAULT 'LOW',
comments IN VARCHAR2 DEFAULT NULL);
--Z定义的调?/p>
DBMS_SCHEDULER.CREATE_WINDOW (
window_name IN VARCHAR2,
resource_plan IN VARCHAR2,
start_date IN TIMESTAMP WITH TIME ZONE DEFAULT NULL,
repeat_interval IN VARCHAR2,
end_date IN TIMESTAMP WITH TIME ZONE DEFAULT NULL,
duration IN INTERVAL DAY TO SECOND,
window_priority IN VARCHAR2 DEFAULT 'LOW',
comments IN VARCHAR2 DEFAULT NULL);
刨开那些看着眼熟的，已经认识的，看参数名q道其所代表含义的之外，下列几个参数可能需要关注：(x)
Resource_planQ这一参数用来指定要用的资源使用计划Q当打开WINDOW Ӟ׃(x)自动按照指定的资源用计划中的设|分配资源，当WINDOW 关闭?没错Qwindow 是会(x)关闭的，要不怎么说有效控制资源的使用情况?Q系l会(x)自动切换回适当资源计划。这个参数在执行q程时甚臛_以指定ؓ(f)NULL 或空?'Q当讄为NULL ӞpCZ用默认的资源计划Q当讄为空?'Ӟ表示用资源使用计划?/p>
DurationQ指定WINDOW 的有效期Q比如说指定为interval '5' hour pC? 个小Ӟ该参数在执行q程时必L定参数|否则创徏?x)报错?/p>
Window_priorityQ该参数用来指定WINDOW 的优先。因为在相同旉只有一个WINDOW 有效Q因此如果在创徏WINDOW 时发现重叠的情况QORACLE 需要根据这一参数指定的规则，来确定优先Q说白了(jin)是先把资源l谁用，q一参数有两个可选|(x)HIGH 或LOWQ默认gؓ(f)LOW?/p>
正如前面CREATE_WINDOW q程语法l构昄的那P调用该过E有两种方式Q差异就在于是指定现有定义好的调度SCHEDULEQ还是在执行q程时指定调度，目标和实现的功能都是相同的，q里仅做CZQ咱挑个最复杂的方式吧Q执行过E时指定调度Q执行脚本如下：(x)
SQL> begin
dbms_scheduler.create_window(
window_name => 'my_first_wd1',
resource_plan => null,
start_date => sysdate,
repeat_interval => 'FREQ=DAILY; INTERVAL=5',
duration => interval '1' hour);
end;
/
PL/SQL procedure successfully completed.
查询当前拥有的WINDOWQ可以通过*_SCHEDULER_WINDOWS视图(注意只有DBA 和ALLQ没有USERQ因为所有定义的WINDOW 都属于SYS 用户)。除?_SCHEDULER_WINDOWS 视图昄当前所有WINDOW外，q有Q?/p>
*_SCHEDULER_WINDOW_DETAILS 视图Q显CWINDOW 的详l信息；
*_SCHEDULER_WINDOW_LOG 视图Q显CWINDOW 的日志，比如打开和关闭；
Q、管理Window
通过前面那些SCHEDULER 对象的学?fn)，相当大家已经了(jin)解了(jin)ORACLE SCHEDULER 中对象的特点Q对于多数对象的理Q不外乎下列几种Q?/p>
修改对象属性，使用SET_ATTRIBUTE q程Q?/p>
SQL> exec dbms_scheduler.set_attribute('sys.my_first_wd1','start_date',sysdate+1);
PL/SQL procedure successfully completed.
ENABLE 对象Q用ENABLE q程Q?/p>
SQL> exec dbms_scheduler.enable('sys.my_first_wd1');
PL/SQL procedure successfully completed.
DISABLE 对象Q用DISABLE q程Q?/p>
SQL> exec dbms_scheduler.disable('sys.my_first_wd1');
PL/SQL procedure successfully completed.
删除对象Q用DROP_WINDOW q程Q?/p>
SQL> exec dbms_scheduler.drop_window('sys.my_first_wd1');
PL/SQL procedure successfully completed.
除此之外呢，对于WINDOW 对象来说Q由于其Ҏ(gu)作用Q又有：(x)手动打开WINDOWQ用OPEN_WINDOW q程Q?/p>
注意WINDOW 是依赖于其调度的Q因此在手动打开WINDOW Ӟ必须为其指定duration 属性：(x)
SQL> exec dbms_scheduler.open_window('sys.my_first_wd1',interval '1' hour);;
PL/SQL procedure successfully completed.
手动关闭WINDOWQ用CLOSE_WINDOW q程Q?/p>
SQL> exec dbms_scheduler.close_window('sys.my_first_wd1');
PL/SQL procedure successfully completed.
关闭和打开WINDOWQ都?x)记录日志，大家可以通过*_SCHEDULER_WINDOW_LOG 视图中获取这部分
信息?/p>
Q、关于WINDOWGROUP
除了(jin)WINDOW 外，q有一个与WINDOW 有关pȝ叫WINDOW GROUPQ一个WINDOW GROUP 可能包含多个WINDOW。用WINDOW GROUP 的本意是q样的，假如说某个job 执行的时间比较长Q甚臛_?4时都在执行Q对于这cjobQ单个WINDOW 很难有效调整其资源占用，q时间呢Q就可以通过讄一个WINDOW GROUPQ该WINDOW GROUP 中包含了(jin)多个WINDOWQ每个WINDOW 分别负责不同旉Ҏ(gu)的资源用计划?/p>
然后在创建JOB Ӟ指定schedule_name 参数为WINDOW GROUP 的名U?想不到SCHEDULE_NAME q能指定为WINDOW GROUP 哪，其实何止WINDOW GROUPQ还可以直接指定成WINDOW ?Q这P可以通过很简单的方式Q将job 与window 联系在一起了(jin)?/p>
WINDOW GROUP 的创建和理与前面介l的方式极其怼Q?/p>
创徏Q用CREATE_WINDOW_GROUP q程Q?/p>
删除Q用DROP_WINDOW_GROUP q程Q?/p>
dWINDOW 成员Q用ADD_WINDOW_GROUP_MEMBER q程Q?/p>
删除WINDOW 成员Q用REMOVE_WINDOW_GROUP_MEMBER q程Q?/p>
启用Q用ENABLE q程Q?/p>
用Q用DISABLE q程Q?/p>
q些q程的调用方式也都非常简单，q里׃着重演CZ(jin)Q感兴趣的朋友不妨自行尝试?/p>
本文来自CSDN博客Q{载请标明出处Qhttp://blog.csdn.net/tianlesoftware/archive/2009/10/22/4715218.aspx
]]>
七、用Windows
此Windows非彼WindowsQ通常说的Windows是指盖首富的操作pȝQ而此处所说的WindowsQ是指SCHEDULERҎ(gu)中的一个子V在SCHEDULER中，W(xu)INDOW对应的是一个时间窗口的概念?
我们知道普通的jobs是没有运行时间管理地概念的，是说一个job启动之后Q用户只能被动地{待其执行，一直到其执行地d完成(或DBA手动kill对应q程)Q在此期_(d)执行的job与其它zd的进E共同竞争当前系l中的资源。对于大型数据库pȝQ系l资源那可是相当宝贵的无形资产哪Q企能谁说用q、想什么时候用׃么时候用Q没点儿计划没点儿节制这q了(jin)得。你q别_(d)?i之前Q还真就是这么回事儿Q谁想用qQ谁也管不了(jin)Q其中表C最甚的是job。你是否惌v?jin)Job ClassesQ没错定义Job Classes实可以控制job能够使用的资源，不过单单使用Job Classesq不能灵zȝ控制job在合适的旉使用适当的资源。进?0g之后QSCHEDULER中提供了(jin)WINDOWQ事情终于有?jin)缓解?
WINDOW 可以指定一个时间窗口，在此期间Q通过与Job Classes的搭配组合，能够有效控制job执行时支?使用)的资源。比如说job通常是在凌晨服务器负载较低时执行Q那么就可以通过WINDOW讄在此期间Q允许jobs使用更多的系l资源，而到?jin)工作时间后Q如果job仍未执行完成Qؓ(f)其分配另一个有限的资源Q以可能降低job执行占用的资源对其它业务的媄(jing)响?
Q、创建Window
创徏Window有一个专门的q程QDBMS_SCHEDULER.CREATE_WINDOWq行处理Q该q程有两U调用方式，如下Q?
-- ZSCHEDULE
DBMS_SCHEDULER.CREATE_WINDOW (
window_name IN VARCHAR2,
resource_plan IN VARCHAR2,
schedule_name IN VARCHAR2,
duration IN INTERVAL DAY TO SECOND,
window_priority IN VARCHAR2 DEFAULT ¨LOW¨,
comments IN VARCHAR2 DEFAULT NULL);
-- Z定义的调?
DBMS_SCHEDULER.CREATE_WINDOW (
window_name IN VARCHAR2,
resource_plan IN VARCHAR2,
start_date IN TIMESTAMP WITH TIME ZONE DEFAULT NULL,
repeat_interval IN VARCHAR2,
end_date IN TIMESTAMP WITH TIME ZONE DEFAULT NULL,
duration IN INTERVAL DAY TO SECOND,
window_priority IN VARCHAR2 DEFAULT ¨LOW¨,
comments IN VARCHAR2 DEFAULT NULL);刨开那些看着眼熟的，已经认识的，看参数名q道其所代表含义的之外，下列几个参数可能需要关注：(x)
- Resource_plan Q这一参数用来指定要用的资源使用计划Q当打开WINDOWӞ׃(x)自动按照指定的资源用计划中的设|分配资源，当WINDOW关闭?没错Qwindow是会(x)关闭的，要不怎么说有效控制资源的使用情况?Q系l会(x)自动切换回适当资源计划。这个参数在执行q程时甚臛_以指定ؓ(f)NULL或空?#168;¨Q当讄为NULLӞpCZ用默认的资源计划Q当讄为空?#168;¨Ӟ表示用资源使用计划?
- Duration Q指定WINDOW的有效期Q比如说指定为interval ¨5¨ hourpC?个小Ӟ该参数在执行q程时必L定参数|否则创徏?x)报错?
- Window_priority Q该参数用来指定WINDOW的优先。因为在相同旉只有一个WINDOW有效Q因此如果在创徏WINDOW时发现重叠的情况QORACLE需要根据这一参数指定的规则，来确定优先Q说白了(jin)是先把资源l谁用，q一参数有两个可选|(x)HIGH或LOWQ默认gؓ(f)LOW?
正如前面CREATE_WINDOWq程语法l构昄的那P调用该过E有两种方式Q差异就在于是指定现有定义好的调度SCHEDULEQ还是在执行q程时指定调度，目标和实现的功能都是相同的，q里仅做CZQ咱挑个最复杂的方式吧Q执行过E时指定调度Q执行脚本如下：(x)
SQL> begin
2 dbms_scheduler.create_window(window_name => ¨my_first_wd1¨,
3 resource_plan => null,
4 start_date => sysdate,
5 repeat_interval => ¨FREQ=DAILY; INTERVAL=5¨,
6 duration => interval ¨1¨ hour);
7 end;
8 /
PL/SQL procedure successfully completed.查询当前拥有的WINDOWQ可以通过*_SCHEDULER_WINDOWS视图(注意只有DBA和ALLQ没有USERQ因为所有定义的WINDOW都属于SYS用户)。除?_SCHEDULER_WINDOWS视图昄当前所有WINDOW外，q有Q?
- *_SCHEDULER_WINDOW_DETAILS 视图Q显CWINDOW的详l信息；
- *_SCHEDULER_WINDOW_LOG 视图Q显CWINDOW的日志，比如打开和关闭；
Q、管理Window
通过前面那些SCHEDULER对象的学?fn)，相当大家已经了(jin)解了(jin)ORACLE SCHEDULER中对象的特点Q对于多数对象的理Q不外乎下列几种Q?
- 修改对象属性，使用SET_ATTRIBUTEq程Q?
SQL> exec dbms_scheduler.set_attribute(¨sys.my_first_wd1¨,¨start_date¨,sysdate+1);
PL/SQL procedure successfully completed.- ENABLE 对象Q用ENABLEq程Q?
SQL> exec dbms_scheduler.enable(¨sys.my_first_wd1¨);
PL/SQL procedure successfully completed.- DISABLE 对象Q用DISABLEq程Q?
SQL> exec dbms_scheduler.disable(¨sys.my_first_wd1¨);
PL/SQL procedure successfully completed.- 删除对象Q用DROP_WINDOWq程Q?
SQL> exec dbms_scheduler.drop_window(¨sys.my_first_wd1¨);
PL/SQL procedure successfully completed.除此之外呢，对于WINDOW对象来说Q由于其Ҏ(gu)作用Q又有：(x)
- 手动打开WINDOWQ用OPEN_WINDOWq程Q?
注意WINDOW是依赖于其调度的Q因此在手动打开WINDOWӞ必须为其指定duration属性：(x)
SQL> exec dbms_scheduler.open_window(¨sys.my_first_wd1¨,interval ¨1¨ hour);;
PL/SQL procedure successfully completed.- 手动关闭WINDOWQ用CLOSE_WINDOWq程Q?
SQL> exec dbms_scheduler.close_window(¨sys.my_first_wd1¨);
PL/SQL procedure successfully completed.关闭和打开WINDOWQ都?x)记录日志，大家可以通过*_SCHEDULER_WINDOW_LOG视图中获取这部分信息?
Q、关于WINDOW GROUP
除了(jin)WINDOW外，q有一个与WINDOW有关pȝ叫WINDOW GROUPQ一个WINDOW GROUP可能?含多个WINDOW。用WINDOW GROUP的本意是q样的，假如说某个job执行的时间比较长Q甚臛_?4时都在执行Q对于这cjobQ单个WINDOW很难有效调整其资源占用，q时间呢Q就可以通过讄一个WINDOW GROUPQ该WINDOW GROUP中包含了(jin)多个WINDOWQ每个WINDOW分别负责不同旉Ҏ(gu)的资源用计划?
然后在创建JOBӞ指定schedule_name参数为WINDOW GROUP的名U?想不到SCHEDULE_NAMEq能指定为WINDOW GROUP哪，其实何止WINDOW GROUPQ还可以直接指定成WINDOW?Q这P可以通过很简单的方式Q将job与window联系在一起了(jin)?
WINDOW GROUP 的创建和理与前面介l的方式极其怼Q?
- 创徏Q用CREATE_WINDOW_GROUPq程Q?
- 删除Q用DROP_WINDOW_GROUPq程Q?
- dWINDOW成员Q用ADD_WINDOW_GROUP_MEMBERq程Q?
- 删除WINDOW成员Q用REMOVE_WINDOW_GROUP_MEMBERq程Q?
- 启用Q用ENABLEq程Q?
- 用Q用DISABLEq程Q?
q些q程的调用方式也都非常简单，q里׃着重演CZ(jin)Q感兴趣的朋友不妨自行尝试?
]]>
六、用Job Classes
Job Classes 相当于创Z(jin)一个jobl，DBA可以那些具有相同特性的jobQ统l放到相同的Job Classes中，然后通过对Job Class应用ORACLE中的"资源使用计划"Ҏ(gu)，可以对q些job执行q程中所需要的资源分配情况q行理?
1?创徏Job Classes
使用DBMS_SCHEDULER包的CREATE_JOB_CLASSq程创徏Job ClassesQ该q程支持的参数如下：(x)
JSSWEB> desc dbms_scheduler.create_job_class;
Parameter Type Mode Default?
----------------------- -------------- ---- --------
JOB_CLASS_NAME VARCHAR2 IN
RESOURCE_CONSUMER_GROUP VARCHAR2 IN Y
SERVICE VARCHAR2 IN Y
LOGGING_LEVEL BINARY_INTEGER IN Y
LOG_HISTORY BINARY_INTEGER IN Y
COMMENTS VARCHAR2 IN Y其中Q?
- JOB_CLASS_NAME Q要创徏的Job Class的名Uͼ注意指定的长度不要超q?0个字W，也不要与现有Job Class同名Q?
- RESOURCE_CONSUMER_GROUP Q指定创建的Job Class所在的RCGQ?
提示Q啥是Resource Consumer Group
你可以将其理解成一个资源分配的方式Q处于相同RCGl中的用戗会(x)话、或者对象共用一l资源，q组资源中可供分配的资源按照DBA指定的方式分配给RCG。如果设计合理，通过q种方式Q可以更有效的利用服务器的资源?- SERVICE Q指定创建的Job Class所在ServiceQ本选项常见于RAC环境Q我们都知道RAC环境由多实例+数据库组成，此处所指定的Service实际是指Job Class?x)在哪个实例上运行?/li>
- 注意Q本参数与RESOURCE_CONSUMER_GROUP参数怺冲突Q同一个Job Class只同讄两个参数中的一个倹{?
- LOGGING_LEVEL Q指定日志记录的U别Q有下列三种U别Q?
- n DBMS_SCHEDULER.LOGGING_OFF Q关闭日志记录功能；
- n DBMS_SCHEDULER.LOGGING_RUNS Q对该Job Class下所有Q务的q行信息q行记录Q?
- n DBMS_SCHEDULER.LOGGING_FULL Q记录该Job Class下Q务的所有相关信息，不仅有Q务的q行情况Q甚臌d的创建、修改等也均记入日志?
- LOG_HISTORY Q指定日志记录的旉Q以天ؓ(f)单位Q比如指定LOG_HISTORY参数gؓ(f)90Q就表示日志信息保留最q?0天的内容?
- COMMENTS Q指定注释信息?
上述各个参数Q除?jin)LOG_CLASS_NAME参数为必选参外，其它均ؓ(f)可选参敎ͼ例如Q?
JSSWEB> EXEC DBMS_SCHEDULER.CREATE_JOB_CLASS(¨my_first_jc¨);
PL/SQL procedure successfully completed查询pȝ中已l存在的Job ClassesQ可以通过DBA_SCHEDULER_JOB_CLASSES视图(或ALL_SCHEDULER_JOB_CLASS视图)Q例如：(x)
JSSWEB> select job_class_name,resource_consumer_group,service from dba_scheduler_job_classes;
JOB_CLASS_NAME RESOURCE_CONSUMER_GROUP SERVICE
------------------------------ ------------------------------ -----------------------------
DEFAULT_JOB_CLASS
AUTO_TASKS_JOB_CLASS AUTO_TASK_CONSUMER_GROUP
MY_FIRST_JC当创建JobsӞ可以通过JOB_CLASS参数来指定job所在的Job ClassQ如果不指定的话Q创建的job默认属于DEFAULT_JOB_CLASS。至于说如何查询创徏的jobs属于哪个Job ClassQ还用说吗，*_SCHEDULER_JOBS视图中的JOB_CLASS列呗?
2?理Job Classes
DBMS_SCHEDULER.SET_ATTRIBUTE q程大家应当q记的，前面的小节中演示中用该q程Q修改job的属性，实际上SET_ATTRIBUTE也同样可以用来修改Job Class的属性，操作Ҏ(gu)与修改job属性完全相同，只不q作用函概的范围更广Q修改Job Class后，该Job Class下属的所有job属性都?x)被U联修改(当前正运行的不会(x)立刻生效Q将{到下次q行时生??
例如Q修改刚刚创建的MY_FIRST_JC的日志保存时_(d)(x)
JSSWEB> EXEC DBMS_SCHEDULER.SET_ATTRIBUTE(¨SYS.MY_FIRST_JC¨,¨LOG_HISTORY¨,¨30¨);
PL/SQL procedure successfully completed.- 提示QJob Class可被修改的属性，卛_建时可选择指定的那5个属性?
3?删除Job Classes
DBMS_SCHEDULER 包提供了(jin)DROP_JOB_CLASSq程Q用来删除Job Classes。该q程调用非常单，例如Q删除刚刚创建的MY_FIRST_JCQ执行命令如下：(x)
JSSWEB> EXEC DBMS_SCHEDULER.DROP_JOB_CLASS(¨MY_FIRST_JC¨);
PL/SQL procedure successfully completed.如果有多个Job Classes需要删除，q不需要多ơ执行DROP_JOB_CLASSQ只需要在q程指定值时Q参数值间以逗号分隔卛_?
]]>
5.2 理Chains
5.2.1 修改Chains属?
基本上碰C改CHAIN属性的机率不会(x)太大Q因此确实没啥可修改的，对于CHAIN对象来说Q能够修改的属性只有两个：(x)evaluation_interval和commentsQ这两个参数一般情况下甚至都不?x)进行设|。如果你到?jin)确实需要修改的情况Q没问题QDBMS_SCHEDULER.SET_ATTRIBUTEq程q记的吧Q没错，修改CHAIN也是用它。例如：(x)
SQL> select chain_name,comments from user_scheduler_chains;
CHAIN_NAME COMMENTS
-------------------- --------------------------
MY_CHAIN1
SQL> exec dbms_scheduler.set_attribute(¨my_chain1¨,¨comments¨,¨change it for a test!¨);
PL/SQL procedure successfully completed.
SQL> select chain_name,comments from user_scheduler_chains;
CHAIN_NAME COMMENTS
-------------------- --------------------------
MY_CHAIN1 change it for a test !5.2.2 讄Chain Stepq行属?
修改Chain Step的运行属性就不能使用DBMS_SCHEDULER.SET_ATTRIBUTE?jin)，而是有专门的q程DBMS_SCHEDULER.ALTER_CHAIN处理Q该q程的定义如下：(x)
SQL> desc dbms_scheduler.alter_chain;
Parameter Type Mode Default?
---------- -------- ---- --------
CHAIN_NAME VARCHAR2 IN
STEP_NAME VARCHAR2 IN
ATTRIBUTE VARCHAR2 IN
VALUE BOOLEAN IN前两个参数就不说?jin)，ATTRIBUTE参数用来指定STEP的属性|可设定的属性值有3个，每个属性值都有TRUE和FALSE两个选项Q由VALUE参数指定Q?
- PAUSE Q设|该参数gؓ(f)TRUEӞ当stepq行Ӟ其运行状态就?x)变更?f)PAUSEDQ?
- SKIP Q设|该参数gؓ(f)TRUEӞ当step满q行条gӞq不是执行step中的programQ而是直接跌Q注意当SKIP参数D|ؓ(f)TRUEQƈ且PAUSE参数g被设|ؓ(f)TRUEQ那么将?x)以PAUSE的状态优先；
- RESTART_ON_RECOVERY Q设|该参数gؓ(f)TRUEӞ如果׃数据库shutdownDstep被停止，那么当下ơ数据库启动Ӟstep?x)自动重新运行?
DBMS_SCHEDULER.ALTER_CHAIN q程修改Chain Step属性后Q只有当下次q行时才?x)生效，如果要修改当前运行中Chain Step的属性，也有一个专门的q程DBMS_SCHEDULER.ALTER_RUNNING_CHAINq行处理Q该q程语法与DBMS_SCHEDULER.ALTER_CHAIN一模一Pq里׃详细介绍?jin)?
5.2.3 删除Chain Rules
Chain Rules 没有对应的修Ҏ(gu)法，如果要修Ҏ(gu)个Chain的ruleQ只能首先删除不适当的ruleQ然后重新添加新rule(所谓添加，其实是再重新定义一个rule)?
删除Chain Rule有专门的q程DBMS_SCHEDULER.DROP_CHAIN_RULEQ该q程语法如下Q?
SQL> desc dbms_scheduler.drop_chain_rule;
Parameter Type Mode Default?
---------- -------- ---- --------
CHAIN_NAME VARCHAR2 IN
RULE_NAME VARCHAR2 IN
FORCE BOOLEAN IN Y三?/a>一眼就能看出来Q这个过E的调用方式那是相当单，因此׃对各个参数详l介l了(jin)Q下面D个简单的CZQ比如删除前面定义的my_rule3Q执行过E如下：(x)
SQL> exec dbms_scheduler.drop_chain_rule(¨my_chain1¨,¨my_rule3¨,true);
PL/SQL procedure successfully completed.5.2.4 删除Chain Steps
删除Chain Step也有专门的过EDBMS_SCHEDULER.DROP_CHAIN_STEPq行处理Q该q程语法如下Q?
SQL> desc dbms_scheduler.drop_chain_step;
Parameter Type Mode Default?
---------- -------- ---- --------
CHAIN_NAME VARCHAR2 IN
STEP_NAME VARCHAR2 IN
FORCE BOOLEAN IN Y看着有点儿眼熟是吧，没错Q与drop_chain_rule的相似度高达90%以上。例如，删除之前定义的my_step3Q执行过E如下：(x)
SQL> exec dbms_scheduler.drop_chain_step(¨my_chain1¨,¨my_step3¨,true);
PL/SQL procedure successfully completed.5.2.5 删除Chains
如果要删除Chain那就更简单了(jin)Q执行dbms_scheduler.drop_chainq程卛_Q例如：(x)
SQL> exec dbms_scheduler.drop_chain(¨my_chain1¨,true);
PL/SQL procedure successfully completed.注意Q执行drop_chainӞ如果不指定force参数为TRUEQ那么默认情况下ORACLE?x)首先检查要删除的CHAIN是否q有被依赖的对象Q如果存在的话，?x)报ORA-27479错误Q提CZ然有依赖的对?所谓依赖的对象是指，该chain仍然存在chain_step或chain_rule之类)Q因此无法直接删除。这U情况下解决Ҏ(gu)有两U：(x)一是手动删除所有相关的chain_step和chain_ruleQ然后再执行chain的删除，再就是附加force参数q指定参数gؓ(f)trueQ这样ORACLE׃(x)自动替你清除所有依赖的对象?jin)?
]]>
五、用Chains
今天要来认识一位新同学QCHAIN(注意不要敲成CHINA)。CHAIN可以被视做一lPrograms的复合，举个单的例子Q运行PROGRAM:A以及(qing)PROGRAM:BQ如果成功的话l运行PROGRAM:CQ否则的话运行PROGRAM:D。Programs:A、B、C、D以及(qing)执行的逻辑关系构成了(jin)一个最单的CHAIN?
关于CHAIN的管理操作比较多Q比如创?删除/修改ChainsQ添?修改/删除Chain Steps{等?
5.1 创徏Chains
5.1.1 创徏CHAIN对象
创徏CHAIN使用DBMS_SCHEDULER.CREATE_CHAINq程Q这个过E调用非常简单，因ؓ(f)需要指定的参数极少Q该q程的定义如下：(x)
SQL> desc dbms_scheduler.create_chain;
Parameter Type Mode Default?
------------------- ---------------------- ---- --------
CHAIN_NAME VARCHAR2 IN
RULE_SET_NAME VARCHAR2 IN Y
EVALUATION_INTERVAL INTERVAL DAY TO SECOND IN Y
COMMENTS VARCHAR2 IN Y在创建时Q甚臛_以简单到只指定一个CHAIN的名Uͼ其它均ؓ(f)I即可，例如Q?
SQL> exec dbms_scheduler.create_chain(¨my_chain1¨);
PL/SQL procedure successfully completed.定义好的ChainsQ可以通过*_SCHEDULER_CHAINS视图查看Q例如：(x)
SQL> select chain_name from user_scheduler_chains;
CHAIN_NAME
------------------------------
MY_CHAIN1注意Q不是说创徏?jin)CHAIN齐z，只有一个CHAIN对象ORACLEq是啥也q不?当然啦，怿从上面执行的创徏语句大家也看出来?QCHAIN对象创徏之后Q要做的工作其实才刚刚开始。其后，q需要定义Chain Steps以及(qing)Chain rules?
5.1.2 创徏Chain Step
Chain Steps 是用来指定CHAIN执行的操作及(qing)执行步骤Q创建CHAIN STEP是通过DBMS_SCHEDULER.DEFINE_CHAIN_STEPq程q行Q例如，为刚刚创建的my_chain1d一个stepQ执行操作如下：(x)
SQL> begin
2 DBMS_SCHEDULER.DEFINE_CHAIN_STEP (
3 chain_name => ¨my_chain1¨,
4 step_name => ¨my_step1¨,
5 program_name => ¨p_p1¨);
6 end;
7 /
PL/SQL procedure successfully completed.Chain Steps 卛_以调用PROGRAM(注意是programQ不是procedureQ当然program中可以定义执行procedure)Q也可以调用EVENTQ甚臌用其它CHAIN(q就叫嵌套CHAIN)?
下面接着为my_chain1d两个stepQ操作如下：(x)
SQL> begin
2 DBMS_SCHEDULER.DEFINE_CHAIN_STEP (
3 chain_name => ¨my_chain1¨,
4 step_name => ¨my_step2¨,
5 program_name => ¨p_p2¨);
6 DBMS_SCHEDULER.DEFINE_CHAIN_STEP (
7 chain_name => ¨my_chain1¨,
8 step_name => ¨my_step3¨,
9 program_name => ¨p_p3¨);
10 end;
11 /
PL/SQL procedure successfully completed.要查询定义的Chain StepsQ则是通过*_SCHEDULER_CHAIN_STEPS视图Q例如：(x)
SQL> select chain_name,step_name,program_name from user_scheduler_chain_steps;
CHAIN_NAME STEP_NAME PROGRAM_NAME
-------------------- -------------------- --------------------
MY_CHAIN1 MY_STEP1 P_P1
MY_CHAIN1 MY_STEP2 P_P2
MY_CHAIN1 MY_STEP3 P_P35.1.3 创徏Chain Rule
接下来，要ؓ(f)CHAIN的运行定义规则。定义规则是使用DBMS_SCHEDULER.DEFINE_CHAIN_RULEq程QChain Rules依赖于Chain StepsQ每个CHAIN RULE都拥有condition和action属性，当满condition时则执行action中指定的step?
DBMS_SCHEDULER.DEFINE_CHAIN_RULE q程的语法如下：(x)
SQL> desc dbms_scheduler.define_chain_rule;
Parameter Type Mode Default?
---------- -------- ---- --------
CHAIN_NAME VARCHAR2 IN
CONDITION VARCHAR2 IN
ACTION VARCHAR2 IN
RULE_NAME VARCHAR2 IN Y
COMMENTS VARCHAR2 IN YCHAIN_NAME ׃说了(jin)Q需要注意的是CONDITION和ACTION两个参数。在为condition参数指定值时Q其语法看v来稍E复杂一些，或者说是灵z，condition参数值支持下列的语法形式Q?
- TRUE
- FALSE
- stepname [NOT] SUCCEEDED
- stepname [NOT] FAILED
- stepname [NOT] STOPPED
- stepname [NOT] COMPLETED
- stepname ERROR_CODE IN (integer, integer, integer ...)
- stepname ERROR_CODE NOT IN (integer, integer, integer ...)
- stepname ERROR_CODE = integer
- stepname ERROR_CODE != integer
- stepname ERROR_CODE <> integer
- stepname ERROR_CODE > integer
- stepname ERROR_CODE >= integer
- stepname ERROR_CODE < integer
- stepname ERROR_CODE <= integer
甚至于，q可以制定成下列逻辑语法Q?
- expression AND expression
- expression OR expression
- NOT (expression)
比如_(d)我们希望条g为step1成功q行Q那么可以指定condition参数值如下：(x)
- ¨step1 completed¨
Action 参数相对单一些，q个参数用来指定当满condition参数ӞCHAIN执行的操作?
例如Q创建CHAIN RULEQ首先执行my_step1Q如果my_step1成功执行的话Q就l箋执行my_step2Q如果my_step2也成功执行的话，则结束该CHAINQ创本如下：(x)
SQL> BEGIN
2 DBMS_SCHEDULER.DEFINE_CHAIN_RULE (
3 chain_name => ¨my_chain1¨,
4 condition => ¨TRUE¨,
5 action => ¨START my_step1¨,
6 rule_name => ¨my_rule1¨);
7 DBMS_SCHEDULER.DEFINE_CHAIN_RULE (
8 chain_name => ¨my_chain1¨,
9 condition => ¨my_step1 completed¨,
10 action => ¨START my_step2¨,
11 rule_name => ¨my_rule2¨);
12 DBMS_SCHEDULER.DEFINE_CHAIN_RULE (
13 chain_name => ¨my_chain1¨,
14 condition => ¨my_step2 completed¨,
15 action => ¨end 0¨,
16 rule_name => ¨my_rule3¨);
17 END;
18 /
PL/SQL procedure successfully completed.5.1.4 q行Chains
最后，来运行一下创建的my_chain1吧，手动q行CHAIN是通过DBMS_SCHEDULER.RUN_CHAINq程Q例如：(x)
SQL> BEGIN
2 DBMS_SCHEDULER.RUN_CHAIN (
3 chain_name => ¨my_chain1¨,
4 start_steps => ¨my_step1¨);
5 END;
6 /
PL/SQL procedure successfully completed.语句执行成功Q下面需要查看一下执行的l果。我们之前定义的p_p1{program对象Q实际上是调用procedureQ向一个指定表jss_t2中插入记录，q里直接查询一下该表，q道执行情况了(jin)(在此之前Qjss_t2表ؓ(f)I?Q?
SQL> select * from jss_t2;
TP DT
------------------------------ ------------
p_p1 inserted 03-SEP-09
p_p2 inserted 03-SEP-09你看Qjss_t2表中有了(jin)两条记录Q对应前面设|的CHAIN RULEQ说明my_step1和my_step2均已正确执行?
- 提示QChains在执行前Q必被|于enabled状态，默认情况下刚刚创建的CHAIN都是disabled状态，要修改Chains的状态，q是通过DBMS_SCHEDULER.ENABLE和DBMS_SCHEDULER.DISABLE两过E，q里׃演示?jin)?
手动执行的CHAIN的话没有pȝU的日志记录Q因此如果希望看到详l执行情늚话，创徏job来执行CHAINQ例如：(x)
SQL> BEGIN
2 DBMS_SCHEDULER.CREATE_JOB (
3 job_name => ¨chain_job_1¨,
4 job_type => ¨CHAIN¨,
5 job_action => ¨my_chain1¨,
6 repeat_interval => ¨freq=daily;interval=1¨,
7 enabled => TRUE);
8 END;
9 /
PL/SQL procedure successfully completed.然后Qdba可以通过定期观察*_scheduler_job_run_details视图来确认chain的执行情况了(jin)?
]]>
4.2 Application抛出的Events
首先要说明，q里所说的Application是个代词Q即可以表示ORACLE数据库之外的应用E序Q也可以是ORACLE数据库中的PROCEDURE{对象，M你就其理解成用戯己创建的对象好?jin)?
Scheduler 能够抛出Events让外部应用处理，外部的应用也可以抛出Events让Scheduler启动job处理Q不qƈ不是Mjob都能够对外部应用抛出的Events做出响应Q必d创徏jobs时明指定响应的事g。那么如何指定呢Q依靠下列两个附加的参数Q?
- queue_spec Q指定外部应用抛出的events消息入队的队列名Q?
- event_condition Q指定触发job启动的条Ӟq一参数的参数值在讄时应当基于事件消息的自n属性，因ؓ(f)事g消息在入队时Q消息的属性都是由application定义的，因此在设|触发条件时Q也应该Ҏ(gu)q些属性值就行设|?
下面Q我们就演示创徏一个由event触发启动的jobQ在此之前，首先需要进行一些准备工P比如创徏队列Q由于队列需要基于一个队列表Q因此在创徏队列之前Q首先要创徏一个队列表Q考虑到队列表需要依赖一个对象类型，因此在创建队列表之前Q先得创Z个type.......复杂Q具体的操作步骤如下Q客官可要看仔细?jin)?x)
SQL> create or replace type jss_type 1 as object
2 (
3 event_type VARCHAR2( 1 0),
4 object_owner VARCHAR2( 30 ),
5 object_name VARCHAR2( 3 0)
6 );
7 /
Type created.
SQL> begin
2 dbms_aqadm.create_queue_table(
3 queue_table => ¨my_queue_tbl1¨,
4 queue_payload_type => ¨JSS_TYPE1¨,
5 multiple_consumers => true);
6 end;
7 /
PL/SQL procedure successfully completed.
SQL> begin
2 dbms_aqadm.create_queue(
3 queue_name => ¨event_t1¨,
4 queue_table => ¨my_queue_tbl1¨);
5 end;
6 /
PL/SQL procedure successfully completed.OK, 准备工作完成Q下面就来创Z个event触发启动的jobQ创本如下：(x)
SQL> BEGIN
2 DBMS_SCHEDULER.CREATE_JOB (
3 job_name => ¨EVENT_JOB_T1¨,
4 job_type => ¨STORED_PROCEDURE¨,
5 job_action => ¨P_INSERTINTOTEST¨,
6 event_condition => ¨tab.user_data.event_type = ¨¨OP_INSERT¨¨¨,
7 queue_spec => ¨EVENT_T1¨,
8 enabled => TRUE);
9 END;
10 /
PL/SQL procedure successfully completed.上述脚本仅做演示Q因此创建的job仍然执行P_INSERTINTOTESTq程?
三?/a>q不准备再编写一套外部的应用来触发，q里仅ؓ(f)?jin)演Capplication触发job启动的示例，因此三?/a>军_通过pl/sql直接向event_t1队列中添加消息的方式Q触发job的启动，具体操作如下?
首先要执行DBMS_AQADM.START_QUEUEq程Q将event_t1|于允许入队和出队状?默认情况下创建的队列是不允许出队和入队操作的)Q脚本如下：(x)
SQL> exec dbms_aqadm.start_queue(queue_name => ¨event_t1¨,enqueue => true,dequeue => true);
PL/SQL procedure successfully completed.执行入队操作Q?
SQL> declare
2 v_Message jss_type1;
3 v_EnqueueOptions dbms_aq.enqueue_options_t;
4 v_MessageProperties dbms_aq.message_properties_t;
5 v_msg_handle raw(16);
6 begin
7 v_message := jss_type1(¨OP_ SELECT ¨, user, ¨tmpObj¨);
8
9 dbms_aq.enqueue(queue_name => ¨event_t1¨,
10 enqueue_options => v_enqueueOptions,
11 message_properties => v_messageproperties,
12 payload => v_message,
13 msgid => v_msg_handle);
14 commit;
15
16 end;
17 /
PL/SQL procedure successfully completed.查询队列表中的数据：(x)
SQL> select user_data from my_queue_tbl1;
USER_DATA(EVENT_TYPE, OBJECT_OWNER, OBJECT_NAME)
---------------------------------------------------------
JSS_TYPE1(¨OP_SELECT¨, ¨TEST¨, ¨tmpObj¨)然后查询job
SQL> select to_char(created,¨yyyy-mm-dd hh24:mi:ss¨) from jss_1;
TO_CHAR(CREATED,¨YY
-------------------
2009-08-25 12:49:29看v来jss_1表中q未有新增加记录Q似乎job没有执行啊。这很正常，q记得咱们创建job时指定的 event_condition 条g吗：(x)
- 6 event_condition => ¨tab.user_data.event_type = ¨¨OP_INSERT¨¨¨,
没错Q只有当event_type?#168;OP_INSERT¨时才?x)触发job的执行，前面入队时指定的?OP_ SELECT Q当然没有触发job中指定的procedure啦，下面再次执行入队操作Q?
SQL> declare
2 v_Message jss_type1;
3 v_EnqueueOptions dbms_aq.enqueue_options_t;
4 v_MessageProperties dbms_aq.message_properties_t;
5 v_msg_handle raw(16);
6 begin
7 v_message := jss_type1(¨OP_INSERT¨, user, ¨tmpObj¨);
8
9 dbms_aq.enqueue(queue_name => ¨event_t1¨,
10 enqueue_options => v_enqueueOptions,
11 message_properties => v_messageproperties,
12 payload => v_message,
13 msgid => v_msg_handle);
14 commit;
15
16 end;
17 /再次查看jss_1表看看：(x)
SQL> select to_char(created,¨yyyy-mm-dd hh24:mi:ss¨) from jss_1;
TO_CHAR(CREATED,¨YY
-------------------
2009-08-25 12:49:29
2009-08-25 13:21:21多了(jin)一条记录，说明job已经被自动触发?
最后再补充一句，Zevent的job不能通过DBMS_SCHEDULER.RUN_JOBq程执行Q否则会(x)触发ORA-00942: table or view does not exist错误?
]]>
四、用Events
Event直译对应的中文解释是指事Ӟ不过单纯讲事件毕竟太抽象?jin)，举个CZ来Ş容吧。A(对应某个应用E序Q或者是ORACLE中的q程)在干zLH然眉头一p道，不好Q前Ҏ(gu)情况Q这可怎么办！q时Q只见它认真想了(jin)惻Iq了(jin)一?x)儿怸一喜说道：(x)有了(jin)Q俗话说早请C啊晚汇报，出现情况要找领导Q赶紧给领导发消息呗Q于是B(也是对应某个应用或ORACLEq程)收C(jin)一条A发过来的"前方有XX情况"的消息，q个q程叫EVENT(含A发消息以?qing)B接收消息)?
SCHEDULER 中有两种触发EVENT的情况：(x)
- Scheduler 触发的Events
Scheduler 中触发的EventsQ一般是说当前schduler中job的状态发生修改，cMjob启动Q或者运行结束，或者达到运行时间等诸如此类的动作，都能够抛Z个EVENTQ接收到EVENT的applicate可以根据这些信息进行适当的处理?
比如_(d)׃pȝ太过于繁忙，出job启动旉?0分钟Qjob仍然没能利启动Q那么这个时候，Scheduler可以抛Z条EVENTl外部的应用Q以便外部应用能够及(qing)旉知DBAQ进行处理?
- application 触发的Events
外部的应用也可以触发EventsQƈ且由Scheduler来接收ƈ处理q一cd的Events。所谓Scheduler处理EVENT是指Scheduler启动相应的job来执行相x作，q类job在创建时专门声明?jin)event的处理，q样当接收到EVENTӞq类job׃(x)启动?
Scheduler 使用Oracle高队列来抛Z?qing)销毁Events。当抛出Schduler触发的EventsӞScheduler消息入队到默认的event队列Qapplication则通过(g)查该队列来处理Events。当抛出application触发的EventsӞapplication消息入队到处理job对应的队列中?
下面我们也按照这两个cd来介lScheduler中的Events?
4.1 Scheduler抛出的Events
前面说了(jin)QScheduler抛出的Events一般是指job状态改变时触发的，那么是不是说只要job状态发生了(jin)改变Q就?x)触发EventsQ其实ƈ非如此，因ؓ(f)默认情况下，job是不触发Events的?
Scheduler 中的job有一个属性叫raise_eventsQ专门用来设|job触发Events的条Ӟ该属性在CREATE_JOB时不能执行，因此默认情况下该属性不?x)赋|自然也就不会(x)触发EVENT。要讄raise_events属性，只能是在job创徏完成后，通过SET_ATTRIBUTEq程修改job的raise_events属性?
例如Q修改前面创建的job-Q启用raise_events属性，执行语句如下Q?
SQL> BEGIN
2 DBMS_SCHEDULER.SET_ATTRIBUTE(¨INSERT_TEST_TBL¨, ¨raise_events¨, DBMS_SCHEDULER.JOB_ALL_EVENTS)
3 END;
4 /
PL/SQL procedure successfully completed.上述CZ中指定的raise_events属性的属性值DBMS_SCHEDULER.JOB_ALL_EVENTSQ就是抛出Events的触发条件?
触发Events的有下列的类型，分别代表不同的操作：(x)
- job_started QJOB启动Q?
- job_succeeded QJOB成功l束Q?
- job_failed QJOB执行p|Q?
- job_broken QJOB被置为BROKEN状态；
- job_completed QJOB辑ֈ最大运行次敎ͼ或者运行的l束日期Q?
- job_stopped QJOB被STOP_JOBq程|ؓ(f)停止执行的状态；
- job_sch_lim_reached QJob的schedule辑ֈ限定|
- job_disabled QJOB被置于DISABLE状态；
- job_chain_stalled Q运行于chain的JOB被置于CHAIN_STALLED状态；
- job_all_events Q含上述提到的所有类型；
- job_run_completed Q由于Jobq行出错、成功结束或被手动停止?
L(fng)raise_events后，Scheduler׃(x)按照讑֮的触发条Ӟ当达到触发条件时Q即?x)抛Z件信息到SYS.SCHEDULER$_EVENT_QUEUE队列?
例如Q手动执行一ơINSERT_TEST_TBLQ看看是否向队列中记录信息，操作如下Q?
SQL> exec dbms_scheduler.run_job(¨INSERT_TEST_TBL¨);
PL/SQL procedure successfully completed.执行下列脚本Q出队数据：(x)
SQL> set serveroutput on
SQL> DECLARE
2 l_dequeue_options DBMS_AQ.dequeue_options_t;
3 l_message_properties DBMS_AQ.message_properties_t;
4 l_message_handle RAW(16);
5 l_queue_msg sys.scheduler$_event_info;
6 BEGIN
7 l_dequeue_options.consumer_name := ¨TEST¨;
8
9 DBMS_AQ.dequeue(queue_name => ¨SYS.SCHEDULER$_EVENT_QUEUE¨,
10 dequeue_options => l_dequeue_options,
11 message_properties => l_message_properties,
12 payload => l_queue_msg,
13 msgid => l_message_handle);
14 COMMIT;
15
16 DBMS_OUTPUT.put_line(¨event_type : ¨ || l_queue_msg.event_type);
17 DBMS_OUTPUT.put_line(¨object_owner : ¨ || l_queue_msg.object_owner);
18 DBMS_OUTPUT.put_line(¨object_name : ¨ || l_queue_msg.object_name);
19 DBMS_OUTPUT.put_line(¨event_timestamp: ¨ || l_queue_msg.event_timestamp);
20 DBMS_OUTPUT.put_line(¨error_code : ¨ || l_queue_msg.error_code);
21 DBMS_OUTPUT.put_line(¨event_status : ¨ || l_queue_msg.event_status);
22 DBMS_OUTPUT.put_line(¨log_id : ¨ || l_queue_msg.log_id);
23 DBMS_OUTPUT.put_line(¨run_count : ¨ || l_queue_msg.run_count);
24 DBMS_OUTPUT.put_line(¨failure_count : ¨ || l_queue_msg.failure_count);
25 DBMS_OUTPUT.put_line(¨retry_count : ¨ || l_queue_msg.retry_count);
26 END;
27 /
event_type : JOB_STARTED
object_owner : TEST
object_name : INSERT_TEST_TBL
event_timestamp: 25-AUG-09 12.49.29.558758 PM +08:00
error_code : 0
event_status : 1
log_id :
run_count : 1
failure_count : 0
retry_count : 0
PL/SQL procedure successfully completed.从返回的信息可以看到Qevent的类型ؓ(f)JOB_STARTEDQ表CJOB启动。实际上job:INSERT_TEST_TBL执行一ơ至会(x)向队列中插入两条event信息Q一条ؓ(f)JOB_STARTEDQ一条则为JOB_SUCCEEDED(也可能是JOB_FAILED)Q这里不详细演示Q感兴趣的朋友不妨自行测试?
- 提示QSYS.SCHEDULER$_EVENT_QUEUE队列ZSYS.SCHEDULER$_EVENT_QTAB队列表，因此查询SYS.SCHEDULER$_EVENT_QTAB也可以获取上q的信息?
SYS.SCHEDULER$_EVENT_QUEUE 是一个固定队列，实际应用的过E中QDBA应该Ҏ(gu)实际情况Q将该表讉K权限授予相关用户Q以侉K利出队该队列中的events信息?
另外Q友情提醒，默认情况下Scheduler仅保留最q?4时的Events信息Q如果希望修改该讄的话Q可以通过SET_SCHEDULER_ATTRIBUTEq程Q修改scheduler的event_expiry_time属性，该项属性的属性gUؓ(f)单位?/p>
]]>
3.3 讄Repeat Interval
Job 和Schedule中REPEAT_INTERVAL参数都是用来控制执行的频率或周期Q虽然说周期是一个时间性概念，不过REPEAT_INTERVAL指定的时候ƈ不是一个时间|而是׃l关键字描述的时间?
除了(jin)前面介绍Job和Schedule的REPEAT_INTERVAL参数Ӟ提到该参数拥有FREQ以及(qing)INTERVAL两个关键字，其实除此之外Q还有如BYMONTH、BYWEEKNO、BYYEARDAY、BYDATE{等参数Q可以用来进行更_的定义，比如通过BYMONTH关键字指定调度运行的月䆾QBYDAY指定调度在哪天运行等{?
REPEAT_INTERVAL 参数的详l语法如下：(x)
repeat_interval = regular_schedule | combined_schedule
Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝
regular_schedule = frequency_clause
[";" interval_clause] [";" bymonth_clause] [";" byweekno_clause]
[";" byyearday_clause] [";" bydate_clause] [";" bymonthday_clause]
[";" byday_clause] [";" byhour_clause] [";" byminute_clause]
[";" bysecond_clause] [";" bysetpos_clause] [";" include_clause]
[";" exclude_clause] [";" intersect_clause][";" periods_clause]
[";" byperiod_clause]
Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝
combined_schedule = schedule_list [";" include_clause]
[";" exclude_clause] [";" intersect_clause]
frequency_clause = "FREQ" "=" ( predefined_frequency | user_defined_frequency )
predefined_frequency = "YEARLY" | "MONTHLY" | "WEEKLY" | "DAILY" |
"HOURLY" | "MINUTELY" | "SECONDLY"
user_defined_frequency = named_schedule
Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝
interval_clause = "INTERVAL" "=" intervalnum
intervalnum = 1 through 99
bymonth_clause = "BYMONTH" "=" monthlist
monthlist = monthday ( "," monthday)*
month = numeric_month | char_month
numeric_month = 1 | 2 | 3 ... 12
char_month = "JAN" | "FEB" | "MAR" | "APR" | "MAY" | "JUN" |
"JUL" | "AUG" | "SEP" | "OCT" | "NOV" | "DEC"
byweekno_clause = "BYWEEKNO" "=" weeknumber_list
weeknumber_list = weeknumber ( "," weeknumber)*
weeknumber = [minus] weekno
weekno = 1 through 53
byyearday_clause = "BYYEARDAY" "=" yearday_list
yearday_list = yearday ( "," yearday)*
yearday = [minus] yeardaynum
yeardaynum = 1 through 366
bydate_clause = "BYDATE" "=" date_list
date_list = date ( "," date)*
date = [YYYY]MMDD [ offset | span ]
bymonthday_clause = "BYMONTHDAY" "=" monthday_list
monthday_list = monthday ( "," monthday)*
monthday = [minus] monthdaynum
monthdaynum = 1 through 31
byday_clause = "BYDAY" "=" byday_list
byday_list = byday ( "," byday)*
byday = [weekdaynum] day
weekdaynum = [minus] daynum
daynum = 1 through 53 /* if frequency is yearly */
daynum = 1 through 5 /* if frequency is monthly */
day = "MON" | "TUE" | "WED" | "THU" | "FRI" | "SAT" | "SUN"
byhour_clause = "BYHOUR" "=" hour_list
hour_list = hour ( "," hour)*
hour = 0 through 23
byminute_clause = "BYMINUTE" "=" minute_list
minute_list = minute ( "," minute)*
minute = 0 through 59
bysecond_clause = "BYSECOND" "=" second_list
second_list = second ( "," second)*
second = 0 through 59
bysetpos_clause = "BYSETPOS" "=" setpos_list
setpos_list = setpos ("," setpos)*
setpos = [minus] setpos_num
setpos_num = 1 through 9999
Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝
include_clause = "INCLUDE" "=" schedule_list
exclude_clause = "EXCLUDE" "=" schedule_list
intersect_clause = "INTERSECT" "=" schedule_list
schedule_list = schedule_clause ("," schedule_clause)*
schedule_clause = named_schedule [ offset ]
named_schedule = [schema "."] schedule
periods_clause = "PERIODS" "=" periodnum
byperiod_clause = "BYPERIOD" "=" period_list
period_list = periodnum ("," periodnum)*
periodnum = 1 through 100
Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝Q＝
offset = ("+" | "-") ["OFFSET:"] duration_val
span = ("+" | "-" | "^") "SPAN:" duration_val
duration_val = dur-weeks | dur_days
dur_weeks = numofweeks "W"
dur_days = numofdays "D"
numofweeks = 1 through 53
numofdays = 1 through 376
minus = "-"q个语法形式看v来复杂无比，其实实用h很简单，之所以看h复杂Q是因ؓ(f)其功能太q灵z?之前?a title="点击阅读三思笔?--诙谐q默单易ȝORACLE学习(fn)文章" target="_blank">三?/a>pdW记中，已经阐述q灵zM复杂的关p?Q这里不准备逐条解释每一个语法细节，下面着重通过一些常用设|，希望能够更有助于q大同仁的理解?
例如Q设|Q务仅在周5的时候运行：(x)
REPEAT_INTERVAL => ¨FREQ=DAILY; BYDAY=FRI¨;
REPEAT_INTERVAL => ¨FREQ=WEEKLY; BYDAY=FRI¨;
REPEAT_INTERVAL => ¨FREQ=YEARLY; BYDAY=FRI¨;上述三条语句虽然指定的关键字有差异Q不q功能相同?
讄d隔一周运行一ơ，q且仅在?q行Q?
- REPEAT_INTERVAL => ¨FREQ=WEEKLY; INTERVAL=2; BYDAY=FRI¨;
讄d在当月最后一天运行：(x)
- REPEAT_INTERVAL => ¨FREQ=MONTHLY; BYMONTHDAY=-1¨;
讄d??0日运行：(x)
- REPEAT_INTERVAL => ¨FREQ=YEARLY; BYMONTH=MAR; BYMONTHDAY=10¨;
REPEAT_INTERVAL => ¨FREQ=YEARLY; BYDATE=0310¨;
上述两条语句功能相同?
讄d?0隔天q行Q?
- REPEAT_INTERVAL => ¨FREQ=DAILY; INTERVAL=10¨;
讄d在每天的下午4??Ҏ(gu)q行Q?
- REPEAT_INTERVAL => ¨FREQ=DAILY; BYHOUR=16,17,18¨;
讄d在每?9日运行：(x)
- REPEAT_INTERVAL => ¨FREQ=MONTHLY; BYMONTHDAY=29¨;
讄d在每q的最后一个周5q行Q?
- REPEAT_INTERVAL => ¨FREQ=YEARLY; BYDAY=-1FRI¨;
讄d每隔50个小时运行：(x)
- REPEAT_INTERVAL => ¨FREQ=HOURLY; INTERVAL=50¨;
另外Q你是否在怀念常规job中设|interval的简便，虽然功能较弱Q但是设|操作非常简单，无须懊恼Q其实SCHEDULER中的REPEAT_INTERVAL也完全可以按照那U方式设|，前面都说?jin)，REPEAT_INTERVAL实际上是指定周期Q直接指定一个时间|当然也是周期喽?
比如_(d)讄d每天执行一ơ，也可以设|REPEAT_INTERVAL参数值如下：(x)
- REPEAT_INTERVAL => ¨trunc(sysdate)+1¨
又比如设|Q务每周执行一ơ：(x)
- REPEAT_INTERVAL => ¨trunc(sysdate)+7¨
不过需要注意，q种方式仅用于创建SCHEDULER中jobs时用，不能用于schedule?
]]>
3.2 Schedules调度Programs执行的Jobs
通过schedule调度program的执行的jobQ看到这L(fng)形容是不是让你彻底晕头了(jin)Q就说明你还是没搞明?0g中SCHEDULERSҎ(gu)管理的jobs的含意，?a title="点击阅读三思笔?--诙谐q默单易ȝORACLE学习(fn)文章" target="_blank">三?/a>更直白地l你描述描述?0g版本中SCHEDULERJOB分成?jin)多个部分，program负责做什么，schedule负责啥时候做Qjobq单了(jin)Q一个字Q做?
前面几个节Q?a title="点击阅读三思笔?--诙谐q默单易ȝORACLE学习(fn)文章" target="_blank">三?/a>已经分别演示?jin)创建管理JobsQ创建管理Programs以及(qing)创徏和管理SchedulesQ下面我们通过实例来演C，如何创徏通过schedule调度program的执行的job吧?
首先Q创Z个programQ操作如下：(x)
SQL> BEGIN
2 DBMS_SCHEDULER.CREATE_PROGRAM (
3 program_name => ¨my_program1¨,
4 program_action => ¨/bin/date¨,
5 program_type => ¨EXECUTABLE¨,
6 enabled => TRUE);
7 END;
8 /
PL/SQL procedure successfully completed.通过上述语句Q我们定义了(jin)一个programQ执行操作系l命令dateQƈ输入到dt.log文g中?
接下来定义一个scheduleQ操作如下：(x)
SQL> begin
2 DBMS_SCHEDULER.CREATE_SCHEDULE (
3 schedule_name => ¨my_first_schedule¨,
4 start_date => SYSDATE,
5 repeat_interval => ¨FREQ= DAILY ; INTERVAL=1¨,
6 comments => ¨Every 1 weeks¨);
7 END;
8 /
PL/SQL procedure successfully completed.定义调试为每周执行一ơ。此处repeat_interval可根据实现情况进行修攏V?
最后，创徏jobQ按照指定的scheduleQ执行programQ操作如下：(x)
SQL> BEGIN
2 DBMS_SCHEDULER.CREATE_JOB (
3 job_name => ¨execOScmd¨,
4 program_name => ¨my_program1¨,
5 schedule_name => ¨my_first_schedule¨,
6 enabled => true);
7 END;
8 /
PL/SQL procedure successfully completed.创徏jobӞstart_date,repeat_interval,job_action{均无须指定Q因些参数将由program和schedule来控制?
q样Q操作完成后QORACLE׃(x)自动定时(当前讄为每周执行一?program中定义的操作?
要查看当前的执行情况Q通过*_scheduler_job_run_details卛_查询(*_scheduler_job_log也可以，不过该视图中信息不如detail中全?。例如，查看刚刚创徏?EXECOSCMD"d的执行情况，执行命o(h)如下Q?
SQL> select log_id, log_date, status, additional_info
2 from user_scheduler_job_run_details
3 where job_name = ¨EXECOSCMD¨
4 ;
LOG_ID LOG_DATE STATUS ADDITIONAL_INFO
---------- -------------------- ---------- ------------------------------
13760 17-AUG-09 02.47.53.7 SUCCEEDED
34050 PM +08:00看完q个CZ之后Q你是否?0g中的SCHEDULERҎ(gu)多?jin)些了(jin)解呢？千万表自满，SCHEDULERҎ(gu)的功能q多着哪，接着往下看吧?
]]>
三、用Schedules
10g 中新推出的SCHEDULER可能实?x)让很多初接触的朋友感觉晕头晕脑Q相比之前的jobsQSCHEDULER中新增的概念太多。比如说jobsQ仍然可以理解成之前版本中的jobsQ不q功能更加强?注意10g中也仍然可以使用普通jobsQ这是废话，怿看本文章的朋友目前应该q是q样在用)Q比如说programQ指的是q行的程?把要做什么单提出来了(jin))Q比如说scheduleQ我其译?job我翻译ؓ(f)d)Q定义执行的频率或者说周期?
3.1 创徏和管理Schedule s
Schedule Q中文直译的话应该理解成调度Q从名字来看Q它是一个逻辑实体(逻辑Q还实体Q好矛盾)Q就是说当创Z(jin)schedule之后Q数据库中就肯定存在q一对象Q只不过q一对象是用来描qjob的执行周期?
创徏schedule可以通过DBMS_SCHEDULER.CREATE_SCHEDULEq程Q该q程支持的参数如下：(x)
SQL> desc dbms_scheduler.create_schedule;
Parameter Type Mode Default?
--------------- ------------------------ ---- --------
SCHEDULE_NAME VARCHAR2 IN
START_DATE TIMESTAMP WITH TIME ZONE IN Y
REPEAT_INTERVAL VARCHAR2 IN
END_DATE TIMESTAMP WITH TIME ZONE IN Y
COMMENTS VARCHAR2 IN Y各参数分别代表含意如下：(x)
- SCHEDULE_NAME Q指定schedule名称Q注意名UC能重复?
- START_DATE Q指定该调度的开始时_(d)可ؓ(f)I，当ؓ(f)I时表示该调度暂不v用?
- REPEAT_INTERVAL Q指定调度的执行频率或周期?
- END_DATE Q指定调度的l束旉Q可为空Qؓ(f)I时pC调度一直进行?
- COMMENTS Q注释信息?
q其中，比较有技术含量的是REPEAT_INTERVAL参数Q对于这个参数大家应该不?x)太陌生Q因为前面介lJobsQ也曄提到q同名的参数QSchedules中的REPEAT_INTERVAL参数和Jobs中的REPEAT_INTERVAL参数功能完全相同Q甚臛_数格式也一模一栗?
REPEAT_INTERVAL 参数的语法结构要复杂的多。其中最重要的是FREQ和INTERVAL两个关键字?
- FREQ 关键字用来指定间隔的旉周期Q可选参数有QYEARLY, MONTHLY, WEEKLY, DAILY, HOURLY, MINUTELY, and SECONDLYQ分别表C年、月、周、日、时、分、秒{单位?
- INTERVAL 关键字用来指定间隔的频繁Q可指定的值的范围?-99?
比如_(d)当指定REPEAT_INTERVAL=>¨FREQ=DAILY;INTERVAL=1¨;pC每天执行一ơ，如果INTERVAL改ؓ(f)7pC每7天执行一ơ，效果{同于FREQ=WEEKLY;INTERVAL=1?
下面Q创Z个scheduleQ指定调度ؓ(f)每周一ơ的频率Q执行脚本如下：(x)
SQL> begin
2 DBMS_SCHEDULER.CREATE_SCHEDULE (
3 schedule_name => ¨my_first_schedule¨,
4 start_date => SYSDATE,
5 repeat_interval => ¨FREQ=WEEKLY; INTERVAL=1¨,
6 comments => ¨Every 1 weeks¨);
7 END;
8 /
PL/SQL procedure successfully completed.查询当前已经创徏的schedulesQ可以通过*_SCHEDULER_SCHEDULES视图(含DBA_,ALL_,USER_)Q例如，查看当前用户拥有的schedulesQ执行语句如下：(x)
SQL> select schedule_name,repeat_interval from user_scheduler_schedules;
SCHEDULE_NAME REPEAT_INTERVAL
------------------------------ ------------------------------
MY_FIRST_SCHEDULE FREQ=WEEKLY; INTERVAL=1如果要修改schedule属性的话，也是使用DBMS_SCHEDULER.SET_ATTRIBUTEq程Q该q程的调用方式前面已l多ơ演CQ这里就不再重复举例?jin)，仅说明一点，对于schedule来说Q能够修改的属性包括：(x)REPEAT_INTERVAL、COMMENTS、END_DATE、START_DATE以及(qing)EVENT_SPEC?
至于删除scheduleQ再单不q，执行DBMS_SCHEDULER.DROP_SCHEDULEq程卛_Q例如：(x)
SQL> EXEC DBMS_SCHEDULER.DROP_SCHEDULE(¨MY_FIRST_SCHEDULE¨);
PL/SQL procedure successfully completed.]]>
二、用Programs
在论坛中偶尔见过有h讨论如何在ORACLE中执行操作系l命令，或是ORACLE数据库外的应用。应该说?i?qing)之前的版本中，虽然说ƈ非完全无法实玎ͼ其实q是有多U方式能够变相实现的Q，不过复杂的实现方式让DBA使劲?jin)力Q伤透了(jin)?j)，费劲了(jin)事ѝ?
q入10g版本之后Q就完全不必如此费神Q因为有?jin)DBMS_SCHEDULERQ因为有?jin)PROGRAM?
2.1 创徏Programs
Scheduler 中的Program对象q不是常规意义上?E序"?应用"Q而就是一?对象"Q由DBA定义的，h执行某项功能的特D对象。Program中实际执行的操作可以分ؓ(f)下列三种cdQ?
- PL/SQL BLOCK Q标准的pl/sql代码块；
- STORED PROCEDURE Q编译好的PL/SQL存储q程Q或者Java存储q程Q以?qing)外部的c子程序；
- EXECUTEABLE QORACLE数据库之外的应用Q比如操作系l命令等{?
创徏Programs使用DBMS_SCHEDULER.CREATE_PROGRAMq程Q该q程支持的参数如下：(x)
JSSWEB> desc dbms_scheduler.create_program;
Parameter Type Mode Default?
------------------- -------------- ---- --------
PROGRAM_NAME VARCHAR2 IN
PROGRAM_TYPE VARCHAR2 IN
PROGRAM_ACTION VARCHAR2 IN
NUMBER_OF_ARGUMENTS BINARY_INTEGER IN Y
ENABLED BOOLEAN IN Y
OMMENTS VARCHAR2 IN Y如上所C，前三ؓ(f)必选参敎ͼ各参数实际代表的意义如下Q?
- PROGRAM_NAME Q指定一个program名称Q?
- PROGRAM_TYPE QProgram的类型，如前文中所qͼProgram支持三种cdQ?
- PROGRAM_ACTION Q实际执行的操作Q应与前面PROGRAM_TYPE参数兌使用。比如说前面指定?jin)PROGRAM_TYPE?PLSQL_BLOCK"Q那么此处要执行的action应当是一D|准的pl/sql代码。如果前面指定PROGRAM_TYPE?STORED_PROCEDURE"Q那么此处要执行的action应当是ORACLE中定义好的存储过E?含Java存储q程)Q如果前面指定PROGRAM_TYPE?EXECUTABLE"Q那么此处就应该指定外部命o(h)的命令行信息(含\径信?Q?
- NUMBER_OF_ARGUMENTS Q指定支持的参数个数Q默认gؓ(f)0x有参数。每个program最多能够支?55个参敎ͼ注意如果PROGRAM_TYPE讄为PLSQL_BLOCKQ那么本参数自动忽略Q?
- ENABLED Q指定是否将创徏的program|ؓ(f)有效状态，默认情况下ؓ(f)false?
- COMMENTS Q这个不用再说了(jin)吧，注释信息?
下面实际操作一下看看，PL/SQL或PROCEDURE没有挑战(ORACLE中直接即可调?Q咱们创Z下programQ直接调用操作系l中的ls命o(h)Q操作如下：(x)
-- 与三思有点不?/span>
SQL> BEGIN
DBMS_SCHEDULER.CREATE_PROGRAM (
program_name => 'IPCONFIG',
program_action => 'C:\WINDOWS\system32\ipconfig.exe',
program_type => 'EXECUTABLE',
enabled => TRUE);
END;
/
PL/SQL procedure successfully completed.2.2 理Programs
定义的program如何执行Q这里先卖个兛_Q前面介lCREATE_PROGRAMq程的参数时提到Q每个program最多支?55个参敎ͼ要ؓ(f)programd参数Q可以通过DEFINE_PROGRAM_ARGUMENTq程。不q在为其d参数前，要注意program的NUMBER_OF_ARGUMENTS指定的数量，如果该gؓ(f)0Q那么ؓ(f)其添加参数时׃(x)报错?
查询创徏的program的信息，可以通过USER_SCHEDULER_PROGRAMS视图Q例如：(x)
SQL> select program_name,program_type,program_action,number_of_arguments,enabled
2 from user_scheduler_programs;
PROGRAM_NAME PROGRAM_TYPE PROGRAM_ACTION NUMBER_OF_ARGUMENTS ENABL
-------------------- ---------------- -------------------- ------------------- -----
MY_PROGRAM1 EXECUTABLE /bin/ls 1 FALSE׃前面创徏program時並未指定NUMBER_OF_ARGUMENTS的|因此我们q里需要首先修改该gؓ(f)一个非0|操作如下Q?
SQL> exec dbms_scheduler.set_attribute(¨my_program1¨,¨NUMBER_OF_ARGUMENTS¨,1);
PL/SQL procedure successfully completed.没错Q操作还是用DBMS_SCHEDULER.SET_ATTRIBUTEq程。另外需要注意，program的NUMBER_OF_ARGUMENTS参数可是说想改就能改的，正常情况下该处理必须是在program处于enabled之前认完毕Q否则会(x)触发ORA-27465错误Q因此要修改program的参C前，必须首先保要修改program的enabled状态ؓ(f)false?
那么对于已经处于enabled状态的programQ如何修改其状态属性呢Q其实很单，前面操作jobs时用的DBMS_SCHEDULER.DISABLEq程q记的吗Q没错，该过E对于program同样好Qƈ且调用方式也完全一P例如Q?
SQL> exec dbms_scheduler.disable(¨my_program1¨);
PL/SQL procedure successfully completed.另外Q如果希望将program|ؓ(f)enabled状态，执行DBMS_SCHEDULER.ENABLEq程卛_Q这里不再例举?
接下来，可以ؓ(f)刚刚创徏的my_program1d路径参数Q操作如下：(x)
SQL> BEGIN
2 DBMS_SCHEDULER.DEFINE_PROGRAM_ARGUMENT (
3 program_name => ¨my_program1¨,
4 argument_position => 1,
5 argument_name => ¨dirpath¨,
6 argument_type => ¨VARCHAR2¨,
7 default_value => ¨/home/oracle¨);
8 END;
9 /
PL/SQL procedure successfully completed.查询为program定义的参敎ͼ可以通过USER_SCHEDULER_PROGRAM_ARGS视图Q例如：(x)
SQL> select program_name,argument_name,argument_position,argument_type
2 default_value from user_scheduler_program_args;
PROGRAM_NAME ARGUMENT_NAME ARGUMENT_POSITION DEFAULT_VALUE
-------------------- -------------------- ----------------- --------------------
MY_PROGRAM1 DIRPATH 1 VARCHAR2删除program的argument操作也很单，使用DROP_PROGRAM_ARGUMENTq程卛_Q例如：(x)
SQL> exec dbms_scheduler.drop_program_argument(¨my_program1¨,¨dirpath¨);
PL/SQL procedure successfully completed.该过E第一个参数指定program名称Q第二个参数指定定义的argument名称Q当然此处也可以指定argument的位|，卛_例视图返回结果中?ARGUMENT_POSITION 列倹{?
要删除program的话更单了(jin)Q用DROP_PROGRAMq程卛_Q例如：(x)
SQL> exec dbms_scheduler.drop_program(¨my_program1¨);
PL/SQL procedure successfully completed.当然啦，删除program的同Ӟ也会(x)删除该program对应的所有arguments?
实际上SCHEDULER中创建jobӞ也可以指定执行外部的E序。SCHEDULER中的Job更像是之前版本承过来的JOBSQ只不过10g中SCHEDULER理的JOBS功能更加强大。Programs与Jobs不同的是QJobs是定义好的，定时执行的Q务，而Programs则是定义好的Q等待被执行的对象。那么Programs是由谁来执行呢，不要走开Q广告之后即全面揭晓?
]]>
1.2 理Jobs
1.2.1 启用Jobs
前面创徏JOBӞ׃未显式的指定ENABLED参数Q因此即使指定了(jin)START_DATEQ不q默认情况下JOB不会(x)自动执行。对于这U情况，DBMS_SCHEDULER包中提供?jin)一个过EENABLEQ可以用来修改JOB的启用状态，调用方式非常单，例如Q?
SQL> exec dbms_scheduler.enable(¨INSERT_TEST_TBL¨);
PL/SQL procedure successfully completed.1.2.2 用Jobs
DBMS_SCHEDULER.ENABLE 仅用来将JOB(其实不仅仅对JOB有效Q对于CHAIN、PROGRAM{也有效)的启用状态置为TRUE。如果想其启用状态置为FALSEQ简单，q有一个与该功能对应的q程QDBMS_SCHEDULER.DISABLEQ例如：(x)
SQL> exec dbms_scheduler.disable(¨INSERT_TEST_TBL¨);
PL/SQL procedure successfully completed.q两个过E仅用来重置对象的状态，因此均可以无限次执行Q即使执行时对象已经被置指定的状态?
1.2.3 修改Jobs
׃JOB的属性众多，隑օ时不时的可能?x)遇到需要修改的情况Q比如说前面创徏JOB时不心(j)Q指定要执行的过E名输入错误(完全有可能，CREATE_JOB在创建时不会(x)自动(g)查指定的q程是否有效Q从q方面考虑QSCHEDULER不如普通JOB严}?Q这U情况下必然涉?qing)到对JOB的修?或者说重定?Q没问题QDBMS_SCHEDULER包中专门提供?jin)一个过ESET_ATTRIBUTEQ可以用来修改Q务的属性倹{?
例如Q修改刚刚创建的JOBQINSERT_TEST_TBL执行的过E，执行语句如下Q?
SQL> exec dbms_scheduler.set_attribute(¨INSERT_TEST_TBL¨,¨JOB_ACTION¨,¨P_ INSERT INTOTEST¨);
PL/SQL procedure successfully completed当然啦，我们q里执行的这条语句，执行跟没执行没有区别Q此处仅做示例，大家表深I?
SET_ATTRIBUTE q程虽然仅有三个参数Q不q能够修改的属性值可是不，以下列D几个较常用到的：(x)
- LOGGING_LEVEL Q指定对jobs执行情况记录的日志信息别?
SCHEDULER 理的JOB对Q务的执行情况专门q行?jin)记录，同时用户q可以选择日志中记录信息的U别Q有下列三种选择Q?
- DBMS_SCHEDULER.LOGGING_OFF Q关闭日志记录功能；
- DBMS_SCHEDULER.LOGGING_RUNS Q对d的运行信息进行记录；
- DBMS_SCHEDULER.LOGGING_FULL Q记录Q务所有相关信息，不仅有Q务的q行情况Q甚臌d的创建、修改等也均记入日志?
提示Q查看SCHEDULER理的JOBQ可以通过USER_SCHEDULER_JOB_LOG和USER_SCHEDULER_JOB_RUN_DETAILS两个视图中查?
- RESTARTABLE Q指定jobsq行出错后，是否能够适时重启
创徏d时如未明指定，本参数默认情况下讄为FALSEQ如果设|ؓ(f)TRUEQ就表示当Q务运行时出错Q下ơ运行时间点到达时仍?x)启动，q且如果q行仍然出错Q会(x)l箋重新q行Q不q如果连接出错达?ơ，该job׃(x)停止?
- MAX_FAILURES Q指定jobs最大连l出错次?
该参数值可指定的范围从1-1000000Q默认情况下该参数设|ؓ(f)NULLQ表C无限制。达到指定出错次数后Q该job?x)被自动disable?
- MAX_RUNS Q指定jobs最大运行次?
该参数值可指定的范围从1-1000000Q默认情况下该参数设|ؓ(f)NULLQ表C无限制(只是q行ơ数无限Ӟ实际job?x)否l箋q行Q仍受制于end_date以及(qing)max_failures{参数的讄)。达到指定运行次数后Q该job也将被自动disableQƈ且状态会(x)被置为COMPLETED?
- JOB_TYPE Q指定job执行的Q务的cd
有四个可选|(x)¨PLSQL_BLOCK¨, ¨STORED_PROCEDURE¨, ¨EXECUTABLE¨, and ¨CHAIN¨?
- JOB_ACTION Q指定job执行的Q?
q一参数所指定的g赖于JOB_TYPE参数中的|比如说JOB_TYPE讄?#168;STORED_PROCEDURE¨Q那么本参数g指定的一定是ORACLE中的q程名?
- START_DATE Q指定job初次启动的时?
- END_DATE Q指定job停止q行的时?
本参数又与AUTO_DROP相关联，如果AUTO_DROP讄为TRUE的话Q那么一旦job到达停止q行的时_(d)该job׃(x)被自动删除，否则的话jobM存在Q不q状态被修改为COMPLETED?
除此之外Q其它还包括MAX_RUN_DURATIONQJOB_WEIGHTQINSTANCE_STICKINESSQSTOP_ON_WINDOW_CLOSEQJOB_PRIORITYQSCHEDULE_LIMITQPROGRAM_NAMEQNUMBER_OF_ARGUMENTSQSCHEDULE_NAMEQREPEAT_INTERVALQJOB_CLASSQCOMMENTSQAUTO_DROPQEVENT_SPECQRAISE_EVENTS{等Q这些参数所代表的意义此处不一一详述Q感兴趣的朋友可以查阅相兛_Ҏ(gu)档，或者等待本pd文章的外传，黑黑?
仅从q些可设|属性就可以看出QScheduler理的job实非常灉|Q上q提C(jin)q些参数Q均可以使用DBMS_SCHEDULER.SET_ATTRIBUTEq程q行讄?
另外需要注意一点，除了(jin)用户手动创徏的jobs之外Q数据库在运行过E中也有可能自动创徏jobs。对于这cjobs除非必要Q否则不q行修改。至于如何区分jobs是用户创建，q是数据库自动创建，可以通过*_SCHEDULER_JOBS视图的SYSTEM列来定Q如果该列显CZؓ(f)TRUEQ则表示ql创?
1.2.4 执行Jobs
虽然说jobs大多都应该是自动执行Q不q经q前面的CZQ大家想必也认识C(jin)Qƈ不是说创Z(jin)jobs它就?x)自动执行，是否能够真正自动执行q不是由你的主观意愿p直接军_Q而是由jobs自n的多个相兛_性决定?
关于jobs自动执行的话题相信看完前面的内容后，应该都知道如何设|，下面主要演示Q如何手动调用jobsq执行，q其中，当然不?jin)DBMS_SCHEDULER包。例如，手动执行前面刚刚创徏的job:INSERT_TEST_TBLQ?
SQL> exec dbms_scheduler.run_job(¨INSERT_TEST_TBL¨);
PL/SQL procedure successfully completedJobs 每执行一ơ，无论成功或失败，均会(x)?_SCHEDULER_JOB_LOG中生成一条对应的记录(前提是LOGGING_LEVEL属性值未讄为DBMS_SCHEDULER.LOGGING_OFF)Q同Ӟ用户也可以通过*_SCHEDULER_JOB_RUN_DETAILS视图查询job执行的详l信息?
1.2.5 停止Jobs
停止job可以使用DMBS_SCHEDULER.STOP_JOBq程Q例如：(x)
SQL> exec dbms_scheduler.stop_job(¨INSERT_TEST_TBL¨);
PL/SQL procedure successfully completed注意QSTOP_JOBq程不仅仅是更新job的状态，而是停止当前正在执行的Q务，如果你处理的d当前未在q行的话Q那么执行STOP_JOBq程Q会(x)触发ORA-27366错误?
停止Jobs也会(x)触发一条Q务的日志信息Q对于执行停止操作的jobQ其*_SCHEDULER_JOB_LOG视图的OPERATION?x)记录?f)¨STOPPED¨QADDITIONAL_INFO列中记录的信息类?#168;REASON="Stop job called by user: username"¨?
1.2.6 删除Jobs
删除创徏的job比较简单了(jin)Q直接执行DBMS_SCHEDULER.DROP_JOBq程卛_Q例如：(x)
SQL> exec dbms_scheduler.drop_job(¨INSERT_TEST_TBL¨);
PL/SQL procedure successfully completed删除jobsq不是修改该job中某个字D늚标记|而是直接删除其在数据字典中的字义Q因此被删除的job如果未来发现仍然需要，只能重徏Q而无法通过其它方式快速恢复。不q，删除jobs的操作，q不?x)联删除这些job曄执行q的日志信息?
]]>
所谓出于job而胜于jobQ说的就是Oracle 10g后的新特性Scheduler啦。在10g环境中，ORACLE使用Scheduler替换普通的jobQ来理d的执行。其实，Scheduler描述成管理job的工具已l太q片面了(jin)Q?0G版本中新增的Schedulerl不仅仅是创ZQ务这么简单。。。?
- 提示QORACLE中管理Scheduler是通过DBMS_SCHEDULER包，本章也以此ؓ(f)切入点，通过详细介绍DBMS_SCHEDULER包的使用Q来演示如何使用Scheduler。似乎本末倒置?jin)，没关p，"三?/a>W记"Q俺的地盘俺做主?
一、用Jobs
所谓JOBSQ其实就是Scheduler理的一?或多?d的执行调度?
1.1 创徏Jobs
通过DBMS_SCHEDULER包来创徏JobsQ是使用其CREATE_JOBq程。在创徏JobӞ用户可以指定要执行的dQ调度信?啥时候执行，执行周期Q终止日期等)以及(qing)其它一些Q务相关的属性。CREATE_JOBq程调用q是比较单的Q例如：(x)
另外加上与三思有点不?/span>
-- Create table
create table TEST
(
DATES DATE
)
CREATE OR REPLACE PROCEDURE IT
AS
BEGIN
insert into TEST VALUES(sysdate);
END;
SQL> BEGIN
2 DBMS_SCHEDULER.CREATE_JOB (
3 job_name => 'INSERT_TEST_TBL',
4 job_type => 'STORED_PROCEDURE',
5 job_action => 'SCOTT.IT', --与三思有所不同
6 start_date => sysdate,
7 repeat_interval => 'FREQ=DAILY;INTERVAL=10');
8 END;
9 /
PL/SQL q程已成功完成?事实上，有权限的话，用户也可以创建其它SCHEMA下的JOBQ只需要在指定JOB_NAMEӞ按照schema.job_name的格式即可。注意哟Q这U情况下创徏的JOBQ其CREATED与OWNER有可能ƈ不相同的哟?
当用CREATE_JOBq程创徏JOBӞ可指定的参数值很多，只不q多数情况下用户仅指定部分参数即可满需求?
其中Q上例中指定的参敎ͼ分别代表的含义如下：(x)
- JOB_NAME Q指定Q务的名称Q必选|注意要确保指定的名称唯一?
- JOB_TYPE QQ务执行的操作cdQ必选|有下列几个可选|(x)
- PLSQL_BLOCK Q表CZQ务执行的是一个PL/SQL匿名块?
- STORED_PROCEDURE Q表CZQ务执行的是ORACLEq程(含PL/SQL PROCEDURE和JAVA PROCEDURE)Q本例中正是指定q一参数倹{?
- EXECUTABLE Q表CZQ务执行的是一个外部程序，比如说操作系l命令?
- CHAIN Q表CZQ务执行的是一个CHAIN?
- JOB_ACTION QQ务执行的操作Q必选|应与JOB_TYPEcd中指定的参数相匹配?
比如说对于PL/SQL匿名块，此处可以放|PL/SQL块的具体代表Q类似DECLARE .. BEGIN ..ENDq类Q如果是ORACLEq程Q那么此处应该指定具体的q程名，注意׃d执行Q即使过E中有OUT之类参数Q实际执行时也不?x)有输出的?
- START_DATE Q指定Q务初ơ执行的旉Q本参数可ؓ(f)I，当ؓ(f)I时Q表CZQ务立L行，效果{同于指定该参数gؓ(f)SYSDATE?
- REPEAT_INTERVAL Q指定Q务执行的频率Q比如多长时间会(x)被触发再ơ执行。本参数也可以ؓ(f)I，如果为空的话Q就表示当前讑֮的Q务只执行一ơ。REPEAT_INTERVAL参数需要好好说_(d)因ؓ(f)q一参数与标准JOB中的INTERVAL参数有很大区别，相比之下QREPEAT_INTERVAL参数的语法结构要复杂的多。其中最重要的是FREQ和INTERVAL两个关键字?
- FREQ 关键字用来指定间隔的旉周期Q可选参数有QYEARLY, MONTHLY, WEEKLY, DAILY, HOURLY, MINUTELY, and SECONDLYQ分别表C年、月、周、日、时、分、秒{单位?
- INTERVAL 关键字用来指定间隔的频繁Q可指定的值的范围?-99?
例如QREPEAT_INTERVAL=>¨FREQ=DAILY;INTERVAL=1¨;表示每天执行一ơ，如果INTERVAL改ؓ(f)7pC每7天执行一ơ，效果{同于FREQ=WEEKLY;INTERVAL=1?
一般来_(d)使用DBMS_SCHEDULER.CREATE_JOB创徏一个JOBQ至需要指定上q参C的前3V除此之外，q可以在CREATE_JOBӞ指定下列参数Q?
- NUMBER_OF_ARGUMENTS Q指定该JOB执行旉要附带的参数的数量，默认gؓ(f)0Q注意当JOB_TYPE列gؓ(f)PLSQL_BLOCK或CHAINӞ本参数必设|ؓ(f)0Q因ZqCU情况下不支持附带参数?
- END_DATE Q指定Q务的q期旉Q默认gؓ(f)NULL。Q务过期后QQ务的STATE自动被修改为COMPLETEDQENABLED被置为FALSE。如果该参数讄为空的话Q表Cd怸q期Q将一直按照REPEAT_INTERVAL参数讄的周期重复执行，直到辑ֈ讄的MAX_RUNS或MAX_FAILURES倹{?
- JOB_CLASS Q指定Q务关联的CLASSQ默认gؓ(f)DEFAULT_JOB_CLASS。关于JOB CLASS的信息就x本系列的后箋文章?
- ENABLED Q指定Q务是否启用，默认gؓ(f)FALSE。FALSE状态表Cdq不?x)被执行Q除非被用户手动调用Q或者用户将该Q务的状态修改ؓ(f)TRUE?
- AUTO_DROP Q当该标志被|ؓ(f)TRUEӞORACLE?x)在满条g时自动删除创建的d
- d已过期；
- d最大运行次数已达MAX_RUNS的设||
- d未指定REPEAT_INTERVAL参数Q仅q行一ơ；
该参数的默认值即为TRUE。用户在执行CREATE_JOBq程时可以手动将该标志指定ؓ(f)FALSEQ当参数D|ؓ(f)FALSEӞ即满上述提到的条件Q务也不会(x)被自动删除，q种情况下，唯一能够Dd被删除的情况Q就是用户主动调用DROP_JOBq程?
- COMMENTS Q设|Q务的注释信息Q默认gؓ(f)NULL?
上面的例子创Z(jin)一个新的JOBQ不q这个JOB与普通JOB不同哟，此时查询USER_JOBS视图是查不到刚刚创徏的JOB的信息，因ؓ(f)q个JOB是SCHEDULER理的JOB。要查询SCHEDULER理的JOSQ应该通过USER_SCHEDULER_JOBS(当然ALL_SCHEDULER_JOBS和DBA_SCHEDULER_JOBS也可?Q例如：(x)
SQL> select job_name,job_type,job_action,to_char(start_date,¨yyyy-mm-dd hh24:mi:ss¨),repeat_interval,enabled,state from user_scheduler_jobs;
JOB_NAME JOB_TYPE JOB_ACTION TO_CHAR(START_DATE, REPEAT_INTERVAL ENABL STATE
-------------------- ---------------- ------------------------- ------------------- ------------------------------ ----- ---------------
INSERT_TEST_TBL STORED_PROCEDURE P_INSERTINTOTEST 2009-07-27 13:46:50 FREQ=DAILY;INTERVAL=1 FALSE DISABLED不过Q细?j)的盆友可能会(x)发玎ͼJOB虽然成功创徏?jin)，但却q未执行Q这是怎么回事Q其实原因很单，q记的前面介lCREATE_JOBq程时提到的ENABLED参数吗，当不昑ּ指定Ӟ该参数的默认gؓ(f)falseQJOB自然不会(x)q行?jin)。如果遇到这cL形，如何修改呢？L(fng)l关注下一节?
]]>
W?0?-V$WAITSTAT 2007.6.15
本视图保持自实例启动所有的{待事gl计信息。常用于当你发现pȝ存在大量?buffer busy waits"时据此做出适当调整?/p>
V$WAITSTAT中的常用?/strong> {待发生的原因：(x)
CLASSQ块cd
WAITSQ本cd的等待次?br />
TIMEQ本cd的ȝ待时?/p>
1.undoD头部：(x)没有_的回滚段
2.数据D头?数据D늩闲列Q空闲列争夺
3.数据块冲H?br />
4.~存存在大量的CR复制
5.range(g)索时Q烦(ch)引列存在大量不连l?br />
6.全表(g)索的表有大量被删除记?br />
7.高ƈ发的d?/p>
本视囄控当前实例中undoI间以及(qing)事务如何q行。ƈl计undoI间开销Q事务开销以及(qing)实例可用的查询长度?/p>
V$UNDOSTAT中的常用?/strong>
EndtimeQ以10分钟为间隔的l束旉
UndoBlocksUsedQ用的undo块L
TxnConcurrencyQ事务ƈ发执行的最大数
TxnTotalQ在旉D内事务执行L
QueryLengthQ查询长度的最大?br />
ExtentsStolenQ在旉D内undo区必M一个undoD{到另一个的ơ数
SSTooOldErrorQ在旉D内'Snapshot Too Old'错误发生的次?br />
UNDOTSNQ这D|间内最后活动的undo表空间ID
视图的第一行显CZ(jin)当前旉D늚l计Q其它的每一条记录分别以?0分钟一个区间?4时循环Q一天最?44条记录?/p>
CZQ?/strong>
1.本例昄undoI间?6:27C?4时内的各项l计?br />
SQL>select * from v$undostat;
End-Time UndoBlocks TxnConcrcy TxnTotal QueryLen ExtentsStolen SSTooOldError
-------- ---------- ---------- -------- -------- ------------- -------------
16:07 252 15 1511 25 2 0
16:00 752 16 1467 150 0 0
15:50 873 21 1954 45 4 0
15:40 1187 45 3210 633 20 1
15:30 1120 28 2498 1202 5 0
15:20 882 22 2002 55 0 0
在统计项攉q程中，undo消耗最高发生在15:30-15:40q个旉Dc(din)?0分钟内有1187个undo块被占用(基本上每U钟2个块)。同Ӟ最高事务ƈ发也是在相同的时间段Q?5个事务被q发执行。执行的最长查?1202U?是在15:20-15:30之间Q需要注意的是查询实际上?5:00-15:10D即开始ƈ直到15:20q个旉Dc(din)?/p>
本视图概括了(jin)实例各项事g的等待信息。v$session_wait昄?jin)系l的当前{待，v$system_event则提供了(jin)自实例启动后各个{待事g的概括。常用于获取pȝ{待信息的历史媄(jing)象。而通过两个snapshot获取{待增量，则可以确定这D|间内pȝ的等待项?/p>
V$SYSTEM_EVENT中的常用?/strong> CZQ?/strong> 比如Q通过checkpoint completed、log file switchQcheckpoint incompleteQ可以查看检查点q程的性能。通过log file parallel write、log file switch completed可以查看联机重做日志文g的性能。通过log file switchQarchiving neededQ事件可以检查归档进E的性能?/p>
扑և瓉Q?/strong>
EVENT:{待事g名称
TOTAL_WAITSQ此事件ȝ待次?br />
TIME_WAITEDQ此事件的ȝ待时?单位Q百分之一U?
AVERAGE_WAITQ此事件的q_{待用时(单位Q百分之一U?(time_waited/total_waits)
TOTAL_TIMEOUTSQ此事情ȝ待超时次?/p>
1.查看pȝ的各等待，按总耗时排序
SELECT event,total_waits waits,total_timeouts timeouts,
time_waited total_time,average_wait avg
FROM V$SYSTEM_EVENT
ORDER BY 4 DESC;
1。通过Statspack列出I闲事g?br />
2。检查不同事件的{待旉开销?br />
3。检查每条等待记录的q_用时Q因为某些等待事?比较log file switch completion)可能周期性地发生Q但发生时却造成?jin)严重的性能损耗?/p>
]]>
本视囑֮时监控段U?segment-level)l计，支持oracle9ir2?qing)更高版?/p>
V$SEGSTAT中的常用?/strong> V$SEGSTAT中的q接?/strong> CZQ?/strong>
W?7?(2)-V$SEGMENT_STATISTICS q是一个友好的视图Q支持Oracle9ir2?qing)更高版本。实时监段U?segment-level)l计，可用于鉴定性能问题源于表或索引 V$SEGMENT_STATISTICS中的?/strong>
TS#Q表I间标识
OBJ#Q字典对象标?br />
DATAOBJ#Q数据对象标?br />
STATISTIC_NAMEQ统计项名称
STATISTIC#Q统计项标识
VALUEQ统计项?/p>
Column View Joined Column(s)
-------------- ----------------------- ------------------------
TS# V$TABLESPACE TS#
OBJ# ALL_OBJECTS OBJECT_ID
查询指定对象的统?br />
select * from v$segstat where ts# = 11
and obj# = (select object_id from user_objects
where object_name = 'TMPTABLE1' and owner = 'JSS')
OWNERQ对象所有?br />
OBJECT_NAMEQ对象名U?br />
SUBOBJECT_NAMEQ子对象名称
TABLESPACE_NAMEQ对象所在表I间
TS#Q表I间标识
OBJ#Q字典对象标?br />
DATAOBJ#Q数据对象标?br />
OBJECT_TYPEQ对象类?br />
STATISTIC_NAMEQ统计项名称
STATISTIC#Q统计项标识
VALUEQ统计项?/p>
基本与上相同Q只是信息更加详l，不再赘述?/p>
本视图显C数据字典缓?也叫rowcache)的各统计。每一条记录包含不同类型的数据字典~存数据l计Q注意数据字典缓存有层次差别Q因此同L(fng)~存名称可能不止一ơ出现?/p>
V$ROWCACHE常用?/strong>
PARAMETERQ缓存名
COUNTQ缓存项L
USAGEQ包含有效数据的~存Ҏ(gu)
GETSQ请求L
GETMISSESQ请求失败数
SCANSQ扫描请求数
SCANMISSESQ扫描请求失败次?br />
MODIFICATIONSQ添加、修攏V删除操作数
DLM_REQUESTSQDLMh?br />
DLM_CONFLICTSQDLM冲突?br />
DLM_RELEASESQDLM释放?br />
使用V$ROWCACHE数据
1>.认数据字典~存是否拥有适当的大。如果shared poolq小Q那数据字典~存׃以拥有合适的大小以缓存请求信息?br /> 2>.认应用是否有效讉K~存。如果应用设计未能有效用数据字典缓?比如Q大数据字典~存q不有助于解x能问题)。例如，DC_USERS~存在过LD|期内出现大量GETSQ看h像是数据库中创徏?jin)大量的不同用户Qƈ且应用记录下用户频繁登陆和注销。通过(g)查logon比率以及(qing)pȝ用户数可以验证上q数据。同时解析比率也?x)很高，如果q是一个大型的OLTPpȝ的中间层Q它可能在中间层更有效的理个别帐户Q允怸间层以单用户登陆成ؓ(f)应用所有者。通过保持zdq接来减logon/logoff比率也同h效?br /> 3>.认是否发生动态空间分配。DC_SEGMENTS, DC_USED_EXTENTS, 以及(qing)DC_FREE_EXTENTS大量的类似大修改将指出存在大量动态空间分配。可行的解决Ҏ(gu)包括指定下一个区大小或者用本地管理表I间。如果发生空间分配的是(f)时的表空_(d)则可以ؓ(f)其指定真正的临时表空?If the space allocation is occurring on the temp tablespace, then use a true temporary tablespace for the temp. )?br /> 4>.dc_sequences值的变化指出是否大量sequenceh在生?br /> 5>.搜集解析的证据。硬解析常表Cؓ(f)大量向DC_COLUMNS, DC_VIEWS 以及(qing) DC_OBJECTS caches的gets?/p>
CZQ?/strong>
1.分组l计数据字典l计?br />
SELECT parameter,sum("COUNT"),sum(usage),sum(gets),sum(getmisses),
sum(scans),sum(scanmisses),sum(modifications),
sum(dlm_requests),sum(dlm_conflicts),sum(dlm_releases)
FROM V$ROWCACHE
GROUP BY parameter;
2.(g)查数据字典的命中?br /> select 1 - sum(getmisses) / sum(gets) "data dictionary hitratio" from v$rowcache;
]]>
本视图自启动即保持ƈ记录各回滚段l计V?/p>
V$ROLLSTAT中的常用?/strong>
USNQ回滚段标识
RSSIZEQ回滚段默认大小
XACTSQ活动事务数
在一D|间内增量用到的列
WRITESQ回滚段写入?单位:bytes)
SHRINKSQ回滚段收羃ơ数
EXTENDSQ回滚段扩展ơ数
WRAPSQ回滚段{(wrap)ơ数
GETSQ获取回滚段头次?br />
WAITSQ回滚段头等待次?/p>
V$ROLLSTAT中的q接?/strong>
Column View Joined Column(s)
-------------- ----------------------- ------------------------
USN V$ROLLNAME USN
注意Q?/strong> CZQ?/strong> 查看回滚D늚l计信息Q?br />
SELECT n.name, s.extents, s.rssize, s.optsize, s.hwmsize, s.xacts, s.status 3.查看回滚D늚使用情况Q哪个用h在用回滚段的资?
通过p旉除以{ơ数Q你可以得到一ơ回滚段{(wrap)的^均用时。此Ҏ(gu)常用于在长查询中指定合适的回滚D大以避免'Snapshot Too Old'错误。同Ӟ通过查看extends和shrinks列可以看出optimal是否需要增加?/p>
1.查询回滚D늚信息。所用数据字典：(x)DBA_ROLLBACK_SEGSQ可以查询的信息Q回滚段的标?SEGMENT_ID)、名U?SEGMENT_NAME)、所在表I间(TABLESPACE_NAME)、类?OWNER)、状?STATUS)?
select * from DBA_ROLLBACK_SEGS
FROM v$rollname n, v$rollstat s
WHERE n.usn = s.usn;
select s.username, u.name
from v$transaction t, v$rollstat r, v$rollname u, v$session s
where s.taddr = t.addr
and t.xidusn = r.usn
and r.usn = u.usn
order by s.username;
]]>
q两个视囑ֈ出的各参数项名称以及(qing)参数倹{V$PARAMETER昄执行查询的session的参数倹{V$SYSTEM_PARAMETER视图则列出实例的参数倹{?/p>
例如Q下列查询显C执行查询的session的SORT_AREA_SIZE参数|(x)
SELECT value
FROM V$PARAMETER
WHERE name = 'sort_area_size';
呵呵Q可能有朋友q是不明白v$parameter和v$system_parameter的区别，我再举个例子Q相信你马上明白了(jin)?br />
SQL>select value from v$parameter where name = 'global_names';
VALUE
------------------------------------------------------------------------------------------------
TRUE
1 row selected.
SQL> alter session set global_names = false;
Session altered.
SQL> select value from v$parameter where name = 'global_names';
VALUE
------------------------------------------------------------------------------------------------
FALSE
1 row selected.
SQL> select value from v$system_parameter where name = 'global_names';
VALUE
------------------------------------------------------------------------------------------------
TRUE
1 row selected.
V$PARAMETER中的常用列：(x)
NAMEQ参?br />
VALUEQ参?session或实?
ISDEFAULTQ参值是否默认?br />
ISSES_MODIFIABLEQ此参数是否sessionU可修改
ISSYS_MODIFIABLEQ此参数在实例启动后是否可由实例修改
ISMODIFIEDQ自实例启动P参值是否被修改Q如果被修改QsessionU或是实?pȝ)U修?如果执行一条alter session,则值将被MODIFIEDQ如果执行的是alter systemQ则gؓ(f)SYS_MODIFIED)
ISADJUSTEDQ?br />
DESCRIPTIONQ参数简要描q?br />
UPDATE_COMMENTQ由dba提供的参数说?/p>
使用v$parameter以及(qing)v$system_parameter数据Q?/strong>
在调优期间通过查询v$parameter以确认当前参数设|。例如，如果buffer cache hit ratio较低Q那么通过查询DB_BLOCK_BUFFERS(或DB_CACHE_SIZE)可以明确当前的buffer cache大小?/p>
SELECT name, value, isdefault, isses_modifiable, issys_modifiable, ismodified
FROM V$PARAMETER
WHERE name = 'sort_area_size';
NAME VALUE ISDEF ISSES ISSYS_MOD ISMODIFIED
-------------------- ---------- ----- ----- --------- ----------
sort_area_size 1048576 TRUE TRUE DEFERRED MODIFIED
前例昄?jin)SORT_AREA_SIZE初始参数在实例启动时q初始|不过被session修改回了(jin)初始倹{?br />
注意Q当查询v$parameter时要注意Q如果你x看实例参敎ͼ要查询v$system_parameter?/p>
本视囑ֈ出session打开的所有cursorsQ很多时候都被用到Q比如：(x)你可以通过它查看各个session打开的cursor数?/p>
当诊断系l资源占用时Q它常被用于联接v$sqlarea和v$sql查询出特定SQL(高逻辑或物理I/O)。然后，下一步就是找出源头。在应用环境Q基本都是同一cȝL(fng)陆到数据?在V$SQLAREA中拥有相同的PARSING_USER_ID)Q而通过q个可以找出它们的不同。V$SQLAREA中的l计在语句完全执行后被更新(q且从V$SESSION.SQL_HASH_VALUE中消?。因此，你不能直接找到session除非语句被再ơ执行。不q如果session的cursor仍然打开着Q你可以通过v$open_cursor扑և执行q个语句的session?/p>
V$OPEN_CURSOR中的q接?/strong>
Column View Joined Column(s)
----------------------------- ---------------------------------------- -----------------------------
HASH_VALUE, ADDRESS V$SQLAREA, V$SQL, V$SQLTEXT HASH_VALUE, ADDRESS
SID V$SESSION SID
CZQ?/strong>
1.扑և执行某语句的sessionQ?br />
SELECT hash_value, buffer_gets, disk_reads
FROM V$SQLAREA
WHERE disk_reads > 1000000
ORDER BY buffer_gets DESC;
HASH_VALUE BUFFER_GETS DISK_READS
---------- ----------- ----------
1514306888 177649108 3897402
478652562 63168944 2532721
360282550 14158750 2482065
3 rows selected.
SQL> SELECT sid FROM V$SESSION WHERE sql_hash_value = 1514306888 ;
no rows selected
--直接通过hash_value查找v$sessionQ没有记?/p>
SQL> SELECT sid FROM V$OPEN_CURSOR WHERE hash_Value = 1514306888 ;
SID
-----
1125
233
935
1693
531
5 rows selected.
--通过hash_value在v$open_cursor中查找sid(只有在session的cursor仍然打开的情况下才有可能扑ֈ)
2.列出拥有过400个cursor的sessionID
SQL> SELECT sid, count(0) ct FROM v$open_cursor
GROUP BY sid HAVING COUNT(0) > 400 ORDER BY ct desc;
事实上，v$open_cursor是一个相当常用的视图Q特别是web开发应用的时候。仅通过它一个视图你p分析出当前的q接情况Q主要执行语句等?/p>
本视图提供对象在library cache(shared pool)中对象统计，提供比v$librarycache更多的细节，q且常用于找出shared pool中的zd对象?/p>
v$db_object_cache中的常用列：(x)OWNERQ对象拥有?br />
NAMEQ对象名U?br />
TYPEQ对象类?如，sequence,procedure,function,package,package body,trigger)
KEPTQ告知是否对象常驻shared pool(yes/no)Q有赖于q个对象是否已经利用PL/SQL q程DBMS_SHARED_POOL.KEEP“保持”Q永久固定在内存中）(j)
SHARABLE_MEMQ共享内存占?br />
PINSQ当前执行对象的session?br />
LOCKSQ当前锁定对象的session?/p>
瞬间状态列Q?/strong> CZQ?/strong> 2.通过载入ơ数扑և对象 扑և使用的内存超q?0Mq且不在帔R内存的对象?br />
SELECT owner, name, sharable_mem, kept
下列列保持对象自初次加蝲L(fng)l计信息Q?br />
LOADSQ对象被加蝲ơ数?/p>
1.shared pool执行以及(qing)内存使用总计
下列查询昄出shared pool内存对不同类别的对象
同时也显C是否有对象通过DBMS_SHARED_POOL.KEEP()q程帔Rshared pool?br />
SELECT type, kept, COUNT(*), SUM(sharable_mem)
FROM V$DB_OBJECT_CACHE
GROUP BY type, kept;
SELECT owner, name sharable_mem, kept, loads
FROM V$DB_OBJECT_CACHE
WHERE loads > 1 ORDER BY loads DESC;
FROM V$DB_OBJECT_CACHE
WHERE sharable_mem > 102400 AND kept = 'NO'
ORDER BY sharable_mem DESC;
]]>
Oracle Rdbms应用?jin)各U不同类型的锁定机制Qlatchx其中的一U。Latch是用于保护SGAZ׃n数据l构的一U串行化锁定机制。Latch的实现是与操作系l相关的Q尤其和一个进E是否需要等待一个latch、需要等待多长时间有兟뀂Latch是一U能够极快地被获取和释放的锁Q它通常用于保护描述buffer cache中block的数据结构。与每个latch相联pȝq有一个清除过E，当持有latch的进E成为死q程Ӟ该清除过E就?x)被调用。Latchq具有相关别，用于防止死锁Q一旦一个进E在某个U别上得C个latchQ它?yu)׃可能再获得等同或低于该别的latch?
本视图保存自实例启动各类栓锁的统计信息。常用于当v$session_wait中发现栓锁竞争时鉴别SGAZ问题所在区域?/p>
v$latch表的每一行包括了(jin)对不同类型latch的统计，每一列反映了(jin)不同cd的latchh的活动情c(din)不同类型的latchh之间的区别在于，当latch不可立即获得Ӟhq程是否l箋q行。按此分c，latchh的类型可分ؓ(f)两类Qwilling-to-wait和immediate?/p>
Willing-to-waitQ是指如果所h的latch不能立即得到Q请求进E将{待一很短的时间后再次发出h。进E一直重复此q程直到得到l(f)atch?
ImmediateQ是指如果所h的latch不能立即得到Q请求进E就不再{待Q而是l箋执行下去?
V$LATCH中的常用列：(x)
NAMEQlatch名称
IMMEDIATE_GETSQ以Immediate模式latchh?br />
IMMEDIATE_MISSESQ请求失败数
GETSQ以Willing to waith模式latch的请求数
MISSESQ初ơ尝试请求不成功ơ数
SPIN_GETSQ第一ơ尝试失败，但在以后的轮ơ中成功
SLEEP[x]Q成功获取前sleepingơ数
WAIT_TIMEQ花费在{待latch的时?/p>
V$LATCH中的q接?/strong>
Column View Joined Column(s)
--------------------- ------------------------------ ------------------------
NAME/LATCH# V$LATCH_CHILDREN NAME/LATCH#
NAME V$LATCHHOLDER NAME
NAME/LATCH# V$LATCHNAME NAME/LATCH#
NAME V$LATCH_MISSES PARENT_NAME
CZQ?/strong>下列的示例中Q创Z个表存储查询自v$latch的数据：(x)
CREATE TABLE snap_latch as SELECT 0 snap_id, sysdate snap_date, a.* FROM V$LATCH a;
ALTER TABLE snap_latch add (constraint snap_filestat primary key (snap_id, name));
最初，snap_id被置?Q稍后，snap_latch表的snap_id列被更新?Q?br />
INSERT INTO snap_latch SELECT 1, sysdate, a.* FROM V$LATCH a;
注意你通过sql语句插入记录时必d加snap_id的倹{?/p>
在你q箋插入记录之后Q用下列的select语句列出l计。注?不能成ؓ(f)被除数?/p>
SELECT SUBSTR(a.name,1,20) NAME, (a.gets-b.gets)/1000 "Gets(K)",
(a.gets-b.gets)/(86400*(a.snap_date-b.snap_date)) "Get/s",
DECODE ((a.gets-b.gets), 0, 0, (100*(a.misses-b.misses)/(a.gets-b.gets))) MISS,
DECODE ((a.misses-b.misses), 0, 0,
(100*(a.spin_gets-b.spin_gets)/(a.misses-b.misses))) SPIN,
(a.immediate_gets-b.immediate_gets)/1000 "Iget(K)",
(a.immediate_gets-b.immediate_gets)/ (86400*(a.snap_date-b.snap_date)) "IGet/s",
DECODE ((a.immediate_gets-b.immediate_gets), 0, 0,
(100*(a.immediate_misses-b.immediate_misses)/ (a.immediate_gets-b.immediate_gets)))
IMISS
FROM snap_latch a, snap_latch b
WHERE a.name = b.name
AND a.snap_id = b.snap_id + 1
AND ( (a.misses-b.misses) > 0.001*(a.gets-b.gets)
or (a.immediate_misses-b.immediate_misses) >
0.001*(a.immediate_gets-b.immediate_gets))
ORDER BY 2 DESC;
下例列出latchl计，miss列小?.1%的记录已l被qo(h)?br />
NAME Gets(K) Get/s MISS SPIN IGets(K) IGet/s IMISS
------------------ -------- ------- ----- ------ -------- ------- -----
cache buffers chai 255,272 69,938 0.4 99.9 3,902 1,069 0.0
library cache 229,405 62,851 9.1 96.9 51,653 14,151 3.7
shared pool 24,206 6,632 14.1 72.1 0 0 0.0
latch wait list 1,828 501 0.4 99.9 1,836 503 0.5
row cache objects 1,703 467 0.7 98.9 1,509 413 0.2
redo allocation 984 270 0.2 99.7 0 0 0.0
messages 116 32 0.2 100.0 0 0 0.0
cache buffers lru 91 25 0.3 99.0 7,214 1,976 0.3
modify parameter v 2 0 0.1 100.0 0 0 0.0
redo copy 0 0 92.3 99.3 1,460 400 0.0
什么时候需要检查latchl计呢？看下列项Q?/p>
misses/gets的比率是多少
莯spinning的misses的百分比是多?br />
latchh?jin)多?br />
latch休眠?jin)多?/p>
Redo copy latch看v来有很高的的p率，高达92.3%。不q，我们再仔l看的话QRedo copy latches是获自immediate模式。immediate模式的数值看hq不错，q且immediate模式只有个别数大于willing to wait模式。所以Redo copy latch其实q不存在竞争。不q，看v来shared pool和library cache latches可能存在竞争。考虑执行一条查询检查latches的sleeps以确认是否确实存在问题?/p>
latch?0余种Q但作ؓ(f)DBA兛_(j)的主要应有以下几U：(x)
Cache buffers chains latchQ当用户q程搜烦(ch)SGALdatabase cache buffers旉要用此latch?br />
Cache buffers LRU chain latchQ当用户q程要搜索buffer cache中包括所?dirty blocks的LRU (least recently used) 链时使用该种latch?
Redo log buffer latchQ这Ulatch控制redo log buffer中每条redo entries的空间分配?
Row cache objects latchQ当用户q程讉K~存的数据字典数值时Q将使用Row cache objects latch?
Latches调优
不要调整latches。如果你发现l(f)atch存在竞争Q它可能是部分SGA资源使用反常的征兆。要修正问题所在，你更多的是去(g)查那部分SGA资源使用的竞争情c(din)仅仅从v$latch是无法定位问题所在的?/p>
关于latches的更多信息可以浏览Oracle Database Concepts?/p>
W十一?(2)-V$LATCH_CHILDREN
数据库中有些cd的latches拥有多个。V$LATCH中提供了(jin)每个cd的总计信息。如果想看到单个latchQ你可以通过查询本视图?/p>
例如Q?br /> select name,count(*) ct from v$Latch_children group by name order by ct desc;
与v$latch相比Q除多child#列外Q其余列与之同，不详q~~
]]>
本视图显C行超q?U的操作的状态。包括备份，恢复Q统计信息收集，查询{等?/p>
要监控查询执行进展状况，你必M用cost-based优化方式Qƈ且：(x)
讄TIMED_STATISTICS或SQL_TRACE参数gؓ(f)true?br />
通过ANALYZE或DBMS_STATS数据包收集对象统计信息?/p>
你可以通过DBMS_APPLICATION_INFO.SET_SESSION_LONGOPSq程dapplication-specific长运行操作信息到本视图。关于DBMS_APPLICATION_INFO.SET_SESSION_LONGOPS的更多信息可以浏览：(x)Oracle Supplied PL/SQL Packages and Types Reference?/p>
V$SESSION_LONGOPS列说?/strong>
SIDQSession标识
SERIAL#QSession串号
OPNAMEQ操作简要说?br />
TARGETQ操作运行所在的对象
TARGET_DESCQ目标对象说?br />
SOFARQ至今ؓ(f)止完成的工作?br />
TOTALWORKQd作量
UNITSQ工作量单位
START_TIMEQ操作开始时?br />
LAST_UPDATE_TIMEQ统计项最后更新时?br />
TIME_REMAININGQ预计完成操作的剩余旉(U?
ELAPSED_SECONDSQ从操作开始总花Ҏ(gu)?U?
CONTEXTQ前后关p?br />
MESSAGEQ统计项的完整描q?br />
USERNAMEQ执行操作的用户ID
SQL_ADDRESSQ用于连接查询的?br />
SQL_HASH_VALUEQ用于连接查询的?br />
QCSIDQ?/p>
CZQ?/strong>
找一较大表，认该表查询超q?U，哎呀让它快咱没把握，让它慢这可是我的强项啊~~
SQL> set timing on
SQL> create table ttt as select level lv,rownum rn from dual connect by level<10000000; --创徏一个(f)时表
Table created
Executed in 19.5 seconds
SQL> commit;
Commit complete
Executed in 0 seconds
SQL> select * from (select * from ttt order by lv desc) where rownum<2; --执行一个费时的查询
LV RN
---------- ----------
9999999 9999999
Executed in 9.766 seconds --哈哈Q成功超q?U?br />
SQL> select sid,opname,sofar,totalwork,units,sql_hash_value from v$session_longops; ----看看v$session_longops中是不是已经有记录了(jin)
SID OPNAME SOFAR TOTALWORK UNITS SQL_HASH_VALUE
---------- ---------------------------------------------------------------- ---------- ---------- -------------------------------- --------------
10 Table Scan 47276 47276 Blocks 2583310173
Executed in 0.047 seconds
SQL> select a.sql_text from v$sqlarea a,v$session_longops b where a.HASH_VALUE=b.SQL_HASH_VALUE; --通过hash_value联系查询出刚执行的查询语句?br />
SQL_TEXT
--------------------------------------------------------------------------------
select * from (select * from ttt order by lv desc) where rownum<2
Executed in 0.063 seconds
]]>
本视图记录各文g物理I/O信息。如果瓶颈与I/O相关Q可用于分析发生的活动I/O事g。V$FILESTAT昄出数据库I/O的下列信?不包括日志文?Q?/p>
物理d?br />
块读写数
I/Od总耗时
以上数D实例启动卛_始记录。如果获取了(jin)两个快照Q那么二者之间的差异xq一旉D内zdI/Ol计?/p>
V$FILESTAT中的常用列：(x)
FILE#Q文件序P
PHYRDSQ已完成的物理读ơ数Q?br />
PHYBLKRDQ块d敎ͼ
PHYWRTSQDBWR完成的物理写ơ数Q?br />
PHYBLKWRTQ写入磁盘的块数Q?/p>
V$FILESTAT注意：(x)
因ؓ(f)multiblock读调用，物理L和数据块L有可能不同；
因ؓ(f)q程直写Q物理写和数据块写也可能不一_(d)
Sum(physical blocks read) q似于v$sysstat中的physical readsQ?br />
Sum(physical blocks written) q似于v$sysstat中的physical writesQ?br />
数据?q存读比直d)由服务进E处理。从buffer cache写只能由DBWRq行Q直写由服务q程处理?/p>
V$FILESTAT中的q接?/strong>
Column View Joined Column(s)
----------- ------------------------- -------------------------
FILE# DBA_DATA_FILES FILE_ID
FILE# V$DATAFILE FILE#
CZQ?/strong>
获得数据文g物理d和数据块d信息Q?br />
select df.tablespace_name name,
df.file_name "file",
f.phyrds pyr,
f.phyblkrd pbr,
f.phywrts pyw,
f.phyblkwrt pbw
from v$filestat f, dba_data_files df where f.file# = df.file_id
order by df.tablespace_name;
注意Q尽oracle记录的读写次数非常精，但如果数据库q行在Unix文gpȝ(UFS)有可能不能表现真实的盘dQ例如，L数可能ƈ非真实的盘读，而是UFS~存。不q裸讑֤的读写次数应该是比较_և的?/p>
]]>
本视囑ֈ出系l上的每个事务处理所获得的所有锁?/p>
V$LOCKED_OBJECT中的列说明：(x)
XIDUSNQ回滚段?br />
XIDSLOTQ槽?br />
XIDSQNQ序列号
OBJECT_IDQ被锁对象ID
SESSION_IDQ持有锁的sessionID
ORACLE_USERNAMEQ持有锁的Oracle 用户?br />
OS_USER_NAMEQ持有锁的操作系l?用户?br />
PROCESSQ操作系l进E号
LOCKED_MODEQ锁模式Q值同上表1
CZQ?/strong>1.以DBA角色, 查看当前数据库里锁的情况可以用如下SQL语句Q?br /> select object_id,session_id,locked_mode from v$locked_object;
select t2.username, t2.sid, t2.serial#, t2.logon_time
from v$locked_object t1, v$session t2
where t1.session_id = t2.sid order by t2.logon_time;
如果有长期出现的一列，可能是没有释攄锁。我们可以用下面SQL语句杀掉长期没有释N正常的锁Q?/p>
alter system kill session 'sid,serial#';
]]>
Column View Joined Column(s)
SID V$SESSION SID
ID1, ID2, TYPE V$LOCK ID1, ID2, TYPE
ID1 DBA_OBJECTS OBJECT_ID
TRUNCID1/65536) V$ROLLNAME USN
如果session在等待锁Q这可被用于扑ևsession持有的锁Q?br />
可被用于扑ևDML锁类型的被锁对象(type='TM')
可被用于扑և行事务?TYPE='TX')使用中的回滚D，不过Q需要通过V$TRANSACTIONq接查询得到?/p>
? Oracle的TM锁类?
锁模?锁描q?解释 SQL操作
0 none
1 NULL I?Select
2 SS(Row-S) 行׃n锁，其他对象只能查询q些数据?Select for update、Lock for update、Lock row share
3 SX(Row-X) 行排它锁，在提交前不允许做DML操作 Insert、Update、Delete、Lock row share
4 S(Share) ׃n?Create index、Lock share
5 SSX(S/Row-X) ׃n行排它?Lock share row exclusive
6 X(Exclusive) 排它?Alter table、Drop able、Drop index、Truncate table 、Lock exclusive
数字大锁别越? 影响的操作越多。一般的查询语句如select ... from ... ;是小?的锁, 有时?x)在v$locked_object出现。select ... from ... for update; ?的锁?/p>
当对话用for update子串打开一个游标时Q所有返回集中的数据行都处于行U?Row-X)独占式锁定，其他对象只能查询q些数据行，不能q行update、delete或select...for update操作。insert / update / delete ... ; ?的锁?
没有commit之前插入同样的一条记录会(x)没有反应, 因ؓ(f)后一?的锁?x)一直等待上一?的锁, 我们必须释放掉上一个才能l工作?/p>
创徏索引的时候也?x)?,4U别的锁。locked_mode?,3,4不媄(jing)响DML(insert,delete,update,select)操作, 但DDL(alter,drop{?操作?x)提Cora-00054错误。有d键约束时 update / delete ... ; 可能?x)?,5的锁。DDL语句时是6的锁?/p>
如果出现?jin)锁的问? 某个DML操作可能{待很久没有反应。当你采用的是直接连接数据库的方式，也不要用OSpȝ命o(h) $kill process_num 或?$kill -9 process_num来终止用戯接，因ؓ(f)一个用戯E可能生一个以上的? 杀OSq程q不能彻底清除锁的问题。记得在数据库别用alter system kill session 'sid,serial#';杀掉不正常的锁?/p>
CZQ?/strong> q一节是我在自整理v$pd视图以来p旉和精力最多的一个，我反复看?jin)documentQ又从网上搜索了(jin)各种资料实际使用案例{，是不开H。这一节至今我也仍未有把握说尽在掌握，所以在上述文字中除?jin)例子，我如实?chung)Z(jin)攉来的内容Q未加Q何自我理解，是担心(j)万一我的理解有误Q会(x)对其它浏览本文的人造成困扰。同时我把在攉q程中自我感觉对理解v$lock可能有帮助的资料地址列出Q供有心(j)人参考：(x) Oracle数据库中的锁机制研究 DB2?Oracle的ƈ发控Ӟ锁）(j)比较 Itpub论坛的oracle专题深入讨论Z有一非常精彩的讨论Q地址如下Q?br />
我对ORACLE数据锁的一点体?br />
http://www.itpub.net/270059.html
我按照自q理解演示的TX,TM锁如下：(x)
1.create table TMP1(col1 VARCHAR2(50));--创徏临时?br />
2.select * from v$lock;--x当前锁信?br />
3.select * from tmp1 for update; --加锁
4.select * from v$lock; ---看看现在的锁列表Q是不是多了(jin)两条记录。Type分别为tx,tmQ对照表1?br />
5.新开一个连接，然后
select * from tmp1 for update; --呵呵Q等待状态了(jin)?br />
6.select * from v$lock; --又新增了(jin)两条记录Q其它一条type=tx,lmode=0
7.查看当前被锁的session正在执行的sql语句
select /*+ NO_MERGE(a) NO_MERGE(b) NO_MERGE(c) */ a.username, a.machine, a.sid, a.serial#, a.last_call_et "Seconds", b.id1, c.sql_text "SQL"
from v$session a, v$lock b, v$sqltext c
where a.username is not null and a.lockwait = b.kaddr and c.hash_value =a.sql_hash_value
8.之前的for update语句commit或者rollbackQ然后新开q接的session拥有锁。有兴趣的朋友还可以试试两条for update的时候，关闭先执行的那个H口Q看看oracle?x)给Z么样的响应?/p>
http://soft.zdnet.com.cn/software_zone/2007/0208/377403.shtml
http://www.ibm.com/developerworks/cn/db2/library/techarticles/dm-0512niuxzh/
]]>
本视囑ֈ出Oracle 服务器当前拥有的锁以?qing)未完成的锁或栓锁请求。如果你觉着session在等待等待事仉列那你应该检查本视图。如果你发现session在等待一个锁。那么按如下先后序Q?br /> 1.使用V$LOCK扑ևsession持有的锁?br /> 2.使用V$SESSION扑և持有锁或{待锁的session执行的sql语句?br /> 3.使用V$SESSION_WAIT扑և什么原因导致session持有锁堵塞?br /> 4.使用V$SESSION获取关于持有锁的E序和用L(fng)更多信息?/p>
V$LOCK中的常用?/strong> 公共锁类?/strong> 在Oracle数据库中QDML锁主要包括TM锁和TX锁，其中TM锁称U锁QTX锁称Z务锁或行U锁?/p>
当Oracle执行DML语句Ӟpȝ自动在所要操作的表上甌TMcd的锁。当TM锁获得后Q系l再自动甌TXcd的锁Qƈ实际锁定的数据行的锁标志位q行|位。这样在事务加锁前检查TX锁相Ҏ(gu)时׃用再逐行(g)查锁标志Q而只需(g)查TM锁模式的相容性即可，大大提高?jin)系l的效率。TM锁包括了(jin)SS、SX、S、X{多U模式，在数据库中用0Q?来表C。不同的SQL操作产生不同cd的TM锁，如下??/p>
TXQ行U锁Q事务锁 按下列项以避免竞争：(x) TMQ表U锁 ·数据库执行Q何DDL语句时必L排它模式Q例如，alter table,drop table?br />
·执行像insert,update,deleteq类DML语句时处于共享模式。它防止其它session对同一个对象同时执行ddl语句?br />
·M对象拥有正被改变的数据，TM锁都必d在?br />
·锁指向对象?/p>
在TM队列避免竞争Q可以考虑屏蔽对象表锁，屏蔽表锁防止对象执行Q何ddl语句?/p>
STQ空间事务锁 按如下项以避免竞争：(x) ULQ用户定义锁用户可以自定义锁。内容较多ƈ与此节关pM大，略过?/p>
·SIDQ表C持有锁的会(x)话信息?br />
·TYPEQ表C锁的类型。值包括TM和TX{?br />
·LMODEQ表CZ(x)话等待的锁模式的信息。用数字0Q?表示Q和?相对应?br />
·REQUESTQ表Csessionh的锁模式的信息?br />
·ID1,ID2Q表C锁的对象标识?/p>
·在改变数据时必须是排它模?mode 6)?br />
·每一个活动事务都拥有一个锁。它?yu)在事务l束(commit/rollback)旉放?br />
·如果一个块包括的列被改变而没有ITL(interested transaction list)槽位(entries)Q那么session锁|于׃n模式(mode 4)。当session获得块的ITL槽位旉放?br />
·当一个事务首ơ发起一个DML语句时就获得一个TX锁，该锁保持C务被提交或回滚。当两个或多个会(x)话在表的同一条记录上执行DML语句ӞW一个会(x)话在该条记录上加锁，其他的会(x)话处于等待状态。当W一个会(x)话提交后QTX锁被释放Q其他会(x)话才可以加锁?br />
·指出回滚D和事务表项
·避免TXQ?cd竞争Q需要根据?zhn)的应用而定?br />
·避免TXQ?cd竞争Q可以考虑增加对象INITRANS参数倹{?/p>
·每个数据?非实?拥有一个ST锁?br />
·除了(jin)本地理表空_(d)在space理操作(新徏或删除extents)时必L排它模式?br />
·对象creation, dropping, extension, 以及(qing)truncation都处于这U锁
·多数公共原因的争夺，是在盘排序(q使用真正的(f)时表I间)或回滚段扩展或收~?/p>
·使用真正的(f)时表I间(true temporary tablespaces)Q利用(f)时文件。(f)时段在磁盘排序之后ƈ不创建或删除?br />
·使用本地理表空间?br />
·指定回滚D避免动态扩展和收羃Q或使用自动undo management?br />
·避免应用执行创徏或删除数据库对象?/p>
V$SESSION_EVENT中的常用?/strong>
SIDQsession标识
EVENTQsession{待的事?br /> TOTAL_WAITSQ此session当前事g的ȝ待数
TIME_WAITEDQ此sessionȝ待时?单位Q百分之一U?
AVERAGE_WAITQ此session当前事gq_{待旉(单位Q百分之一U?
TOTAL_TIMEOUTSQ等待超时次?/p>
其它用法与V$SESSION_WAIT怼Q不详述?/p>
附注Q?/p>
Oracle的等待事件是衡量Oracleq行状况的重要依据及(qing)指标。等待事件的概念是在Oracle7.0.1.2中引入的Q大致有100个等待事件。在Oracle 8.0中这个数目增加到?jin)大U?50个，在Oracle8i中大U有200个事?在Oracle9i中大U有360个等待事件。主要有两种cd的等待事Ӟ即空?idle){待事g和非I闲(non-idle){待事g?br />
关于I闲事g和非I闲事g目前通过google可以搜烦(ch)到非常多详尽的相关信息，同时
Oracle Database Performance Tuning Guide and Reference中关于Wait Events也有非常详尽的描qͼ在此׃多费口舌?jin)。不q我在itpub论坛看到有热?j)h整理的chm格式非空闲事件说明，有兴的朋友可以下蝲Q链接如下：(x)
非空闲事件说?br />
]]>
1>.扑և资源q程
2>.扑և它们的session,你必dq程与会(x)话联pv来?br />
3>.扑ևZ么session占用?jin)如此多的资?/p>
2.SQL跟踪文g名是Z服务q程的操作系l进EID。要扑ևsession的跟t文Ӟ你必dsession与服务进E联pv来?br /> 3.某些事gQ如rdbms ipc replyQ鉴别sessionq程的Oracleq程ID在等什么。要发现q些q程在做什么，你必L出它们的session?br /> 4.你所看到的服务器上的后台q程(DBWR,LGWR,PMON{?都是服务q程。要想知道他们在做什么，你必LC们的session?/p>
V$PROCESS中的常用?/strong>
ADDRQ进E对象地址
PIDQoracleq程ID
SPIDQ操作系l进EID
V$PROCESS中的q接?/strong>
Column View Joined Column(s)
ADDR V$SESSION PADDR
CZQ?/strong>
1.查找指定pȝ用户在oracle中的session信息?qing)进EidQ假设操作系l用户ؓ(f)Qjunsansi
select s.sid,s.SERIAL#, s.username,p.spid
from v$session s, v$process p
where s.osuser = 'junsansi'
and s.PADDR = p.ADDR
2.查看锁和{待
SELECT /*+ rule */
lpad(' ', decode(l.xidusn, 0, 3, 0)) || l.oracle_username User_name,
o.owner,o.object_name,o.object_type,s.sid,s.serial#,p.spid
FROM v$locked_object l, dba_objects o, v$session s, v$process p
WHERE l.object_id = o.object_id
AND l.session_id = s.sid and s.paddr = p.addr
ORDER BY o.object_id, xidusn DESC
附注Q?/strong>
在linux环境可以通过ps查看q程信息包括pid,windows中Q务管理器的PID与v$process中pid不能一一对应Q这块在oracleDocument中也没有扑ֈ介绍Q后来google?jin)一下，有资料介l说是由于windows是多U程服务?每个q程包含一pdU程。这点于unix{不同，Unix每个Oralceq程独立存在Q在Nt上所有线E由O(jin)ralceq程衍生?br />
要在windows中显Coracle相关q程pidQ我们可以通过一个简单的sql语句来实现?br />
SELECT s.SID, p.pid, p.spid signaled, s.osuser, s.program
FROM v$process p, v$session s
WHERE p.addr = s.paddr;
SID PID SIGNALED OSUSER PROGRAM
1 2 2452 SYSTEM ORACLE.EXE
2 3 2460 SYSTEM ORACLE.EXE
3 4 2472 SYSTEM ORACLE.EXE
4 5 2492 SYSTEM ORACLE.EXE
5 6 2496 SYSTEM ORACLE.EXE
6 7 2508 SYSTEM ORACLE.EXE
7 8 2520 SYSTEM ORACLE.EXE
8 9 2524 SYSTEM ORACLE.EXE
10 12 1316 JSSjunsansi PlSqlDev.exe
9 13 3420 JSSjunsansi PlSqlDev.exe
13 14 660 JSSjunsansi PlSqlDev.exe
q可以通过?v$bgprocess q接查询到后台进E的名字Q?
SELECT s.SID SID, p.spid threadid, p.program processname, bg.NAME NAME
FROM v$process p, v$session s, v$bgprocess bg
WHERE p.addr = s.paddr
AND p.addr = bg.paddr
AND bg.paddr <> '00';
SID THREADID PROCESSNAME NAME
1 2452 ORACLE.EXE PMON
2 2460 ORACLE.EXE DBW0
3 2472 ORACLE.EXE LGWR
4 2492 ORACLE.EXE CKPT
5 2496 ORACLE.EXE SMON
6 2508 ORACLE.EXE RECO
7 2520 ORACLE.EXE CJQ0
8 2524 ORACLE.EXE QMN0
Eygle大师写了(jin)一Dsql脚本getsql.sqlQ用来获取指定pid正在执行的sql语句Q在此也附注上来?br />
REM getsql.sql
REM author eygle
REM 在windows?已知q程ID,得到当前正在执行的语?br />
REM 在windows?q程ID?6q制,需要{?在UNIX直接?0q制
SELECT /*+ ORDERED */
sql_text
FROM v$sqltext a
WHERE (a.hash_value, a.address) IN (
SELECT DECODE (sql_hash_value,
0, prev_hash_value,
sql_hash_value
),
DECODE (sql_hash_value, 0, prev_sql_addr, sql_address)
FROM v$session b
WHERE b.paddr = (SELECT addr
FROM v$process c
WHERE c.spid = TO_NUMBER ('&pid', 'xxxx')))
ORDER BY piece ASC
/
]]>