CREATE OR REPLACE PACKAGE BODY EFT_NOM.cg$DOCUMENTS IS


PROCEDURE   validate_mandatory(cg$val_rec IN cg$row_type,
                               loc        IN VARCHAR2 DEFAULT '');
PROCEDURE   up_autogen_columns(cg$rec    IN OUT cg$row_type,
                               cg$ind    IN OUT cg$ind_type,
                               operation IN VARCHAR2 DEFAULT 'INS',
                               do_denorm IN BOOLEAN DEFAULT TRUE);
PROCEDURE   err_msg(msg  IN VARCHAR2,
                    type IN INTEGER,
                    loc  IN VARCHAR2 DEFAULT '');

--------------------------------------------------------------------------------
-- Name:        raise_uk_not_updateable
--
-- Description: Raise appropriate error when unique key updated
--
-- Parameters:  none
--------------------------------------------------------------------------------
PROCEDURE raise_uk_not_updateable(uk IN VARCHAR2) IS
BEGIN
    cg$errors.push(cg$errors.MsgGetText(cg$errors.API_UNIQUE_KEY_UPDATE, cg$errors.ERR_UK_UPDATE, uk),
                   'E',
                   'API',
                   cg$errors.API_UNIQUE_KEY_UPDATE,
                   'cg$DOCUMENTS.raise_uk_not_updateable');
                   cg$errors.raise_failure;
END raise_uk_not_updateable;


--------------------------------------------------------------------------------
-- Name:        raise_fk_not_transferable
--
-- Description: Raise appropriate error when foreign key updated
--
-- Parameters:  none
--------------------------------------------------------------------------------
PROCEDURE raise_fk_not_transferable(fk IN VARCHAR2) IS
BEGIN
    cg$errors.push(cg$errors.MsgGetText(cg$errors.API_FOREIGN_KEY_TRANS, cg$errors.ERR_FK_TRANS, fk),
                   'E',
                   'API',
                   cg$errors.API_FOREIGN_KEY_TRANS,
                   'cg$DOCUMENTS.raise_fk_not_transferable');
    cg$errors.raise_failure;
END raise_fk_not_transferable;


--------------------------------------------------------------------------------
-- Name:        up_autogen_columns
--
-- Description: Specific autogeneration of column values and conversion to
--              uppercase
--
-- Parameters:  cg$rec    Record of row to be manipulated
--              cg$ind    Indicators for row
--              operation Procedure where this procedure was called
--------------------------------------------------------------------------------
PROCEDURE up_autogen_columns(cg$rec IN OUT cg$row_type,
                             cg$ind IN OUT cg$ind_type,
                             operation IN VARCHAR2 DEFAULT 'INS',
                             do_denorm IN BOOLEAN DEFAULT TRUE) IS
BEGIN
    IF (operation = 'INS') THEN
        BEGIN
			IF (cg$ind.DOCU_ID = FALSE OR cg$rec.DOCU_ID is NULL) THEN
				SELECT DOCU_SEQ.nextval
				INTO   cg$rec.DOCU_ID
				FROM   DUAL;
				cg$ind.DOCU_ID := TRUE;
			END IF;
        EXCEPTION WHEN OTHERS THEN
            cg$errors.push(SQLERRM,
                           'E',
                           'ORA',
                           SQLCODE,
                           'cg$DOCUMENTS.up_autogen.DOCU_ID.others');
            cg$errors.raise_failure;
        END;

        NULL;
    ELSE
NULL;
    END IF;


EXCEPTION
    WHEN no_data_found THEN
        NULL;
    WHEN OTHERS THEN
        cg$errors.push(SQLERRM,
                      'E',
                      'ORA',
                      SQLCODE,
                      'cg$DOCUMENTS.up_autogen_columns.denorm');
        cg$errors.raise_failure;

END up_autogen_columns;


--------------------------------------------------------------------------------
-- Name:        validate_mandatory
--
-- Description: Checks all mandatory columns are not null and raises appropriate
--              error if not satisfied
--
-- Parameters:  cg$val_rec Record of row to be checked
--              loc        Place where this procedure was called for error
--                         trapping
--------------------------------------------------------------------------------
PROCEDURE validate_mandatory(cg$val_rec IN cg$row_type,
                             loc        IN VARCHAR2 DEFAULT '') IS
BEGIN
    IF (cg$val_rec.DOCU_ID IS NULL) THEN
        cg$errors.push(cg$errors.MsgGetText(cg$errors.API_MAND_COLUMN_ISNULL, cg$errors.VAL_MAND, P10DOCU_ID),
                       'E',
                       'API',
                       cg$errors.API_MAND_COLUMN_ISNULL,
                       loc);
    END IF;
    IF (cg$val_rec.BLOB_CONTENT IS NULL) THEN
        cg$errors.push(cg$errors.MsgGetText(cg$errors.API_MAND_COLUMN_ISNULL, cg$errors.VAL_MAND, P20BLOB_CONTENT),
                       'E',
                       'API',
                       cg$errors.API_MAND_COLUMN_ISNULL,
                       loc);
    END IF;
    IF (cg$val_rec.NAME IS NULL) THEN
        cg$errors.push(cg$errors.MsgGetText(cg$errors.API_MAND_COLUMN_ISNULL, cg$errors.VAL_MAND, P60NAME),
                       'E',
                       'API',
                       cg$errors.API_MAND_COLUMN_ISNULL,
                       loc);
    END IF;
    IF (cg$val_rec.DESCRIPTION IS NULL) THEN
        cg$errors.push(cg$errors.MsgGetText(cg$errors.API_MAND_COLUMN_ISNULL, cg$errors.VAL_MAND, P90DESCRIPTION),
                       'E',
                       'API',
                       cg$errors.API_MAND_COLUMN_ISNULL,
                       loc);
    END IF;
    NULL;
END validate_mandatory;


--------------------------------------------------------------------------------
-- Name:        validate_foreign_keys
--
-- Description: Checks all mandatory columns are not null and raises appropriate
--              error if not satisfied
--
-- Parameters:  cg$rec Record of row to be checked
--------------------------------------------------------------------------------
PROCEDURE validate_foreign_keys_ins(cg$rec IN cg$row_type) IS
    fk_check INTEGER;
BEGIN
NULL;
END;

