在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;
/