plgstr.spb

Oracle PL/SQL procedure generator (second generator type)

CREATE OR REPLACE
PACKAGE BODY PLGstr
IS
/*----------------------------------------------------------------
||                  PL/Vision Professional
||----------------------------------------------------------------
||    File: PLGstr.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
||
-----------------------------------------------------------------*/
   FUNCTION betwn
      (string_in IN VARCHAR2,
       start_in IN INTEGER,
       end_in IN INTEGER,
       inclusive IN BOOLEAN := TRUE)
   RETURN VARCHAR2
   IS
      v_start INTEGER := start_in;
      v_numchars INTEGER := ABS (end_in) - ABS (start_in) + 1;
   BEGIN
      IF string_in IS NULL OR
         NVL (start_in, 0) = 0 OR
         ABS(start_in) > ABS (end_in)
      THEN
         RETURN NULL;
      ELSE
         IF v_start < 0
         THEN
            v_start := end_in;
         ELSE
            v_start := start_in;
         END IF;

         IF NOT NVL (inclusive, FALSE)
         THEN
            v_start := v_start + 1;
            v_numchars := v_numchars - 2;
         END IF;

         IF v_start > end_in OR v_numchars < 1
         THEN
            RETURN NULL;
         ELSE
            RETURN (SUBSTR (string_in, v_start, v_numchars));
         END IF;
      END IF;
   END;

   FUNCTION betwn
      (string_in IN VARCHAR2,
       start_in IN VARCHAR2,
       end_in IN VARCHAR2 := NULL,
       startnth_in IN INTEGER := 1,
       endnth_in IN INTEGER := 1,
       inclusive IN BOOLEAN := TRUE,
       gotoend IN BOOLEAN := FALSE)
   RETURN VARCHAR2
   IS
      v_start BINARY_INTEGER;
      v_end BINARY_INTEGER;
   BEGIN
      IF string_in IS NULL OR start_in IS NULL OR end_in IS NULL OR
         startnth_in < 0 OR endnth_in < 1
      THEN
         RETURN NULL;

      ELSE
         IF startnth_in = 0
         THEN
            v_start := 1;
            v_end := INSTR (string_in, NVL (end_in, start_in), 1, endnth_in);
         ELSE
            v_start := INSTR (string_in, start_in, 1, startnth_in);
            v_end := INSTR (string_in, NVL (end_in, start_in), v_start+1, endnth_in);
         END IF;

         IF v_start = 0
         THEN
		    RETURN NULL;
         ELSE
	         IF NOT inclusive
	         THEN
	            IF startnth_in > 0
	            THEN
	               v_start := v_start + LENGTH (start_in);
	            END IF;
	            v_end := v_end - 1;
	         ELSE
	            v_end := v_end + LENGTH (end_in) - 1;
	         END IF;
			 
	         IF v_start = 0 OR
	            (v_start > v_end AND v_end > 0) OR
	            (v_end <= 0 AND NOT NVL (gotoend, FALSE))
	         THEN
	            RETURN NULL;
	         ELSE
	            IF v_end <= 0 THEN v_end := LENGTH (string_in); END IF;		 

	            RETURN betwn (string_in, v_start, v_end);
	         END IF;
         END IF;
      END IF;
   END;

   FUNCTION swap
      (string_in IN VARCHAR2,
       replace_in IN VARCHAR2,
       start_in IN INTEGER := 1,
       oldlen_in IN INTEGER := NULL)
   RETURN VARCHAR2
   IS
      v_len BINARY_INTEGER := LENGTH (string_in);
      v_rlen BINARY_INTEGER := NVL (oldlen_in, LENGTH (replace_in));
   BEGIN
      IF start_in = 0 OR
         string_in IS NULL OR
         /* 8/98 Remove condition. replace_in IS NULL OR */
         start_in > v_len
      THEN
         RETURN string_in;
      ELSIF start_in = 1
      THEN
         RETURN replace_in || SUBSTR (string_in, v_rlen+1);
      ELSE
         RETURN (SUBSTR (string_in, 1, start_in-1) ||
            replace_in || SUBSTR (string_in, start_in + v_rlen));
      END IF;
   END;

   PROCEDURE swap
      (string_inout IN OUT VARCHAR2,
       replace_in IN VARCHAR2,
       start_in IN INTEGER := 1,
       oldlen_in IN INTEGER := NULL)
   IS
   BEGIN
      string_inout := swap (string_inout, replace_in, start_in, oldlen_in);
   END;

   FUNCTION lstrip
      (string_in IN VARCHAR2,
       substring_in IN VARCHAR2,
       num_in IN INTEGER := 1)
   RETURN VARCHAR2
   IS
   BEGIN
      IF num_in < 1 OR
         string_in IS NULL OR
         substring_in IS NULL
      THEN
         RETURN string_in;

      ELSIF INSTR (string_in, substring_in) = 1
      THEN
         RETURN lstrip (SUBSTR (string_in, LENGTH (substring_in)+1),
            substring_in, num_in-1);
      ELSE
         RETURN string_in;
      END IF;
   END;

   FUNCTION rstrip
      (string_in IN VARCHAR2,
       substring_in IN VARCHAR2,
       num_in IN INTEGER := 1)
   RETURN VARCHAR2
   IS
      v_loc INTEGER;
   BEGIN
      IF num_in < 1 OR
         string_in IS NULL OR
         substring_in IS NULL
      THEN
         RETURN string_in;
      ELSE
         v_loc := INSTR (string_in, substring_in, -1, 1);
         IF v_loc + LENGTH (substring_in) = LENGTH (string_in) + 1
         THEN
            RETURN rstrip (SUBSTR (string_in, 1, v_loc-1), substring_in, num_in-1);
         ELSE
            RETURN string_in;
         END IF;
      END IF;
   END;

   FUNCTION rvrs (string_in IN VARCHAR2,
      start_in IN INTEGER := 1,
      end_in IN INTEGER := NULL,
      embed_in IN BOOLEAN := FALSE)
   RETURN VARCHAR2
   IS
      invalid_arguments EXCEPTION;

      v_len BINARY_INTEGER := LENGTH (string_in);
      v_start BINARY_INTEGER := NVL (start_in, 1);
      v_end BINARY_INTEGER;
      v_temp BINARY_INTEGER;
      retval PLGadmin.maxvc2;
   BEGIN

      /* Make sure arguments are valid. */
      IF string_in IS NULL OR
         (start_in = 0 OR end_in = 0) OR
         (start_in > end_in AND start_in > 0) OR
         (start_in < end_in AND start_in < 0)
      THEN
         RAISE invalid_arguments;
      END IF;

      /* Handle negative values */
      IF v_start < 0
      THEN
         v_temp := v_len + NVL (end_in, -1 * v_len) + 1; /* end */
         v_end := v_len + v_start + 1;
         v_start := v_temp;
      ELSE
         v_end := NVL (end_in, v_len);
      END IF;

      /* Do the reversal */
      FOR strind IN REVERSE v_start .. v_end
      LOOP
         retval := retval || SUBSTR (string_in, strind, 1);
      END LOOP;

      /* Embed if requested. */
      IF embed_in
      THEN
         retval := SUBSTR (string_in, 1, v_start-1) ||
                   retval ||
                   SUBSTR (string_in, v_end+1);
      END IF;

      RETURN retval;
   EXCEPTION
      WHEN invalid_arguments
      THEN
         RETURN NULL;
   END;

   FUNCTION rvrs_old (string_in IN VARCHAR2,
      start_in IN INTEGER := 1,
      end_in IN INTEGER := NULL)
   RETURN VARCHAR2
   IS
      v_len BINARY_INTEGER := LENGTH (string_in);
      v_start BINARY_INTEGER := NVL (start_in, 1);
      v_end BINARY_INTEGER;
   BEGIN
      /* Do not use LEAST due to bug in 7.1
         v_end := LEAST (NVL (end_in, v_len), v_len);
      */
      IF end_in IS NULL
      THEN
         v_end := v_len;
      ELSIF v_len < v_end
      THEN
         v_end := v_len;
      END IF;

      IF string_in IS NULL OR
         v_start > v_end OR
         v_start < 1 OR v_end < 1 OR
         v_start > v_len
      THEN
         RETURN NULL;
      ELSIF v_start = v_end
      THEN
         RETURN SUBSTR (string_in, v_start, 1);
      ELSE
         RETURN rvrs (string_in, v_start + 1, v_end) ||
            SUBSTR (string_in, v_start, 1);
      END IF;
   END;

   FUNCTION lpart
      (string_in IN VARCHAR2,
       divider_in IN VARCHAR2,
       start_in IN INTEGER := 1,
       nth_in IN INTEGER := 1,
       all_if_notfound_in IN BOOLEAN := FALSE)
   RETURN VARCHAR2
   IS
      v_loc INTEGER;
   BEGIN
      v_loc := INSTR (string_in, divider_in, start_in, nth_in);

      IF v_loc = 0
      THEN
         IF all_if_notfound_in
         THEN
            RETURN string_in;
         ELSE
            RETURN NULL;
         END IF;
      ELSE
         RETURN SUBSTR (string_in, 1, v_loc-1);
      END IF;
   END;

   FUNCTION rpart
      (string_in IN VARCHAR2,
       divider_in IN VARCHAR2,
       start_in IN INTEGER := 1,
       nth_in IN INTEGER := 1,
       all_if_notfound_in IN BOOLEAN := FALSE)
   RETURN VARCHAR2
   IS
      v_loc INTEGER;
   BEGIN
      v_loc := INSTR (string_in, divider_in, start_in, nth_in);

      IF v_loc = 0
      THEN
         IF all_if_notfound_in
         THEN
            RETURN string_in;
         ELSE
            RETURN NULL;
         END IF;
      ELSE
         RETURN SUBSTR (string_in, v_loc+1);
      END IF;
   END;

END PLGstr;
/