PROCEDURE validate_foreign_keys_upd( cg$rec IN cg$row_type,
                                     cg$old_rec IN cg$row_type,
                                     cg$ind IN cg$ind_type) IS
    fk_check INTEGER;
BEGIN
NULL;
END;

PROCEDURE validate_foreign_keys_del(cg$rec IN cg$row_type) IS
    fk_check INTEGER;
BEGIN
NULL;
END;


--------------------------------------------------------------------------------
-- Name:        slct
--
-- Description: Selects into the given parameter all the attributes for the row
--              given by the primary key
--
-- Parameters:  cg$sel_rec  Record of row to be selected into using its PK
--------------------------------------------------------------------------------
PROCEDURE slct(cg$sel_rec IN OUT cg$row_type) IS

BEGIN

    IF cg$sel_rec.the_rowid is null THEN
       SELECT    DOCU_ID
       ,         BLOB_CONTENT
       ,         CONTENT_TYPE
       ,         LAST_UPDATED
       ,         MIME_TYPE
       ,         NAME
       ,         DOC_SIZE
       ,         DAD_CHARSET
       ,         DESCRIPTION
       ,         LANGUAGE
       , rowid
       INTO      cg$sel_rec.DOCU_ID
       ,         cg$sel_rec.BLOB_CONTENT
       ,         cg$sel_rec.CONTENT_TYPE
       ,         cg$sel_rec.LAST_UPDATED
       ,         cg$sel_rec.MIME_TYPE
       ,         cg$sel_rec.NAME
       ,         cg$sel_rec.DOC_SIZE
       ,         cg$sel_rec.DAD_CHARSET
       ,         cg$sel_rec.DESCRIPTION
       ,         cg$sel_rec.LANGUAGE
       ,cg$sel_rec.the_rowid
       FROM   DOCUMENTS
       WHERE        DOCU_ID = cg$sel_rec.DOCU_ID;
    ELSE
       SELECT    DOCU_ID
       ,         BLOB_CONTENT
       ,         CONTENT_TYPE
       ,         LAST_UPDATED
       ,         MIME_TYPE
       ,         NAME
       ,         DOC_SIZE
       ,         DAD_CHARSET
       ,         DESCRIPTION
       ,         LANGUAGE
       , rowid
       INTO      cg$sel_rec.DOCU_ID
       ,         cg$sel_rec.BLOB_CONTENT
       ,         cg$sel_rec.CONTENT_TYPE
       ,         cg$sel_rec.LAST_UPDATED
       ,         cg$sel_rec.MIME_TYPE
       ,         cg$sel_rec.NAME
       ,         cg$sel_rec.DOC_SIZE
       ,         cg$sel_rec.DAD_CHARSET
       ,         cg$sel_rec.DESCRIPTION
       ,         cg$sel_rec.LANGUAGE
       ,cg$sel_rec.the_rowid
       FROM   DOCUMENTS
       WHERE  rowid = cg$sel_rec.the_rowid;
    END IF;

EXCEPTION WHEN OTHERS THEN
    cg$errors.push(SQLERRM,
                   'E',
                   'ORA',
                   SQLCODE,
                   'cg$DOCUMENTS.slct.others');
    cg$errors.raise_failure;

END slct;


--------------------------------------------------------------------------------
-- Name:        cascade_update
--
-- Description: Updates all child tables affected by a change to DOCUMENTS
--
-- Parameters:  cg$rec     Record of DOCUMENTS current values
--              cg$old_rec Record of DOCUMENTS previous values
--------------------------------------------------------------------------------
PROCEDURE cascade_update(cg$new_rec IN OUT cg$row_type,
                         cg$old_rec IN     cg$row_type) IS
BEGIN
  NULL;
END cascade_update;


--------------------------------------------------------------------------------
-- Name:        validate_domain_cascade_update
--
-- Description: Implement the Domain Key Constraint Cascade Updates Resticts rule
--              of each child table that references this tableDOCUMENTS
--
-- Parameters:  cg$old_rec     Record of DOCUMENTS current values
--------------------------------------------------------------------------------
PROCEDURE validate_domain_cascade_update( cg$old_rec IN cg$row_type ) IS
  dk_check INTEGER;
BEGIN
  NULL;
END validate_domain_cascade_update;


-----------------------------------------------------------------------------------------
-- Name:        domain_cascade_update
--
-- Description: Implement the Domain Key Constraint Cascade Updates rules of each
--              child table that references this table DOCUMENTS
--
-- Parameters:  cg$new_rec  New values for DOCUMENTS's domain key constraint columns
--              cg$new_ind  Indicates changed DOCUMENTS's domain key constraint columns
--              cg$old_rec  Current values for DOCUMENTS's domain key constraint columns
-----------------------------------------------------------------------------------------
PROCEDURE domain_cascade_update(cg$new_rec IN OUT cg$row_type,
                                cg$new_ind IN OUT cg$ind_type,
                                cg$old_rec IN     cg$row_type) IS
BEGIN
  NULL;
END domain_cascade_update;


--------------------------------------------------------------------------------
-- Name:        cascade_delete
--
-- Description: Delete all child tables affected by a delete to DOCUMENTS
--
-- Parameters:  cg$rec     Record of DOCUMENTS current values
--------------------------------------------------------------------------------
PROCEDURE cascade_delete(cg$old_rec IN OUT cg$row_type)
IS
BEGIN
  NULL;
END cascade_delete;

--------------------------------------------------------------------------------
-- Name:        domain_cascade_delete
--
-- Description: Implement the Domain Key Constraint Cascade Delete rules of each
--              child table that references this tableDOCUMENTS
--
-- Parameters:  cg$old_rec     Record of DOCUMENTS current values
--------------------------------------------------------------------------------
PROCEDURE domain_cascade_delete( cg$old_rec IN cg$row_type )
IS
BEGIN
  NULL;
END domain_cascade_delete;


--------------------------------------------------------------------------------
-- Name:        validate_domain_cascade_delete
--
-- Description: Implement the Domain Key Constraint Cascade Delete Restricts rule
--              of each child table that references this tableDOCUMENTS
--
-- Parameters:  cg$old_rec     Record of DOCUMENTS current values
--------------------------------------------------------------------------------
PROCEDURE validate_domain_cascade_delete(cg$old_rec IN cg$row_type)
IS
    dk_check INTEGER;
BEGIN
  NULL;
END validate_domain_cascade_delete;



