Oracle 使用DBMS_JOB和DBMS_SCHEDULER 创建定时任务创建管理job示例

不念不忘少年蓝@ 2022-04-11 13:50 702阅读 0赞

# 使用DBMS\_JOB和DBMS\_SCHEDULER创建、管理job示例 #

原创 [Oracle][] 作者：[Hoegh][] 时间：2015-04-28 16:52:41  6439  0

DBMS\_JOB和DBMS\_SCHEDULER都是Oracle提供的程序包，都可以用来创建、管理job，其中DBMS\_SCHEDULER的功能更为强大。先解释scheduler的基础概念，scheduler 包含了以下几个实体对象：

1.  Program -- 提供了scheduler 将要运行什么，包含program name，program type(PL/SQ块、存储过程、外部程序)，program action(具体的程序实体，比如说一个PL/SQL块、或者是存储过程的名称、或者是外部程序的路径加名称) 。 
2.  Schedules -- 指定何时何种频率来运行job，可以被不同的job重复的利用。比如说我有两个job都要求在每天的凌晨4点运行，那么两个job可以同时指定相同的schedule。 
3.  Jobs -- 具体的作业的名称，依赖于那个program、schedule。也可以不指定program、schedule，而直接写入program、schedule的相应参数。

另外，需要注意的是，通过DBMS\_JOB和DBMS\_SCHEDULER创建的job信息存储在不同的数据字典中，其中，**通过****DBMS\_JOB****创建的job信息存储在user\_jobs，而通过****DBMS\_SCHEDULER创建的job信息****存储在****user\_scheduler\_jobs中**。  
  
下面，分别使用DBMS\_JOB和DBMS\_SCHEDULER来创建job。  
  
**使用DBMS\_JOB**  
**1.创建测试表**

**点击(此处)折叠或打开**

1.  **SQL> create table hoegh(h1 date); **
2.  ** **
3.  **Table created**
4.  ** **
5.  **SQL>**

**2.创建存储过程，向hoegh表中插入一条数据**

**点击(此处)折叠或打开**

