Need Help: Dynamically displaying parameter values for a procedure.

Question

Problem Statement: Generic Code should display the parameter values dynamically by taking "package name" and "procedure name" as inputs and the values needs to be obtained from the parameters of the wrapper procedure.
Example:
a) Let us assume that there is an application package called customer.
create or replace package spec customer
as
begin
TYPE cust_in_rec_type IS RECORD
cust_id NUMBER,
,cust_name VARCHAR2(25) );
TYPE cust_role_rec_type IS RECORD
(cust_id NUMBER,
role_type VARCHAR2(20)
TYPE role_tbl_type IS TABLE OF cust_role_rec_type INDEX BY BINARY_INTEGER;
Procedure create_customer
p_code in varchar2
,p_cust_rec cust_in_rec_type
,p_cust_roles role_tbl_type
end;
b) Let us assume that we need to test the create customer procedure in the package.For that various test cases needs to be executed.
c) We have created a testing package as mentioned below.
create or replace package body customer_test
as
begin
-- signature of this wrapper is exactly same as create_customer procedure.
procedure create_customer_wrapper
p_code in varchar2
,p_cust_rec customer.cust_in_rec_type
,p_cust_roles customer.role_tbl_type
as
begin
//<<<<<---Need to display parameter values dynamically for each test case-->>>>>
Since the signature of this wrapper procedure is similar to actual app procedure, we can get all the parameter definition for this procedure using ALL_ARGUMENTS table as mentioned below.
//<<
select * from ALL_ARGUMENTS where package_name = CUSTOMER' and object_name = 'CREATE_CUSTOMER'
but the problem is there are other procedures exists inside customer package like update_customer, add_address so need to have generalized code that is independent of each procedure inside the package.
Is there any way to achieve this.
Any help is appreciated.
// >>>>
create_customer
p_code => p_code
,p_cust_rec => p_cust_rec
,p_cust_roles => p_cust_roles
end;
procedure testcase1
as
l_cust_rec customer.cust_in_rec_type ;
l_cust_roles customer.role_tbl_type;
begin
l_cust_rec.cust_id := 1;
l_cust_rec.cust_name := 'ABC';
l_cust_roles(1).cust_id := 1;
l_cust_roles(1).role_type := 'Role1';
create_customer_wrapper
p_code => 'code1'
,p_cust_rec => l_cust_rec
,p_cust_roles => l_cust_role
end;
procedure testcase2
as
l_cust_rec customer.cust_in_rec_type ;
l_cust_roles customer.role_tbl_type;
begin
l_cust_rec.cust_id := 2;
l_cust_rec.cust_name := 'DEF';
l_cust_roles(1).cust_id := 2;
l_cust_roles(1).role_type := 'Role2';
create_customer_wrapper
p_code => 'code2'
,p_cust_rec => l_cust_rec
,p_cust_roles => l_cust_role
end;
end;

Answer 1

Not possible to dynamically in a procedure, deal with the parameter values passed by a caller. There is no struct or interface that a procedure can use to ask the run-time to give it the value of the 1st or 2nd or n parameter.
There could perhaps be some undocumented/unsupported method - as debugging code (<i>DBMS_DEBUG</i>) is able to dynamically reference a variable (see Get_Value() function). But debugging requires a primary session (the debug session) and the target session (session being debugged).
So easy answer is no - the complex answer is.. well, complex as the basic functionality for this do exists in Oracle in its DBMS_DEBUG feature, but only from a special debug session.
The easiest way would be to generate the wrapper itself, dynamically. This allows your to generate code that displays the parameter values and add whatever other code needed into the wrapper. The following example demonstrates the basics of this approach:
SQL> -- // our application proc called FooProc
SQL> create or replace procedure FooProc( d date, n number, s varchar2 ) is
  2  begin
  3          -- // do some stuff
  4          null;
  5  end;
  6  /
Procedure created.
SQL>
SQL> create or replace type TArgument is object(
  2          name            varchar2(30),
  3          datatype        varchar2(30)
  4  );
  5  /
Type created.
SQL>
SQL> create or replace type TArgumentList is table of TArgument;
  2  /
Type created.
SQL>
SQL> -- // create a proc that creates wrappers dynamically
SQL> create or replace procedure GenerateWrapper( procName varchar2 ) is
  2          procCode        varchar2(32767);
  3          argList         TArgumentList;
  4  begin
  5          select
  6                  TArgument( argument_name, data_type )
  7                          bulk collect into
  8                  argList
  9          from    user_arguments
10          where   object_name = upper(procName)
11          order by position;
12 
13          procCode := 'create or replace procedure Test'||procName||'( ';
14          for i in 1..argList.Count
15          loop
16                  procCode := procCode||argList(i).name||' '||argList(i).datatype;
17                  if i < argList.Count then
18                          procCode := procCode||', ';
19                  end if;
20          end loop;
21 
22          procCode := procCode||') as begin ';
23          procCode := procCode||'DBMS_OUTPUT.put_line( '''||procName||''' ); ';
24 
25          for i in 1..argList.Count
26          loop
27                  procCode := procCode||'DBMS_OUTPUT.put_line( '''||argList(i).name||'=''||'||argList(i).name||' ); ';
28          end loop;
29 
30          -- // similarly, a call to the real proc can be added into the test wrapper
31          procCode := procCode||'end;';
32 
33          execute immediate procCode;
34  end;
35  /
Procedure created.
SQL>
SQL> -- // generate a wrapper for a FooProc
SQL> exec GenerateWrapper( 'FooProc' );
PL/SQL procedure successfully completed.
SQL>
SQL> -- // call the FooProc wrapper
SQL> exec TestFooProc( sysdate, 100, 'Hello World' )
FooProc
D=2011-01-07 13:11:32
N=100
S=Hello World
PL/SQL procedure successfully completed.
SQL>