--------------------------------------------------------------------------------
-- Name:        validate_arc
--
-- Description: Checks for adherence to arc relationship
--
-- Parameters:  cg$rec     Record of DOCUMENTS current values
--------------------------------------------------------------------------------
PROCEDURE validate_arc(cg$rec IN OUT cg$row_type) IS
i NUMBER;
BEGIN
    NULL;
END validate_arc;


--------------------------------------------------------------------------------
-- Name:        validate_domain
--
-- Description: Checks against reference table for values lying in a domain
--
-- Parameters:  cg$rec     Record of DOCUMENTS current values
--------------------------------------------------------------------------------
PROCEDURE validate_domain(cg$rec IN OUT cg$row_type,
                          cg$ind IN cg$ind_type DEFAULT cg$ind_true)
IS
  dummy NUMBER;
  found BOOLEAN;
  no_tabview EXCEPTION;
  PRAGMA EXCEPTION_INIT(no_tabview, -942);
BEGIN












    NULL;

EXCEPTION
    WHEN cg$errors.cg$error THEN
        cg$errors.raise_failure;
    WHEN no_tabview THEN
        cg$errors.push(cg$errors.MsgGetText(cg$errors.API_RV_TAB_NOT_FOUND,
                                            cg$errors.APIMSG_RV_TAB_NOT_FOUND,
                                            'HPMIS.CG_REF_CODES','DOCUMENTS'),
                       'E',
                       'API',
                       cg$errors.API_RV_TAB_NOT_FOUND,
                       'cg$DOCUMENTS.v_domain.no_reftable_found');
        cg$errors.raise_failure;
    WHEN OTHERS THEN
        cg$errors.push(SQLERRM,
                       'E',
                       'ORA',
                       SQLCODE,
                       'cg$DOCUMENTS.v_domain.others');
        cg$errors.raise_failure;
END validate_domain;


--------------------------------------------------------------------------------
-- Name:        err_msg
--
-- Description: Pushes onto stack appropriate user defined error message
--              depending on the rule violated
--
-- Parameters:  msg     Oracle error message
--              type    Type of violation e.g. check_constraint: ERR_CHECK_CON
--              loc     Place where this procedure was called for error
--                      trapping
--------------------------------------------------------------------------------
PROCEDURE err_msg(msg   IN VARCHAR2,
                  type  IN INTEGER,
                  loc   IN VARCHAR2 DEFAULT '') IS
con_name VARCHAR2(240);
BEGIN
    con_name := cg$errors.parse_constraint(msg, type);
    IF (con_name = 'DOCU_PK') THEN
        cg$errors.push(nvl(DOCU_PK
                  ,cg$errors.MsgGetText(cg$errors.API_PK_CON_VIOLATED
					                 ,cg$errors.APIMSG_PK_VIOLAT
                                     ,'DOCU_PK'
                                     ,'DOCUMENTS')),
                       'E',
                       'API',
                       cg$errors.API_PK_CON_VIOLATED,
                       loc);
    ELSIF (con_name = 'DOCU_DOCU_UK') THEN
        cg$errors.push(nvl(DOCU_DOCU_UK
                  ,cg$errors.MsgGetText(cg$errors.API_UQ_CON_VIOLATED
					                 ,cg$errors.APIMSG_UK_VIOLAT
                                     ,'DOCU_DOCU_UK'
                                     ,'DOCUMENTS')),
                       'E',
                       'API',
                       cg$errors.API_UQ_CON_VIOLATED,
                       loc);

    ELSE
        cg$errors.push(SQLERRM,
                       'E',
                       'ORA',
                       SQLCODE,
                       loc);
    END IF;
END err_msg;




--------------------------------------------------------------------------------
-- Name:        doLobs
--
-- Description: This function is updating lob columns
--
-- Parameters:  cg$rec  Record of row to be inserted
--              cg$ind  Record of columns specifically set
--------------------------------------------------------------------------------
PROCEDURE doLobs(cg$rec IN OUT cg$row_type,
                 cg$ind IN OUT cg$ind_type) IS
BEGIN
   IF(cg$rec.BLOB_CONTENT is not null) THEN
      DECLARE
         lobVar BLOB;
         lobSize INTEGER;
      BEGIN
         lobSize := DBMS_LOB.GETLENGTH(cg$rec.BLOB_CONTENT);
         SELECT BLOB_CONTENT INTO lobVar
         FROM DOCUMENTS
         WHERE
            DOCU_ID = cg$rec.DOCU_ID;
         DBMS_LOB.COPY(lobVar, cg$rec.BLOB_CONTENT, lobSize);
      END;
   END IF;
   NULL;
END doLobs;


--------------------------------------------------------------------------------
-- Name:        ins
--
-- Description: API insert procedure
--
-- Parameters:  cg$rec  Record of row to be inserted
--              cg$ind  Record of columns specifically set
--              do_ins  Whether we want the actual INSERT to occur
--------------------------------------------------------------------------------
PROCEDURE ins(cg$rec IN OUT cg$row_type,
              cg$ind IN OUT cg$ind_type,
              do_ins IN BOOLEAN DEFAULT TRUE) IS
cg$tmp_rec cg$row_type;

--  Constant default values

D100_LANGUAGE CONSTANT DOCUMENTS.LANGUAGE%TYPE := 'EN';

BEGIN
--  Application_logic Pre-Insert <<Start>>
--  Application_logic Pre-Insert << End >>

--  Defaulted

    IF NOT (cg$ind.LANGUAGE) THEN cg$rec.LANGUAGE := D100_LANGUAGE; END IF;
--  Auto-generated and uppercased columns

    up_autogen_columns(cg$rec, cg$ind, 'INS', do_ins);

    called_from_package := TRUE;

    IF (do_ins) THEN
        validate_foreign_keys_ins(cg$rec);
        validate_arc(cg$rec);
        validate_domain(cg$rec);

        INSERT INTO DOCUMENTS
            (DOCU_ID
            ,BLOB_CONTENT
            ,CONTENT_TYPE
            ,LAST_UPDATED
            ,MIME_TYPE
            ,NAME
            ,DOC_SIZE
            ,DAD_CHARSET
            ,DESCRIPTION
            ,LANGUAGE)
        VALUES
            (cg$rec.DOCU_ID
            ,EMPTY_BLOB()
            ,cg$rec.CONTENT_TYPE
            ,cg$rec.LAST_UPDATED
            ,cg$rec.MIME_TYPE
            ,cg$rec.NAME
            ,cg$rec.DOC_SIZE
            ,cg$rec.DAD_CHARSET
            ,cg$rec.DESCRIPTION
            ,cg$rec.LANGUAGE
);
        doLobs(cg$rec, cg$ind);
        slct(cg$rec);

        upd_oper_denorm2(cg$rec, cg$tmp_rec, cg$ind, 'INS');
    END IF;

    called_from_package := FALSE;