1.  **SQL> **
2.  **SQL> create or replace procedure pro\_hoegh is**
3.  **  2 begin**
4.  **  3 insert into hoegh values(sysdate);**
5.  **  4 COMMIT;**
6.  **  5 end pro\_hoegh;**
7.  **  6 /**
8.  ** **
9.  **Procedure created**
10. ** **
11. **SQL>**

**3.创建job**

**点击(此处)折叠或打开**

1.  **SQL> **
2.  **SQL> variable job1 number**
3.  **SQL> begin**
4.  **  2 dbms\_job.submit(:job1,\\'pro\_hoegh;\\',sysdate,\\'sysdate+1/1440\\');--每天1440分钟，即一分钟运行test过程一次**
5.  **  3 end;**
6.  **  4 /**
7.  ** **
8.  **PL/SQL procedure successfully completed**
9.  **job1**
10. **---------**
11. **1**
12. ** **
13. **SQL>**

**4.执行job**

**点击(此处)折叠或打开**

1.  **SQL> **
2.  **SQL> begin**
3.  **  2 dbms\_job.run(:job1);**
4.  **  3 end;**
5.  **  4 /**
6.  ** **
7.  **PL/SQL procedure successfully completed**
8.  **job1**
9.  **---------**
10. **1**
11. ** **
12. **SQL>**

**两分钟后，查询测试表，确认job是否正常执行**

**点击(此处)折叠或打开**

1.  **SQL> select to\_char(h1,\\'yyyy-mm-dd HH24:mi:ss\\') H1 from hoegh;**
2.  ** **
3.  **H1**
4.  **-------------------**
5.  **2015-04-28 16:08:23**
6.  **2015-04-28 16:07:21**
7.  ** **
8.  **SQL>**

**5.停止job**

**点击(此处)折叠或打开**

1.  **SQL> **
2.  **SQL> begin**
3.  **  2 dbms\_job.broken(1,true);**
4.  **  3 end;**
5.  **  4 /**
6.  ** **
7.  **PL/SQL procedure successfully completed**
8.  ** **
9.  **SQL>**

**其中，1是创建job是定义的变量值，可以唯一标识一个job  
6.启用job**

**点击(此处)折叠或打开**

1.  **SQL> **
2.  **SQL> begin**
3.  **  2 dbms\_job.broken(1,false);**
4.  **  3 end;**
5.  **  4 /**
6.  ** **
7.  **PL/SQL procedure successfully completed**
8.  ** **
9.  **SQL>**

**7.删除job**

**点击(此处)折叠或打开**

1.  **SQL> **
2.  **SQL> begin**
3.  **  2 dbms\_job.remove(1);**
4.  **  3 end;**
5.  **  4 /**
6.  ** **
7.  **PL/SQL procedure successfully completed**
8.  ** **
9.  **SQL>**

**使用DBMS\_SCHEDULER  
1.创建测试表**

**点击(此处)折叠或打开**

1.  **SQL> create table hoegh(h1 date); **
2.  ** **
3.  **Table created**
4.  ** **
5.  **SQL>**

**2.创建存储过程，向hoegh表中插入一条数据**

**点击(此处)折叠或打开**

**3.创建schedule  
在schedule中定义了schedule名称、起止时间、调用间隔等参数。**

**点击(此处)折叠或打开**

1.  **SQL> **
2.  **SQL> begin**
3.  **  2 -- create\_schedule**
4.  **  3 dbms\_scheduler.create\_schedule(schedule\_name => \\'schedule\_hoegh\\',**
5.  **  4 start\_date => \\'28-4月 -15 4.30.00.000 下午\\',**
6.  **  5 repeat\_interval => \\'FREQ=MINUTELY; INTERVAL=1\\',**
7.  **  6 end\_date => \\'29-4月 -15 4.30.00.000 下午\\',**
8.  **  7 comments => \\'TEST schedule\\');**
9.  **  8 end;**
10. **  9 /**
11. ** **
12. **PL/SQL procedure successfully completed**
13. ** **
14. **SQL>**

**4.创建program  
在program中定义了程序的类型、具体操作、参数个数等参数**

**点击(此处)折叠或打开**

1.  **SQL> **
2.  **SQL> begin**
3.  **  2 -- create\_program**
4.  **  3 dbms\_scheduler.create\_program(program\_name => \\'program\_hoegh\\',**
5.  **  4 program\_type => \\'PLSQL\_BLOCK\\',**
6.  **  5 program\_action => \\'BEGIN PRO\_HOEGH; END;\\',**
7.  **  6 number\_of\_arguments => 0,**
8.  **  7 enabled => TRUE,**
9.  **  8 comments => \\'TEST program\\');**
10. **  9 end;**
11. ** 10 /**
12. ** **
13. **PL/SQL procedure successfully completed**
14. ** **
15. **SQL>**

**5.创建job  
在job中指定了job\_name，以及相关联的program\_name、schedule\_name等参数。**

**点击(此处)折叠或打开**

1.  **SQL> **
2.  **SQL> begin**
3.  **  2 -- create\_job**
4.  **  3 dbms\_scheduler.create\_job(job\_name => \\'job\_hoegh\\',**
5.  **  4 program\_name => \\'program\_hoegh\\',**
6.  **  5 schedule\_name => \\'schedule\_hoegh\\',**
7.  **  6 job\_class => \\'DEFAULT\_JOB\_CLASS\\',**
8.  **  7 enabled => true,**
9.  **  8 auto\_drop => true,**
10. **  9 comments => \\'TEST procedure\\');**
11. ** 10 end;**
12. ** 11 /**
13. ** **
14. **PL/SQL procedure successfully completed**
15. ** **
16. **SQL>**

**6.执行job**

**点击(此处)折叠或打开**

1.  **SQL> **
2.  **SQL> begin**
3.  **  2 -- Call the procedure**
4.  **  3 dbms\_scheduler.run\_job(job\_name => \\'job\_hoegh\\',**
5.  **  4 use\_current\_session => false);**
6.  **  5 end;**
7.  **  6 /**
8.  ** **
9.  **PL/SQL procedure successfully completed**
10. ** **
11. **SQL>**

**几分钟后，查询测试表，确认job是否正常执行**

**点击(此处)折叠或打开**

1.  **SQL> select to\_char(h1,\\'yyyy-mm-dd HH24:mi:ss\\') H1 from hoegh;**
2.  ** **
3.  **H1**
4.  **-------------------**
5.  **2015-04-28 16:30:00**
6.  **2015-04-28 16:31:00**
7.  **2015-04-28 16:32:00**
8.  **2015-04-28 16:24:25**
9.  ** **
10. **SQL>**

**7.禁用job**

**点击(此处)折叠或打开**

1.  **SQL> **
2.  **SQL> begin**
3.  **  2 dbms\_scheduler.disable(\\'job\_hoegh\\');**
4.  **  3 end;**
5.  **  4 /**
6.  ** **
7.  **PL/SQL procedure successfully completed**
8.  ** **
9.  **SQL> **
10. **SQL> select job\_name,enabled,state from user\_scheduler\_jobs;**
11. ** **
12. **JOB\_NAME ENABLED STATE**
13. **------------------------------ ------- ---------------**
14. **JOB\_HOEGH FALSE DISABLED**
15. ** **
16. **SQL>**

**8.启用job**

**点击(此处)折叠或打开**

1.  **SQL> **
2.  **SQL> begin**
3.  **  2 dbms\_scheduler.enable(\\'job\_hoegh\\');**
4.  **  3 end;**
5.  **  4 /**
6.  ** **
7.  **PL/SQL procedure successfully completed**
8.  ** **
9.  **SQL> **
10. **SQL> select job\_name,enabled,state from user\_scheduler\_jobs;**
11. ** **
12. **JOB\_NAME ENABLED STATE**
13. **------------------------------ ------- ---------------**
14. **JOB\_HOEGH TRUE SCHEDULED**
15. ** **
16. **SQL>**

**9.删除job**

**点击(此处)折叠或打开**

1.  **SQL> **
2.  **SQL> begin**
3.  **  2 dbms\_scheduler.drop\_job(\\'job\_hoegh\\');**
4.  **  3 end;**
5.  **  4 /**
6.  ** **
7.  **PL/SQL procedure successfully completed**
8.  ** **
9.  **SQL> **
10. **SQL> select job\_name,enabled,state from user\_scheduler\_jobs;**
11. ** **
12. **JOB\_NAME ENABLED STATE**
13. **------------------------------ ------- ---------------**
14. ** **
15. **SQL>**

来自 “ ITPUB博客 ” ，链接：http://blog.itpub.net/30162081/viewspace-1609120/，如需转载，请注明出处，否则将追究法律责任。

[http://blog.itpub.net/30162081/viewspace-1609120/][http_blog.itpub.net_30162081_viewspace-1609120]

# Oracle 使用DBMS\_SCHEDULER创建定时任务 #

2016年04月01日 17:08:06 [Seabiscuit\_92][Seabiscuit_92] 阅读数：6616 标签： [oracle][][DBMS\_SCHEDULER][DBMS_SCHEDULER] 更多

个人分类： [Oracle][Oracle 1]

在Oracle10g里面，已经不赞成使用DBMS\_JOB，推荐使用DBMS\_SCHEDULER，它的健壮为调度提供更好的规划和结构。下面我只简单写一个例子。   
begin   
    DBMS\_SCHEDULER.CREATE\_PROGRAM(   
    program\_name => 'guozhw',   
    program\_type => 'STORED\_PROCEDURE',   
    program\_action => 'guozhwTest',   
    number\_of\_arguments => 0,   
    enabled => true,   
    comments => '定时调度测试'   
    );   
end;   
program\_name:program的名字   
program\_type:program的类型。STORED\_PROCEDURE存储过程   
program\_action:要执行的程序。guozhwTest 存储过程的名字   
  
    
  
    
  
举例如下：   
  
BEGIN   
      DBMS\_SCHEDULER.CREATE\_PROGRAM (   
         program\_name            => 'PRM\_CREATEDUNDATA',   
         program\_action          => 'PKG\_SCHEDULER.CREATEDUNDATA',   
         program\_type            => 'STORED\_PROCEDURE',   
         enabled                 => FALSE,   
     number\_of\_arguments     => 5,   
     comments            => '生成催缴数据'        
     );   
  
  DBMS\_SCHEDULER.DEFINE\_PROGRAM\_ARGUMENT(PROGRAM\_NAME      => 'PRM\_CREATEDUNDATA',  
                                         ARGUMENT\_POSITION => 1,   
                                         ARGUMENT\_NAME     => 'I\_BILLINGCYCLEID',  
                                         ARGUMENT\_TYPE     => 'VARCHAR2',   
                                         DEFAULT\_VALUE     => NULL,   
                                         OUT\_ARGUMENT      => FALSE);   
                                            
  DBMS\_SCHEDULER.DEFINE\_PROGRAM\_ARGUMENT(PROGRAM\_NAME      => 'PRM\_CREATEDUNDATA',  
                                         ARGUMENT\_POSITION => 2,   
                                         ARGUMENT\_NAME     => 'I\_BUSINESSTYPE',   
                                         ARGUMENT\_TYPE     => 'VARCHAR2',   
                                         DEFAULT\_VALUE     => NULL,   
                                         OUT\_ARGUMENT      => FALSE);   
  
  DBMS\_SCHEDULER.DEFINE\_PROGRAM\_ARGUMENT(PROGRAM\_NAME      => 'PRM\_CREATEDUNDATA',  
                                         ARGUMENT\_POSITION => 3,   
                                         ARGUMENT\_NAME     => 'I\_STATE',   
                                         ARGUMENT\_TYPE     => 'VARCHAR2',   
                                         DEFAULT\_VALUE     => NULL,   
                                         OUT\_ARGUMENT      => FALSE);   
                                            
  DBMS\_SCHEDULER.DEFINE\_PROGRAM\_ARGUMENT(PROGRAM\_NAME      => 'PRM\_CREATEDUNDATA',  
                                         ARGUMENT\_POSITION => 4,   
                                         ARGUMENT\_NAME     => 'I\_BANKCODE',   
                                         ARGUMENT\_TYPE     => 'VARCHAR2',   
                                         DEFAULT\_VALUE     => NULL,   
                                         OUT\_ARGUMENT      => FALSE);   
  
  DBMS\_SCHEDULER.DEFINE\_PROGRAM\_ARGUMENT(PROGRAM\_NAME      => 'PRM\_CREATEDUNDATA',  
                                         ARGUMENT\_POSITION => 5,   
                                         ARGUMENT\_NAME     => 'I\_OPERATORCODE',   
                                         ARGUMENT\_TYPE     => 'VARCHAR2',   
                                         DEFAULT\_VALUE     => NULL,   
                                         OUT\_ARGUMENT      => FALSE);   
  
  DBMS\_SCHEDULER.ENABLE(NAME => 'PRM\_CREATEDUNDATA');   
  COMMIT;   
END;   
  
    
  
    
  
    
  
之后就可以在select \* from sys.USER\_SCHEDULER\_PROGRAMS t中看到program了   
  
    
  
    
  
    
  
×××××××××××××××××××××××××××××××××××××××××\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*  
  
最近遇到一个CASE，要做定时任务，想来想去，还是先看看Oracle提供了啥..   
Oracle10g引入了一种新的作业调度程序：dbms\_scheduler，通过如下命令可以查看它包含一些什么功能，   
SQL> desc sys.dbms\_scheduler;   
...   
不过，最好还是用PL/SQL dev或者TOAD来展开包头，这样所有功能和注释都一幕了然了。   
在Oracle9i，我们都是job来运行定时任务，例如定时备份一些数据，定时清理一下归档。在Oracle10g里面，已经不   
赞成试用DBMS\_JOB，而是推荐使用DBMS\_SCHEDULER，它更加的复杂和健壮，为调度提供更好的规划和结构。   
dbms\_scheduler把创建一个作业分成了不同的部分：dbms\_scheduler，program和job，下面我们依次来创建一个例子。   
首先创建一个测试表:   
SQL> desc user118800;   
Name     Type     Nullable Default Comments   
\------------- ------------ -------- ------- --------   
SN       NUMBER           序列      
AREACODE   VARCHAR2(4)         区号      
DEVICESNUMBER VARCHAR2(12)         电话号码   
READ     INTEGER       0   是否读取   
BIT     INTEGER           业务位      
DDATE     DATE     Y              
有如下存储过程：   
create or replace procedure pro\_test is   
begin   
UPDATE user118800 SET READ=1,ddate=SYSDATE WHERE READ=0 AND ROWNUM <2;   
COMMIT;   
\--sys.dbms\_lock.sleep(120);   
end pro\_test;   
这个测试，就是用过程来更新user118800表里面的一行数据，并记录下更新时间，接着我们就创建作业来定时执行。   
创建一个scheduler：   
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*   
\* Schedule Administration Procedures   
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*   
\*/   
\-- Schedule attributes which can be used with set\_attribute/get\_attribute are :   
\--   
\-- repeat\_interval   - VARCHAR2   
\--           an expression using the calendar syntax   
\-- comments     - VARCHAR2   
\--           an optional comment.   
\-- end\_date     - TIMESTAMP WITH TIME ZONE   
\--           cutoff date after which the schedule will not specify   
\--           any dates   
\-- start\_date   - TIMESTAMP WITH TIME ZONE   
\--           start or reference date used by the calendar syntax   
\--   
\-- Schedules cannot be enabled and disabled.   
\-- Create a named schedule. This must be a valid schedule.   
PROCEDURE create\_schedule(   
schedule\_name     IN VARCHAR2,   
start\_date       IN TIMESTAMP WITH TIME ZONE DEFAULT NULL,   
repeat\_interval     IN VARCHAR2,   
end\_date       IN TIMESTAMP WITH TIME ZONE DEFAULT NULL,   
comments       IN VARCHAR2         DEFAULT NULL);   
这是创建scheduler的存储过程，运行如下：   
begin   
\-- Call the procedure   
sys.dbms\_scheduler.create\_schedule(schedule\_name => 'your schedule\_name',   
                start\_date => '27-8月 -07 12.00.00.000 上午',   
                repeat\_interval => 'FREQ=MINUTELY; INTERVAL=1',   
                end\_date => '28-8月 -07 12.00.00.000 上午',   
                comments => 'TEST SCHEDULER');   
