Oracle 10g Scheduler 特性

Scheduler可以简单简单的帮助我们调度成百上千的tasks。Oracle Scheduler通过在DBMS_SCHEDULER PL/SQL包中存储和过程来执行。

一．使用Jobs

JOBS，其实就是Scheduler管理的一个(或多个)任务的执行调度。

1.1创建Jobs

通过DBMS_SCHEDULER包来创建Jobs，是使用其CREATE_JOB过程。在创建Job时，用户可以指定要执行的任务，调度信息(什么时候执行，执行周期，终止日期等)以及其它一些任务相关的属性。例如：

createtableTEST(idnumber);

CREATEORREPLACEPROCEDUREIT

AS

BEGIN

insertintoTESTVALUES(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;

/

事实上，有权限的话，用户也可以创建其它SCHEMA下的JOB，只需要在指定JOB_NAME时，按照schema.job_name的格式即可。这种情况下创建的JOB，其CREATED与OWNER有可能并不相同。当使用CREATE_JOB过程创建JOB时，可指定的参数值很多，只不过多数情况下用户仅指定部分参数即可满足需求。

其中，上例中指定的参数，分别代表的含义如下：

JOB_NAME：指定任务的名称，必选值，注意要确保指定的名称唯一。

JOB_TYPE：任务执行的操作类型，必选值，有下列几个可选值：

（1）PLSQL_BLOCK：表示任务执行的是一个PL/SQL匿名块。

（2）STORED_PROCEDURE：表示任务执行的是ORACLE过程(含L/SQLPROCEDURE和JAVA PROCEDURE)，本例中正是指定这一参数值。

（3）EXECUTABLE：表示任务执行的是一个外部程序，比如说操作系统命令。

（4）CHAIN：表示任务执行的是一个CHAIN。

JOB_ACTION：任务执行的操作，必选值，应与JOB_TYPE类型中指定的参数相匹配。比如说对于PL/SQL匿名块，此处就可以放置PL/SQL块的具体代表，类似DECLARE..BEGIN..END这类；如果是ORACLE过程，那么此处应该指定具体的过程名，注意由于任务执行，即使过程中有OUT之类参数，实际执行时也不会有输出的。

START_DATE：指定任务初次执行的时间，本参数可为空，当为空时，表示任务立刻执行，效果等同于指定该参数值为SYSDATE。

REPEAT_INTERVAL：指定任务执行的频率，比如多长时间会被触发再次执行。本参数也可以为空，如果为空的话，就表示当前设定的任务只执行一次。REPEAT_INTERVAL参数与标准JOB中的INTERVAL参数有很大区别，相比之下，REPEAT_INTERVAL参数的语法结构要复杂的多。其中最重要的是FREQ和INTERVAL两个关键字。

（1）FREQ关键字用来指定间隔的时间周期，可选参数有：YEARLY,MONTHLY,WEEKLY,DAILY,HOURLY,MINUTELY,andSECONDLY，分别表示年、月、周、日、时、分、秒等单位。

（2）INTERVAL关键字用来指定间隔的频繁，可指定的值的范围从1-99。

例如：REPEAT_INTERVAL=>'FREQ=DAILY;INTERVAL=1';表示每天执行一次，如果将INTERVAL改为7就表示每7天执行一次，效果等同于FREQ=WEEKLY;INTERVAL=1。

一般来说，使用DBMS_SCHEDULER.CREATE_JOB创建一个JOB，至少需要指定上述参数中的前3项。除此之外，还可以在CREATE_JOB时，指定下列参数：

（1）NUMBER_OF_ARGUMENTS：指定该JOB执行时需要附带的参数的数量，默认值为0，注意当JOB_TYPE列值为PLSQL_BLOCK或CHAIN时，本参数必须设置为0，因为上述两种情况下不支持附带参数。

（2）END_DATE：指定任务的过期时间，默认值为NULL。任务过期后，任务的STATE将自动被修改为COMPLETED，ENABLED被置为FALSE。如果该参数设置为空的话，表示该任务永不过期，将一直按照REPEAT_INTERVAL参数设置的周期重复执行，直到达到设置的MAX_RUNS或MAX_FAILURES值。

（3）JOB_CLASS：指定任务关联的CLASS，默认值为DEFAULT_JOB_CLASS。

（4）ENABLED：指定任务是否启用，默认值为FALSE。FALSE状态表示该任务并不会被执行，除非被用户手动调用，或者用户将该任务的状态修改为TRUE。

（5）AUTO_DROP：当该标志被置为TRUE时，ORACLE会在满足条件时自动删除创建的任务

1）任务已过期；

2）任务最大运行次数已达MAX_RUNS的设置值；

3）任务未指定REPEAT_INTERVAL参数，仅运行一次；

该参数的默认值即为TRUE。用户在执行CREATE_JOB过程时可以手动将该标志指定为FALSE，当参数值设置为FALSE时，即使满足上述提到的条件任务也不会被自动删除，这种情况下，唯一能够导致任务被删除的情况，就是用户主动调用DROP_JOB过程。

（6）COMMENTS：设置任务的注释信息，默认值为NULL。

上面的例子创建了一个新的JOB，不过这个JOB与普通JOB不同，此时查询USER_JOBS视图是查不到刚刚创建的JOB的信息，因为这个JOB是SCHEDULER管理的JOB。要查询SCHEDULER管理的JOBS，应该通过user_scheduler_jobs(all_scheduler_jobs，dba_scheduler_jobs也可以)，例如：

SQL>selectjob_name,job_type,job_action,to_char(start_date,'yyyy-mm-dd

hh24:mi:ss')TM,repeat_interval,enabled,statefromuser_scheduler_jobs;

JOB_NAMEJOB_TYPEJOB_ACTIONTMREPEAT_INTERVALENABLSTATE

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

JOBTESTSTORED_PROCEDURESYSTEM.IT2009-09-25FREQ=MINUTELY;INTERVAL=10FALSEDISABLED

注意：JOB虽然成功创建了，但却并未执行.因为ENABLED参数当不显式指定时，该参数的默认值为false。

1.2管理Jobs

1.2.1启用Jobs

前面创建JOB时，由于未显式的指定ENABLED参数，因此即使指定了START_DATE，不过默认情况下JOB不会自动执行。对于这种情况，DBMS_SCHEDULER包中提供了一个过程ENABLE，可以用来修改JOB的启

用状态，调用方式非常简单，例如：

SQL>execdbms_scheduler.enable('JOBTEST');

PL/SQLproceduresuccessfullycompleted.

1.2.2禁用Jobs

DBMS_SCHEDULER.ENABLE仅用来将JOB(其实不仅仅对JOB有效，对于CHAIN、PROGRAM等也有效)的启用状态置为TRUE。如果想将其启用状态置为FALSE，还有一个与该功能对应的过程：DBMS_SCHEDULER.DISABLE，如：

SQL>execdbms_scheduler.disable('JOBTEST');

PL/SQLproceduresuccessfullycompleted.

这两个过程仅用来重置对象的状态，因此均可以无限次执行，即使执行时对象已经被置为要指定的状态。

1.2.3修改Jobs

由于JOB的属性众多，难免可能会遇到需要修改的情况，比如说前面创建JOB时不小心，指定要执行的过程名输入错误(CREATE_JOB在创建时不会自动检查指定的过程是否有效)，这种情况下就必然涉及到对JOB的修改(或者说重定义)，DBMS_SCHEDULER包中专门提供了一个过程SET_ATTRIBUTE，可以用来修改任务的属性值。

例如，修改刚刚创建的JOB：INSERT_TEST_TBL执行的过程，执行语句如下：

SQL>execdbms_scheduler.set_attribute('JobTest','JOB_ACTION','SYSTEM.IT');

PL/SQLproceduresuccessfullycompleted

SET_ATTRIBUTE过程虽然仅有三个参数，不过能够修改的属性值可是不少，以下列举几个较常用到的：

（1）LOGGING_LEVEL：指定对jobs执行情况记录的日志信息级别。SCHEDULER管理的JOB对任务的执行情况专门进行了记录，同时用户还可以选择日志中记录信息的级别，有下列三种选择：

1）DBMS_SCHEDULER.LOGGING_OFF：关闭日志记录功能；

2）DBMS_SCHEDULER.LOGGING_RUNS：对任务的运行信息进行记录；

3）DBMS_SCHEDULER.LOGGING_FULL：记录任务所有相关信息，不仅有任务的运行情况，甚至连任务的创建、修改等也均将记入日志。

提示：查看scheduler管理的job，可以通过user_scheduler_job_log和user_scheduler_job_run_details两个视图中查询。

（2）RESTARTABLE：指定jobs运行出错后，是否能够适时重启创建任务时如未明确指定，本参数默认情况下设置为FALSE，如果设置为TRUE，就表示当任务运行时出错，下次运行时间点到达时仍会启动，并且如果运行仍然出错，会继续重新运行，不过如果连接出错达到6次，该job就会停止。

（3）MAX_FAILURES：指定jobs最大连续出错次数该参数值可指定的范围从1-1000000，默认情况下该参数设置为NULL，表示无限制。达到指定出错次数后，该job会被自动disable。

（4）MAX_RUNS：指定jobs最大运行次数，该参数值可指定的范围从1-1000000，默认情况下该参数设置为NULL，表示无限制(只是运行次数无限制，实际job是否继续运行，仍受制于end_date以及max_failures等参数的设置)。达到指定运行次数后，该job也将被自动disable，并且状态会被置为COMPLETED。

（5）JOB_TYPE：指定job执行的任务的类型，有四个可选值：'PLSQL_BLOCK','STORED_PROCEDURE','EXECUTABLE',and'CHAIN'。

（6）JOB_ACTION：指定job执行的任务.这一参数所指定的值依赖于JOB_TYPE参数中的值，比如说JOB_TYPE设置为'STORED_PROCEDURE'，那么本参数值中指定的一定是ORACLE中的过程名。

（7）START_DATE：指定job初次启动的时间

（8）END_DATE：指定job停止运行的时间

本参数又与AUTO_DROP相关联，如果AUTO_DROP设置为TRUE的话，那么一旦job到达停止运行的时间，该job就会被自动删除，否则的话job任何存在，不过状态被修改为COMPLETED。

除此之外，其它还包括max_run_duration，job_weight，instance_stickiness，stop_on_window_close，job_priority，schedule_limit，program_name，number_of_arguments，schedule_name，repeat_interval，job_class，comments，auto_drop，event_spec，raise_events等等。

另外需要注意一点，除了用户手动创建的jobs之外，数据库在运行过程中也有可能自动创建jobs。对于这类jobs除非必要，否则不建议进行修改。至于如何区分jobs是用户创建，还是数据库自动创建，可以通过*_SCHEDULER_JOBS视图的SYSTEM列来确定，如果该列显示为TRUE，则表示由系统创建。

1.2.4执行Jobs

虽然说jobs大多都应该是自动执行，不过经过前面的示例看出，并不是说创建了jobs它就会自动执行，是否能够真正自动执行由jobs自身的多个相关属性

决定。

可以使用DBMS_SCHEDULER包手动调用jobs并执行。如：

SQL>execdbms_scheduler.run_job('JOBTEST');

PL/SQLproceduresuccessfullycompleted

jobs每执行一次，无论成功或失败，均会在*_scheduler_job_log中生成一条对应的记录(前提是logging_level属性值未设置为dbms_scheduler.logging_off)，同时，用户也可以通过*_scheduler_job_run_details视图查询job执行的详细信息。

1.2.5停止Jobs

停止job可以使用DMBS_SCHEDULER.STOP_JOB过程，例如：

SQL>execdbms_scheduler.stop_job('JOBTEST');

PL/SQLproceduresuccessfullycompleted

注意，STOP_JOB过程不仅仅是更新job的状态，而是停止当前正在执行的任务，如果你处理的任务当前未在运行的话，那么执行STOP_JOB过程，会触发ORA-27366错误。

停止Jobs也会触发一条任务的日志信息，对于执行停止操作的job，其*_SCHEDULER_JOB_LOG视图的OPERATION会记录为'STOPPED'，ADDITIONAL_INFO列中记录的信息类似'REASON="Stopjobcalledbyuser:username"'。

1.2.6删除Jobs

删除创建的job就比较简单了，直接执行dbms_scheduler.drop_job过程即可，例如：

SQL>execdbms_scheduler.drop_job('JOBTEST');

PL/SQLproceduresuccessfullycompleted

删除jobs并不是修改该job中某个字段的标记值，而是直接删除其在数据字典中的字义，因此被删除的job如果未来发现仍然需要，只能重建，而无法通过其它方式快速恢复。不过，删除jobs的操作，并不会级联删除这些job曾经执行过的日志信息。

二、使用Programs

进入10g版本之后，可以在ORACLE中执行操作系统命令，或是ORACLE数据库外的应用，因为有了DBMS_SCHEDULER，因为有了PROGRAM。

2.1创建Programs

Scheduler中的Program对象并不是常规意义上的"程序"或"应用"，而就是一个"对象"，由DBA定义的，具有执行某项功能的特殊对象。Program中实际执行的操作可以分为下列三种类型：

（1）PL/SQLBLOCK：标准的pl/sql代码块；

（2）STOREDPROCEDURE：编译好的PL/SQL存储过程，或者Java存储过程，以及外部的子程序；

（3）EXECUTEABLE：ORACLE数据库之外的应用，比如操作系统命令等等。

创建Programs使用DBMS_SCHEDULER.CREATE_PROGRAM过程，该过程支持的参数如下：

SQL>descdbms_scheduler.create_program;

ParameterTypeModeDefault

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

PROGRAM_NAMEVARCHAR2IN

PROGRAM_TYPEVARCHAR2IN

PROGRAM_ACTIONVARCHAR2IN

NUMBER_OF_ARGUMENTSBINARY_INTEGERINY

ENABLEDBOOLEANINY

COMMENTSVARCHAR2INY

如上所示，前三项为必选参数，各参数实际代表的意义如下：

（1）PROGRAM_NAME：指定一个program名称；

（2）PROGRAM_TYPE：Program的类型，如前文中所述，Program支持三种类型；

（3）PROGRAM_ACTION：实际执行的操作，应与前面PROGRAM_TYPE参数关联使用。比如说前面指定了PROGRAM_TYPE为"PLSQL_BLOCK"，那么此处要执行的action就应当是一段标准的pl/sql代码。如果前面指定PROGRAM_TYPE为"STORED_PROCEDURE"，那么此处要执行的action就应当是ORACLE中定义好的存储过程(含Java存储过程)，如果前面指定PROGRAM_TYPE为"EXECUTABLE"，那么此处就应该指定外部命令的命令行信息(含路径信息)；

（4）NUMBER_OF_ARGUMENTS：指定支持的参数个数，默认值为0即没有参数。每个program最多能够

支持255个参数，注意如果PROGRAM_TYPE设置为PLSQL_BLOCK，那么本参数自动忽略；

（5）ENABLED：指定是否将创建的program置为有效状态，默认情况下为false。

（6）COMMENTS：这个不用再说了吧，注释信息。

下面实际操作一下看看，PL/SQL或PROCEDURE没有挑战(ORACLE中直接即可调用)，咱们创建一下program，直接调用操作系统中的ipconfig命令，操作如下：

SQL>BEGIN

DBMS_SCHEDULER.CREATE_PROGRAM(

program_name=>'IPCONFIG',

program_action=>'C:/WINDOWS/system32/ipconfig.exe',

program_type=>'EXECUTABLE',

enabled=>TRUE);

END;

/

PL/SQLproceduresuccessfullycompleted.

2.2管理Programs

CREATE_PROGRAM过程的参数时提到，每个program最多支持255个参数，要为program添加参数，可以通过DEFINE_PROGRAM_ARGUMENT过程。不过在为其添加参数前，要注意program的NUMBER_OF_ARGUMENTS指定的数量，如果该值为0，那么为其添加参数时就会报错。

查询创建的program的信息，可以通过USER_SCHEDULER_PROGRAMS视图，例如：

SQL>selectprogram_name,program_type,program_action,number_of_arguments,enabled fromuser_scheduler_programs;

由于前面创建program时並未指定NUMBER_OF_ARGUMENTS的值，因此我们这里需要首先修改该值为一个非0值，操作如下：

SQL>execdbms_scheduler.set_attribute('IPCONFIG','NUMBER_OF_ARGUMENTS',1);

PL/SQLproceduresuccessfullycompleted.

另外需要注意，program的NUMBER_OF_ARGUMENTS参数不是说想改就能改的，正常情况下该处理必须是在program处于enabled之前确认完毕，否则会触发ORA-27465错误，因此要修改program的参数之前，必须首先确保要修改program的enabled状态为false。

那么对于已经处于enabled状态的program，在修改之前要修改其状态。如：

SQL>execdbms_scheduler.disable('IPCONFIG');

PL/SQLproceduresuccessfullycompleted.

如果想启用，执行dbms_scheduler.enable过程即可。

接下来，就可以为刚刚创建的IPCONFIG添加路径参数，操作如下：

SQL>BEGIN

DBMS_SCHEDULER.DEFINE_PROGRAM_ARGUMENT(

program_name=>'IPCONFIG',

argument_position=>1,

argument_name=>'dirpath',

argument_type=>'VARCHAR2',

default_value=>'C:/');

END;

/

PL/SQLproceduresuccessfullycompleted.

execDBMS_SCHEDULER.ENABLE('IPCONFIG');

查询为program定义的参数，可以通过user_scheduler_program_args视图，例如：

SQL>selectprogram_name,argument_name,argument_position,argument_type

default_valuefromuser_scheduler_program_args;

删除program的argument，使用drop_program_argument过程即可，例如：

SQL>execdbms_scheduler.drop_program_argument('IPCONFIG','dirpath');

PL/SQLproceduresuccessfullycompleted.

该过程第一个参数指定program名称，第二个参数指定定义的argument名称，当然此处也可以指定argument的位置，即前例视图返回结果中的ARGUMENT_POSITION列值。

要删除program的话就更简单了，使用DROP_PROGRAM过程即可，例如：

SQL>execdbms_scheduler.drop_program('IPCONFIG');

PL/SQLproceduresuccessfullycompleted.

在删除program的同时，也会删除该program对应的所有arguments。scheduler中创建job时，也可以指定执行外部的程序。scheduler中的job更像是之前版本继承过来的jobs，只不过10g中scheduler管理的jobs功能更加强大。programs与jobs不同的是，jobs是定义好的，定时执行的任务，而programs则是定义好的，等待被执行的对象。

三、使用Schedules

10g中的SCHEDULER中新增的概念太多。比如说jobs，仍然可以理解成之前版本中的jobs，不过功能更加强大。

3.1创建和管理Schedules

Schedule，用来描述job的执行周期。创建schedule可以通过dbms_scheduler.create_schedule过程，该过程支持的参数如下：

SQL>descdbms_scheduler

SQL>descdbms_scheduler.create_schedule;

ParameterTypeModeDefault?

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

SCHEDULE_NAMEVARCHAR2IN

START_DATETIMESTAMPWITHTIMEZONEINY

REPEAT_INTERVALVARCHAR2IN

END_DATETIMESTAMPWITHTIMEZONEINY

COMMENTSVARCHAR2INY

各参数分别代表含意如下：

（1）SCHEDULE_NAME：指定schedule名称，注意名称不能重复。

（2）START_DATE：指定该调度的开始时间，可为空，当为空时表示该调度暂不起用。

（3）REPEAT_INTERVAL：指定调度的执行频率或周期。

（4）END_DATE：指定调度的结束时间，可为空，为空时就表示该调度将一直进行。

（5）COMMENTS：注释信息。

Schedules中的REPEAT_INTERVAL参数和Jobs中的REPEAT_INTERVAL参数功能完全相同，甚至参数格式也一模一样。其中最重要的是FREQ和INTERVAL两个关键字。

（1）FREQ关键字用来指定间隔的时间周期，可选参数有：YEARLY,MONTHLY,WEEKLY,DAILY,

HOURLY,MINUTELY,andSECONDLY，分别表示年、月、周、日、时、分、秒等单位。

（2）INTERVAL关键字用来指定间隔的频繁，可指定的值的范围从1-99。

比如说，当指定REPEAT_INTERVAL=>'FREQ=DAILY;INTERVAL=1';就表示每天执行一次，如果将INTERVAL改为7就表示每7天执行一次，效果等同于FREQ=WEEKLY;INTERVAL=1。

下面，创建一个schedule，指定调度为每周一次的频率，执行脚本如下：

SQL>BEGIN

DBMS_SCHEDULER.CREATE_SCHEDULE(

schedule_name=>'MySchedule',

start_date=>SYSDATE,

repeat_interval=>'FREQ=WEEKLY;INTERVAL=1',

comments=>'Every1weeks');

END;

/

查询当前已经创建的schedules，可以通过*_SCHEDULER_SCHEDULES视图(含DBA_,ALL_,USER_)，例如，查看当前用户拥有的schedules，执行语句如下：

SQL>selectschedule_name,repeat_intervalfromuser_scheduler_schedules;

如果要修改schedule属性的话，也是使用dbms_scheduler.set_attribute过程，该过程的调用方式前面已经多次演示过，对于schedule来说，能够修改的属性包括：repeat_interval、comments、end_date、start_date以及event_spec。

删除schedule，执行DBMS_SCHEDULER.DROP_SCHEDULE过程即可，如：

sql>execdbms_scheduler.drop_schedule('my_first_schedule');

pl/sqlproceduresuccessfullycompleted.

3.2Schedules调度Programs执行的Jobs

通过schedule调度program的执行的job。下面我们通过实例来演示，如何创建通过schedule调度program的执行的job。

1.我们用前面创建的Program：IPCONFIG，执行操作系统命令ipconfig。

2.用我们刚创建的schedule：MySchedule

3.创建job，按照指定的schedule，执行program，操作如下：

SQL>BEGIN

DBMS_SCHEDULER.CREATE_JOB(

job_name=>'ExecCmd',

program_name=>'IPCONFIG',

schedule_name=>'MySchedule',

enabled=>true);

END;

/

创建job时，start_date,repeat_interval,job_action等均无须指定，因为这些参数将由program和schedule来控制。这样，操作完成后，ORACLE就会自动定时(当前设置为每周执行一次)program中定义的操作。

要查看当前的执行情况，通过*_scheduler_job_run_details即可查询(*_scheduler_job_log也可以，不过该视图中信息不如detail中全面)。例如，查看刚刚创建的"ExecCmd"任务的执行情况，执行命令如下：

SQL>selectlog_id,log_date,status,additional_infofromuser_scheduler_job_run_detailswherejob_name='ExecCmd';

3.3设置RepeatInterval

Job和Schedule中REPEAT_INTERVAL参数都是用来控制执行的频率或周期，虽然说周期是一个时间性概念，不过REPEAT_INTERVAL指定的时候并不是一个时间值，而是由一组关键字描述的时间。

除了前面介绍Job和Schedule的REPEAT_INTERVAL参数时，提到该参数拥有FREQ以及INTERVAL两个关键字，其实除此之外，还有如BYMONTH、BYWEEKNO、BYYEARDAY、BYDATE等等参数，可以用来进行更精确的定义，比如通过BYMONTH关键字指定调度运行的月份，BYDAY指定调度在哪天运行等等。

REPEAT_INTERVAL参数的详细语法如下：

repeat_interval=regular_schedule|combined_schedule

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

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]

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

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

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

interval_clause="INTERVAL""="intervalnum

intervalnum=1through99

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=1through53

byyearday_clause="BYYEARDAY""="yearday_list

yearday_list=yearday(","yearday)*

yearday=[minus]yeardaynum

yeardaynum=1through366

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=1through31

byday_clause="BYDAY""="byday_list

byday_list=byday(","byday)*

byday=[weekdaynum]day

weekdaynum=[minus]daynum

daynum=1through53/*iffrequencyisyearly*/

daynum=1through5/*iffrequencyismonthly*/

day="MON"|"TUE"|"WED"|"THU"|"FRI"|"SAT"|"SUN"

byhour_clause="BYHOUR""="hour_list

hour_list=hour(","hour)*

hour=0through23

byminute_clause="BYMINUTE""="minute_list

minute_list=minute(","minute)*

minute=0through59

bysecond_clause="BYSECOND""="second_list

second_list=second(","second)*

second=0through59

bysetpos_clause="BYSETPOS""="setpos_list

setpos_list=setpos(","setpos)*

setpos=[minus]setpos_num

setpos_num=1through9999

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

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=1through100

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

offset=("+"|"-")["OFFSET:"]duration_val

span=("+"|"-"|"^")"SPAN:"duration_val

duration_val=dur-weeks|dur_days

dur_weeks=numofweeks"W"

dur_days=numofdays"D"

numofweeks=1through53

numofdays=1through376

minus="-"

例如：设置任务仅在周5的时候运行：

REPEAT_INTERVAL=>'FREQ=DAILY;BYDAY=FRI';

REPEAT_INTERVAL=>'FREQ=WEEKLY;BYDAY=FRI';

REPEAT_INTERVAL=>'FREQ=YEARLY;BYDAY=FRI';

设置任务隔一周运行一次，并且仅在周5运行：

REPEAT_INTERVAL=>'FREQ=WEEKLY;INTERVAL=2;BYDAY=FRI';

设置任务在当月最后一天运行：

REPEAT_INTERVAL=>'FREQ=MONTHLY;BYMONTHDAY=-1';

设置任务在3月10日运行：

REPEAT_INTERVAL=>'FREQ=YEARLY;BYMONTH=MAR;BYMONTHDAY=10';

REPEAT_INTERVAL=>'FREQ=YEARLY;BYDATE=0310';

上述两条语句功能相同。

设置任务每10隔天运行：

REPEAT_INTERVAL=>'FREQ=DAILY;INTERVAL=10';

设置任务在每天的下午4、5、6点时运行：

REPEAT_INTERVAL=>'FREQ=DAILY;BYHOUR=16,17,18';

设置任务在每月29日运行：

REPEAT_INTERVAL=>'FREQ=MONTHLY;BYMONTHDAY=29';

设置任务在每年的最后一个周5运行：

REPEAT_INTERVAL=>'FREQ=YEARLY;BYDAY=-1FRI';

设置任务每隔50个小时运行：

REPEAT_INTERVAL=>'FREQ=HOURLY;INTERVAL=50';

注意：SCHEDULER中的REPEAT_INTERVAL也完全可以按照以前Job方式设置，REPEAT_INTERVAL实际上是指定周期，直接指定一个时间值，当然也是周期。

比如说，设置任务每天执行一次，也可以设置REPEAT_INTERVAL参数值如下：

REPEAT_INTERVAL=>'trunc(sysdate)+1'

又比如设置任务每周执行一次：

REPEAT_INTERVAL=>'trunc(sysdate)+7'

不过需要注意，这种方式仅用于创建SCHEDULER中jobs时使用，不能用于schedule。

四、使用Events

SCHEDULER中有两种触发EVENT的情况：

（1）Scheduler触发的Events

Scheduler中触发的Events，一般是说当前schduler中job的状态发生修改，类似job启动，或者运行结束，或者达到运行时间等诸如此类的动作，都能够抛出一个EVENT，接收到EVENT的applicate就可以根据这些信息进行适当的处理。

比如说，由于系统太过于繁忙，超出job启动时间后30分钟，job仍然没能顺利启动，那么这个时候，Scheduler就可以抛出一条EVENT给外部的应用，以便外部应用能够及时通知DBA，进行处理。

（2）application触发的Events

外部的应用也可以触发Events，并且由Scheduler来接收并处理这一类型的Events。所谓Scheduler处理EVENT就是指Scheduler启动相应的job来执行相关操作，这类job在创建时专门声明了event的处理，这样当接收到EVENT时，这类job就会启动。

Scheduler使用Oracle高级队列来抛出以及销毁Events。当抛出Schduler触发的Events时，Scheduler将消息入队到默认的event队列，application则通过检查该队列来处理Events。当抛出application触发的Events时，application将消息入队到处理job对应的队列中。

4.1Scheduler抛出的Events

Scheduler抛出的Events一般是指job状态改变时触发的，默认情况下，job是不触发Events的。

Scheduler中的job有一个属性叫raise_events，专门用来设置job触发Events的条件，该属性在CREATE_JOB时不能执行，因此默认情况下该属性不会赋值，自然也就不会触发EVENT。要设置raise_events属性，只能是在job创建完成后，通过SET_ATTRIBUTE过程修改job的raise_events属性。

例如，修改前面创建的jobtest，启用raise_events属性，执行语句如下：

sql>begin

dbms_scheduler.set_attribute('jobtest','raise_events',dbms_scheduler.job_all_events);

end;

/

上述示例中指定的raise_events属性的属性值dbms_scheduler.job_all_events，就是抛出events的触发条件。

触发Events的有下列的类型，分别代表不同的操作：

（1）job_started：JOB启动；

（2）job_succeeded：JOB成功结束；

（3）job_failed：JOB执行失败；

（4）job_broken：JOB被置为BROKEN状态；

（5）job_completed：JOB达到最大运行次数，或者运行的结束日期；

（6）job_stopped：JOB被STOP_JOB过程置为停止执行的状态；

（7）job_sch_lim_reached：Job的schedule达到限定值；

（8）job_disabled：JOB被置于DISABLE状态；

（9）job_chain_stalled：运行于chain的JOB被置于CHAIN_STALLED状态；

（10）job_all_events：含上述提到的所有类型；

（11）job_run_completed：由于Job运行出错、成功结束或被手动停止。

起用raise_events后，Scheduler就会按照设定的触发条件，当达到触发条件时，即会抛出事件信息到SYS.SCHEDULER$_EVENT_QUEUE队列。

例如，手动执行一次JOBTEST，看看是否向队列中记录信息，操作如下：

SQL>execdbms_scheduler.run_job('JOBTEST');

PL/SQLproceduresuccessfullycompleted.

执行下列脚本，出队数据：

SQL>setserveroutputon

SQL>DECLARE

l_dequeue_optionsDBMS_AQ.dequeue_options_t;

l_message_propertiesDBMS_AQ.message_properties_t;

l_message_handleRAW(16);

l_queue_msgsys.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-0912.49.29.558758PM+08:00

error_code:0

event_status:1

log_id:

run_count:1

failure_count:0

retry_count:0

PL/SQLproceduresuccessfullycompleted.

从返回的信息可以看到，event的类型为JOB_STARTED，表示JOB启动。实际上job:JOBTEST执行一次至少会向队列中插入两条event信息，一条为JOB_STARTED，一条则为JOB_SUCCEEDED(也可能是JOB_FAILED)，这里不详细演示，感兴趣的朋友不妨自行测试。

提示：sys.scheduler$_event_queue队列基于sys.scheduler$_event_qtab队列表，因此查询sys.scheduler$_event_qtab也可以获取上述的信息。

sys.scheduler$_event_queue是一个固定队列，实际应用的过程中，dba应该根据实际情况，将该表访问权限授予相关用户，以便顺利出队该队列中的events信息。

默认情况下Scheduler仅保留最近24小时的Events信息，如果希望修改该设置的话，可以通过SET_SCHEDULER_ATTRIBUTE过程，修改scheduler的event_expiry_time属性，该项属性的属性值以秒为单位。

4.2Application抛出的Events

Scheduler能够抛出Events让外部应用处理，外部的应用也可以抛出Events让Scheduler启动job处理，不过并不是任何job都能够对外部应用抛出的Events做出响应，必须在创建jobs时明确指定响应的事件。可以通过如下参数指定：

（1）queue_spec：指定外部应用抛出的events消息入队的队列名；

（2）event_condition：指定触发job启动的条件，这一参数的参数值在设置时应当基于事件消息的自身属性，因为事件消息在入队时，消息的属性都是由application定义的，因此在设置触发条件时，也应该根据这些属性值就行设置。

下面，我们就演示创建一个由event触发启动的job，具体的操作步骤如下：

SQL>createorreplacetypeTest_type1asobject

2(

3event_typeVARCHAR2(10),

4object_ownerVARCHAR2(30),

5object_nameVARCHAR2(30)

6);

7/

Typecreated.

SQL>begin

2dbms_aqadm.create_queue_table(

3queue_table=>'my_queue_tbl1',

4queue_payload_type=>'Test_type1',

5multiple_consumers=>true);

6end;

7/

PL/SQLproceduresuccessfullycompleted.

SQL>begin

2dbms_aqadm.create_queue(

3queue_name=>'event_t1',

4queue_table=>'my_queue_tbl1');

5end;

6/

PL/SQLproceduresuccessfullycompleted.

准备工作完成，下面就来创建一个event触发启动的job，创建脚本如下：

SQL>BEGIN

2DBMS_SCHEDULER.CREATE_JOB(

3job_name=>'EVENT_JOB_T1',

4job_type=>'STORED_PROCEDURE',

5job_action=>'SYSTEM.IT',

6event_condition=>'tab.user_data.event_type=''OP_INSERT''',

7queue_spec=>'EVENT_T1',

8enabled=>TRUE);

9END;

10/

PL/SQLproceduresuccessfullycompleted.

上述脚本仅做演示，因此创建的job仍然执行IT过程。

通过pl/sql直接向event_t1队列中添加消息的方式，触发job的启动，具体操作如下。

（1）首先要执行DBMS_AQADM.START_QUEUE过程，将event_t1置于允许入队和出队状态(默认情况下创建的队列是不允许出队和入队操作的)，脚本如下：

SQL>execdbms_aqadm.start_queue(queue_name=>'event_t1',enqueue=>true,dequeue=>true);

PL/SQLproceduresuccessfullycompleted.

（2）执行入队操作：

SQL>declare

v_MessageTest_type1;

v_EnqueueOptionsdbms_aq.enqueue_options_t;

v_MessagePropertiesdbms_aq.message_properties_t;

v_msg_handleraw(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/SQLproceduresuccessfullycompleted.

（3）查询队列表中的数据：

SQL>selectuser_datafrommy_queue_tbl1;

USER_DATA(EVENT_TYPE,OBJECT_OWNER,OBJECT_NAME)

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

JSS_TYPE1('OP_SELECT','TEST','tmpObj')

（4）然后查询job

SQL>selectto_char(created,'yyyy-mm-ddhh24:mi:ss')fromjss_1;

TO_CHAR(CREATED,'YY

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

2009-08-2512:49:29

看起来jss_1表中并未有新增加记录，job没有执行。因为创建job时指定的event_condition条件吗：

event_condition=>'tab.user_data.event_type=''OP_INSERT''',

只有当event_type为'OP_INSERT'时才会触发job的执行，前面入队时指定的是OP_SELECT，当然没有触发job中指定的procedure，下面再次执行入队操作：

SQL>declare

v_Messagejss_type1;

v_EnqueueOptionsdbms_aq.enqueue_options_t;

v_MessagePropertiesdbms_aq.message_properties_t;

v_msg_handleraw(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表看看：

SQL>selectto_char(created,'yyyy-mm-ddhh24:mi:ss')fromjss_1;

TO_CHAR(CREATED,'YY

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

2009-08-2512:49:29

2009-08-2513:21:21

多了一条记录，说明job已经被自动触发。

最后再补充一句，基于event的job不能通过dbms_scheduler.run_job过程执行，否则会触发ora-00942:tableorviewdoesnotexist错误。

五、使用Chains

CHAIN可以被视做一组Programs的复合，举个简单的例子：运行PROGRAM:A以及PROGRAM:B，如果成功的话继续运行PROGRAM:C，否则的话运行PROGRAM:D。Programs:A、B、C、D以及执行的逻辑关系就构成了一个最简单的CHAIN。

关于CHAIN的管理操作比较多，比如创建/删除/修改Chains，添加/修改/删除ChainSteps等等。

5.1创建Chains

5.1.1创建CHAIN对象

创建CHAIN使用DBMS_SCHEDULER.CREATE_CHAIN过程，这个过程调用非常简单，因为需要指定的参数极少，该过程的定义如下：

SQL>descdbms_scheduler.create_chain;

ParameterTypeModeDefault?

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

CHAIN_NAMEVARCHAR2IN

RULE_SET_NAMEVARCHAR2INY

EVALUATION_INTERVALINTERVALDAYTOSECONDINY

COMMENTSVARCHAR2INY

在创建时，甚至可以简单到只指定一个CHAIN的名称，其它均为空即可，例如：

SQL>execdbms_scheduler.create_chain('my_chain1');

PL/SQLproceduresuccessfullycompleted.

定义好的Chains，可以通过*_SCHEDULER_CHAINS视图查看，例如：

SQL>selectchain_namefromuser_scheduler_chains;

CHAIN_NAME

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

MY_CHAIN1

5.1.2创建ChainStep

ChainSteps就是用来指定CHAIN执行的操作及执行步骤，创建CHAINSTEP是通过DBMS_SCHEDULER.DEFINE_CHAIN_STEP过程进行，例如，为刚刚创建的my_chain1添加一个step，执行操作如下：

SQL>begin

DBMS_SCHEDULER.DEFINE_CHAIN_STEP(

chain_name=>'my_chain1',

step_name=>'my_step1',

program_name=>'p_p1');

end;

/

PL/SQLproceduresuccessfullycompleted.

ChainSteps即可以调用PROGRAM，也可以调用EVENT，甚至调用其它CHAIN(这就叫嵌套CHAIN)。

下面接着为my_chain1添加两个step，操作如下：

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/SQLproceduresuccessfullycompleted.

要查询定义的ChainSteps，则是通过*_SCHEDULER_CHAIN_STEPS视图，例如：

SQL>selectchain_name,step_name,program_namefromuser_scheduler_chain_steps;

CHAIN_NAMESTEP_NAMEPROGRAM_NAME

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

MY_CHAIN1MY_STEP1P_P1

MY_CHAIN1MY_STEP2P_P2

MY_CHAIN1MY_STEP3P_P3

5.1.3创建ChainRule

接下来，要为CHAIN的运行定义规则。定义规则是使用DBMS_SCHEDULER.DEFINE_CHAIN_RULE过程，ChainRules依赖于ChainSteps，每个CHAINRULE都拥有condition和action属性，当满足condition时则执行action中指定的step。

DBMS_SCHEDULER.DEFINE_CHAIN_RULE过程的语法如下：

SQL>descdbms_scheduler.define_chain_rule;

ParameterTypeModeDefault?

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

CHAIN_NAMEVARCHAR2IN

CONDITIONVARCHAR2IN

ACTIONVARCHAR2IN

RULE_NAMEVARCHAR2INY

COMMENTSVARCHAR2INY

需要注意的是CONDITION和ACTION两个参数。在为condition参数指定值时，其语法看起来稍稍复杂一些，或者说是灵活，condition参数值支持下列的语法形式：

TRUE

FALSE

stepname[NOT]SUCCEEDED

stepname[NOT]FAILED

stepname[NOT]STOPPED

stepname[NOT]COMPLETED

stepnameERROR_CODEIN(integer,integer,integer...)

stepnameERROR_CODENOTIN(integer,integer,integer...)

stepnameERROR_CODE=integer

stepnameERROR_CODE!=integer

stepnameERROR_CODE<>integer

stepnameERROR_CODE>integer

stepnameERROR_CODE>=integer

stepnameERROR_CODE<integer

stepnameERROR_CODE<=integer

甚至于，还可以制定成下列逻辑语法：

expressionANDexpression

expressionORexpression

NOT(expression)

比如说，我们希望条件为step1成功运行，那么可以指定condition参数值如下：

'step1completed'

Action参数相对简单一些，这个参数用来指定当满足condition参数时，CHAIN执行的操作。

例如，创建CHAINRULE，首先执行my_step1，如果my_step1成功执行的话，就继续执行my_step2，如果my_step2也成功执行的话，则结束该CHAIN，创建脚本如下：

SQL>BEGIN

DBMS_SCHEDULER.DEFINE_CHAIN_RULE(

chain_name=>'my_chain1',

condition=>'TRUE',

action=>'STARTmy_step1',

rule_name=>'my_rule1');

DBMS_SCHEDULER.DEFINE_CHAIN_RULE(

chain_name=>'my_chain1',

condition=>'my_step1completed',

action=>'STARTmy_step2',

rule_name=>'my_rule2');

DBMS_SCHEDULER.DEFINE_CHAIN_RULE(

chain_name=>'my_chain1',

condition=>'my_step2completed',

action=>'end0',

rule_name=>'my_rule3');

END;

/

PL/SQLproceduresuccessfullycompleted.

5.1.4运行Chains

最后，来运行一下创建的my_chain1吧，手动运行CHAIN是通过DBMS_SCHEDULER.RUN_CHAIN过程，例如：

SQL>BEGIN

DBMS_SCHEDULER.RUN_CHAIN(

chain_name=>'my_chain1',

start_steps=>'my_step1');

END;

/

PL/SQLproceduresuccessfullycompleted.

语句执行成功，下面需要查看一下执行的结果。我们之前定义的p_p1等program对象，实际上是调用procedure，向一个指定表jss_t2中插入记录，这里直接查询一下该表，就知道执行情况了(在此之前，jss_t2表为空)：

SQL>select*fromjss_t2;

TPDT

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

p_p1inserted03-SEP-09

p_p2inserted03-SEP-09

jss_t2表中有了两条记录，对应前面设置的CHAINRULE，说明my_step1和my_step2均已正确执行。

提示：Chains在执行前，必须被置于enabled状态，默认情况下刚刚创建的CHAIN都是disabled状态，要修改Chains的状态，还是通过DBMS_SCHEDULER.ENABLE和DBMS_SCHEDULER.DISABLE两过程，这里就不演示了。手动执行的CHAIN的话没有系统级的日志记录，因此如果希望看到详细执行情况的话，建议创建job来执行CHAIN，例如：

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/SQLproceduresuccessfullycompleted.

然后，dba就可以通过定期观察*_scheduler_job_run_details视图来确认chain的执行情况了。

5.2管理Chains

5.2.1修改Chains属性

对于CHAIN对象来说，能够修改的属性只有两个：evaluation_interval和comments，这两个参数一般情况下甚至都不会进行设置。如果你碰到了确实需要修改的情况，可以使用DBMS_SCHEDULER.SET_ATTRIBUTE过程。例如：

SQL>selectchain_name,commentsfromuser_scheduler_chains;

CHAIN_NAMECOMMENTS

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

MY_CHAIN1

SQL>execdbms_scheduler.set_attribute('my_chain1','comments','changeitforatest!');

PL/SQLproceduresuccessfullycompleted.

SQL>selectchain_name,commentsfromuser_scheduler_chains;

CHAIN_NAMECOMMENTS

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

MY_CHAIN1changeitforatest!

5.2.2设置ChainStep运行属性

修改chainstep的运行属性就不能使用dbms_scheduler.set_attribute了，而是有专门的过程dbms_scheduler.alter_chain处理，该过程的定义如下：

SQL>descdbms_scheduler.alter_chain;

ParameterTypeModeDefault?

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

CHAIN_NAMEVARCHAR2IN

STEP_NAMEVARCHAR2IN

ATTRIBUTEVARCHAR2IN

VALUEBOOLEANIN

前两个参数就不说了，ATTRIBUTE参数用来指定STEP的属性值，可设定的属性值有3个，每个属性值都有TRUE和FALSE两个选项，由VALUE参数指定：

（1）PAUSE：设置该参数值为TRUE时，当step运行时，其运行状态就会变更为PAUSED；

（2）SKIP：设置该参数值为TRUE时，当step满足运行条件时，并不是执行step中的program，而是直接跳过，注意当SKIP参数值设置为TRUE，并且PAUSE参数值也被设置为TRUE，那么将会以PAUSE的状态优先；

（3）RESTART_ON_RECOVERY：设置该参数值为TRUE时，如果由于数据库shutdown导致step被停止，那么当下次数据库启动时，step会自动重新运行。

DBMS_SCHEDULER.ALTER_CHAIN过程修改ChainStep属性后，只有当下次运行时才会生效，如果要修改当前运行中ChainStep的属性，也有一个专门的过程DBMS_SCHEDULER.ALTER_RUNNING_CHAIN进行处理，该过程语法与DBMS_SCHEDULER.ALTER_CHAIN一模一样。

5.2.3删除ChainRules

ChainRules没有对应的修改方法，如果要修改某个Chain的rule，只能首先删除不适当的rule，然后重新添加新rule(所谓添加，其实就是再重新定义一个rule)。

删除ChainRule有专门的过程DBMS_SCHEDULER.DROP_CHAIN_RULE，该过程语法如下：

SQL>descdbms_scheduler.drop_chain_rule;

ParameterTypeModeDefault?

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

CHAIN_NAMEVARCHAR2IN

RULE_NAMEVARCHAR2IN

FORCEBOOLEANINY

举个简单的示例，比如删除前面定义的my_rule3，执行过程如下：

SQL>execdbms_scheduler.drop_chain_rule('my_chain1','my_rule3',true);

PL/SQLproceduresuccessfullycompleted.

5.2.4删除ChainSteps

删除ChainStep也有专门的过程dbms_scheduler.drop_chain_step进行处理，该过程语法如下：

SQL>descdbms_scheduler.drop_chain_step;

ParameterTypeModeDefault?

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

CHAIN_NAMEVARCHAR2IN

STEP_NAMEVARCHAR2IN

FORCEBOOLEANINY

例如，删除之前定义的my_step3，执行过程如下：

SQL>execdbms_scheduler.drop_chain_step('my_chain1','my_step3',true);

PL/SQLproceduresuccessfullycompleted.

5.2.5删除Chains

如果要删除Chain那就更简单了，执行dbms_scheduler.drop_chain过程即可，例如：

SQL>execdbms_scheduler.drop_chain('my_chain1',true);

PL/SQLproceduresuccessfullycompleted.

注意，执行drop_chain时，如果不指定force参数为TRUE，那么默认情况下ORACLE会首先检查要删除的CHAIN是否还有被依赖的对象，如果存在的话，会报ORA-27479错误，提示仍然有依赖的对象(所谓依赖的对象就是指，该chain仍然存在chain_step或chain_rule之类)，因此无法直接删除。

这种情况下解决方案有两种：

（1）手动删除所有相关的chain_step和chain_rule，然后再执行chain的删除，

（2）附加force参数并指定参数值为true，这样ORACLE就会自动替你清除所有依赖的对象了。

六、使用JobClasses

JobClasses相当于创建了一个job组，DBA可以将那些具有相同特性的job，统统放到相同的JobClasses中，然后通过对JobClass应用ORACLE中的"资源使用计划"特性，就可以对这些job执行过程中所需要的资源分配情况进行管理。

1、创建JobClasses

使用DBMS_SCHEDULER包的CREATE_JOB_CLASS过程创建JobClasses，该过程支持的参数如下：

SQL>descdbms_scheduler.create_job_class;

ParameterTypeModeDefault?

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

JOB_CLASS_NAMEVARCHAR2IN

RESOURCE_CONSUMER_GROUPVARCHAR2INY

SERVICEVARCHAR2INY

LOGGING_LEVELBINARY_INTEGERINY

LOG_HISTORYBINARY_INTEGERINY

COMMENTSVARCHAR2INY

其中：

JOB_CLASS_NAME：要创建的JobClass的名称，注意指定的长度不要超过30个字符，也不要与现有JobClass同名；

RESOURCE_CONSUMER_GROUP：指定创建的JobClass所在的RCG；

ResourceConsumerGroup可以将其理解成一个资源分配的方式，处于相同RCG组中的用户、会话、或者对象共用一组资源，这组资源中可供分配的资源按照DBA指定的方式分配给RCG。如果设计合理，通过这种方式，可以更有效的利用服务器的资源。

SERVICE：指定创建的JobClass所在Service，本选项常见于RAC环境，我们都知道RAC环境由多实例+数据库组成，此处所指定的Service实际就是指JobClass会在哪个实例上运行。

注意：本参数与RESOURCE_CONSUMER_GROUP参数相互冲突，同一个JobClass只同设置两个参数中的一个值。

LOGGING_LEVEL：指定日志记录的级别，有下列三种级别：

（1）DBMS_SCHEDULER.LOGGING_OFF：关闭日志记录功能；

（2）DBMS_SCHEDULER.LOGGING_RUNS：对该JobClass下所有任务的运行信息进行记录；

（3）DBMS_SCHEDULER.LOGGING_FULL：记录该JobClass下任务的所有相关信息，不仅有任务的运行情况，甚至连任务的创建、修改等也均将记入日志。

LOG_HISTORY：指定日志记录的时间，以天为单位，比如指定LOG_HISTORY参数值为90，就表示日志信息保留最近90天的内容。

COMMENTS：指定注释信息。

上述各个参数，除了LOG_CLASS_NAME参数为必选参外，其它均为可选参数，例如：

SQL>EXECDBMS_SCHEDULER.CREATE_JOB_CLASS('my_first_jc');

PL/SQLproceduresuccessfullycompleted

查询系统中已经存在的jobclasses.可以通过dba_scheduler_job_classes视图(或all_scheduler_job_class视图)

当创建Jobs时，可以通过JOB_CLASS参数来指定job所在的JobClass，如果不指定的话，创建的job默认属于DEFAULT_JOB_CLASS。可以使用*_SCHEDULER_JOBS视图中的JOB_CLASS列查看对应的信息。

2、管理JobClasses

DBMS_SCHEDULER.SET_ATTRIBUTE过程的SET_ATTRIBUTE也可以用来修改JobClass的属性，操作方法与修改job属性完全相同，只不过作用函概的范围更广，修改JobClass后，该JobClass下属的所有job属性都会被级联修改(当前正运行的不会立刻生效，将等到下次运行时生效)。

例如：修改刚刚创建的MY_FIRST_JC的日志保存时间：

SQL>EXECDBMS_SCHEDULER.SET_ATTRIBUTE('SYS.MY_FIRST_JC','LOG_HISTORY','30');

PL/SQLproceduresuccessfullycompleted.

提示：JobClass可被修改的属性，即创建时可选择指定的那5个属性。

3、删除JobClasses

DBMS_SCHEDULER包提供了DROP_JOB_CLASS过程，用来删除JobClasses。该过程调用非常简单，例如，删除刚刚创建的MY_FIRST_JC，执行命令如下：

SQL>EXECDBMS_SCHEDULER.DROP_JOB_CLASS('MY_FIRST_JC');

PL/SQLproceduresuccessfullycompleted.

如果有多个JobClasses需要删除，并不需要多次执行DROP_JOB_CLASS，只需要在为该过程指定值时，参数值间以逗号分隔即可。

七、使用Windows

此处所说的Windows，是指SCHEDULER特性中的一个子项。在SCHEDULER中，WINDOW对应的是一个时间窗口的概念。我们知道普通的jobs是没有运行时间管理地概念的，就是说一个job启动之后，用户只能被动地等待其执行，一直到其执行地任务完成(或DBA手动kill对应进程)，在此期间，执行的job将与其它活动的进程共同竞争当前系统中的资源。

对于大型数据库系统，系统资源那可是相当宝贵的，在9i之前，谁想用就用，谁也管不了，其中表示最甚的就是job。你是否想起了JobClasses，没错定义JobClasses确实可以控制job能够使用的资源，不过单单使用JobClasses并不能灵活的控制job在合适的时间使用适当的资源。

进入10g之后，SCHEDULER中提供了WINDOW，事情终于有了缓解。WINDOW可以指定一个时间窗口，在此期间，通过与JobClasses的搭配组合，能够有效控制job执行时支配(使用)的资源。比如说job通常是在凌晨服务器负载较低时执行，那么就可以通过WINDOW设置在此期间，允许jobs使用更多的系统资源，而到了工作时间后，如果job仍未执行完成，为其分配另一个有限的资源，以尽可能降低job执行占用的资源对其它业务的影响。

１、创建Window

创建window有一个专门的过程：dbms_scheduler.create_window进行处理，该过程有两种调用方式，如下：

--基于SCHEDULE

DBMS_SCHEDULER.CREATE_WINDOW(

window_nameINVARCHAR2,

resource_planINVARCHAR2,

schedule_nameINVARCHAR2,

durationININTERVALDAYTOSECOND,

window_priorityINVARCHAR2DEFAULT'LOW',

commentsINVARCHAR2DEFAULTNULL);

--基于定义的调度

DBMS_SCHEDULER.CREATE_WINDOW(

window_nameINVARCHAR2,

resource_planINVARCHAR2,

start_dateINTIMESTAMPWITHTIMEZONEDEFAULTNULL,

repeat_intervalINVARCHAR2,

end_dateINTIMESTAMPWITHTIMEZONEDEFAULTNULL,

durationININTERVALDAYTOSECOND,

window_priorityINVARCHAR2DEFAULT'LOW',

commentsINVARCHAR2DEFAULTNULL);

下列几个参数可能需要关注：

（1）Resource_plan：这一参数用来指定要使用的资源使用计划，当打开WINDOW时，就会自动按照指定的资源使用计划中的设置分配资源，当WINDOW关闭时，系统会自动切换回适当资源计划。这个参数在执行过程时甚至可以指定为NULL或空值''，当设置为NULL时，就表示使用默认的资源计划，当设置为空值''时，表示禁用资源使用计划。

（2）Duration：指定WINDOW的有效期，比如说指定为interval'5'hour就表示5个小时，该参数在执行过程时必须指定参数值，否则创建会报错。

（3）Window_priority：该参数用来指定WINDOW的优先级。因为在相同时间只有一个WINDOW有效，因此如果在创建WINDOW时发现重叠的情况，ORACLE就需要根据这一参数指定的规则，来确定优先级，说白了就是先把资源给谁用，这一参数有两个可选值：HIGH或LOW，默认值为LOW。

正如前面CREATE_WINDOW过程语法结构显示的那样，调用该过程有两种方式，差异就在于是指定现有定义好的调度SCHEDULE，还是在执行过程时指定调度，目标和实现的功能都是相同的，这里仅做示例，咱就挑个最复杂的方式吧，执行过程时指定调度，执行脚本如下：

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/SQLproceduresuccessfullycompleted.

查询当前拥有的WINDOW，可以通过*_SCHEDULER_WINDOWS视图(注意只有DBA和ALL，没有USER，因为所有定义的WINDOW都属于SYS用户)。除了*_SCHEDULER_WINDOWS视图显示当前所有WINDOW外，还有：

（1）*_SCHEDULER_WINDOW_DETAILS视图：显示WINDOW的详细信息；

（2）*_SCHEDULER_WINDOW_LOG视图：显示WINDOW的日志，比如打开和关闭；

２、管理Window

修改对象属性，使用SET_ATTRIBUTE过程；

SQL>execdbms_scheduler.set_attribute('sys.my_first_wd1','start_date',sysdate+1);

PL/SQLproceduresuccessfullycompleted.

ENABLE对象，使用ENABLE过程；

SQL>execdbms_scheduler.enable('sys.my_first_wd1');

PL/SQLproceduresuccessfullycompleted.

DISABLE对象，使用DISABLE过程；

SQL>execdbms_scheduler.disable('sys.my_first_wd1');

PL/SQLproceduresuccessfullycompleted.

删除对象，使用DROP_WINDOW过程；

SQL>execdbms_scheduler.drop_window('sys.my_first_wd1');

PL/SQLproceduresuccessfullycompleted.

除此之外呢，对于WINDOW对象来说，由于其特殊作用，又有：手动打开WINDOW，使用OPEN_WINDOW过程；

注意WINDOW是依赖于其调度的，因此在手动打开WINDOW时，必须为其指定duration属性：

SQL>execdbms_scheduler.open_window('sys.my_first_wd1',interval'1'hour);;

PL/SQLproceduresuccessfullycompleted.

手动关闭WINDOW，使用CLOSE_WINDOW过程；

SQL>execdbms_scheduler.close_window('sys.my_first_wd1');

PL/SQLproceduresuccessfullycompleted.

关闭和打开WINDOW，都会记录日志，大家可以通过*_SCHEDULER_WINDOW_LOG视图中获取这部分信息。

３、关于WINDOWGROUP

除了WINDOW外，还有一个与WINDOW有关系的叫WINDOWGROUP，一个WINDOWGROUP可能包含多个WINDOW。

使用WINDOWGROUP的本意是这样的，假如说某个job执行的时间比较长，甚至全天24小时都在执行，对于这类job，单个WINDOW很难有效调整其资源占用，这时间呢，就可以通过设置一个WINDOWGROUP，该WINDOWGROUP中包含了多个WINDOW，每个WINDOW分别负责不同时间点时的资源使用计划。

然后在创建JOB时，指定schedule_name参数为WINDOWGROUP的名称(SCHEDULE_NAME可以指定为WINDOWGROUP，WINDOWGROUP，还可以直接指定成WINDOW)，这样，就可以通过很简单的方式，将job与window联系在一起了。

WINDOWGROUP的创建和管理与前面介绍的方式极其相似：

（1）创建，使用CREATE_WINDOW_GROUP过程；

（2）删除，使用DROP_WINDOW_GROUP过程；

（3）添加WINDOW成员，使用ADD_WINDOW_GROUP_MEMBER过程；

（4）删除WINDOW成员，使用REMOVE_WINDOW_GROUP_MEMBER过程；

（5）启用，使用ENABLE过程；

（6）禁用，使用DISABLE过程；

整理自网络

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