--  Application logic Post-Insert <<Start>>
--  Application logic Post-Insert << End >>

EXCEPTION
    WHEN cg$errors.cg$error THEN
        called_from_package := FALSE;
        cg$errors.raise_failure;
    WHEN cg$errors.mandatory_missing THEN
        validate_mandatory(cg$rec, 'cg$DOCUMENTS.ins.mandatory_missing');
        called_from_package := FALSE;
        cg$errors.raise_failure;
    WHEN cg$errors.check_violation THEN
        err_msg(SQLERRM, cg$errors.ERR_CHECK_CON, 'cg$DOCUMENTS.ins.check_violation');
        called_from_package := FALSE;
        cg$errors.raise_failure;
    WHEN cg$errors.fk_violation THEN
        err_msg(SQLERRM, cg$errors.ERR_FOREIGN_KEY, 'cg$DOCUMENTS.ins.fk_violation');
        called_from_package := FALSE;
        cg$errors.raise_failure;
    WHEN cg$errors.uk_violation THEN
        err_msg(SQLERRM, cg$errors.ERR_UNIQUE_KEY, 'cg$DOCUMENTS.ins.uk_violation');
        called_from_package := FALSE;
        cg$errors.raise_failure;
    WHEN OTHERS THEN
        cg$errors.push(SQLERRM,
                       'E',
                       'ORA',
                       SQLCODE,
                       'cg$DOCUMENTS.ins.others');
        called_from_package := FALSE;
        cg$errors.raise_failure;
END ins;


--------------------------------------------------------------------------------
-- Name:        upd
--
-- Description: API update procedure
--
-- Parameters:  cg$rec  Record of row to be updated
--              cg$ind  Record of columns specifically set
--              do_upd  Whether we want the actual UPDATE to occur
--------------------------------------------------------------------------------
PROCEDURE upd(cg$rec             IN OUT cg$row_type,
              cg$ind             IN OUT cg$ind_type,
              do_upd             IN BOOLEAN DEFAULT TRUE,
              cg$pk              IN cg$row_type DEFAULT NULL )
IS
  cg$upd_rec    cg$row_type;
  cg$old_rec    cg$row_type;
  RECORD_LOGGED BOOLEAN := FALSE;
BEGIN
--  Application_logic Pre-Update <<Start>>
--  Application_logic Pre-Update << End >>


    IF ( cg$pk.DOCU_ID IS NULL ) THEN
      cg$upd_rec.DOCU_ID := cg$rec.DOCU_ID;
    ELSE
      cg$upd_rec.DOCU_ID := cg$pk.DOCU_ID;
    END IF;
    cg$old_rec.DOCU_ID := cg$upd_rec.DOCU_ID;

    IF ( cg$pk.the_rowid IS NULL ) THEN
      cg$upd_rec.the_rowid := cg$rec.the_rowid;
    ELSE
      cg$upd_rec.the_rowid := cg$pk.the_rowid;
    END IF;
    cg$old_rec.the_rowid := cg$upd_rec.the_rowid;

    IF ( do_upd ) THEN

        slct(cg$upd_rec);


        --  Report error if attempt to update non updateable Primary Key DOCU_PK
        IF (cg$ind.DOCU_ID AND cg$rec.DOCU_ID != cg$upd_rec.DOCU_ID) THEN
            raise_uk_not_updateable('DOCU_PK');
        END IF;
        IF NOT (cg$ind.DOCU_ID) THEN
            cg$rec.DOCU_ID := cg$upd_rec.DOCU_ID;
        END IF;
        IF NOT (cg$ind.BLOB_CONTENT) THEN
            cg$rec.BLOB_CONTENT := cg$upd_rec.BLOB_CONTENT;
        END IF;
        IF NOT (cg$ind.CONTENT_TYPE) THEN
            cg$rec.CONTENT_TYPE := cg$upd_rec.CONTENT_TYPE;
        END IF;
        IF NOT (cg$ind.LAST_UPDATED) THEN
            cg$rec.LAST_UPDATED := cg$upd_rec.LAST_UPDATED;
        END IF;
        IF NOT (cg$ind.MIME_TYPE) THEN
            cg$rec.MIME_TYPE := cg$upd_rec.MIME_TYPE;
        END IF;
        IF NOT (cg$ind.NAME) THEN
            cg$rec.NAME := cg$upd_rec.NAME;
        END IF;
        IF NOT (cg$ind.DOC_SIZE) THEN
            cg$rec.DOC_SIZE := cg$upd_rec.DOC_SIZE;
        END IF;
        IF NOT (cg$ind.DAD_CHARSET) THEN
            cg$rec.DAD_CHARSET := cg$upd_rec.DAD_CHARSET;
        END IF;
        IF NOT (cg$ind.DESCRIPTION) THEN
            cg$rec.DESCRIPTION := cg$upd_rec.DESCRIPTION;
        END IF;
        IF NOT (cg$ind.LANGUAGE) THEN
            cg$rec.LANGUAGE := cg$upd_rec.LANGUAGE;
        END IF;
    ELSE
	     -- Perform checks if called from a trigger
	     -- Indicators are only set on changed values
	     null;
        --  Report error if attempt to update non updateable Primary Key DOCU_PK
        IF ( cg$ind.DOCU_ID ) THEN
          raise_uk_not_updateable('DOCU_PK');
        END IF;
    END IF;

    up_autogen_columns(cg$rec, cg$ind, 'UPD', do_upd);  --  Auto-generated and uppercased columns