end;   
这里需要注意的是，参数start\_date和end\_date都是TIMESTAMP 类型，在输入的时候要遵循它们的格式，   
往往doc里面的格式都是英文环境下的，这个时候你要通过查询字典nls\_database\_parameters或者   
select to\_timestamp(sysdate) from dual; 来获得格式。   
repeat\_interval是调度运行的时间间隔，本例是每分钟运行一次   
repeat\_interval => 'FREQ=HOURLY; INTERVAL=1'   
每小时运行一次   
repeat\_interval => 'FREQ=DAILY INTERVAL=1'   
每天运行一次   
更详细的说明，要查询doc。另外它还有一个过程dbms\_scheduler.evaluate\_calendar\_string是估算下一次运行的时间的。   
第二步，创建一个program   
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*   
\* Program Administration Procedures   
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*   
\*/   
\-- Program attributes which can be used with set\_attribute/get\_attribute are:   
\--   
\-- program\_action   - VARCHAR2   
\--           This is a string specifying the action. In case of:   
\--           'PLSQL\_BLOCK': PLSQL code   
\--           'STORED\_PROCEDURE: name of the database object   
\--           representing the type (optionally with schema).   
\--           'EXECUTABLE': Full pathname including the name of the   
\--           executable, or shell script.   
\-- program\_type   - VARCHAR2   
\--           type of program. This must be one of the supported   
\--           program types. Currently these are   
\--           'PLSQL\_BLOCK', 'STORED\_PROCEDURE', 'EXECUTABLE'   
\-- comments       - VARCHAR2   
\--           an optional comment. This can describe what the   
\--           program does, or give usage details.   
\-- number\_of\_arguments- PLS\_INTEGER   
\--           the number of arguments of the program that can be set   
\--           by any job using it, these arguments MUST be defined   
\--           before the program can be enabled   
\-- enabled       - BOOLEAN   
\--           whether the program is enabled or not. When the program   
\--           is enabled, checks are made to ensure that the program   
\--           is valid.   
\-- Create a new program. The program name can be optionally qualified with a   
\-- schema. If enabled is set to TRUE, validity checks will be performed and   
\-- the program will be created in an enabled state if all are passed.   
PROCEDURE create\_program(   
program\_name       IN VARCHAR2,   
program\_type       IN VARCHAR2,   
program\_action     IN VARCHAR2,   
number\_of\_arguments   IN PLS\_INTEGER DEFAULT 0,   
enabled       IN BOOLEAN DEFAULT FALSE,   
comments       IN VARCHAR2 DEFAULT NULL);   
运行如下：   
begin   
\-- Call the procedure   
sys.dbms\_scheduler.create\_program(program\_name => 'your program\_name',   
                program\_type => 'PLSQL\_BLOCK',   
                program\_action => 'BEGIN PRO\_TEST; END;',   
                number\_of\_arguments => 0,   
                enabled => TRUE,   
                comments => 'comments');   
end;   
这里需要注意的是program\_type,如果你要运行PLSQL块，则选择PLSQL\_BLOCK，如果是sh脚本，则'EXECUTABLE'。   
这里我选择PLSQL块。   
第三步创建一个job   
\-- create a job using a named schedule object and a named program object.   
\-- If enabled is set TRUE, it will be attempted to enable this job after   
\-- creating it.   
\-- Values must be set for each argument of the program that does not have a   
\-- default\_value specified (before enabling the job).   
PROCEDURE create\_job(   
job\_name       IN VARCHAR2,   
program\_name       IN VARCHAR2,   
schedule\_name     IN VARCHAR2,   
job\_class       IN VARCHAR2       DEFAULT 'DEFAULT\_JOB\_CLASS',   
enabled       IN BOOLEAN         DEFAULT FALSE,   
auto\_drop       IN BOOLEAN         DEFAULT TRUE,   
comments       IN VARCHAR2       DEFAULT NULL);   
实际在10g提供的过程里面，有6中create job的方法，而且也可以单独创建作业，但这里我们选择其中一种。   
begin   
\-- Call the procedure   
sys.dbms\_scheduler.create\_job(job\_name => 'my test job',   
            program\_name => 'your program\_name',   
            schedule\_name => 'your schedule\_name',   
            job\_class => 'DEFAULT\_JOB\_CLASS',   
            enabled => true,   
            auto\_drop => true,   
            comments => 'comments');   
end;   
这样就完成了一个job的创建，下面就是运行它：   
begin   
\-- Call the procedure   
sys.dbms\_scheduler.run\_job(job\_name => 'my test job',   
            use\_current\_session => 'false');   
end;   
use\_current\_session 这个参数要定义为false，它才能在后台运行。   
创建以后的监控：   
查看调度   
SELECT \* FROM User\_Scheduler\_Schedules;   
查看作业   
SELECT \* FROM User\_Scheduler\_Jobs;   
查看程序   
SELECT \* FROM User\_Scheduler\_Programs;   
查看执行中的作业，也就是PRO\_TEST在运行阶段的作业。前面的过程中，我定义了一个sys.dbms\_lock.sleep(120);   
实际就是为了查看这个视图。   
SELECT \* FROM User\_Scheduler\_Running\_Jobs;   
查看job的日志   
SELECT \* FROM User\_Scheduler\_Job\_Log;   
如果日志中有FAILeD的状态，那么就要查看altersid.log了。   
好了，一个基本的调度例子就完成了。如果想更详细的了解它，请阅读该包头的注释，和查阅相关DOC   
Oracle&reg; Database   
PL/SQL Packages and Types Reference   
10g Release 2 (10.2)   
在9i的时候，job有一个烦人的问题，就是延时，一个job的执行耗时是10分钟，inteval为1天，第一次执行为晚上12点，   
在以后的执行过程中，该job为逐渐按10分钟递增时间。10g的Scheduler解决了这个问题，但是我还是发现Scheduler同样无法异步的执行，我的inteval是1分钟，但在程序中如果打开  
sleep(120)后，实际inteval就变成了120秒...它还是和job一样，必须等待上一次任务的完成，这样也没有达到我的初衷。   
最后，我也应用中是否最终会使用Scheduler，还有待测试。除了Scheduler，在中间层，如EJB和Spring....   
  
    
  
    
  
    
  
    
  
part 1   
  
1. 创建job   
  
