plgprs.spb

Oracle PL/SQL procedure generator (second generator type)

CREATE OR REPLACE PACKAGE BODY PLGprs
IS
   /*----------------------------------------------------------------
   ||                  PL/Vision Professional
   ||----------------------------------------------------------------
   ||    File: PLGprs.spb
   ||  Author: Steven Feuerstein
   ||
   || This is a part of the PL/Vision Professional Code library.
   || Copyright (C) 1996-99 Quest Software, Inc.
   || All rights reserved.
   ||
   || For more information, call Quest Software at 1-800-REVEAL4
   || or check out our Web page: www.Quest Software.com
   ||
   ******************************************************************/
   c_pkg CONSTANT PLGadmin.identifier := 'PLGprs';

   /* Package variables used repeatedly throughout the body. */

   len_string NUMBER;
   start_loc NUMBER;
   next_loc NUMBER;

   /*--------------------- Private Modules ---------------------------
   || The following functions are available only to other modules in
   || package. No user of PLGprs can see or use these functions.
   ------------------------------------------------------------------*/

   FUNCTION a_delimiter (
      character_in IN VARCHAR2,
      delimiters_in IN VARCHAR2 := std_delimiters)
      RETURN BOOLEAN
   /*
   || Returns TRUE if the character passsed into the function is found
   || in the list of delimiters.
   */

   IS
   BEGIN
      RETURN INSTR (delimiters_in, character_in) > 0;
   END;

   FUNCTION string_length (string_in IN VARCHAR2)
      RETURN INTEGER
   IS
   BEGIN
      RETURN LENGTH (LTRIM (RTRIM (string_in)));
   END;

   /* CWS begin */

   FUNCTION include_this_atomic (
      atomic_in IN VARCHAR2,
      type_in IN VARCHAR2 := c_all,
      delimiters_in IN VARCHAR2 := std_delimiters)
      RETURN BOOLEAN
   /*
   ||   given a type of atomic to include (c_all for all atomics,
   ||   c_word for words only, c_delim for delimiters only) return
   ||   TRUE if the input atomic should be included
   */

   IS
      return_value BOOLEAN := FALSE;
   BEGIN
      IF    type_in = c_all
         OR (   type_in = c_word
            AND NOT a_delimiter (atomic_in, delimiters_in))
         OR (   type_in = c_delim
            AND a_delimiter (atomic_in, delimiters_in))
      THEN
         return_value := TRUE;
      ELSE
         return_value := FALSE;
      END IF;
      RETURN (return_value);
   END;
   /* CWS end   */
   FUNCTION next_atom_loc (
      string_in IN VARCHAR2,
      start_loc_in IN NUMBER,
      direction_in IN NUMBER := +1,
      delimiters_in IN VARCHAR2 := std_delimiters)
      RETURN INTEGER
   IS
      /* Boolean variable which uses private function to determine
      || if the current character is a delimiter or not.
      */
      was_a_delimiter BOOLEAN 
               := a_delimiter (
                     SUBSTR (string_in, start_loc_in, 1),
                     delimiters_in
                  );

      /* If not a delimiter, then it was a word. */

      was_a_word BOOLEAN := NOT was_a_delimiter;

      /* The next character scanned in the string */

      next_char VARCHAR2(1);
      /*
      || The value returned by the function. This location is the start
      || of the next atomic found. Initialize it to next character,
      || forward or backward depending on increment.
      */
      return_value NUMBER := start_loc_in + direction_in;
   BEGIN
      LOOP
         next_char := SUBSTR (string_in, return_value, 1);

         EXIT WHEN
                      /* On a delimiter, since that is always an atomic */

                      a_delimiter (next_char, delimiters_in)
                   OR
                      /* Was a delimiter, but am now in a word. */

                      (   was_a_delimiter
                      AND NOT a_delimiter (next_char, delimiters_in))
                   OR
                      /* Reached end of string scanning forward. */

                      next_char IS NULL
                   OR
                      /* Reached beginning of string scanning backward. */

                      return_value < 0;

         /* Shift return_value to move the next character. */

         return_value := return_value + direction_in;
      END LOOP;

      RETURN GREATEST (return_value, 0);
   END;

   /* ------------------------- Public Modules -----------------------*/

   PROCEDURE string (
      string_in IN VARCHAR2,
      atomics_list_out IN OUT PLGadmin.vc2000_tabtype,
      delimiters_in IN VARCHAR2 := std_delimiters,
      type_in IN VARCHAR2 := c_all,
      usehash IN BOOLEAN := FALSE)
   IS
      v_row PLS_INTEGER := 0;
      v_str PLGadmin.dbmaxvc2;
   BEGIN
      len_string := LENGTH (string_in);

      IF len_string IS NOT NULL
      THEN
         start_loc := LEAST (1, INSTR (string_in, ' ') + 1);
         WHILE start_loc <= len_string
         LOOP
            next_loc := next_atom_loc (string_in, start_loc, 1, delimiters_in);

            IF include_this_atomic (
                  SUBSTR (string_in, start_loc, 1),
                  type_in,
                  delimiters_in
               )
            THEN
               IF next_loc > len_string
               THEN
                  v_str := SUBSTR (string_in, start_loc);
               ELSE
                  v_str := SUBSTR (string_in, start_loc, next_loc - start_loc);
               END IF;

               v_row := NVL (atomics_list_out.LAST, 0) + 1;

               atomics_list_out (v_row) := v_str;
            END IF;

            -- Move starting point of scan for next atomic.

            start_loc := next_loc;

         END LOOP;
      END IF;
   END string;

   PROCEDURE string1 (
   /* Parsing for a single character delimiter, default of CR,
      just return the "words". */
      string_in IN VARCHAR2,
      atomics_list_out IN OUT PLGadmin.vc2000_tabtype,
      delimiter_in IN VARCHAR2 := CHR(10))
   IS
      v_start PLS_INTEGER := 1;
      v_loc PLS_INTEGER := 0;
      v_str PLGadmin.dbmaxvc2;
   BEGIN
      LOOP
         v_loc := INSTR (string_in, delimiter_in, v_start);
         IF v_loc = 0
         THEN
            v_str := SUBSTR (string_in, v_start);
         ELSE
            v_str := SUBSTR (string_in, v_start, v_loc - v_start);
         END IF;
         atomics_list_out (NVL (atomics_list_out.LAST, 0) + 1) := v_str;
         EXIT WHEN v_loc = 0;
         v_start := v_loc + 1;
      END LOOP;
   END string1;

   FUNCTION numinstr (
      string_in IN VARCHAR2,
      substring_in IN VARCHAR2,
      ignore_case_in IN VARCHAR2 := c_ignore_case)
      RETURN INTEGER
   /*
   || Function returns the number of times a sub-string
   || appears in a string.
   ||
   || Idea for this simple, one-pass algorithm comes
   || from Kevin Loney. If it looks crazy, it is because
   || I am handling the case issue.
   */

   IS
      return_value INTEGER := NULL;
   BEGIN

      IF ignore_case_in = c_ignore_case
      THEN
         return_value :=
            (LENGTH (
               string_in
            ) -
            NVL (
               LENGTH (
                  REPLACE (
                     UPPER (
                        string_in
                     ),
                     UPPER (
                        substring_in
                     )
                  )
               ),
               0
            )) /
            LENGTH (
               substring_in
            );
      ELSE
         return_value :=
            (LENGTH (string_in) -
            NVL (LENGTH (REPLACE (string_in, substring_in)), 0)) /
            LENGTH (substring_in);
      END IF;

      RETURN return_value;
   END;
END PLGprs;
/