--  Now do update if updateable columns exist
    IF (do_upd) THEN
        DECLARE
            called_from BOOLEAN := called_from_package;
        BEGIN
          called_from_package := TRUE;

          slct(cg$old_rec);
          validate_foreign_keys_upd(cg$rec, cg$old_rec, cg$ind);
          validate_arc(cg$rec);
          validate_domain(cg$rec, cg$ind);
          validate_domain_cascade_update(cg$old_rec);

          IF cg$rec.the_rowid is null THEN
            UPDATE DOCUMENTS
            SET
              BLOB_CONTENT = cg$rec.BLOB_CONTENT
              ,CONTENT_TYPE = cg$rec.CONTENT_TYPE
              ,LAST_UPDATED = cg$rec.LAST_UPDATED
              ,MIME_TYPE = cg$rec.MIME_TYPE
              ,NAME = cg$rec.NAME
              ,DOC_SIZE = cg$rec.DOC_SIZE
              ,DAD_CHARSET = cg$rec.DAD_CHARSET
              ,DESCRIPTION = cg$rec.DESCRIPTION
              ,LANGUAGE = cg$rec.LANGUAGE
            WHERE  DOCU_ID = cg$rec.DOCU_ID;
            null;
          ELSE
            UPDATE DOCUMENTS
            SET
              BLOB_CONTENT = cg$rec.BLOB_CONTENT
              ,CONTENT_TYPE = cg$rec.CONTENT_TYPE
              ,LAST_UPDATED = cg$rec.LAST_UPDATED
              ,MIME_TYPE = cg$rec.MIME_TYPE
              ,NAME = cg$rec.NAME
              ,DOC_SIZE = cg$rec.DOC_SIZE
              ,DAD_CHARSET = cg$rec.DAD_CHARSET
              ,DESCRIPTION = cg$rec.DESCRIPTION
              ,LANGUAGE = cg$rec.LANGUAGE
            WHERE rowid = cg$rec.the_rowid;

            null;
          END IF;

          slct(cg$rec);

          upd_denorm2(cg$rec, cg$ind);
          upd_oper_denorm2(cg$rec, cg$old_rec, cg$ind, 'UPD');
          cascade_update(cg$rec, cg$old_rec);
          domain_cascade_update(cg$rec, cg$ind, cg$old_rec);
          called_from_package := called_from;
        END;
    END IF;



    IF NOT (do_upd) THEN
        cg$table(idx).DOCU_ID := cg$rec.DOCU_ID;
        cg$tableind(idx).DOCU_ID := cg$ind.DOCU_ID;
        cg$table(idx).BLOB_CONTENT := cg$rec.BLOB_CONTENT;
        cg$tableind(idx).BLOB_CONTENT := cg$ind.BLOB_CONTENT;
        cg$table(idx).CONTENT_TYPE := cg$rec.CONTENT_TYPE;
        cg$tableind(idx).CONTENT_TYPE := cg$ind.CONTENT_TYPE;
        cg$table(idx).LAST_UPDATED := cg$rec.LAST_UPDATED;
        cg$tableind(idx).LAST_UPDATED := cg$ind.LAST_UPDATED;
        cg$table(idx).MIME_TYPE := cg$rec.MIME_TYPE;
        cg$tableind(idx).MIME_TYPE := cg$ind.MIME_TYPE;
        cg$table(idx).NAME := cg$rec.NAME;
        cg$tableind(idx).NAME := cg$ind.NAME;
        cg$table(idx).DOC_SIZE := cg$rec.DOC_SIZE;
        cg$tableind(idx).DOC_SIZE := cg$ind.DOC_SIZE;
        cg$table(idx).DAD_CHARSET := cg$rec.DAD_CHARSET;
        cg$tableind(idx).DAD_CHARSET := cg$ind.DAD_CHARSET;
        cg$table(idx).DESCRIPTION := cg$rec.DESCRIPTION;
        cg$tableind(idx).DESCRIPTION := cg$ind.DESCRIPTION;
        cg$table(idx).LANGUAGE := cg$rec.LANGUAGE;
        cg$tableind(idx).LANGUAGE := cg$ind.LANGUAGE;
        idx := idx + 1;
    END IF;

--  Application_logic Post-Update <<Start>>
--  Application_logic Post-Update << End >>

EXCEPTION
    WHEN cg$errors.cg$error THEN
        called_from_package := FALSE;
        cg$errors.raise_failure;
    WHEN cg$errors.upd_mandatory_null THEN
        validate_mandatory(cg$rec, 'cg$DOCUMENTS.upd.upd_mandatory_null');
        called_from_package := FALSE;
        cg$errors.raise_failure;
    WHEN cg$errors.check_violation THEN
        err_msg(SQLERRM, cg$errors.ERR_CHECK_CON, 'cg$DOCUMENTS.upd.check_violation');
        called_from_package := FALSE;
        cg$errors.raise_failure;
    WHEN cg$errors.fk_violation THEN
        err_msg(SQLERRM, cg$errors.ERR_FOREIGN_KEY, 'cg$DOCUMENTS.upd.fk_violation');
        called_from_package := FALSE;
        cg$errors.raise_failure;
    WHEN cg$errors.uk_violation THEN
        err_msg(SQLERRM, cg$errors.ERR_UNIQUE_KEY, 'cg$DOCUMENTS.upd.uk_violation');
        called_from_package := FALSE;
        cg$errors.raise_failure;
    WHEN OTHERS THEN
        cg$errors.push(SQLERRM,
                       'E',
                       'ORA',
                       SQLCODE,
                       'cg$DOCUMENTS.upd.others');
        called_from_package := FALSE;
        cg$errors.raise_failure;
END upd;


----------------------------------------------------------------------------------------
-- Name:        domain_cascade_upd
--
-- Description: Update the Domain Constraint Key columns of DOCUMENTS when the
--              Cascade Update rule is Cascades and the domain table has been
--              updated. Called from <Domain Table pkg>.domain_cascade_update().
--
-- Parameters:  cg$rec      New values for DOCUMENTS's domain key constraint columns
--              cg$ind      Indicates changed DOCUMENTS's domain key constraint columns
--              cg$old_rec  Current values for DOCUMENTS's domain key constraint columns
----------------------------------------------------------------------------------------
PROCEDURE   domain_cascade_upd( cg$rec     IN OUT cg$row_type,
                                cg$ind     IN OUT cg$ind_type,
                                cg$old_rec IN     cg$row_type )
IS
  called_from BOOLEAN := called_from_package;
BEGIN

  null;
END domain_cascade_upd;