job是什么呢? 简单的说就是计划(schedule)加上任务说明. 另外还有一些必须的参数.   
  
这里提到的"任务"可以是数据库内部的存储过程,匿名的PL/SQL块,也可以是操作系统级别的脚本.   
  
可以有两种方式来定义"计划":   
1) 使用DBMS\_SCHDULER.CREATE\_SCHEDULE 定义一个计划;   
2) 调用DBMS\_SCHDULER.CREATE\_JOBE过程直接指定 (下面会详细说明)   
  
在创建一个计划时，你至少需要指定下面的属性，它们是job运行所必须的:   
  
开始时间 (start\_time);   
  
重复频率 (repeat\_interval);   
  
结束时间 (end\_time)   
  
  
另外，对于一个job而言，还有很多的附加参数:   
  
job\_class   
job\_priority   
auto\_drop   
restartable   
max\_runs   
max\_failures   
schedule\_limit   
logging\_level   
  
  
下面，我以问答的形式来具体解释.   
  
  
Q1:怎么从数据库中查询job的属性 ?   
  
A1: 有两种方法:   
  
1) 查询(DBA|ALL|USER)\_SCHEDULER\_JOBS 视图   
(提示: 根据用户权限的不同，选择性的查询 DBA|ALL|USER视图)   
  
2) 调用DBMS\_SCHEDULER包中的GET\_ATTRIBUTE 过程   
  
  
Q2: 怎么设置这些属性呢?   
  
A2: 也是有两种方法   
  
1) 在创建job时直接指定   
  
2) 调用DBMS\_SCHEDULER包中的SET\_ATTRIBUTE 过程   
  
  
Q3: "我需要什么权限才能创建job" ?   
  
A3: 你至少需要create\_job这个系统权限。如果用户拥有create any job这个权限，   
它可以创建属主为任何用户(SYS用户除外)的job.   
  
缺省情况下,job会被创建在当前的schema下，并且是没有激活的; 如果要使job一创建   
就自动激活，需要显式的设置enabled 属性为true, 来看一个例子:   
  
begin   
dbms\_scheduler.create\_job   
(   
job\_name => 'ARC\_MOVE',   
schedule\_name => 'EVERY\_60\_MINS',   
job\_type => 'EXECUTABLE',   
job\_action => '/home/dbtools/move\_arcs.sh',   
enabled => true,   
comments => 'Move Archived Logs to a Different Directory'   
);   
end;   
/   
  
  
Q4: 能不能详细地讲述一下上面这个过程用到的各个参数?   
  
A4:   
job\_name: 顾名思义,每个job都必须有一个的名称   
schedule\_name: 如果定义了计划，在这里指定计划的名称   
job\_type: 目前支持三种类型:   
  
PL/SQL块: PLSQL\_BLOCK,   
存储过程: STORED\_PROCEDURE   
外部程序: EXECUTABLE (外部程序可以是一个shell脚本,也可以是操作系统级别的指令).   
  
job\_action: 根据job\_type的不同，job\_action有不同的含义.   
如果job\_type指定的是存储过程，就需要指定存储过程的名字;   
如果job\_type指定的是PL/SQL块，就需要输入完整的PL/SQL代码;   
如果job\_type指定的外部程序，就需要输入script的名称或者操作系统的指令名   
  
enabled: 上面已经说过了，指定job创建完毕是否自动激活   
comments: 对于job的简单说明   
  
  
  
2. 指定job的执行频率   
  
如果我们创建了一个job,并且希望它按照我们指定的日期和时间来运行，就需要定义   
job的重复频度了. 例如每天运行，每周日的22:00运行, 每周一,三,五运行，每年的   
最后一个星期天运行等等.   
(说明:10G以前的版本，与操作系统的交互方面，实现的不是很好。例如要实现一个   
定期的rman备份任务，就需要结合OS的命令来实现,在UNIX下可以用crontab实现，   
在windows下用AT命令来实现)   
  
10G 在这方面有了很大的增强，因为创建job时可以直接指定操作系统的命令或者   
脚本，再合理的定义job的执行频率,可以很轻松地完成复杂的调度任务.   
  
10G 支持两种模式的repeat\_interval,一种是PL/SQL表达式，这也是dbms\_job包   
中所使用的,例如SYSDATE+1, SYSDATE + 30/24\*60; 另一种就是日历表达式。   
例如MON表示星期一,SUN表示星期天,DAY表示每天,WEEK表示每周等等. 下面来   
看几个使用日历表达式的例子：   
  
repeat\_interval => 'FREQ=HOURLY; INTERVAL=2'   
每隔2小时运行一次job   
  
repeat\_interval => 'FREQ=DAILY'   
每天运行一次job   
  
repeat\_interval => 'FREQ=WEEKLY; BYDAY=MON,WED,FRI"   
每周的1,3,5运行job   
  
repeat\_interval => 'FREQ=YEARLY; BYMONTH=MAR,JUN,SEP,DEC; BYMONTHDAY=30'   
每年的3,6,9,12月的30号运行job   
  
用过crontab的人应该都有种似曾相识的感觉吧，呵呵   
  
  
下面再说说使用日历表达式的规则:   
  
日历表达式基本分为三部分: 第一部分是频率，也就是"FREQ"这个关键字，   
它是必须指定的; 第二部分是时间间隔，也就是"INTERVAL"这个关键字，   
取值范围是1-999. 它是可选的参数; 最后一部分是附加的参数,可用于   
精确地指定日期和时间,它也是可选的参数,例如下面这些值都是合法的:   
BYMONTH,BYWEEKNO,BYYEARDAY,BYMONTHDAY,BYDAY   
BYHOUR,BYMINUTE,BYSECOND   
  
详细的参数说明请参考 dbms\_scheduler的使用说明.   
  
既然说到了repeat\_interval,你可能要问:"有没有一种简便的方法来得出，   
或者说是评估出job的每次运行时间，以及下一次的运行时间呢?"   
  
dbms\_scheduler包提供了一个过程evaluate\_calendar\_string,可以很   
方便地完成这个需求. 来看下面的例子:   
  
SQL> set serveroutput on size 999999   
  
SQL> declare   
L\_start\_date TIMESTAMP;   
l\_next\_date TIMESTAMP;   
l\_return\_date TIMESTAMP;   
  
begin   
l\_start\_date := trunc(SYSTIMESTAMP);   
l\_return\_date := l\_start\_date;   
for ctr in 1..10 loop   
dbms\_scheduler.evaluate\_calendar\_string(   
'FREQ=DAILY; BYDAY=MON,TUE,WED,THU,FRI; BYHOUR=7,15',   
l\_start\_date, l\_return\_date, l\_next\_date   
);   
  
dbms\_output.put\_line('Next Run on: ' ||   
to\_char(l\_next\_date,'mm/dd/yyyy hh24:mi:ss')   
);   
  
l\_return\_date := l\_next\_date;   
  
end loop;   
end;   
/   
  
  
输出结果如下:   
  
Next Run on: 03/22/2004 07:00:00   
Next Run on: 03/22/2004 15:00:00   
Next Run on: 03/23/2004 07:00:00   
Next Run on: 03/23/2004 15:00:00   
Next Run on: 03/24/2004 07:00:00   
Next Run on: 03/24/2004 15:00:00   
Next Run on: 03/25/2004 07:00:00   
Next Run on: 03/25/2004 15:00:00   
Next Run on: 03/26/2004 07:00:00   
Next Run on: 03/26/2004 15:00:00   
  
    
  
DBMS\_SCHEDULER 中度解析: part 2   
  
3. 创建程序 (program)   
  
什么是程序? 我的理解就是准备计划需要的元数据(metadata),它   
包括以下部分:   
  
程序名;   
  
程序中用到的参数: 例如程序的类型，以及具体操作的描述   
  
来看一个例子   
begin   
dbms\_scheduler.create\_program(   
program\_name=> 'DAILY\_BACKUP\_SH',   
program\_type=> 'EXECUTABLE',   
program\_action=> '/home/oracle/script/daily\_backup.sh');   
end;   
/   
  
这个例子将会创建一个名为"DAILY\_BACKUP\_SH"的程序，类型是可执行的shell脚本，脚本的名称是“/home/oracle/script/daily\_backup.sh”  
  
  
Q1: 程序和作业相比，有什么区别呢?   
  
