plgofst.spb

Oracle PL/SQL procedure generator (second generator type)

CREATE OR REPLACE PACKAGE BODY PLGofst
IS

/* The Table Partition Offset Package */

/*----------------------------------------------------------------
||                  PL/Vision Professional 
||----------------------------------------------------------------
||    File: PLGofst.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 := 'plgofst';

   v_start BINARY_INTEGER := c_start;

   PROCEDURE valofst (ofst_in IN INTEGER) IS
   BEGIN
      PLGerr.assert (ofst_in > 0,
         'PLGofst: offset value must be positive. Adjust startrow if you ' ||
         'want to use negative row numbers.');
   END;
   
   PROCEDURE valrow (row_in IN INTEGER,
      ofst_in IN INTEGER := NULL, max_in IN INTEGER := NULL,
      start_in IN INTEGER := NULL) IS
   BEGIN
      PLGerr.assert (row_in > 0,
         'PLGofst: row must be positive. Adjust startrow if you ' ||
         'want to use negative row numbers. ' ||
         'Offset: ' || TO_CHAR (ofst_in) || ' ' ||
         'Maximum: ' || TO_CHAR (max_in) || ' ' ||
         'Row: ' || TO_CHAR (row_in) || ' ' ||
         'Start Row: ' || TO_CHAR (start_in)
         );
      
   END;

   PROCEDURE valmax (max_in IN INTEGER) IS
   BEGIN
      PLGerr.assert (max_in > 0, 'PLGofst: max must be positive.');
      PLGerr.assert (max_in < 2 * c_last, 
         'PLGofst: max cannot exceed number of rows allowed in a PL/SQL table.');
   END;
      
   PROCEDURE valall (ofst_in IN INTEGER, max_in IN INTEGER, row_in IN INTEGER)
   IS
   BEGIN
      valofst (ofst_in);
      valmax (max_in);
      valrow (row_in);
   END;  
   
   FUNCTION shiftby (ofst_in IN INTEGER, max_in IN INTEGER,
       start_in IN INTEGER := startrow)
   RETURN INTEGER
   IS
   BEGIN
      RETURN ((ofst_in - 1) * max_in + start_in - 1);
   END;

   PROCEDURE set_startrow (row_in IN INTEGER := c_start)
   IS
   BEGIN
      PLGerr.assert (row_in BETWEEN c_first AND c_last,
         'PLGofst: startrow must be between ' || TO_CHAR (c_first) ||
         ' and ' || TO_CHAR (c_last));
      v_start := row_in;
   END;

   FUNCTION startrow RETURN INTEGER IS
   BEGIN
      RETURN v_start;
   END;

   FUNCTION shifted 
      (ofst_in IN INTEGER, max_in IN INTEGER, row_in IN INTEGER,
       start_in IN INTEGER := startrow)
   RETURN INTEGER
   IS
      retval INTEGER;
   BEGIN
      --valall (ofst_in, max_in, row_in);
	  valmax (max_in);
	  valrow (row_in, ofst_in, max_in, start_in);
      retval := shiftby (ofst_in, max_in, start_in) + row_in;
      RETURN retval;
   END;

   FUNCTION unshifted 
      (ofst_in IN INTEGER, max_in IN INTEGER, row_in IN INTEGER,
       start_in IN INTEGER := startrow)
   RETURN INTEGER
   IS
   BEGIN
      --valofst (ofst_in);
      valmax (max_in);
      RETURN (row_in - shiftby (ofst_in, max_in, start_in));
   END;

   FUNCTION first (ofst_in IN INTEGER, max_in IN INTEGER,
       start_in IN INTEGER := startrow) RETURN INTEGER
   IS
   BEGIN
      --valofst (ofst_in);
      valmax (max_in);
      RETURN (shifted (ofst_in, max_in, 1, start_in));
   END;

   FUNCTION last (ofst_in IN INTEGER, max_in IN INTEGER,
       start_in IN INTEGER := startrow) RETURN INTEGER
   IS
   BEGIN
      --valofst (ofst_in);
      valmax (max_in);
      RETURN (shifted (ofst_in, max_in, max_in, start_in));
   END;

   FUNCTION outofrange
      (ofst_in IN INTEGER, max_in IN INTEGER, row_in IN INTEGER,
       start_in IN INTEGER := startrow)
   RETURN BOOLEAN
   IS
   BEGIN
      RETURN 
         (row_in > PLGofst.last (ofst_in, max_in, start_in) OR 
          row_in < PLGofst.first (ofst_in, max_in, start_in));
   END;
END PLGofst;
/