--------------------------------------------------------------------------------
-- Name:        upd_denorm
--
-- Description: API procedure for simple denormalization
--
-- Parameters:  cg$rec  Record of row to be updated
--              cg$ind  Record of columns specifically set
--              do_upd  Whether we want the actual UPDATE to occur
--------------------------------------------------------------------------------
PROCEDURE upd_denorm2( cg$rec IN cg$row_type,
                       cg$ind IN cg$ind_type ) IS
BEGIN
  NULL;
END upd_denorm2;


--------------------------------------------------------------------------------
-- Name:        upd_oper_denorm
--
-- Description: API procedure for operation denormalization
--
-- Parameters:  cg$rec  Record of row to be updated
--              cg$ind  Record of columns specifically set
--              do_upd  Whether we want the actual UPDATE to occur
--------------------------------------------------------------------------------
PROCEDURE upd_oper_denorm2( cg$rec IN cg$row_type,
                            cg$old_rec IN cg$row_type,
                            cg$ind IN cg$ind_type,
                            operation IN VARCHAR2 DEFAULT 'UPD'
					           )
IS
BEGIN










NULL;
END upd_oper_denorm2;

--------------------------------------------------------------------------------
-- Name:        del
--
-- Description: API delete procedure
--
-- Parameters:  cg$pk  Primary key record of row to be deleted
--------------------------------------------------------------------------------
PROCEDURE del(cg$pk IN cg$pk_type,
              do_del IN BOOLEAN DEFAULT TRUE) IS
BEGIN
--  Application_logic Pre-Delete <<Start>>
--  Application_logic Pre-Delete << End >>

--  Delete the record

    called_from_package := TRUE;

    IF (do_del) THEN
        DECLARE
           cg$rec cg$row_type;
           cg$old_rec cg$row_type;
           cg$ind cg$ind_type;
        BEGIN
           cg$rec.DOCU_ID := cg$pk.DOCU_ID;
           slct(cg$rec);

           validate_foreign_keys_del(cg$rec);
           validate_domain_cascade_delete(cg$rec);

           IF cg$pk.the_rowid is null THEN
              DELETE DOCUMENTS
              WHERE                    DOCU_ID = cg$pk.DOCU_ID;
           ELSE
              DELETE DOCUMENTS
              WHERE  rowid = cg$pk.the_rowid;
           END IF;

           upd_oper_denorm2(cg$rec, cg$old_rec, cg$ind, 'DEL');
           cascade_delete(cg$rec);
           domain_cascade_delete(cg$rec);
        END;
    END IF;

    called_from_package := FALSE;


--  Application_logic Post-Delete <<Start>>
--  Application_logic Post-Delete << End >>

EXCEPTION
    WHEN cg$errors.cg$error THEN
        called_from_package := FALSE;
        cg$errors.raise_failure;
    WHEN cg$errors.delete_restrict THEN
        err_msg(SQLERRM, cg$errors.ERR_DELETE_RESTRICT, 'cg$DOCUMENTS.del.delete_restrict');
        called_from_package := FALSE;
        cg$errors.raise_failure;
    WHEN no_data_found THEN
        cg$errors.push(cg$errors.MsgGetText(cg$errors.API_ROW_DEL, cg$errors.ROW_DEL),
                       'E',
                       'ORA',
                       SQLCODE,
                       'cg$DOCUMENTS.del.no_data_found');
        called_from_package := FALSE;
        cg$errors.raise_failure;
    WHEN OTHERS THEN
        cg$errors.push(SQLERRM,
                       'E',
                       'ORA',
                       SQLCODE,
                       'cg$DOCUMENTS.del.others');
        called_from_package := FALSE;
        cg$errors.raise_failure;
END del;


--------------------------------------------------------------------------------
-- Name:        lck
--
-- Description: API lock procedure
--
-- Parameters:  cg$old_rec  Calling apps view of record of row to be locked
--              cg$old_ind  Record of columns to raise error if modified
--              nowait_flag TRUE lock with NOWAIT, FALSE don't fail if busy
--------------------------------------------------------------------------------
PROCEDURE lck(cg$old_rec IN cg$row_type,
              cg$old_ind IN cg$ind_type,
              nowait_flag IN BOOLEAN DEFAULT TRUE) IS
cg$tmp_rec cg$row_type;
any_modified BOOLEAN := FALSE;

BEGIN
--  Application_logic Pre-Lock <<Start>>
--  Application_logic Pre-Lock << End >>