A1: 程序其实是可以与作业分离的，因此不同的用户可以在不同的时间段去重用它.而一个作业是属于特定的用户的;   
  
另外，将程序与作业分离，也就激活了一个新的程序库(Program Library),利用程序库,用户可以很自由地选择特定的程序在特定的时间段运行，以及自由的配置程序执行时的参数.  
  
  
Q2: 能否解释一下 create\_program与create\_job的关系?   
  
A2: 首先，你应该知道创建程序并不是一个计划的必须组成部分，一个计划可以没有程序,但是必须有一个已经定义好的作业;   
另外,program\_action这个参数也是可选的，假如程序的类型是pl/sql 块,你完全可以在创建作业时来指定它.   
  
上面已经提到了，程序和作业可以是分离的，这样一个程序的具体执行(ACTION) 就可以灵活地确定。它既可以只运行一次，也可以在多个不同的作业中来重用这个执行. 这样一来，在修改针对一个作业的计划时就非常灵活，你不需要重新创建pl/sql块.  
  
  
Q3: 运行 create\_program需要什么权限 ?   
  
A3: 要保证create\_program能够顺利执行，你同样需要CREATE JOB这个系统权限. 如果一个用户拥有了create any job这个权限，它就可以创建属主为任何用户的程序(SYS用户除外)  
  
与创建作业一样，一个程序建立完毕，缺省的状态也是非激活的,当然你可以在创建程序时，显式的设置enabled参数为true来   
激活它.   
  
  
Q4: 能否介绍一下create\_program这个过程的各个参数?   
更多的例子?   
  
A4:   
program\_name: 指定程序的名称;   
  
program\_type: 目前只支持下面三种:   
STORED\_PROCEDURE   
PLSQL\_BLOCK   
EXECUTABLE   
  
program\_action: (有长度限制,因为类型是varchar2)   
  
存储过程的名称;   
具体的pl/sql代码   
操作系统脚本名称   
  
  
来看一个使用pl/sql块的例子   
BEGIN   
DBMS\_SCHEDULER.CREATE\_PROGRAM(   
program\_name => 'LEO.UPDATE\_STATS',   
program\_type => 'PLSQL\_BLOCK',   
  
program\_action => 'DECLARE   
sUsername varchar2(30);   
  
cursor cur is select username from dba\_users   
where username not in ('SYS','SYSTEM','SYSMAN','DBSNMP')   
and account\_status='OPEN' and substr(username,1,5)<>'MGMT\_' ;   
  
BEGIN   
  
OPEN cur;   
FETCH cur into sUsername;   
  
WHILE cur%Found   
LOOP   
DBMS\_STATS.GATHER\_SCHEMA\_STATS (sUsername);   
  
FETCH cur into sUsername;   
END LOOP;   
  
close cur;   
  
END;');   
  
END;   
/   
  
上面这个例子创建一个名为"UPDATE\_STATS"的程序，它的类型是PL/SQL 块，完成更新非系统用户的统计信息的工作。在这个基础上你可以定制一个合理的计划，来定期执行这个程序.  
  
  
  
4. 配置程序的参数   
  
先来看一个例子   
  
begin   
dbms\_scheduler.create\_program(   
program\_name=> 'LEO.UPDATE\_STATS\_2',   
program\_action=> 'LEO.UPDATE\_SCHEMA\_STATUS');   
program\_type=> 'STORED\_PROCEDURE',   
number\_of\_arguments => 1,   
enabled => TRUE);   
  
dbms\_scheduler.define\_program\_argument(   
program\_name=> 'UPDATE\_STATS\_2',   
argument\_name => 'SCHEMA\_NAME',   
argument\_position => 1,   
argument\_type => 'varchar2',   
default\_value => 'HR');   
end;   
/   
  
这个例程是不是很像上面的那个例子呢? 对,它们的区别只是   
在这个例子中,程序的类型是存储过程，而不是pl/sql块.   
  
解释:   
使用define\_program\_argument这个过程来定义一个程序所需要的参数. 有两点说明一下:   
  
1) 程序如果使用了参数，就必须事先指定，这样才能在程序被job使用时生效;   
  
2) 定义程序的参数不会改变程序的激活属性。也就是说，如果一个程序是没有激活的状态,运行了define\_program\_argument过程不会自动激活这个程序.  
  
  
关于权限:   
缺省情况下只有program的owner才能修改创建的程序，如果用户被授予了alter 权限 或者 create any job权限，就可以修改属主为另一个用户的程序.  
  
  
  
5. 创建计划(Schedule)   
  
其实，如果你已经了解了怎样创建作业和程序，就等于已经掌握怎样创建计划了。你需要做的附加工作只是指定计划的开始时间，结束时间，重复频率等等.   
  
来看一个例子   
  
begin   
dbms\_scheduler.create\_job(   
job\_name=> 'leo.UPDATE\_STATS\_JOB',   
program\_name=> 'leo.UPDATE\_STATS\_2',   
start\_date=>'2005-06-20 11:00.00.000000 PM +8:00',   
repeat\_interval=>'FREQ=MONTHLY;INTERVAL=1',   
end\_date=>'2006-06-20 11:00.00.000000 PM +8:00',   
comments=>'Monthly statistics collection job');   
end;   
/   
  
start\_date和end\_date这两个参数需要说明一下: 它们的数据类型   
是timestamp，因此需要精确的指定时间和时区. 时间格式继承的是NLS\_DATE\_FORMAT这个初始化参数的值.   
  
下一部分介绍:   
1) 配置作业的参数;   
2) 创建/使用/管理作业,程序,计划所需要的系统权限.   
  
  
  
一些补充   
  
1.在10G R2 中, 如果用dbms\_scheduler创建的job的类型为executable, 需要create external job 权限。   
  
2. 在使用create\_job或者create\_schedule前，请先检查   
NLS\_DATE\_LANGUAGE, NLS\_DATE\_FORMAT,   
NLS\_TIMESTAMP\_FORMAT, NLS\_TIMESTAMP\_TZ\_FORMAT   
等参数的值, 通过alter session 命令来修改   
  
例如:   
SQL> select \* from nls\_session\_parameters;   
  
alter session set NLS\_DATE\_LANGUAGE='AMERICAN';   
alter session set NLS\_DATE\_FORMAT='dd-mm-yyyy hh24:mi:ss';   
alter session set NLS\_TIMESTAMP\_TZ\_FORMAT='dd-mm-yyyy HH:MI:SS.FF AM TZR'   
  
begin   
dbms\_scheduler.create\_job(   
job\_name=> 'zip\_emlog',   
job\_type=> 'EXECUTABLE',   
job\_action =>'/home/leo/zip\_log.sh',   
enabled=>true,   
start\_date=>'03-07-2005 9:30:00 PM + 8:00',   
repeat\_interval=>'FREQ=MINUTELY;INTERVAL=30',   
end\_date=>'31-07-2005 9:30:00 PM + 8:00',   
comments=>'Get a latest em log copy and compress it every 30 minutes');   
end;

\----------------------------------------------------------------

dbms\_scheduler介绍

10g引入的这个dbms\_scheduler包，替代了之前的dbms\_job包，该包功能更强大，可以将job需要的各种资源分开再进行组合。  
  
1.program  
1.1 create\_program  
参数说明：  
  program\_name——程序名称  
  program\_type——程序类型（STORED\_PROCEDURE，PLSQL\_BLOCK，EXECUTABLE）  
      STORED\_PROCEDURE——ORACLE 中定义好的存储过程  
      PLSQL\_BLOCK——是一段标准的pl/sql 代码  
      EXECUTABLE——指定外部命令的命令行信息(含路径信息)  
  program\_action——具体对应的执行内容，若为过程则为过程名  
  enable——若为true则创建后激活反之不激活  
  comments——注释  
例子：  
BEGIN  
   dbms\_scheduler.create\_program(program\_name        => 'myprogram',  
                                 program\_type        => 'STORED\_PROCEDURE',  
                                 program\_action      => 'p\_test1',  
                                 number\_of\_arguments => 1,  
                                 enabled             => FALSE,  
                                 comments            => '更新gi\_pipe表');  
     
