Oracle 数据库复制常用脚本

推（push）一个大的延迟事务（Deferred Transactions）队列是非常慢的。一个常见的
问题就是一个事务中含有非常多的调用（calls）。如果系统检测到一个错误，如ora－01403
（数据未找到错误），也就是我们常说的检测到冲突，而且没有冲突消除方法，写到deferror
错误表和回滚事务的时间就会更长，事务中如果调用calls很多，则消耗在任何一个调用的时
　　对于数据复制中每个事务的调用数Oracel强烈建议不超过50个。下面的存储过程提供了一
个快速查看延迟事务队列中的事务列表以及每个事务中调用数的脚本。输出是以传输顺序排列
的，这个顺序就是事务将要传播到主节点的顺序。这对于确定传播中的延迟以及挂起等是非常
　　在搭建Oracle数据复制环境中，有一个经验是值得注意的，那就是一定要设置冲突解决方
案，即可使用Oracle系统提供的几种方案，也可以自己编写脚本来完成冲突处理。为什么这样
说，一定要设置冲突解决方案，也许我们可以说，我们的复制环境是一个单项复制，不可能出
现冲突现象。在这里我讲一个自己的亲身经历的例子来说明这个问题，在实际工作中，我搭建
了一个具有15个节点的高级复制环境，一个主定义节点，14个主节点，其中14个主节点向主定
义节点单向传递数据。一般来讲这种情况下不会出现冲突。但是在实际应用中，问题就出现了
，其中几个节点在传输了一些数据后，就挂（hang）了起来。所有可能查找的原因到查了，始
终发现不了问题的根结。最后发现是由于数据传播到远程节点后，出现了错误，而在该节点又
没有设置冲突解决方案，同时出现错误的该事务又具有超过1000条的调用。其中有一条调用出
错了，事务需要回滚，而这个在本地和远程节点间的回滚时间就会以几何基数增长。就出现了
前面谈到的系统挂起（hang）的表现。这也就是说即是在根本不可能出现冲突的系统中，由于
偶然的不定的错误进程，批量数据的处理以及没有考虑复制情况下的数据导入都可造成在传播
过程中严重的性能问题，最严重的情况就是系统挂起，不能完成正常的复制工作。最简单和有
效的办法就是在多路复制环境下设置一个系统确省的冲突处理方法来避免这种情况的发生。
　　下面这个存储过程就是在Oracle 8 环境下列出延迟事务队列中的事务和事务中调用个数
的脚本，该脚本对Oracle 7 不支持，这是因为Oracle 8 和Oracle 7 的复制机制发生了变化
　　存储过程调用方法：
　　在SQL/PLUS下，首先运行下面的设置，使存储过程的输出到屏幕上，
　　SET SERVEROUTPUT ON SIZE 200000
　　EXEC P_LIST_TRANSACTIONS(ORA_SJJK);
　　其中，存储过程的参数as_destination为所要查看的事务传播到目的节点的延迟队列，为
　　如果我们看到一个事务具有很多的调用（超过50个），这个事务很可能就是造成延迟事务
　　附：存储过程脚本
　　CREATE OR REPLACE PROCEDURE REPADMIN.P_LIST_TRANSACTION(as_destination in
　　local_node VARCHAR2(128);
　　remote_node VARCHAR2(128);
　　last_scn NUMBER;
　　last_tid VARCHAR2(22);
　　last_tdb VARCHAR2(128);
　　cnt NUMBER;
　　CURSOR c(last_delivered NUMBER, last_tid VARCHAR2, last_tdb VARCHAR2) IS
　　select cscn, enq_tid,
　　dscn, DECODE(c.recipient_key, 0, 'D', 'R')

　　from system.def$_aqcall c where 　　(c.cscn >= last_delivered)
　　and ((c.cscn > last_delivered) or (c.enq_tid > last_tid))
　　and (
　　( c.recipient_key = 0
　　and exists ( select /*+ index(cd def$_calldest_primary) */
　　from system.def$_calldest cd
　　where cd.enq_tid = c.enq_tid
　　and cd.dblink = remote_node ) ) 　　or ( c.recipient_key > 0
　　and ( ( exists (
　　select from system.repcat$_repprop P
　　where P.dblink = remote_node
　　and P.how = 1
　　and P.recipient_key = c.recipient_key
　　and ((P.delivery_order is NULL) 　　or (P.delivery_order < c.cscn))))
　　or ( exists
　　( select /*+ ordered use_nl(rp) */
　　from system.def$_aqcall cc, system.repcat$_repprop rp
　　where cc.enq_tid = c.enq_tid
　　and cc.cscn is
　　and rp.recipient_key = cc.recipient_key
　　and rp.how = 1
　　and rp.dblink = remote_node
　　and ((rp.delivery_order is NULL) 　　or (rp.delivery_order < c.cscn)))))))
　　order by c.cscn, c.enq_tid;
　　BEGIN
　　SELECT NLS_UPPER(global_name) INTO local_node FROM global_name;
　　SELECT dblink INTO remote_node from deftrandest
　　WHERE dblink LIKE UPPER (as_destination||'%') AND ROWNUM < 2;
　　IF (remote_node IS NULL) THEN
　　DBMS_OUTPUT.PUT_LINE ('不能确定目标节点，输入参数有误!');
　　RETURN;
　　ELSE
　　DBMS_OUTPUT.PUT_LINE ('延迟事务目标节点为: '||remote_node);
　　DBMS_OUTPUT.PUT_LINE ('-------------------------------------------');
　　END IF;
　　SELECT last_delivered, last_enq_tid, dblink

　　INTO last_scn, last_tid, last_tdb
　　FROM system.def$_destination
　　WHERE dblink = remote_node;
　　FOR R IN C(last_scn,last_tid,last_tdb) LOOP
　　SELECT count(*) INTO cnt FROM system.def$_aqcall WHERE enq_tid = r.enq_tid;
　　DBMS_OUTPUT.PUT_LINE ('延迟事务 ID='||r.enq_tid||' 调用个数='||to_char(cnt));
　　END LOOP;
　　END;
　　/
　　二、Oracle 8高级复制环境设置问题诊断脚本
　　要保证搭建的一个高级复制环境工作，必须保证所有的复制对象处于正常状态，对于一个
高级复制环境，要检查一个复制环境中是否所有对象均处于正常工作状态，需要检查不同的系
统字典对象，包括复制组对象，复制对象，复制方案对象等等。如果搭建的这个高级复制环境
包含很多节点，每个节点又包含几个复制方案（schema）以及每个方案又包含多个复制对象，
则完成一遍检查需要作很多的重复工作，这里针对这个问题，编写了一个复制设置问题诊断包
，只有运行该包中相应的过程，即可完成对上面提到的相关对象的诊断，给出相应诊断结果。
　　运行方法是，在SQL/PLUS环境下，
　　SQL> spool <文件名>
　　SQL> set serveroutput on
　　SQL> exec rep_diag.rep_diag;
　　这里强调一点，运行该包的用户，必须具有对系统字典表dba_repschema、dba_diagnose
、dba_repcat以及dba_repcatlog的检索(select)权限，当然，复制管理员(RepAdmin)用户是
　　附：高级复制环境设置问题诊断包脚本。下载该脚本
　　CREATE OR REPLACE PACKAGE REP_DIAG IS
　　PROCEDURE REP_DIAG;
　　PROCEDURE REP_SCHEMA;
　　PROCEDURE REP_OBJECT;
　　PROCEDURE REP_ERROR;
　　PROCEDURE REP_STAT;
　　END REP_DIAG;
　　/
　　CREATE OR REPLACE PACKAGE BODY REP_DIAG IS
　　PROCEDURE REP_DIAG IS
　　BEGIN
　　 REP_SCHEMA;
　　 REP_OBJECT;
　　 REP_ERROR;
　　 REP_STAT;
　　END REP_DIAG;
　　PROCEDURE REP_SCHEMA AS
　　 CURSOR C_SCHEMA IS SELECT SNAME, DBLINK, MASTERDEF
　　 FROM SYS.DBA_REPSCHEMA;
　　BEGIN
　　 DBMS_OUTPUT.PUT_LINE('复制方案明细信息');
　　 DBMS_OUTPUT.PUT_LINE('-------------------------');
　　 FOR T_SCHEMA IN C_SCHEMA LOOP
　　 DBMS_OUTPUT.PUT_LINE('方案名称: '||T_SCHEMA.SNAME);
　　 DBMS_OUTPUT.PUT_LINE('是否为主定义节点: '||T_SCHEMA.MASTERDEF)
　　 DBMS_OUTPUT.PUT_LINE('数据库联接名称: '||T_SCHEMA.DBLINK);
　　 DBMS_OUTPUT.PUT_LINE('.');

　　 END LOOP;
　　END REP_SCHEMA;
　　PROCEDURE REP_OBJECT AS
　　 CURSOR C_REP_OBJECT IS SELECT SNAME, ONAME, TYPE, STATUS
　　 FROM SYS.DBA_REPOBJECT;
　　BEGIN
　　 DBMS_OUTPUT.PUT_LINE(' 复制对象 ');
　　 DBMS_OUTPUT.PUT_LINE('----------------------------------');
　　 FOR T_REP_OBJECT IN C_REP_OBJECT LOOP

　　 DBMS_OUTPUT.PUT_LINE('.');

　　 DBMS_OUTPUT.PUT_LINE('属主: '||T_REP_OBJECT.SNAME);
　　 DBMS_OUTPUT.PUT_LINE('对象名称: '||T_REP_OBJECT.ONAME);
　　 DBMS_OUTPUT.PUT_LINE('对象类型: '||T_REP_OBJECT.TYPE);
　　 DBMS_OUTPUT.PUT_LINE('状态: '||T_REP_OBJECT.STATUS);
　　 DBMS_OUTPUT.PUT_LINE('.');

　　 END LOOP;
　　END REP_OBJECT;
　　PROCEDURE REP_ERROR IS
　　 CURSOR C_REP_ERROR IS SELECT REQUEST, STATUS, MESSAGE, ERRNUM
　　 FROM SYS.DBA_REPCATLOG;

　　BEGIN
　　 DBMS_OUTPUT.PUT_LINE('复制目录错误信息');
　　 DBMS_OUTPUT.PUT_LINE('---------------');
　　 FOR T_REP_ERROR IN C_REP_ERROR LOOP

　　 DBMS_OUTPUT.PUT_LINE('.');
　　 DBMS_OUTPUT.PUT_LINE('请求: '||T_REP_ERROR.REQUEST);
　　 DBMS_OUTPUT.PUT_LINE('状态: '||T_REP_ERROR.STATUS);
　　 DBMS_OUTPUT.PUT_LINE('信息: '||T_REP_ERROR.MESSAGE);
　　 DBMS_OUTPUT.PUT_LINE('错误: '||T_REP_ERROR.ERRNUM);
　　 DBMS_OUTPUT.PUT_LINE('.');

　　 END LOOP;
　　END REP_ERROR;
　　PROCEDURE REP_STAT IS
　　 CURSOR C_REP_STAT IS SELECT SNAME, MASTER, STATUS
　　 FROM SYS.DBA_REPCAT;
　　BEGIN
　　 DBMS_OUTPUT.PUT_LINE('复制状态');
　　 DBMS_OUTPUT.PUT_LINE('------------------');
　　 FOR T_REP_STAT IN C_REP_STAT LOOP
　　 DBMS_OUTPUT.PUT_LINE('.');
　　 DBMS_OUTPUT.PUT_LINE('方案: '||T_REP_STAT.SNAME);
　　 DBMS_OUTPUT.PUT_LINE('是否主节点?:'||T_REP_STAT.MASTER);
　　 DBMS_OUTPUT.PUT_LINE('状态: '||T_REP_STAT.STATUS);
　　 DBMS_OUTPUT.PUT_LINE('.');

　　 END LOOP;
　　END REP_STAT;
　　END REP_DIAG;
　　/
　　三、列出一个延迟事务的所有调用
　　作为一个复制管理员，我们经常需要查看某个延迟事务中到底包含那些调用，而这些调用
的参数又是什么。Oracle复制包中没有提供相应的脚本来实现该功能，通常我们的做法只能是
借助于Oracle的复制管理器来查看，但是如果延迟事务很多，且没有延迟事务的调用个数也很
多的话，Oracle复制管理器非常的慢，而且最重要的是我们根本无法直接操作这些数据。下面
这个脚本可以列出延迟队列中的某个事务的所有调用内容，如果再对这个脚本加以改造的话，
甚至可以恢复出延迟事务中的Oracle DDL语句。这对于Oracle复制管理员是非常有用的功能。
　　在对复制环境的管理中，还经常作这样一个工作，如果复制发生错误，将会将错误信息写
入错误队列中（deferror视图），系统会显示出在一个延迟事务中错误的调用号，也可以将下
面的程序加以改造，让其直接输出某个事务的某个调用。由于在很多情况下，一个事务通常含
有很多的调用，将所有的都显示出来没有必要，其实我们更关心其中的某个调用。该存储过程
这里就不详述，其实根据下面的这个过程改造是非常容易的。有感兴趣的也可以和我联系。
　　存储过程 p_list_calls可以列出一个延迟事务中的所有调用的参数类型和值，支持所有
的复制类型，包括NCHAR, NVARCHAR和所有的LOB.
　　运行方法和前面谈到的存储过程一样，首先需要将输出定位到屏幕，
　　set serveroutput on size 200000
　　其中参数存储过程的输入参数T为延迟事务的ID号，可以通过视图deferror或者defcall
得到，下面是一个典型的调用过程例子：

　　DEFERRED_TRAN_ID DELIVERY_ORDER D START_TIME

　　------------------------------ -------------- - ----------
　　7.0.3741 65040962 R 25-7月 -01
　　8.41.3747 65040963 R 25-7月 -01
　　6.18.3739 65040974 R 25-7月 -01
　　8.39.3746 65040843 R 25-7月 -01 　　SQL> set serveroutput on size 1000000
　　SQL> execute p_list_calls('7.0.3741');
　　调用顺序: 0
　　操作： DB_ZGXT.PA_REP_JB.P_REP_DJ_NSRXX_U
　　参数个数: 12
　　参数 数据类型 值
　　-------------------- -------------- ----------------------
　　01 N_NSRNM VARCHAR2 034530001
　　02 N_PZWH VARCHAR2 (NULL)
　　03 N_TBRQ DATE (NULL)
　　04 N_BGRQ DATE 2000-12-28 00:00:00
　　05 N_JBR VARCHAR2 (NULL)
　　06 N_FZR VARCHAR2 (NULL)
　　07 N_SWJGYJ VARCHAR2 (NULL)
　　08 N_BZ VARCHAR2 (NULL)
　　09 N_RYDM VARCHAR2 030811
　　10 N_BGLRRQ DATE 2000-12-28 14:57:01
　　11 N_ZHWZBM VARCHAR2 13302030000270999999

　　12 N_KZBZ CHAR 1
　　PL/SQL 过程已成功完成。
　　附：存储过程代码。下载该脚本
　　CREATE OR REPLACE PROCEDURE P_LIST_CALLS (T IN VARCHAR2) IS
　　ARGNO NUMBER;
　　ARGTYP NUMBER;
　　ARGFORM NUMBER;
　　CALLNO NUMBER;
　　TRANID VARCHAR2(30);
　　TYPDSC CHAR(15);
　　ROWID_VAL ROWID;
　　CHAR_VAL VARCHAR2(255);
　　NCHAR_VAL NVARCHAR2(255);
　　DATE_VAL DATE;
　　NUMBER_VAL NUMBER;
　　VARCHAR2_VAL VARCHAR2(2000);
　　NVARCHAR2_VAL NVARCHAR2(2000);
　　RAW_VAL RAW(255);
　　ARG_NAME VARCHAR2(20);
　　ARG_NAME_C CHAR(20);
　　TABLE_NAME VARCHAR2(100);
　　COL_NAME VARCHAR2(100);
　　PK_CHAR CHAR(1);
　　-- 延迟队列光标
　　CURSOR C_DEFCALL (T VARCHAR2) IS
　　SELECT CALLNO, DEFERRED_TRAN_ID, SCHEMANAME, PACKAGENAME, PROCNAME,ARGCOUNT
　　FROM DEFCALL
　　WHERE DEFERRED_TRAN_ID = T;
　　-- 获得参数名称
　　CURSOR C_ARG_NAME (P_SCHEMA VARCHAR2, P_PROCNAME VARCHAR2,
　　P_PKGNAME VARCHAR2, P_CALL_COUNT VARCHAR2) IS
　　SELECT ARGUMENT_NAME
　　FROM ALL_ARGUMENTS
　　WHERE OWNER = P_SCHEMA
　　AND PACKAGE_NAME = P_PKGNAME
　　AND OBJECT_NAME = P_PROCNAME
　　AND (OVERLOAD = (SELECT OVRLD.OVERLOAD FROM

　　(SELECT OVERLOAD, OBJECT_NAME, PACKAGE_NAME, MAX(POSITION) POS
　　FROM ALL_ARGUMENTS
　　WHERE OBJECT_NAME = P_PROCNAME
　　AND PACKAGE_NAME = P_PKGNAME
　　GROUP BY OVERLOAD, OBJECT_NAME, PACKAGE_NAME

　　) OVRLD
　　WHERE P_CALL_COUNT = OVRLD.POS
　　AND OBJECT_NAME = P_PROCNAME
　　AND PACKAGE_NAME = P_PKGNAME
　　)
　　OR OVERLOAD IS NULL
　　)
　　ORDER BY POSITION;
　　-- 该光标用来获得某个列是否为该表的主键
　　CURSOR PK_CURSOR (SCHEMA VARCHAR2, T_NAME VARCHAR2, COL_NAME VARCHAR2) IS
　　SELECT DECODE (COUNT(*),1,'*',' ')
　　FROM DBA_CONSTRAINTS T1, DBA_CONS_COLUMNS T2
　　WHERE T1.CONSTRAINT_NAME = T2.CONSTRAINT_NAME

　　AND T1.OWNER = T2.OWNER
　　AND T1.OWNER = SCHEMA
　　AND T1.CONSTRAINT_TYPE = 'P'
　　AND T1.TABLE_NAME = T_NAME
　　AND T2.COLUMN_NAME LIKE COL_NAME;
　　BEGIN
　　FOR C1REC IN C_DEFCALL (T) LOOP
　　DBMS_OUTPUT.PUT_LINE('调用顺序: ' ||C1REC.CALLNO);
　　DBMS_OUTPUT.PUT_LINE('操作： '||C1REC.SCHEMANAME||'.'||C1REC.PAC
　　DBMS_OUTPUT.PUT_LINE('参数个数: '||C1REC.ARGCOUNT);
　　DBMS_OUTPUT.PUT_LINE(' 参数 ' || ' 数据类型 ' || '值');
　　DBMS_OUTPUT.PUT_LINE(' ---------------- ' || '---------------- '
　　ARGNO := 1;
　　CALLNO := C1REC.CALLNO;
　　TRANID := C1REC.DEFERRED_TRAN_ID;
　　OPEN C_ARG_NAME (C1REC.SCHEMANAME, C1REC.PROCNAME, C1REC.PACKAGE
　　WHILE TRUE LOOP 　　IF (ARGNO > C1REC.ARGCOUNT) THEN
　　CLOSE C_ARG_NAME;
　　EXIT;
　　END IF;
　　ARGTYP := DBMS_DEFER_QUERY.GET_ARG_TYPE(CALLNO, ARGNO, TRANID);
　　ARGFORM := DBMS_DEFER_QUERY.GET_ARG_FORM(CALLNO, ARGNO, TRANID);
　　FETCH C_ARG_NAME INTO ARG_NAME;
　　ARG_NAME_C := ARG_NAME;
　　TABLE_NAME := SUBSTR(C1REC.PACKAGENAME, 1, INSTR(C1REC.PACKAGENAME, '$') - 1);
　　COL_NAME := SUBSTR(ARG_NAME, 1, LENGTH(ARG_NAME) - 5) || '%';
　　OPEN PK_CURSOR (C1REC.SCHEMANAME, TABLE_NAME, COL_NAME);
　　FETCH PK_CURSOR INTO PK_CHAR;
　　CLOSE PK_CURSOR;
　　IF (ARGTYP = 1 AND ARGFORM = 1) THEN
　　TYPDSC := 'VARCHAR2';
　　VARCHAR2_VAL := DBMS_DEFER_QUERY.GET_VARCHAR2_ARG(CALLNO, ARGNO,TRANID);
　　DBMS_OUTPUT.PUT_LINE(TO_CHAR(ARGNO,'09')||PK_CHAR||ARG_NAME_C||TYPDSC||'
　　ELSIF ARGTYP = 1 AND ARGFORM = 2 THEN
　　TYPDSC := 'NVARCHAR2';
　　NVARCHAR2_VAL := DBMS_DEFER_QUERY.GET_NVARCHAR2_ARG(CALLNO, ARGNO,TRANID);
　　DBMS_OUTPUT.PUT_LINE(TO_CHAR(ARGNO,'09')||PK_CHAR||ARG_NAME_C||TYPDSC||'
'||NVL(TRANSLATE(NVARCHAR2_VAL USING CHAR_CS),'(NULL)'));
　　ELSIF ARGTYP = 2 THEN
　　TYPDSC := 'NUMBER';
　　NUMBER_VAL := DBMS_DEFER_QUERY.GET_NUMBER_ARG(CALLNO, ARGNO, TRANID);
　　DBMS_OUTPUT.PUT_LINE(TO_CHAR(ARGNO,'09')||PK_CHAR||ARG_NAME_C||TYPDSC||'
　　ELSIF ARGTYP = 11 THEN
　　TYPDSC := 'ROWID';
　　ROWID_VAL := DBMS_DEFER_QUERY.GET_ROWID_ARG(CALLNO, ARGNO, TRANID);
　　DBMS_OUTPUT.PUT_LINE(TO_CHAR(ARGNO,'09')||PK_CHAR||ARG_NAME_C||TYPDSC||'
　　ELSIF ARGTYP = 12 THEN
　　TYPDSC := 'DATE';
　　DATE_VAL := DBMS_DEFER_QUERY.GET_DATE_ARG(CALLNO, ARGNO, TRANID);
　　DBMS_OUTPUT.PUT_LINE(TO_CHAR(ARGNO,'09')||PK_CHAR||ARG_NAME_C||TYPDSC||'
'||NVL(TO_CHAR(DATE_VAL,'YYYY-MM-DD HH24:MI:SS'),'(NULL)'));
　　ELSIF ARGTYP = 23 THEN
　　TYPDSC := 'RAW';
　　RAW_VAL := DBMS_DEFER_QUERY.GET_RAW_ARG(CALLNO, ARGNO, TRANID);
　　DBMS_OUTPUT.PUT_LINE(TO_CHAR(ARGNO,'09')||PK_CHAR||ARG_NAME_C||TYPDSC||'
　　ELSIF ARGTYP = 96 AND ARGFORM = 1 THEN
　　TYPDSC := 'CHAR';
　　CHAR_VAL := DBMS_DEFER_QUERY.GET_CHAR_ARG(CALLNO, ARGNO, TRANID);
　　DBMS_OUTPUT.PUT_LINE(TO_CHAR(ARGNO,'09')||PK_CHAR||ARG_NAME_C||TYPDSC||'
　　ELSIF ARGTYP = 96 AND ARGFORM = 2 THEN
　　TYPDSC := 'NCHAR';
　　NCHAR_VAL := DBMS_DEFER_QUERY.GET_NCHAR_ARG(CALLNO, ARGNO, TRANID);
　　DBMS_OUTPUT.PUT_LINE(TO_CHAR(ARGNO,'09')||PK_CHAR||ARG_NAME_C||TYPDSC||'
'||NVL(TRANSLATE(NCHAR_VAL USING CHAR_CS),'(NULL)')||'|');
　　ELSIF ARGTYP = 113 THEN
　　TYPDSC := 'BLOB';
　　VARCHAR2_VAL := DBMS_LOB.SUBSTR(DBMS_DEFER_QUERY.GET_BLOB_ARG(CALLNO,ARGNO,
　　DBMS_OUTPUT.PUT_LINE(TO_CHAR(ARGNO,'09')||PK_CHAR||ARG_NAME_C||TYPDSC||'
　　ELSIF ARGTYP = 112 AND ARGFORM = 1 THEN
　　TYPDSC := 'CLOB';
　　VARCHAR2_VAL := DBMS_LOB.SUBSTR(DBMS_DEFER_QUERY.GET_CLOB_ARG(CALLNO,ARGNO,
　　DBMS_OUTPUT.PUT_LINE(TO_CHAR(ARGNO,'09')||PK_CHAR||ARG_NAME_C||TYPDSC||'
　　ELSIF ARGTYP = 112 AND ARGFORM = 2 THEN
　　TYPDSC := 'NCLOB';
　　NVARCHAR2_VAL := DBMS_LOB.SUBSTR(DBMS_DEFER_QUERY.GET_NCLOB_ARG(CALLNO,
　　DBMS_OUTPUT.PUT_LINE(TO_CHAR(ARGNO,'09')||PK_CHAR||ARG_NAME_C||TYPDSC||'
'||NVL(TRANSLATE(NVARCHAR2_VAL USING CHAR_CS),'(NULL)'));
　　END IF;
　　ARGNO := ARGNO + 1;
　　END LOOP;
　　END LOOP;
　　END;
　　/