--  Do the row lock

    BEGIN
        IF (nowait_flag) THEN
            IF cg$old_rec.the_rowid is null THEN
               SELECT       DOCU_ID
               ,            BLOB_CONTENT
               ,            CONTENT_TYPE
               ,            LAST_UPDATED
               ,            MIME_TYPE
               ,            NAME
               ,            DOC_SIZE
               ,            DAD_CHARSET
               ,            DESCRIPTION
               ,            LANGUAGE
               INTO         cg$tmp_rec.DOCU_ID
               ,            cg$tmp_rec.BLOB_CONTENT
               ,            cg$tmp_rec.CONTENT_TYPE
               ,            cg$tmp_rec.LAST_UPDATED
               ,            cg$tmp_rec.MIME_TYPE
               ,            cg$tmp_rec.NAME
               ,            cg$tmp_rec.DOC_SIZE
               ,            cg$tmp_rec.DAD_CHARSET
               ,            cg$tmp_rec.DESCRIPTION
               ,            cg$tmp_rec.LANGUAGE
               FROM      DOCUMENTS
               WHERE              DOCU_ID = cg$old_rec.DOCU_ID
               FOR UPDATE NOWAIT;
            ELSE
               SELECT       DOCU_ID
               ,            BLOB_CONTENT
               ,            CONTENT_TYPE
               ,            LAST_UPDATED
               ,            MIME_TYPE
               ,            NAME
               ,            DOC_SIZE
               ,            DAD_CHARSET
               ,            DESCRIPTION
               ,            LANGUAGE
               INTO         cg$tmp_rec.DOCU_ID
               ,            cg$tmp_rec.BLOB_CONTENT
               ,            cg$tmp_rec.CONTENT_TYPE
               ,            cg$tmp_rec.LAST_UPDATED
               ,            cg$tmp_rec.MIME_TYPE
               ,            cg$tmp_rec.NAME
               ,            cg$tmp_rec.DOC_SIZE
               ,            cg$tmp_rec.DAD_CHARSET
               ,            cg$tmp_rec.DESCRIPTION
               ,            cg$tmp_rec.LANGUAGE
               FROM      DOCUMENTS
               WHERE rowid = cg$old_rec.the_rowid
               FOR UPDATE NOWAIT;
            END IF;
        ELSE
            IF cg$old_rec.the_rowid is null THEN
               SELECT       DOCU_ID
               ,            BLOB_CONTENT
               ,            CONTENT_TYPE
               ,            LAST_UPDATED
               ,            MIME_TYPE
               ,            NAME
               ,            DOC_SIZE
               ,            DAD_CHARSET
               ,            DESCRIPTION
               ,            LANGUAGE
               INTO         cg$tmp_rec.DOCU_ID
               ,            cg$tmp_rec.BLOB_CONTENT
               ,            cg$tmp_rec.CONTENT_TYPE
               ,            cg$tmp_rec.LAST_UPDATED
               ,            cg$tmp_rec.MIME_TYPE
               ,            cg$tmp_rec.NAME
               ,            cg$tmp_rec.DOC_SIZE
               ,            cg$tmp_rec.DAD_CHARSET
               ,            cg$tmp_rec.DESCRIPTION
               ,            cg$tmp_rec.LANGUAGE
               FROM      DOCUMENTS
               WHERE              DOCU_ID = cg$old_rec.DOCU_ID
               FOR UPDATE;
            ELSE
               SELECT       DOCU_ID
               ,            BLOB_CONTENT
               ,            CONTENT_TYPE
               ,            LAST_UPDATED
               ,            MIME_TYPE
               ,            NAME
               ,            DOC_SIZE
               ,            DAD_CHARSET
               ,            DESCRIPTION
               ,            LANGUAGE
               INTO         cg$tmp_rec.DOCU_ID
               ,            cg$tmp_rec.BLOB_CONTENT
               ,            cg$tmp_rec.CONTENT_TYPE
               ,            cg$tmp_rec.LAST_UPDATED
               ,            cg$tmp_rec.MIME_TYPE
               ,            cg$tmp_rec.NAME
               ,            cg$tmp_rec.DOC_SIZE
               ,            cg$tmp_rec.DAD_CHARSET
               ,            cg$tmp_rec.DESCRIPTION
               ,            cg$tmp_rec.LANGUAGE
               FROM      DOCUMENTS
               WHERE rowid = cg$old_rec.the_rowid
               FOR UPDATE;
            END IF;
        END IF;

    EXCEPTION
        WHEN cg$errors.cg$error THEN
            cg$errors.raise_failure;
        WHEN cg$errors.resource_busy THEN
            cg$errors.push(cg$errors.MsgGetText(cg$errors.API_ROW_LCK, cg$errors.ROW_LCK),
                           'E',
                           'ORA',
                           SQLCODE,
                           'cg$DOCUMENTS.lck.resource_busy');
            cg$errors.raise_failure;
        WHEN no_data_found THEN
            cg$errors.push(cg$errors.MsgGetText(cg$errors.API_ROW_DEL, cg$errors.ROW_DEL),
                           'E',
                           'ORA',
                           SQLCODE,
                           'cg$DOCUMENTS.lck.no_data_found');
            cg$errors.raise_failure;
        WHEN OTHERS THEN
            cg$errors.push(SQLERRM,
                           'E',
                           'ORA',
                           SQLCODE,
                           'cg$DOCUMENTS.lck.others');
            cg$errors.raise_failure;
    END;