END;  
注：如果创建的程序需要输入参数，则必须定义完参数后在激活，即创建这个program时将enable设为false，否则提示：  
    Ora-27456：程序“ ”的参数并未全部定义；然后再对该program定义参数即执行define\_program\_argument过程（见1.3）。  
  
\--查看定义的program  
SELECT \* FROM user\_scheduler\_programs;  
  
1.2 drop\_program  
参数说明：  
program\_name——要删除的程序名称  
force——true或者false。如果为true则不管该program是否被job引用都会删除，FALSE则若被引用无法删除，默认为false。  
例子：  
BEGIN  
   dbms\_scheduler.drop\_program(program\_name => 'myprogram',force => TRUE);  
END;  
  
1.3 define\_program\_argument  
参数说明：  
program\_name——程序名称  
argument\_position——参数位置（也可以知道参数名称选择argument\_name）  
argument\_type——参数类型  
default\_value——参数默认值  
  
例子：  
BEGIN  
   dbms\_scheduler.define\_program\_argument(program\_name      => 'myprogram',  
                                          argument\_position => 1,  
                                          argument\_name     => 'p\_lttid',  
                                          argument\_type     => 'varchar2',  
                                          default\_value     => 'daaa');  
END;  
  
\--查看定义的program参数      
SELECT \*FROM User\_Scheduler\_Program\_Args;  
  
1.4 define\_anydata\_argument（用于定义输入参数为复杂类型需采用sys.AnyData类型来包装的参数）  
参数说明：  
program\_name——程序名称  
argument\_position——参数位置（也可以知道参数名称选择argument\_name）  
argument\_type——参数类型为sys.AnyData  
default\_value——参数默认值  
  
  
1.5 define\_metadata\_argument  
有效的metadata attributes有: 'job\_name', 'job\_subname', 'job\_owner', 'job\_start', 'window\_start',   
                             'window\_end', and 'event\_message'.  
Metadata Attribute              Data Type                              Description   
job\_name                        VARCHAR2                               当前执行的job名称  
job\_subname                     VARCHAR2                               当前执行的job子名称  
job\_owner                       VARCHAR2                               当前执行的job所有者   
job\_start                   TIMESTAMP WITH TIME ZONE                   job启动的时间  
window\_start                TIMESTAMP WITH TIME ZONE                   window打开的时间  
window\_end                  TIMESTAMP WITH TIME ZONE                   window关闭的时间  
event\_message                                                          事件触发job启动的信息  
  
例子：（以下metadata\_attribute设置为job\_name，即以job\_start这个值作为输入参数）  
BEGIN  
   dbms\_scheduler.define\_metadata\_argument(program\_name       => 'myprogram',  
                                           argument\_position  => 1,  
                                           argument\_name      => 'p\_lttid',  
                                           metadata\_attribute => 'job\_start');  
END;  
                                            
  
1.6 drop\_program\_argument  
例子：  
BEGIN  
   dbms\_scheduler.drop\_program\_argument(program\_name      => 'myprogram',  
                                        argument\_position => 1);  
END;  
  
2.schedule  
2.1 create\_schedule  
参数说明：  
repeat\_interval——运行频率  
end\_date和comments默认可以不填  
例子：  
BEGIN  
   dbms\_scheduler.create\_schedule(schedule\_name   => 'myscheduler',  
                                  repeat\_interval => 'FREQ=MINUTELY;INTERVAL=2');  
END;  
  
  
2.2 create\_event\_schedule  
创建基于事件的调度，用于当一个特殊事件被抛出时启动一个job。  
Event类型     描述   
job\_started   job启动  
job\_succeeded job启动成功  
job\_failed    job失败  
job\_broken    被禁止或状态改为broken   
job\_completed job执行完成即完成了限制的最大执行次数或者到达执行指定的结束时间  
job\_stopped   停止job  
job\_sch\_lim\_reached 达到了scheduler的限制设置的值  
job\_disabled    禁止job  
job\_chain\_stalled  A job running a chain was put into the CHAIN\_STALLED state. A running chain becomes   
                   stalled if there are no steps running or scheduled to run and the chain evaluation\_interval is set to NULL.   
                   No progress will be made in the chain unless there is manual intervention.  
job\_all\_events Not an event, but a constant that provides an easy way for you to enable all events  
job\_run\_completed job执行或者失败或者成功或者被停止  
  
参数：  
event\_condition——tab.user\_data  
queue\_spec——必须先创建一个queue，dbms\_aqadm.create\_queue  
  
\--摘至http://www.233.com/oracle/zhonghe/20080807/104612630.html  
BEGIN  
   dbms\_scheduler.create\_event\_schedule(schedule\_name       => 'acc\_mgr\_change',  
                                        start\_date        => systimestamp,  
                                        event\_condition => 'tab.user\_data.event\_name = ''acc\_mgr\_change''',  
                                        queue\_spec      => 'proc\_queue');  
end;  
  
  
2.3 drop\_schedule  
例子：  
BEGIN  
  DBMS\_SCHEDULER.drop\_schedule(schedule\_name => 'myscheduler');  
END;  
  
3.job  
3.1 create\_job  
参数说明：  
job\_type：类同上述创建program  
job\_class DEFAULT 'DEFAULT\_JOB\_CLASS'  
enabled   默认FALSE，其创建后要想执行该job必须先执行enable过程  
auto\_drop 默认TRUE,即当job执行完毕都到期是否直接删除job  
comments  默认NULL  
job\_style 默认REGULAR  
credential\_name 默认 NULL  
destination\_name 默认 NULL  
  
\--不采用program和scheduler直接创建job  
BEGIN  
   dbms\_scheduler.create\_job(job\_name        => 'myjob',  
                             job\_type        => 'STORED\_PROCEDURE',  
                             job\_action      => 'p\_test1',  
                             start\_date      => '',  
                             repeat\_interval => 'FREQ=DAILY;INTERVAL=2',  
                             enabled         => TRUE,  
                             comments        => 'My new job');  
END;  
  
\--根据program和scheduler创建job  
BEGIN  
   dbms\_scheduler.create\_job(job\_name      => 'myjob',  
                             program\_name  => 'myprogram',  
                             schedule\_name => 'myscheduler');  
END;  
  
3.2 run\_job  
BEGIN  
   dbms\_scheduler.run\_job(job\_name => 'myjob2');  
END;  
  
  
3.3 stop\_job  
BEGIN dbms\_scheduler.stop\_job(job\_name => 'myjob');END;  
  
3.4 copy\_job  
BEGIN dbms\_scheduler.copy\_job(old\_job =>'myjob' ,new\_job =>'myjob2' );END;  
  
3.5 drop\_job  
BEGIN dbms\_scheduler.drop\_job(job\_name => 'myjob');END;  
  
3.6 set\_job\_argument\_value  
设置job的输入参数值，设置后会覆盖原先定义该参数设置的默认值  
BEGIN  
   dbms\_scheduler.set\_job\_argument\_value(job\_name          => 'myjob2',  
                                         argument\_position => 1,  
                                         argument\_value    => 'qwerer');  
END;  
  
3.7 set\_job\_anydata\_value  
方法类似3.6，只是设置的参数值类似是sys.anydata  
  
3.8 reset\_job\_argument\_value  
重置job参数值，将其置为空  
  
4.group（11g才有的）  
4.1 create\_group  
参数：  
group\_type——组类型，该组的所有成员必须是同一类型，已有的类型有三种：  
            DB\_DEST：即成员为目标数据库，执行远程数据库的job；  
            EXTERNAL\_DEST（External destination）：Members are external destinations, for running remote external jobs；  
            WINDOW：Members are Scheduler windows  
创建时可以指定成员也可不指定，添加成员通过add\_group\_member过程添加。  
BEGIN  
   dbms\_scheduler.create\_group(group\_name =>,  
                               group\_type =>,  
                               MEMBER     =>,  
                               comments   =>);  
END;  
  
4.2 drop\_group  
删除组  
  
4.3 add\_group\_member  
为组添加成员  
  
4.4 remove\_group\_member  
移除组成员  
  
4.5 create\_database\_destination  
创建目标数据库，用于执行远程job  
AGENT——The external destination name of the Scheduler agent to connect. Equivalent to an agent name.  
       The external destination must already exist. The external destination representing an agent is   
       created automatically on a database instance when the agent registers with that instance.  
       An agent‘s name is specified in its agent configuration file. If it is not specified, it defaults  
       to the first part (before the first period) of the name of the host it resides on.  
  
