plgdesc.spb

Oracle PL/SQL procedure generator (second generator type)

            /* Oracle8 only */
            &authidopen
            arglist (v_argrow).CHARACTER_SET_NAME := rec.CHARACTER_SET_NAME;
            arglist (v_argrow).TYPE_OWNER := rec.TYPE_OWNER;
            arglist (v_argrow).TYPE_NAME := rec.TYPE_NAME;
            arglist (v_argrow).TYPE_SUBNAME := rec.TYPE_SUBNAME;
            arglist (v_argrow).TYPE_LINK := rec.TYPE_LINK;
            &authidclose
                  
            /* Set composite info... */
            arglist (v_argrow).is_composite := based_on_type (rec.data_type);
            IF NOT proglist (v_progrow).has_composite_arg 
            THEN
               proglist (v_progrow).has_composite_arg :=  
                  arglist (v_argrow).is_composite;
            END IF;
         END IF;
      END;

      PROCEDURE set_retarg_info (rec IN arg_cur%ROWTYPE)
      IS
      BEGIN
         retarglist (v_retargrow).OWNER := rec.OWNER;
         retarglist (v_retargrow).OBJECT_NAME := rec.OBJECT_NAME;
         retarglist (v_retargrow).PACKAGE_NAME := rec.PACKAGE_NAME;
         retarglist (v_retargrow).OBJECT_ID := rec.OBJECT_ID;
         retarglist (v_retargrow).OVERLOAD := rec.OVERLOAD;
         retarglist (v_retargrow).ARGUMENT_NAME := rec.ARGUMENT_NAME;
         retarglist (v_retargrow).POSITION := rec.POSITION;
         retarglist (v_retargrow).SEQUENCE := rec.SEQUENCE;
         retarglist (v_retargrow).DATA_LEVEL := rec.DATA_LEVEL;
         set_data_type (rec.DATA_TYPE, retarglist (v_retargrow).DATA_TYPE);
         retarglist (v_retargrow).DEFAULT_VALUE := rec.DEFAULT_VALUE;
         retarglist (v_retargrow).DEFAULT_LENGTH := rec.DEFAULT_LENGTH;
         -- Convert IN/OUT to IN OUT
         retarglist (v_retargrow).IN_OUT := TRANSLATE (rec.IN_OUT, '/', ' ');
         retarglist (v_retargrow).DATA_LENGTH := rec.DATA_LENGTH;
         retarglist (v_retargrow).DATA_PRECISION := rec.DATA_PRECISION;
         retarglist (v_retargrow).DATA_SCALE := rec.DATA_SCALE;
         retarglist (v_retargrow).RADIX := rec.RADIX;

         /* Oracle8 only */
         &authidopen
         retarglist (v_retargrow).CHARACTER_SET_NAME := rec.CHARACTER_SET_NAME;
         retarglist (v_retargrow).TYPE_OWNER := rec.TYPE_OWNER;
         retarglist (v_retargrow).TYPE_NAME := rec.TYPE_NAME;
         retarglist (v_retargrow).TYPE_SUBNAME := rec.TYPE_SUBNAME;
         retarglist (v_retargrow).TYPE_LINK := rec.TYPE_LINK;
         &authidclose
                  
         /* Set composite info... */
         retarglist (v_retargrow).is_composite := based_on_type (rec.data_type);
         IF NOT proglist (v_progrow).ret_has_composite 
         THEN
            proglist (v_progrow).ret_has_composite :=  
               retarglist (v_retargrow).is_composite;
         END IF;
      END;
   BEGIN                                                 
      OPEN arg_cur (NVL (sch, USER), v_pkg, v_obj);
      LOOP
         FETCH arg_cur INTO rec;
         
         IF arg_cur%NOTFOUND
         THEN
            set_end_values;
            EXIT;
         END IF;

         set_prog_info (rec);
         
         IF v_setretarg
         THEN
            set_retarg_info (rec);
         ELSE
            set_arg_info (rec);
         END IF;
         
      END LOOP;
      CLOSE arg_cur;
   END;

   PROCEDURE showarg (
      argrec_in IN arglist_rt,
      last_ovld IN OUT INTEGER,
      argrow_in IN INTEGER,
      indent_in IN INTEGER := 0)
   IS
      v_prefix PLGadmin.identifier := RPAD ('*', indent_in, ' ');

      FUNCTION strval (num IN INTEGER, padto IN INTEGER) RETURN VARCHAR2
      IS
      BEGIN
         RETURN RPAD (TO_CHAR (num), padto) || ' ';
      END;
   BEGIN
      IF last_ovld != argrec_in.overload
      THEN
         DBMS_OUTPUT.PUT_LINE (v_prefix || '----');
         last_ovld := argrec_in.overload;

      ELSIF last_ovld IS NULL
      THEN
         last_ovld := argrec_in.overload;
      END IF;

      IF argrec_in.argument_name IS NULL
      THEN
         DBMS_OUTPUT.PUT_LINE (v_prefix || 'No parameters for this program.');
      ELSE
         DBMS_OUTPUT.PUT_LINE (v_prefix ||
            RPAD (argrec_in.overload, 4) ||
            strval (argrec_in.position, 3) ||
            strval (argrec_in.data_level, 3) ||
            RPAD (argrec_in.data_type, 16) ||
            RPAD (LPAD (' ', 2*argrec_in.data_level, ' ') ||
               NVL (argrec_in.argument_name, 'RETURN Value') ||
               ' (' || argrow_in || ')',
               34) ||
            RPAD (argrec_in.in_out, 6) ||
            RPAD (argrec_in.default_value, 20) ||
            strval (argrec_in.data_length, 5) ||
            argrec_in.startseprow || '-' || argrec_in.endseprow
            );
         IF argrec_in.composite_name != argrec_in.argument_name
         THEN
             DBMS_OUTPUT.PUT_LINE (v_prefix ||
                LPAD (' ', 32) ||
                argrec_in.composite_name
                );
         END IF;
      END IF;
   END;

   PROCEDURE showhdr (indent_in IN INTEGER := 0)
   IS
      v_prefix PLGadmin.identifier := RPAD ('*', indent_in, ' ');
   BEGIN
      DBMS_OUTPUT.PUT_LINE (v_prefix ||
   'OvLd Pos Lev Type            Name                              Mode  Def Len  NonSep');
      DBMS_OUTPUT.PUT_LINE (v_prefix ||
   '---- --- --- --------------- --------------------------------- ----- --- ---- ---------');
   END;

   PROCEDURE showargs (obj IN VARCHAR2 := NULL)
   IS
      v_onearg arglist_rt;
      v_last_overload PLS_INTEGER;

      FUNCTION strval (num IN INTEGER, padto IN INTEGER) RETURN VARCHAR2
      IS
      BEGIN
         RETURN RPAD (TO_CHAR (num), padto) || ' ';
      END;
   BEGIN
      NULL;
      /*
      IF obj IS NOT NULL
      THEN
         args (obj);
      END IF;

      IF g_position.COUNT > 0
      THEN
         showhdr;
         FOR argrow IN g_position.FIRST .. g_position.LAST
         LOOP
            showarg (arg (argrow), v_last_overload, argrow);
         END LOOP;
      END IF;
      */
   END;
   
   PROCEDURE obtain_args (
      sch IN VARCHAR2,
      pkg IN VARCHAR2,
      obj IN VARCHAR2,
      prog_out IN OUT prog_tt,
      arglist_out IN OUT arglist_tt
      )
   IS
   BEGIN
      /* Extract the basic argument information for each program in the list. */
      FOR rowind IN prog_out.FIRST .. prog_out.LAST
      LOOP
         IF pkg IS NOT NULL 
         THEN
            prog_out(rowind).pkgname := pkg;
         END IF;
         
         prog_out(rowind).startrow := PLGofst.shifted (rowind, c_prog_max, 1, 1);

         /* Extract arguments for single program. */
         args (
            sch,
            pkg,
            obj,
            arglist_out,
            prog_out(rowind).startrow
            );

         prog_out(rowind).argcount := arglist_out.COUNT;

         IF prog_out(rowind).argcount = 0
         THEN
            prog_out(rowind).startrow := NULL;
            prog_out(rowind).endrow := NULL;
         ELSE
            prog_out(rowind).endrow :=
               prog_out(rowind).startrow + prog_out(rowind).argcount - 1;
         END IF;
      END LOOP;
   END;

   PROCEDURE separate_progs_and_args (
      prog_out IN OUT prog_tt,
      arglist_out IN OUT arglist_tt,
      progsep_out IN OUT progsep_tt,
      argseplist_out IN OUT arglist_tt
      )
   /*
      - Separate programs and arguments (separate set of arguments for each
        overloaded program, non-composite arguments, be able and ready to
        reference back to the original list, though).

      - RETURN argument information for the functions: cannot be just a single
        datatype. If a composite, need to expand set and save for conversion
        to a procedure or some such thing. Store in negative indexes in the
        argsep list.

      - FUTURE: List of procedures (pointer back to the progsep list).

      - FUTURE: List of functions (pointer back to the progsep list).
   */
   IS
      v_row PLS_INTEGER;
      v_seprow PLS_INTEGER;

      PROCEDURE set_progtype (argrow IN PLS_INTEGER, progrow IN PLS_INTEGER)
      IS
      BEGIN
         IF progsep_out(progrow).argcount = 0
         THEN
            /* If a function, would have at least one argument at this stage. */
            progsep_out(progrow).progtype := 'PROCEDURE';
         ELSIF
            arglist_out(argrow).argument_name IS NULL
            AND
            arglist_out(argrow).data_type IS NOT NULL
         THEN
            progsep_out(progrow).progtype := 'FUNCTION';
            progsep_out(progrow).data_type := arglist_out(argrow).data_type;
         ELSE
            progsep_out(progrow).progtype := 'PROCEDURE';
         END IF;
      END;
   BEGIN
      /* Go back through prog and arg, transfer to sep versions, creating separate
         sets of arguments for each overloading. */

      v_seprow := prog_out.FIRST;

      FOR rowind IN prog_out.FIRST .. prog_out.LAST
      LOOP
         IF prog_out(rowind).argcount = 0
         THEN
            prog_out(rowind).isoverloaded := FALSE;
         ELSE
            prog_out(rowind).isoverloaded :=
               arglist_out(prog_out(rowind).startrow).overload > 0;
         END IF;

         IF prog_out(rowind).isoverloaded
         THEN
            /* Expand into separate prog entries in progsep_out
               and then process the arguments into corresponding areas. */
            DECLARE
               v_last_overload PLS_INTEGER := NULL;
               v_last_startrow PLS_INTEGER;
               v_last_startseprow PLS_INTEGER;
               v_currrow PLS_INTEGER := prog_out(rowind).startrow;
               v_currargseprow PLS_INTEGER :=
					   PLGofst.shifted (v_seprow, c_prog_max, 1, 1);
            BEGIN
               prog_out(rowind).startseprow := v_seprow;
               progsep_out(v_seprow).progname := prog_out(rowind).progname;
               progsep_out(v_seprow).pkgname := prog_out(rowind).pkgname;

               FOR argind IN 1 .. prog_out(rowind).argcount
               LOOP
                  IF v_last_overload != arglist_out(v_currrow).overload OR
                     v_last_overload IS NULL OR
                     argind = prog_out(rowind).argcount
                  THEN
                     /* Done with last overloading (or at first). */
                     IF v_last_overload IS NOT NULL
                     THEN
                        /* Finish up settings for last overloading. */
                        progsep_out(v_seprow).nonseprow := rowind;

                        IF arglist_out(v_currrow-1).data_type IS NOT NULL /* no parameters */
                        THEN
                           progsep_out(v_seprow).argcount := 0;
                           progsep_out(v_seprow).startrow := NULL;
                           progsep_out(v_seprow).endrow := NULL;
                           progsep_out(v_seprow).nonsepargcount := 0;
                           progsep_out(v_seprow).nonsependrow := NULL;
                        ELSE
                           progsep_out(v_seprow).argcount :=
                              v_currargseprow -
                              v_last_startseprow +