-- Optional Columns

    IF (cg$old_ind.CONTENT_TYPE) THEN
        IF (cg$tmp_rec.CONTENT_TYPE IS NOT NULL
        AND cg$old_rec.CONTENT_TYPE IS NOT NULL) THEN
            IF (cg$tmp_rec.CONTENT_TYPE != cg$old_rec.CONTENT_TYPE) THEN
                cg$errors.push(cg$errors.MsgGetText(cg$errors.API_ROW_MOD, cg$errors.ROW_MOD, P30CONTENT_TYPE
                    ),'E', 'API', CG$ERRORS.API_MODIFIED, 'cg$DOCUMENTS.lck');
                any_modified := TRUE;
            END IF;
        ELSIF (cg$tmp_rec.CONTENT_TYPE IS NOT NULL
        OR cg$old_rec.CONTENT_TYPE IS NOT NULL) THEN
            cg$errors.push(cg$errors.MsgGetText(cg$errors.API_ROW_MOD, cg$errors.ROW_MOD, P30CONTENT_TYPE
                ),'E', 'API', CG$ERRORS.API_MODIFIED, 'cg$DOCUMENTS.lck');
            any_modified := TRUE;
        END IF;
    END IF;
    IF (cg$old_ind.LAST_UPDATED) THEN
        IF (cg$tmp_rec.LAST_UPDATED IS NOT NULL
        AND cg$old_rec.LAST_UPDATED IS NOT NULL) THEN
            IF (cg$tmp_rec.LAST_UPDATED != cg$old_rec.LAST_UPDATED) THEN
                cg$errors.push(cg$errors.MsgGetText(cg$errors.API_ROW_MOD, cg$errors.ROW_MOD, P40LAST_UPDATED
                    ),'E', 'API', CG$ERRORS.API_MODIFIED, 'cg$DOCUMENTS.lck');
                any_modified := TRUE;
            END IF;
        ELSIF (cg$tmp_rec.LAST_UPDATED IS NOT NULL
        OR cg$old_rec.LAST_UPDATED IS NOT NULL) THEN
            cg$errors.push(cg$errors.MsgGetText(cg$errors.API_ROW_MOD, cg$errors.ROW_MOD, P40LAST_UPDATED
                ),'E', 'API', CG$ERRORS.API_MODIFIED, 'cg$DOCUMENTS.lck');
            any_modified := TRUE;
        END IF;
    END IF;
    IF (cg$old_ind.MIME_TYPE) THEN
        IF (cg$tmp_rec.MIME_TYPE IS NOT NULL
        AND cg$old_rec.MIME_TYPE IS NOT NULL) THEN
            IF (cg$tmp_rec.MIME_TYPE != cg$old_rec.MIME_TYPE) THEN
                cg$errors.push(cg$errors.MsgGetText(cg$errors.API_ROW_MOD, cg$errors.ROW_MOD, P50MIME_TYPE
                    ),'E', 'API', CG$ERRORS.API_MODIFIED, 'cg$DOCUMENTS.lck');
                any_modified := TRUE;
            END IF;
        ELSIF (cg$tmp_rec.MIME_TYPE IS NOT NULL
        OR cg$old_rec.MIME_TYPE IS NOT NULL) THEN
            cg$errors.push(cg$errors.MsgGetText(cg$errors.API_ROW_MOD, cg$errors.ROW_MOD, P50MIME_TYPE
                ),'E', 'API', CG$ERRORS.API_MODIFIED, 'cg$DOCUMENTS.lck');
            any_modified := TRUE;
        END IF;
    END IF;
    IF (cg$old_ind.DOC_SIZE) THEN
        IF (cg$tmp_rec.DOC_SIZE IS NOT NULL
        AND cg$old_rec.DOC_SIZE IS NOT NULL) THEN
            IF (cg$tmp_rec.DOC_SIZE != cg$old_rec.DOC_SIZE) THEN
                cg$errors.push(cg$errors.MsgGetText(cg$errors.API_ROW_MOD, cg$errors.ROW_MOD, P70DOC_SIZE
                    ),'E', 'API', CG$ERRORS.API_MODIFIED, 'cg$DOCUMENTS.lck');
                any_modified := TRUE;
            END IF;
        ELSIF (cg$tmp_rec.DOC_SIZE IS NOT NULL
        OR cg$old_rec.DOC_SIZE IS NOT NULL) THEN
            cg$errors.push(cg$errors.MsgGetText(cg$errors.API_ROW_MOD, cg$errors.ROW_MOD, P70DOC_SIZE
                ),'E', 'API', CG$ERRORS.API_MODIFIED, 'cg$DOCUMENTS.lck');
            any_modified := TRUE;
        END IF;
    END IF;
    IF (cg$old_ind.DAD_CHARSET) THEN
        IF (cg$tmp_rec.DAD_CHARSET IS NOT NULL
        AND cg$old_rec.DAD_CHARSET IS NOT NULL) THEN
            IF (cg$tmp_rec.DAD_CHARSET != cg$old_rec.DAD_CHARSET) THEN
                cg$errors.push(cg$errors.MsgGetText(cg$errors.API_ROW_MOD, cg$errors.ROW_MOD, P80DAD_CHARSET
                    ),'E', 'API', CG$ERRORS.API_MODIFIED, 'cg$DOCUMENTS.lck');
                any_modified := TRUE;
            END IF;
        ELSIF (cg$tmp_rec.DAD_CHARSET IS NOT NULL
        OR cg$old_rec.DAD_CHARSET IS NOT NULL) THEN
            cg$errors.push(cg$errors.MsgGetText(cg$errors.API_ROW_MOD, cg$errors.ROW_MOD, P80DAD_CHARSET
                ),'E', 'API', CG$ERRORS.API_MODIFIED, 'cg$DOCUMENTS.lck');
            any_modified := TRUE;
        END IF;
    END IF;
    IF (cg$old_ind.LANGUAGE) THEN
        IF (cg$tmp_rec.LANGUAGE IS NOT NULL
        AND cg$old_rec.LANGUAGE IS NOT NULL) THEN
            IF (cg$tmp_rec.LANGUAGE != cg$old_rec.LANGUAGE) THEN
                cg$errors.push(cg$errors.MsgGetText(cg$errors.API_ROW_MOD, cg$errors.ROW_MOD, P100LANGUAGE
                    ),'E', 'API', CG$ERRORS.API_MODIFIED, 'cg$DOCUMENTS.lck');
                any_modified := TRUE;
            END IF;
        ELSIF (cg$tmp_rec.LANGUAGE IS NOT NULL
        OR cg$old_rec.LANGUAGE IS NOT NULL) THEN
            cg$errors.push(cg$errors.MsgGetText(cg$errors.API_ROW_MOD, cg$errors.ROW_MOD, P100LANGUAGE
                ),'E', 'API', CG$ERRORS.API_MODIFIED, 'cg$DOCUMENTS.lck');
            any_modified := TRUE;
        END IF;
    END IF;

-- Mandatory Columns

    IF (cg$old_ind.DOCU_ID) THEN
        IF (cg$tmp_rec.DOCU_ID != cg$old_rec.DOCU_ID) THEN
            cg$errors.push(cg$errors.MsgGetText(cg$errors.API_ROW_MOD, cg$errors.ROW_MOD, P10DOCU_ID
                ),'E', 'API', CG$ERRORS.API_MODIFIED, 'cg$DOCUMENTS.lck');
            any_modified := TRUE;
        END IF;
    END IF;
    IF (cg$old_ind.NAME) THEN
        IF (cg$tmp_rec.NAME != cg$old_rec.NAME) THEN
            cg$errors.push(cg$errors.MsgGetText(cg$errors.API_ROW_MOD, cg$errors.ROW_MOD, P60NAME
                ),'E', 'API', CG$ERRORS.API_MODIFIED, 'cg$DOCUMENTS.lck');
            any_modified := TRUE;
        END IF;
    END IF;
    IF (cg$old_ind.DESCRIPTION) THEN
        IF (cg$tmp_rec.DESCRIPTION != cg$old_rec.DESCRIPTION) THEN
            cg$errors.push(cg$errors.MsgGetText(cg$errors.API_ROW_MOD, cg$errors.ROW_MOD, P90DESCRIPTION
                ),'E', 'API', CG$ERRORS.API_MODIFIED, 'cg$DOCUMENTS.lck');
            any_modified := TRUE;
        END IF;
    END IF;

    IF (any_modified) THEN
        cg$errors.raise_failure;
    END IF;

--  Application_logic Post-Lock <<Start>>
--  Application_logic Post-Lock << End >>

END lck;


BEGIN
      cg$ind_true.DOCU_ID := TRUE;
      cg$ind_true.BLOB_CONTENT := TRUE;
      cg$ind_true.CONTENT_TYPE := TRUE;
      cg$ind_true.LAST_UPDATED := TRUE;
      cg$ind_true.MIME_TYPE := TRUE;
      cg$ind_true.NAME := TRUE;
      cg$ind_true.DOC_SIZE := TRUE;
      cg$ind_true.DAD_CHARSET := TRUE;
      cg$ind_true.DESCRIPTION := TRUE;
      cg$ind_true.LANGUAGE := TRUE;


END cg$DOCUMENTS;
/