DBMS\_SCHEDULER.CREATE\_DATABASE\_DESTINATION (  
   destination\_name        IN VARCHAR2,--目标数据库名称  
   agent                   IN VARCHAR2,--代理名称，事先创建好的  
   tns\_name                IN VARCHAR2,--tns名称  
   comments                IN VARCHAR2 DEFAULT NULL);  
  
  
4.6 drop\_database\_destination  
4.7 drop\_agent\_destination  
  
5.jobclass  
    Job Classes 相当于创建了一个job组，DBA可以将那些具有相同特性的job，放到相同的Job Classes中，  
然后通过对Job Class应用ORACLE中的"资源使用计划"特性，就可以对这些job执行过程中所需要的资源分配情况进行  
管理。  
5.1 create\_job\_class  
参数：  
resource\_consumer\_group——指定该jobclass所使用的资源分配方式。具体创建方法见dbms\_resource\_manager.create\_consumer\_group。  
                         jobclass与resource\_consumer\_group为多对1关系；  
                         若为该jobclass指定的resource\_consumer\_group被删除，则使用默认的resource\_consumer\_group；  
                         若没为jobclass指定具体的resource\_consumer\_group，则使用默认的resource\_consumer\_group；  
                         若为该jobclass指定的resource\_consumer\_group不存在，则会提示错误；  
                         若为该jobclass指定了resource\_consumer\_group，则service参数必须设置为空（即这两个参数只能设置其中一个）。  
  
service——一般用于rac环境指定jobclass运行于哪个节点。  
  
logging\_level——日志记录级别（DBMS\_SCHEDULER.LOGGING\_OFF，DBMS\_SCHEDULER.LOGGING\_RUNS，DBMS\_SCHEDULER.LOGGING\_FULL）  
log\_history——日志存放时间，默认30  
例子：  
BEGIN  
   dbms\_scheduler.create\_job\_class(job\_class\_name          =>,  
                                   resource\_consumer\_group =>,  
                                   service                 =>,  
                                   logging\_level           =>,  
                                   log\_history             =>,  
                                   comments                =>);  
END;  
  
  
5.2 drop\_job\_class  
\--删除多个job class用逗号隔开  
BEGIN  
   dbms\_scheduler.drop\_job\_class(job\_class\_name => '');  
END;  
  
6.window  
   通常job启动后，用户只能被动地等待其执行，一直到其执行地任务完成(或DBA手动kill对应进程)，在此期间，  
执行的job将与其它活动的进程共同竞争当前系统中的资源。在9i之前就是这样。在Job Classes中也可以控制job能够  
使用的资源，不过单单使用Job Classes并不能灵活的控制job在合适的时间使用适当的资源。进入10g之后，采用  
dbms\_scheduler的WINDOW可以缓解该问题。WINDOW 可以指定一个时间窗口，在此期间，通过与Job Classes的搭配组合，  
能够有效控制job执行时支配(使用)的资源。比如说job通常是在凌晨服务器负载较低时执行，那么就可以通过WINDOW  
设置在此期间，允许jobs使用更多的系统资源，而到了工作时间后，如果job仍未执行完成，为其分配另一个有限的  
资源，以尽可能降低job执行占用的资源对其它业务的影响。  
  
6.1 create\_window  
参数：  
resource\_plan——资源计划，即通过 dbms\_resource\_manager.create\_plan来创建。  
schedule\_name——调度名称，基于已经创建好的调度创建window。  
duration——时间窗口打开后持续的时间，创建时必须设置该值，因为没有默认值，设置范围从1分钟到99天。  
window\_priority——window优先级，如果同一时间出现多个window时则根据优先级决定执行哪个。  
\--创建一个基于调度的window  
BEGIN  
   dbms\_scheduler.create\_window(window\_name     =>,  
                                resource\_plan   =>,  
                                schedule\_name   =>,  
                                duration        =>,  
                                window\_priority =>,  
                                comments        =>);  
END;  
  
\--不基于时间调度创建window  
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);  
  
6.2 drop\_window  
删除一个window。

6.3 open\_window  
打开一个window。

6.4 close\_window  
关闭一个window。  
  
  
7.windowgroup  
    一个WINDOW GROUP可能包含多个WINDOW。使用WINDOW GROUP的本意是这样的，假如说某个job执行的时间比较长，  
甚至全天24小时都在执行，对于这类job，单个WINDOW很难有效调整其资源占用，因此就可以通过设置一个  
WINDOW GROUP，该WINDOW GROUP中包含了多个WINDOW，每个WINDOW分别负责不同时间点时的资源使用计划。然后在  
创建JOB时，指定schedule\_name参数为WINDOW GROUP的名称，当然也可以直接指定window名称  
（window已经包含了调度信息了）。  
  
7.1 create\_window\_group  
BEGIN  
   dbms\_scheduler.create\_window\_group(group\_name  =>,  
                                      window\_list =>,  
                                      comments    =>);  
END;  
  
7.2 add\_window\_group\_member  
增加一个window  
BEGIN  
   dbms\_scheduler.add\_window\_group\_member(group\_name => ,window\_list => );  
END;  
  
7.3 remove\_window\_group\_member  
移除一个window  
  
7.4 drop\_window\_group  
删除一个window  
  
  
8.chain 参考http://hi.baidu.com/sqlnever/item/be05b1abba1611fc15329b86  
    CHAIN可以被视做多个program放到同一个链中，这样的话就可以指定这些program执行的先后顺序。  
8.1 create\_chain  
DBMS\_SCHEDULER.CREATE\_CHAIN (  
   chain\_name              IN VARCHAR2,  
   rule\_set\_name           IN VARCHAR2 DEFAULT NULL,  
   evaluation\_interval     IN INTERVAL DAY TO SECOND DEFAULT NULL,  
   comments                IN VARCHAR2 DEFAULT NULL);  
  
  
8.2 define\_chain\_rule  
定义规则  
举例，如my\_step1执行完则执行my\_step2，若my\_step2执行完则结束  
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;  
  
8.3 define\_chain\_step  
 BEGIN  
    dbms\_scheduler.define\_chain\_step(chain\_name   => 'my\_chain1',  
                                     step\_name    => 'my\_step1',  
                                     program\_name => 'p\_p2');  
    dbms\_scheduler.define\_chain\_step(chain\_name   => 'my\_chain1',  
                                     step\_name    => 'my\_step2',  
                                     program\_name => 'p\_p3');  
 END;  
  
8.4 define\_chain\_event\_step  
BEGIN  
   dbms\_scheduler.define\_chain\_event\_step(chain\_name          =>,  
                                          step\_name           =>,  
                                          event\_schedule\_name =>,  
                                          timeout             =>);  
END;  
  
8.5 drop\_chain\_rule  
dbms\_scheduler.drop\_chain\_rule(chain\_name => ,rule\_name => );  
  
8.6 drop\_chain\_step  
dbms\_scheduler.drop\_chain\_step(chain\_name => ,step\_name => );  
  
8.7 alter\_chain  
dbms\_scheduler.alter\_chain(chain\_name => ,step\_name => ,attribute => ,value => );  
  
8.8 drop\_chain  
  
8.9 analyze\_chain  
dbms\_scheduler.analyze\_chain(chain\_name => ,rules => ,steps => ,step\_pairs => );  
  
8.10 alter\_running\_chain  
dbms\_scheduler.alter\_running\_chain(job\_name => ,step\_name => ,attribute => ,value => );  
  
8.11 evaluate\_running\_chain  
dbms\_scheduler.evaluate\_running\_chain(job\_name => );  
  
8.12 run\_chain  
dbms\_scheduler.run\_chain(chain\_name => ,start\_steps => ,job\_name => );  
  
  
9.credential  
创建用户名密码，用于认证job执行  
9.1 create\_credential  
BEGIN  
   dbms\_scheduler.create\_credential(credential\_name =>,  
                                    username        =>,  
                                    password        =>,  
                                    database\_role   =>,  
                                    windows\_domain  =>,  
                                    comments        =>);  
END;  
  
9.2 drop\_credential  
9.3 put\_file  
BEGIN  
   dbms\_scheduler.put\_file(destination\_file        =>,  
                           destination\_host        =>,  
                           credential\_name         =>,  
                           file\_contents           =>,  
                           destination\_permissions =>);  
END;  
  
9.4 get\_file  
9.5 create\_file\_watcher  
BEGIN  
   dbms\_scheduler.create\_file\_watcher(file\_watcher\_name     =>,  
                                      directory\_path        =>,  
                                      file\_name             =>,  
                                      credential\_name       =>,  
                                      destination           =>,  
                                      min\_file\_size         =>,  
                                      steady\_state\_duration =>,  
                                      comments              =>,  
                                      enabled               =>);  
END;  
  
9.6 drop\_file\_watcher  
9.7 add\_job\_email\_notification  
BEGIN  
   dbms\_scheduler.add\_job\_email\_notification(job\_name         =>,  
                                             recipients       =>,  
                                             sender           =>,  
                                             subject          =>,  
                                             BODY             =>,  
                                             events           =>,  
                                             filter\_condition =>);  
END;  
  
9.8 remove\_job\_email\_notification  
  
10.通用的  
10.1 DISABLE  
BEGIN  
   dbms\_scheduler.disable(NAME => 'myjob2');  
END;  
  
10.2 enable  
BEGIN  
   dbms\_scheduler.enable(NAME => 'myprogram');  
END;  
  
BEGIN  
   dbms\_scheduler.enable(NAME => 'myjob2');  
END;  
  
10.3 set\_attribute  
attribute：是指设置job的属性，属性有：  
logging\_level——记录的日志信息，有三个值（DBMS\_SCHEDULER.LOGGING\_OFF，DBMS\_SCHEDULER.LOGGING\_RUNS，  
                                         DBMS\_SCHEDULER.LOGGING\_FULL）  
restartable——设置job失败是否要重启  
max\_failures——允许job失败的次数，范围1到1000000，默认为空。  
max\_runs——job执行的最大次数，范围1到1000000，默认为空（即意味着job会重复执行，或者到达job执行的end\_date，或者达到指定失败的次数）。  
          一旦达到设置的最大值，job将会disable并且状态变更为COMPLETED   
max\_run\_duration——设置job运行的有效时间，如果设置了某个值，则在到达该值时调度会报JOB\_OVER\_MAX\_DUR事件，  
                  然后由事件处理器决定是否要继续  
instance\_stickiness——只用于rac数据库。默认为true，设置为true，则job会运行在负载最轻的节点上；如果某节点  
                     关闭或负载太重，则不会启动新job，而是有另一个节点来执行该job。  
stop\_on\_window\_close——window关闭的时候停止job，默认为false。因此默认情况下关闭了window，job还是会继续执行，  
                      但是要注意，window关闭则意味着资源使用计划就会变化。   
job\_priority——在同一个class，job执行的优先级，默认为3.  
schedule\_limit——允许启动job延迟的时间，设置值从1分钟到99天。超过了延迟的时间则不再启动job。如果不设置  
                该值，则只要得到允许所需的资源就会启动。另外，在延迟的这段时间里，job的执行次数或失败次数  
                会跳过，不计算这段时间的。  
program\_name——job执行的对象。如果设置了该属性，则job\_action, job\_type，number\_of\_arguments要设置为空。  
job\_action——job执行对象内容  
job\_type——job执行对象类型（'PLSQL\_BLOCK', 'STORED\_PROCEDURE', 'EXECUTABLE', and 'CHAIN'）。如果设置了该值，  
          那么program\_name参数必须设置为空 。  
number\_of\_arguments——参数个数。如果设置了该值，那么program\_name参数必须设置为空。   
schedule\_name——调度名，如果设置了该值，则end\_date, start\_date and repeat\_interval需设置为空。  
repeat\_interval——执行间隔，设置了该值，则schedule\_name需为空。  
start\_date——执行开始时间，设置了该值，则schedule\_name需为空。  
end\_date——不再执行job的时间，设置了该值，则schedule\_name需为空。  
job\_class——jobclass  
comments——备注  
auto\_drop——当job状态为completed则自动删除该job  
event\_spec——需含两个值（event condition和queue specification）  
raise\_events——设置当job为什么状态时抛出，具体的时间类型见event类型。  
   
\--设置log\_history为90天，默认30天  
BEGIN  
   dbms\_scheduler.set\_scheduler\_attribute('log\_history', '90');  
END;  
  
10.4 set\_attribute\_null  
10.5 get\_attribute  
  
  
11.schedulerattribute  
设置调度属性的值  
11.1 set\_scheduler\_attribute  
attribute类型有：default\_timezone，email\_server，email\_sender，email\_server\_credential，email\_server\_encryption，  
                event\_expiry\_time ，log\_history，max\_job\_slave\_processes（没使用）  
  
BEGIN  
   dbms\_scheduler.set\_scheduler\_attribute(attribute => ,value => );  
END;  
  
  
11.2 get\_scheduler\_attribute  
BEGIN  
   dbms\_scheduler.get\_scheduler\_attribute(attribute => ,value => );  
END;  
  
11.3 add\_event\_queue\_subscriber  
BEGIN  
   dbms\_scheduler.add\_event\_queue\_subscriber(subscriber\_name => );  
END;  
  
11.4 remove\_event\_queue\_subscriber  
BEGIN  
   dbms\_scheduler.remove\_event\_queue\_subscriber(subscriber\_name => );  
END;  
11.5 purge\_log  
BEGIN  
   dbms\_scheduler.purge\_log(log\_history => ,which\_log => ,job\_name => );  
END;  
  
  
dbms\_scheduler包一些视图  
\--\*代表all或dba或user  
\--1.查看job的视图  
\*\_scheduler\_jobs --查看job  
\*\_scheduler\_job\_args  --查看job的所有输入参数  
\*\_scheduler\_job\_classes --查看job的类信息  
\*\_scheduler\_job\_dests --查看job状态  
\*\_scheduler\_job\_log --查看job日志  
\*\_scheduler\_job\_run\_details --查看job执行的详细信息  
all\_scheduler\_running\_jobs  
  
\--2.查看chain的一些视图  
\*\_scheduler\_chains   
\*\_scheduler\_chain\_rules  
\*\_scheduler\_chain\_steps  
\*\_scheduler\_running\_chains --查看正在执行的chains  
  
\--3.查看program的视图  
\*\_scheduler\_programs --查看程序  
\*\_scheduler\_program\_args --查看程序参数  
  
\--4.查看调度组信息   
\*\_scheduler\_groups  
\*\_scheduler\_group\_members  
  
\--5.查看window的视图（这类视图只有dba和all开头的）  
\*\_scheduler\_windows --查看window  
\*\_scheduler\_window\_details --查看window详细信息  
\*\_scheduler\_window\_groups --查看window组  
\*\_scheduler\_window\_log --查看window日志  
\*\_scheduler\_wingroup\_members ----查看window成员  
  
\--6.查看scheduler视图  
\*\_scheduler\_schedules --查看调度  
\*\_scheduler\_global\_attribute --显示所有的调度属性  
\*\_scheduler\_credentials  
\*\_scheduler\_db\_dests  
\*\_scheduler\_dests  
\*\_scheduler\_external\_dests  
\*\_scheduler\_file\_watchers  
\*\_scheduler\_notifications  
\*\_scheduler\_remote\_databases  
\*\_scheduler\_remote\_jobstate

[https://blog.csdn.net/seabiscuit\_92/article/details/51038281][https_blog.csdn.net_seabiscuit_92_article_details_51038281]

[Oracle]: http://blog.itpub.net/oracle/
[Hoegh]: http://blog.itpub.net/30162081/
[http_blog.itpub.net_30162081_viewspace-1609120]: http://blog.itpub.net/30162081/viewspace-1609120/
[Seabiscuit_92]: https://me.csdn.net/Seabiscuit_92
[oracle]: http://so.csdn.net/so/search/s.do?q=oracle&t=blog
[DBMS_SCHEDULER]: http://so.csdn.net/so/search/s.do?q=DBMS_SCHEDULER&t=blog
[Oracle 1]: https://blog.csdn.net/Seabiscuit_92/article/category/5955933
[https_blog.csdn.net_seabiscuit_92_article_details_51038281]: https://blog.csdn.net/seabiscuit_92/article/details/51038281