db/migrations/V0_3__CREATE_PLGM_DB.sql

-----------------------------------------------------------------------------------
-- *******************************************************************************
-- * Copyright (c) 2018 Contributors to the Eclipse Foundation
-- *
-- * See the NOTICE file(s) distributed with this work for additional
-- * information regarding copyright ownership.
-- *
-- * This program and the accompanying materials are made available under the
-- * terms of the Eclipse Public License v. 2.0 which is available at
-- * http://www.eclipse.org/legal/epl-2.0.
-- *
-- * SPDX-License-Identifier: EPL-2.0
-- *******************************************************************************
-----------------------------------------------------------------------------------
--CREATE ROLE PLGM_SERVICE LOGIN
--NOSUPERUSER INHERIT NOCREATEDB NOCREATEROLE NOREPLICATION;
--ALTER ROLE PLGM_SERVICE with password 'plgm_service';

-- ---------------------------------------------
-- DROPS
-- ---------------------------------------------
DROP TABLE IF EXISTS public.TBL_GRIDMEASURE;
DROP SEQUENCE IF EXISTS public.TBL_GRIDMEASURE_ID_SEQ;

DROP TABLE IF EXISTS public.REF_BRANCH;
DROP SEQUENCE IF EXISTS public.REF_BRANCH_ID_SEQ;

DROP TABLE IF EXISTS public.REF_GM_STATUS;
DROP SEQUENCE IF EXISTS public.REF_GM_STATUS_ID_SEQ;

DROP TABLE IF EXISTS public.REF_GM_TITLE;
DROP SEQUENCE IF EXISTS public.REF_GM_TITLE_ID_SEQ;

DROP TABLE IF EXISTS public.REF_TERRITORY_RESPONSIBILITY;
DROP SEQUENCE IF EXISTS public.REF_TERR_RESP_ID_SEQ;

DROP TABLE IF EXISTS public.REF_BRANCH_LEVEL;
DROP SEQUENCE IF EXISTS public.REF_BRANCH_LEVEL_ID_SEQ;

-- ---------------------------------------------
-- TABLE REF_BRANCH
-- ---------------------------------------------
CREATE SEQUENCE public.REF_BRANCH_ID_SEQ
  INCREMENT 1
  MINVALUE 1
  MAXVALUE 9223372036854775807
  START 1
  CACHE 1;

ALTER TABLE public.REF_BRANCH_ID_SEQ
  OWNER TO PLGM_SERVICE;

CREATE TABLE public.REF_BRANCH
(
  ID integer NOT NULL DEFAULT nextval('REF_BRANCH_ID_SEQ'::regclass),
  NAME character varying(50) NOT NULL,
  DESCRIPTION character varying(255),
  CREATE_USER character varying(100) NOT NULL,
  CREATE_DATE timestamp without time zone  NOT NULL,
  MOD_USER character varying(100),
  MOD_DATE timestamp without time zone NOT NULL,  
  CONSTRAINT REF_BRANCH_PKEY PRIMARY KEY (id)
)
WITH (
  OIDS=FALSE
);

ALTER TABLE public.REF_BRANCH
  OWNER TO PLGM_SERVICE;
GRANT ALL ON TABLE public.REF_BRANCH TO PLGM_SERVICE;

-- ---------------------------------------------
-- TABLE REF_GM_STATUS
-- ---------------------------------------------
CREATE SEQUENCE public.REF_GM_STATUS_ID_SEQ
  INCREMENT 1
  MINVALUE 1
  MAXVALUE 9223372036854775807
  START 1
  CACHE 1;
  
ALTER TABLE public.REF_GM_STATUS_ID_SEQ
  OWNER TO PLGM_SERVICE;

CREATE TABLE public.REF_GM_STATUS
(
  ID integer NOT NULL DEFAULT nextval('REF_GM_STATUS_ID_SEQ'::regclass),
  NAME character varying(50) NOT NULL,
  CREATE_USER character varying(100) NOT NULL,
  CREATE_DATE timestamp without time zone NOT NULL,
  MOD_USER character varying(100),
  MOD_DATE timestamp without time zone,  
  CONSTRAINT REF_GM_STATUS_PKEY PRIMARY KEY (id)
)
WITH (
  OIDS=FALSE
);

ALTER TABLE public.REF_GM_STATUS
  OWNER TO PLGM_SERVICE;
GRANT ALL ON TABLE public.REF_GM_STATUS TO PLGM_SERVICE;

-- ---------------------------------------------
-- TABLE REF_GM_TITLE
-- ---------------------------------------------
CREATE SEQUENCE public.REF_GM_TITLE_ID_SEQ
  INCREMENT 1
  MINVALUE 1
  MAXVALUE 9223372036854775807
  START 1
  CACHE 1;
  
ALTER TABLE public.REF_GM_TITLE_ID_SEQ
  OWNER TO PLGM_SERVICE;

CREATE TABLE public.REF_GM_TITLE
(
  ID integer NOT NULL DEFAULT nextval('REF_GM_TITLE_ID_SEQ'::regclass),
  NAME character varying(50) NOT NULL,
  CREATE_USER character varying(100) NOT NULL,
  CREATE_DATE timestamp without time zone NOT NULL,
  MOD_USER character varying(100),
  MOD_DATE timestamp without time zone,  
  CONSTRAINT REF_GM_TITLE_PKEY PRIMARY KEY (id)
)
WITH (
  OIDS=FALSE
);
ALTER TABLE public.REF_GM_TITLE
  OWNER TO PLGM_SERVICE;
GRANT ALL ON TABLE public.REF_GM_TITLE TO PLGM_SERVICE;

-- ---------------------------------------------
-- TABLE REF_TERRITORY_RESPONSIBILITY
-- ---------------------------------------------
CREATE SEQUENCE public.REF_TERR_RESP_ID_SEQ
  INCREMENT 1
  MINVALUE 1
  MAXVALUE 9223372036854775807
  START 1
  CACHE 1;
  
ALTER TABLE public.REF_TERR_RESP_ID_SEQ
  OWNER TO PLGM_SERVICE;

CREATE TABLE public.REF_TERRITORY_RESPONSIBILITY
(
  ID integer NOT NULL DEFAULT nextval('REF_TERR_RESP_ID_SEQ'::regclass),
  NAME character varying(50) NOT NULL,
  CREATE_USER character varying(100) NOT NULL,
  CREATE_DATE timestamp without time zone NOT NULL,
  MOD_USER character varying(100),
  MOD_DATE timestamp without time zone,  
  CONSTRAINT REF_TERR_RESP_PKEY PRIMARY KEY (id)
)
WITH (
  OIDS=FALSE
);
ALTER TABLE public.REF_TERRITORY_RESPONSIBILITY
  OWNER TO PLGM_SERVICE;
GRANT ALL ON TABLE public.REF_GM_TITLE TO PLGM_SERVICE;


-- ---------------------------------------------
-- TABLE REF_BRANCH_LEVEL
-- ---------------------------------------------
CREATE SEQUENCE public.REF_BRANCH_LEVEL_ID_SEQ
  INCREMENT 1
  MINVALUE 1
  MAXVALUE 9223372036854775807
  START 1
  CACHE 1;
  
ALTER TABLE public.REF_BRANCH_LEVEL_ID_SEQ
  OWNER TO PLGM_SERVICE;
CREATE TABLE public.REF_BRANCH_LEVEL
(
  ID integer NOT NULL DEFAULT nextval('REF_BRANCH_LEVEL_ID_SEQ'::regclass),
  NAME character varying(50) NOT NULL,
  DESCRIPTION character varying(255),
  CREATE_USER character varying(100) NOT NULL,
  CREATE_DATE timestamp without time zone NOT NULL,
  MOD_USER character varying(100),
  MOD_DATE timestamp without time zone,  
  CONSTRAINT REF_BRANCH_LEVEL_PKEY PRIMARY KEY (id)
)
WITH (
  OIDS=FALSE
);

ALTER TABLE public.REF_BRANCH_LEVEL
  OWNER TO PLGM_SERVICE;
GRANT ALL ON TABLE public.REF_BRANCH_LEVEL TO PLGM_SERVICE;

-- ---------------------------------------------
-- TABLE REF_GRIDMEASURE
-- ---------------------------------------------
CREATE SEQUENCE public.TBL_GRIDMEASURE_ID_SEQ
  INCREMENT 1
  MINVALUE 1
  MAXVALUE 9223372036854775807
  START 1
  CACHE 1;
  
ALTER TABLE public.TBL_GRIDMEASURE_ID_SEQ
  OWNER TO PLGM_SERVICE;

CREATE TABLE public.TBL_GRIDMEASURE
(
  ID integer NOT NULL DEFAULT nextval('TBL_GRIDMEASURE_ID_SEQ'::regclass),
  ID_EXT character varying(50) NOT NULL,
  FK_REF_GM_TITLE integer NOT NULL,
  FK_REF_GM_STATUS integer NOT NULL,
  FK_REF_BRANCH integer NOT NULL,
  FK_REF_BRANCH_LEVEL integer NOT NULL,
  FK_REF_TERR_RESP integer NOT NULL,
  COST_CENTRE character varying(50) NULL,

  CREATE_USER character varying(100) NOT NULL,
  CREATE_USER_DEPARTMENT character varying(100) NULL,
  CREATE_DATE timestamp without time zone NOT NULL,
  MOD_USER character varying(100),
  MOD_USER_DEPARTMENT character varying(100) NULL,
  MOD_DATE timestamp without time zone,  
  
  
  CONSTRAINT TBL_GRIDMEASURE_PKEY PRIMARY KEY (ID),
  CONSTRAINT FK_GRIDMEASURE__GM_TITLE FOREIGN KEY (FK_REF_GM_TITLE)
      REFERENCES public.REF_GM_TITLE (ID) MATCH SIMPLE
      ON UPDATE NO ACTION ON DELETE NO ACTION,  
  CONSTRAINT FK_GRIDMEASURE__GM_STATUS FOREIGN KEY (FK_REF_GM_STATUS)
      REFERENCES public.REF_GM_STATUS (ID) MATCH SIMPLE
      ON UPDATE NO ACTION ON DELETE NO ACTION,  
  CONSTRAINT FK_GRIDMEASURE__BRANCH FOREIGN KEY (FK_REF_BRANCH)
      REFERENCES public.REF_BRANCH (ID) MATCH SIMPLE
      ON UPDATE NO ACTION ON DELETE NO ACTION,  
  CONSTRAINT FK_GRIDMEASURE__TERR_RESP FOREIGN KEY (FK_REF_TERR_RESP)
      REFERENCES public.REF_TERRITORY_RESPONSIBILITY (ID) MATCH SIMPLE
      ON UPDATE NO ACTION ON DELETE NO ACTION 
)
WITH (
  OIDS=FALSE
);
ALTER TABLE public.TBL_GRIDMEASURE
  OWNER TO PLGM_SERVICE;
GRANT ALL ON TABLE public.TBL_GRIDMEASURE TO PLGM_SERVICE;


DROP TABLE IF EXISTS public.REF_VERSION;

CREATE TABLE public.REF_VERSION
(
  id integer NOT NULL,
  version character varying(100) NOT NULL,
  CONSTRAINT ref_version_pkey PRIMARY KEY (id)
)
WITH (
  OIDS=FALSE
);
ALTER TABLE public.REF_VERSION
  OWNER TO PLGM_SERVICE;
GRANT ALL ON TABLE public.REF_VERSION TO PLGM_SERVICE;

INSERT INTO REF_VERSION VALUES (1, '0.0.1_PG');

-- ----------------------------------------------------------------------------
-- ----------------------------------------------------------------------------
-- HISTORY-TABLES
-- ----------------------------------------------------------------------------
-- ----------------------------------------------------------------------------

-- PUBLIC.HREF_BRANCH Automatic generanted History Table DDL --
-- <GENERATED CODE!>

DROP TABLE IF EXISTS PUBLIC.HREF_BRANCH;
DROP SEQUENCE IF EXISTS PUBLIC.HREF_BRANCH_ID_SEQ;

CREATE SEQUENCE PUBLIC.HREF_BRANCH_ID_SEQ
  INCREMENT 1
  MINVALUE 1
  MAXVALUE 9223372036854775807
  START 1
  CACHE 1;

ALTER TABLE PUBLIC.HREF_BRANCH_ID_SEQ
  OWNER TO PLGM_SERVICE;

CREATE TABLE PUBLIC.HREF_BRANCH
(
  HID integer NOT NULL DEFAULT nextval('HREF_BRANCH_ID_SEQ'::regclass),
  HACTION integer NOT NULL,
  HDATE timestamp without time zone NOT NULL,
  HUSER character varying(100),

  ID integer,
  NAME character varying(50),
  DESCRIPTION character varying(255),
  
  CREATE_USER character varying(100),
  CREATE_DATE timestamp without time zone,
  MOD_USER character varying(100),
  MOD_DATE timestamp without time zone,
  CONSTRAINT HREF_BRANCH_PKEY PRIMARY KEY (HID)
)
WITH (
  OIDS=FALSE
);

ALTER TABLE PUBLIC.HREF_BRANCH
  OWNER TO PLGM_SERVICE;
GRANT ALL ON TABLE PUBLIC.HREF_BRANCH TO PLGM_SERVICE;

-- PUBLIC.HREF_BRANCH_LEVEL Automatic generanted History Table DDL --
-- <GENERATED CODE!>

DROP TABLE IF EXISTS PUBLIC.HREF_BRANCH_LEVEL;
DROP SEQUENCE IF EXISTS PUBLIC.HREF_BRANCH_LEVEL_ID_SEQ;

CREATE SEQUENCE PUBLIC.HREF_BRANCH_LEVEL_ID_SEQ
  INCREMENT 1
  MINVALUE 1
  MAXVALUE 9223372036854775807
  START 1
  CACHE 1;

ALTER TABLE PUBLIC.HREF_BRANCH_LEVEL_ID_SEQ
  OWNER TO PLGM_SERVICE;
  
CREATE TABLE PUBLIC.HREF_BRANCH_LEVEL
(
  HID integer NOT NULL DEFAULT nextval('HREF_BRANCH_LEVEL_ID_SEQ'::regclass),
  HACTION integer NOT NULL,
  HDATE timestamp without time zone NOT NULL,
  HUSER character varying(100),

  ID integer,
  NAME character varying(50) NOT NULL,
  DESCRIPTION character varying(255),

  CREATE_USER character varying(100),
  CREATE_DATE timestamp without time zone,
  MOD_USER character varying(100),
  MOD_DATE timestamp without time zone,
  CONSTRAINT HREF_BRANCH_LEVEL_PKEY PRIMARY KEY (HID)
)
WITH (
  OIDS=FALSE
);

ALTER TABLE PUBLIC.HREF_BRANCH_LEVEL
  OWNER TO PLGM_SERVICE;
GRANT ALL ON TABLE PUBLIC.HREF_BRANCH_LEVEL TO PLGM_SERVICE;

-- PUBLIC.HREF_GM_STATUS Automatic generanted History Table DDL --
-- <GENERATED CODE!>

DROP TABLE IF EXISTS PUBLIC.HREF_GM_STATUS;
DROP SEQUENCE IF EXISTS PUBLIC.HREF_GM_STATUS_ID_SEQ;

CREATE SEQUENCE PUBLIC.HREF_GM_STATUS_ID_SEQ
  INCREMENT 1
  MINVALUE 1
  MAXVALUE 9223372036854775807
  START 1
  CACHE 1;

ALTER TABLE PUBLIC.HREF_GM_STATUS_ID_SEQ
  OWNER TO PLGM_SERVICE;

CREATE TABLE PUBLIC.HREF_GM_STATUS
(
  HID integer NOT NULL DEFAULT nextval('HREF_GM_STATUS_ID_SEQ'::regclass),
  HACTION integer NOT NULL,
  HDATE timestamp without time zone NOT NULL,
  HUSER character varying(100),

  ID integer,
  NAME character varying(50),

  CREATE_USER character varying(100),
  CREATE_DATE timestamp without time zone,
  MOD_USER character varying(100),
  MOD_DATE timestamp without time zone,
  CONSTRAINT HREF_GM_STATUS_PKEY PRIMARY KEY (HID)
)
WITH (
  OIDS=FALSE
);

ALTER TABLE PUBLIC.HREF_GM_STATUS
  OWNER TO PLGM_SERVICE;
GRANT ALL ON TABLE PUBLIC.HREF_GM_STATUS TO PLGM_SERVICE;

-- PUBLIC.HREF_GM_TITLE Automatic generanted History Table DDL --
-- <GENERATED CODE!>

DROP TABLE IF EXISTS PUBLIC.HREF_GM_TITLE;
DROP SEQUENCE IF EXISTS PUBLIC.HREF_GM_TITLE_ID_SEQ;

CREATE SEQUENCE PUBLIC.HREF_GM_TITLE_ID_SEQ
  INCREMENT 1
  MINVALUE 1
  MAXVALUE 9223372036854775807
  START 1
  CACHE 1;

ALTER TABLE PUBLIC.HREF_GM_TITLE_ID_SEQ
  OWNER TO PLGM_SERVICE;
  
CREATE TABLE PUBLIC.HREF_GM_TITLE
(
  HID integer NOT NULL DEFAULT nextval('HREF_GM_TITLE_ID_SEQ'::regclass),
  HACTION integer NOT NULL,
  HDATE timestamp without time zone NOT NULL,
  HUSER character varying(100),

  ID integer,
  NAME character varying(50),

  CREATE_USER character varying(100),
  CREATE_DATE timestamp without time zone,
  MOD_USER character varying(100),
  MOD_DATE timestamp without time zone,
  CONSTRAINT HREF_GM_TITLE_PKEY PRIMARY KEY (HID)
)
WITH (
  OIDS=FALSE
);

ALTER TABLE PUBLIC.HREF_GM_TITLE
  OWNER TO PLGM_SERVICE;
GRANT ALL ON TABLE PUBLIC.HREF_GM_TITLE TO PLGM_SERVICE;

-- PUBLIC.HREF_TERRITORY_RESPONSIBILITY Automatic generanted History Table DDL --
-- <GENERATED CODE!>

DROP TABLE IF EXISTS PUBLIC.HREF_TERRITORY_RESPONSIBILITY;
DROP SEQUENCE IF EXISTS PUBLIC.HREF_TERRITORY_RESPONSIBILITY_ID_SEQ;

CREATE SEQUENCE PUBLIC.HREF_TERRITORY_RESPONSIBILITY_ID_SEQ
  INCREMENT 1
  MINVALUE 1
  MAXVALUE 9223372036854775807
  START 1
  CACHE 1;
  
ALTER TABLE PUBLIC.HREF_TERRITORY_RESPONSIBILITY_ID_SEQ
  OWNER TO PLGM_SERVICE;

CREATE TABLE PUBLIC.HREF_TERRITORY_RESPONSIBILITY
(
  HID integer NOT NULL DEFAULT nextval('HREF_TERRITORY_RESPONSIBILITY_ID_SEQ'::regclass),
  HACTION integer NOT NULL,
  HDATE timestamp without time zone NOT NULL,
  HUSER character varying(100),

  ID integer,
  NAME character varying(50),

  CREATE_USER character varying(100),
  CREATE_DATE timestamp without time zone,
  MOD_USER character varying(100),
  MOD_DATE timestamp without time zone,
  CONSTRAINT HREF_TERRITORY_RESPONSIBILITY_PKEY PRIMARY KEY (HID)
)
WITH (
  OIDS=FALSE
);

ALTER TABLE PUBLIC.HREF_TERRITORY_RESPONSIBILITY
  OWNER TO PLGM_SERVICE;
GRANT ALL ON TABLE PUBLIC.HREF_TERRITORY_RESPONSIBILITY TO PLGM_SERVICE;

-- PUBLIC.HTBL_GRIDMEASURE Automatic generanted History Table DDL --
-- <GENERATED CODE!>

DROP TABLE IF EXISTS PUBLIC.HTBL_GRIDMEASURE;
DROP SEQUENCE IF EXISTS PUBLIC.HTBL_GRIDMEASURE_ID_SEQ;

CREATE SEQUENCE PUBLIC.HTBL_GRIDMEASURE_ID_SEQ
  INCREMENT 1
  MINVALUE 1
  MAXVALUE 9223372036854775807
  START 1
  CACHE 1;


ALTER TABLE PUBLIC.HTBL_GRIDMEASURE_ID_SEQ
  OWNER TO PLGM_SERVICE;
  
CREATE TABLE PUBLIC.HTBL_GRIDMEASURE
(
  HID integer NOT NULL DEFAULT nextval('HTBL_GRIDMEASURE_ID_SEQ'::regclass),
  HACTION integer NOT NULL,
  HDATE timestamp without time zone NOT NULL,
  HUSER character varying(100),

  ID integer,
  ID_EXT character varying(50),
  FK_REF_GM_TITLE integer,
  FK_REF_GM_STATUS integer,
  FK_REF_BRANCH integer,
  FK_REF_BRANCH_LEVEL integer,
  FK_REF_TERR_RESP integer,
  COST_CENTRE character varying(50),

  CREATE_USER character varying(100),
  CREATE_USER_DEPARTMENT character varying(100),
  CREATE_DATE timestamp without time zone,
  MOD_USER character varying(100),
  MOD_USER_DEPARTMENT character varying(100),
  CONSTRAINT HTBL_GRIDMEASURE_PKEY PRIMARY KEY (HID)
)
WITH (
  OIDS=FALSE
);

ALTER TABLE PUBLIC.HTBL_GRIDMEASURE
  OWNER TO PLGM_SERVICE;
GRANT ALL ON TABLE PUBLIC.HTBL_GRIDMEASURE TO PLGM_SERVICE;
-- ----------------------------------------------------------------------------
-- ----------------------------------------------------------------------------
-- TRIGGER
-- ----------------------------------------------------------------------------
-- ----------------------------------------------------------------------------


-- PUBLIC.REF_BRANCH INSERT TRIGGER --
-- <GENERATED CODE!>
CREATE OR REPLACE FUNCTION PUBLIC.REF_BRANCH_INSERT_TRG()
  RETURNS trigger AS
$BODY$
    BEGIN
	INSERT INTO HREF_BRANCH (
						  ID,NAME,DESCRIPTION,CREATE_USER,CREATE_DATE,MOD_USER,MOD_DATE,

						  HACTION,
						  HDATE,
						  HUSER
						 )
	VALUES 				 (

						  NEW.ID,NEW.NAME,NEW.DESCRIPTION,NEW.CREATE_USER,NEW.CREATE_DATE,NEW.MOD_USER,NEW.MOD_DATE,

                          1,
						  current_timestamp,
					      NEW.CREATE_USER );

        RETURN NEW;
    END;
$BODY$
  LANGUAGE plpgsql VOLATILE
  COST 100;
ALTER FUNCTION PUBLIC.REF_BRANCH_INSERT_TRG()
  OWNER TO PLGM_SERVICE;


DROP TRIGGER IF EXISTS REF_BRANCH_INSERT_TRG ON PUBLIC.REF_BRANCH;

CREATE TRIGGER REF_BRANCH_INSERT_TRG
  BEFORE INSERT
  ON PUBLIC.REF_BRANCH
  FOR EACH ROW
  EXECUTE PROCEDURE PUBLIC.REF_BRANCH_INSERT_TRG();



-- PUBLIC.REF_BRANCH UPDATE TRIGGER --
-- <GENERATED CODE!>

CREATE OR REPLACE FUNCTION PUBLIC.REF_BRANCH_UPDATE_TRG()
  RETURNS trigger AS
$BODY$
    BEGIN
	INSERT INTO HREF_BRANCH (
						  ID,NAME,DESCRIPTION,CREATE_USER,CREATE_DATE,MOD_USER,MOD_DATE,

						  HACTION,
						  HDATE,
						  HUSER
						 )
	VALUES 			    (
	                      NEW.ID,NEW.NAME,NEW.DESCRIPTION,NEW.CREATE_USER,NEW.CREATE_DATE,NEW.MOD_USER,NEW.MOD_DATE,
                          2,
						  current_timestamp,
					      NEW.MOD_USER
					    );

        RETURN NEW;
    END;
$BODY$
  LANGUAGE plpgsql VOLATILE
  COST 100;
ALTER FUNCTION PUBLIC.REF_BRANCH_UPDATE_TRG()
  OWNER TO PLGM_SERVICE;

DROP TRIGGER IF EXISTS REF_BRANCH_UPDATE_TRG ON PUBLIC.REF_BRANCH;

CREATE TRIGGER REF_BRANCH_UPDATE_TRG
  BEFORE UPDATE
  ON PUBLIC.REF_BRANCH
  FOR EACH ROW
  EXECUTE PROCEDURE PUBLIC.REF_BRANCH_UPDATE_TRG();



-- PUBLIC.REF_BRANCH DELETE TRIGGER --
-- <GENERATED CODE!>

CREATE OR REPLACE FUNCTION PUBLIC.REF_BRANCH_DELETE_TRG()
  RETURNS trigger AS
$BODY$
    BEGIN
    IF TG_OP = 'DELETE' THEN
	INSERT INTO HREF_BRANCH (

						  ID,NAME,DESCRIPTION,CREATE_USER,CREATE_DATE,MOD_USER,MOD_DATE,

						  HACTION,
						  HDATE,
						  HUSER
						 )
	VALUES 				(
						  OLD.ID,OLD.NAME,OLD.DESCRIPTION,OLD.CREATE_USER,OLD.CREATE_DATE,OLD.MOD_USER,OLD.MOD_DATE,

                          3,
						  current_timestamp,
					      OLD.MOD_USER );
	END IF;

        RETURN OLD;
    END;
$BODY$
  LANGUAGE plpgsql VOLATILE
  COST 100;
ALTER FUNCTION PUBLIC.REF_BRANCH_DELETE_TRG()
  OWNER TO PLGM_SERVICE;

DROP TRIGGER IF EXISTS REF_BRANCH_DELETE_TRG ON PUBLIC.REF_BRANCH;

CREATE TRIGGER REF_BRANCH_DELETE_TRG
  BEFORE DELETE
  ON PUBLIC.REF_BRANCH
  FOR EACH ROW
  EXECUTE PROCEDURE PUBLIC.REF_BRANCH_DELETE_TRG();






-- PUBLIC.REF_BRANCH_LEVEL INSERT TRIGGER --
-- <GENERATED CODE!>
CREATE OR REPLACE FUNCTION PUBLIC.REF_BRANCH_LEVEL_INSERT_TRG()
  RETURNS trigger AS
$BODY$
    BEGIN
	INSERT INTO HREF_BRANCH_LEVEL (
						  ID,NAME,DESCRIPTION,CREATE_USER,CREATE_DATE,MOD_USER,MOD_DATE,

						  HACTION,
						  HDATE,
						  HUSER
						 )
	VALUES 				 (

						  NEW.ID,NEW.NAME,NEW.DESCRIPTION,NEW.CREATE_USER,NEW.CREATE_DATE,NEW.MOD_USER,NEW.MOD_DATE,

                          1,
						  current_timestamp,
					      NEW.CREATE_USER );

        RETURN NEW;
    END;
$BODY$
  LANGUAGE plpgsql VOLATILE
  COST 100;
ALTER FUNCTION PUBLIC.REF_BRANCH_LEVEL_INSERT_TRG()
  OWNER TO PLGM_SERVICE;


DROP TRIGGER IF EXISTS REF_BRANCH_LEVEL_INSERT_TRG ON PUBLIC.REF_BRANCH_LEVEL;

CREATE TRIGGER REF_BRANCH_LEVEL_INSERT_TRG
  BEFORE INSERT
  ON PUBLIC.REF_BRANCH_LEVEL
  FOR EACH ROW
  EXECUTE PROCEDURE PUBLIC.REF_BRANCH_LEVEL_INSERT_TRG();



-- PUBLIC.REF_BRANCH_LEVEL UPDATE TRIGGER --
-- <GENERATED CODE!>

CREATE OR REPLACE FUNCTION PUBLIC.REF_BRANCH_LEVEL_UPDATE_TRG()
  RETURNS trigger AS
$BODY$
    BEGIN
	INSERT INTO HREF_BRANCH_LEVEL (
						  ID,NAME,DESCRIPTION,CREATE_USER,CREATE_DATE,MOD_USER,MOD_DATE,

						  HACTION,
						  HDATE,
						  HUSER
						 )
	VALUES 			    (
	                      NEW.ID,NEW.NAME,NEW.DESCRIPTION,NEW.CREATE_USER,NEW.CREATE_DATE,NEW.MOD_USER,NEW.MOD_DATE,
                          2,
						  current_timestamp,
					      NEW.MOD_USER
					    );

        RETURN NEW;
    END;
$BODY$
  LANGUAGE plpgsql VOLATILE
  COST 100;
ALTER FUNCTION PUBLIC.REF_BRANCH_LEVEL_UPDATE_TRG()
  OWNER TO PLGM_SERVICE;

DROP TRIGGER IF EXISTS REF_BRANCH_LEVEL_UPDATE_TRG ON PUBLIC.REF_BRANCH_LEVEL;

CREATE TRIGGER REF_BRANCH_LEVEL_UPDATE_TRG
  BEFORE UPDATE
  ON PUBLIC.REF_BRANCH_LEVEL
  FOR EACH ROW
  EXECUTE PROCEDURE PUBLIC.REF_BRANCH_LEVEL_UPDATE_TRG();



-- PUBLIC.REF_BRANCH_LEVEL DELETE TRIGGER --
-- <GENERATED CODE!>

CREATE OR REPLACE FUNCTION PUBLIC.REF_BRANCH_LEVEL_DELETE_TRG()
  RETURNS trigger AS
$BODY$
    BEGIN
    IF TG_OP = 'DELETE' THEN
	INSERT INTO HREF_BRANCH_LEVEL (

						  ID,NAME,DESCRIPTION,CREATE_USER,CREATE_DATE,MOD_USER,MOD_DATE,

						  HACTION,
						  HDATE,
						  HUSER
						 )
	VALUES 				(
						  OLD.ID,OLD.NAME,OLD.DESCRIPTION,OLD.CREATE_USER,OLD.CREATE_DATE,OLD.MOD_USER,OLD.MOD_DATE,

                          3,
						  current_timestamp,
					      OLD.MOD_USER );
	END IF;

        RETURN OLD;
    END;
$BODY$
  LANGUAGE plpgsql VOLATILE
  COST 100;
ALTER FUNCTION PUBLIC.REF_BRANCH_LEVEL_DELETE_TRG()
  OWNER TO PLGM_SERVICE;

DROP TRIGGER IF EXISTS REF_BRANCH_LEVEL_DELETE_TRG ON PUBLIC.REF_BRANCH_LEVEL;

CREATE TRIGGER REF_BRANCH_LEVEL_DELETE_TRG
  BEFORE DELETE
  ON PUBLIC.REF_BRANCH_LEVEL
  FOR EACH ROW
  EXECUTE PROCEDURE PUBLIC.REF_BRANCH_LEVEL_DELETE_TRG();






-- PUBLIC.REF_GM_STATUS INSERT TRIGGER --
-- <GENERATED CODE!>
CREATE OR REPLACE FUNCTION PUBLIC.REF_GM_STATUS_INSERT_TRG()
  RETURNS trigger AS
$BODY$
    BEGIN
	INSERT INTO HREF_GM_STATUS (
						  ID,NAME,CREATE_USER,CREATE_DATE,MOD_USER,MOD_DATE,

						  HACTION,
						  HDATE,
						  HUSER
						 )
	VALUES 				 (

						  NEW.ID,NEW.NAME,NEW.CREATE_USER,NEW.CREATE_DATE,NEW.MOD_USER,NEW.MOD_DATE,

                          1,
						  current_timestamp,
					      NEW.CREATE_USER );

        RETURN NEW;
    END;
$BODY$
  LANGUAGE plpgsql VOLATILE
  COST 100;
ALTER FUNCTION PUBLIC.REF_GM_STATUS_INSERT_TRG()
  OWNER TO PLGM_SERVICE;


DROP TRIGGER IF EXISTS REF_GM_STATUS_INSERT_TRG ON PUBLIC.REF_GM_STATUS;

CREATE TRIGGER REF_GM_STATUS_INSERT_TRG
  BEFORE INSERT
  ON PUBLIC.REF_GM_STATUS
  FOR EACH ROW
  EXECUTE PROCEDURE PUBLIC.REF_GM_STATUS_INSERT_TRG();



-- PUBLIC.REF_GM_STATUS UPDATE TRIGGER --
-- <GENERATED CODE!>

CREATE OR REPLACE FUNCTION PUBLIC.REF_GM_STATUS_UPDATE_TRG()
  RETURNS trigger AS
$BODY$
    BEGIN
	INSERT INTO HREF_GM_STATUS (
						  ID,NAME,CREATE_USER,CREATE_DATE,MOD_USER,MOD_DATE,

						  HACTION,
						  HDATE,
						  HUSER
						 )
	VALUES 			    (
	                      NEW.ID,NEW.NAME,NEW.CREATE_USER,NEW.CREATE_DATE,NEW.MOD_USER,NEW.MOD_DATE,
                          2,
						  current_timestamp,
					      NEW.MOD_USER
					    );

        RETURN NEW;
    END;
$BODY$
  LANGUAGE plpgsql VOLATILE
  COST 100;
ALTER FUNCTION PUBLIC.REF_GM_STATUS_UPDATE_TRG()
  OWNER TO PLGM_SERVICE;

DROP TRIGGER IF EXISTS REF_GM_STATUS_UPDATE_TRG ON PUBLIC.REF_GM_STATUS;

CREATE TRIGGER REF_GM_STATUS_UPDATE_TRG
  BEFORE UPDATE
  ON PUBLIC.REF_GM_STATUS
  FOR EACH ROW
  EXECUTE PROCEDURE PUBLIC.REF_GM_STATUS_UPDATE_TRG();



-- PUBLIC.REF_GM_STATUS DELETE TRIGGER --
-- <GENERATED CODE!>

CREATE OR REPLACE FUNCTION PUBLIC.REF_GM_STATUS_DELETE_TRG()
  RETURNS trigger AS
$BODY$
    BEGIN
    IF TG_OP = 'DELETE' THEN
	INSERT INTO HREF_GM_STATUS (

						  ID,NAME,CREATE_USER,CREATE_DATE,MOD_USER,MOD_DATE,

						  HACTION,
						  HDATE,
						  HUSER
						 )
	VALUES 				(
						  OLD.ID,OLD.NAME,OLD.CREATE_USER,OLD.CREATE_DATE,OLD.MOD_USER,OLD.MOD_DATE,

                          3,
						  current_timestamp,
					      OLD.MOD_USER );
	END IF;

        RETURN OLD;
    END;
$BODY$
  LANGUAGE plpgsql VOLATILE
  COST 100;
ALTER FUNCTION PUBLIC.REF_GM_STATUS_DELETE_TRG()
  OWNER TO PLGM_SERVICE;

DROP TRIGGER IF EXISTS REF_GM_STATUS_DELETE_TRG ON PUBLIC.REF_GM_STATUS;

CREATE TRIGGER REF_GM_STATUS_DELETE_TRG
  BEFORE DELETE
  ON PUBLIC.REF_GM_STATUS
  FOR EACH ROW
  EXECUTE PROCEDURE PUBLIC.REF_GM_STATUS_DELETE_TRG();






-- PUBLIC.REF_GM_TITLE INSERT TRIGGER --
-- <GENERATED CODE!>
CREATE OR REPLACE FUNCTION PUBLIC.REF_GM_TITLE_INSERT_TRG()
  RETURNS trigger AS
$BODY$
    BEGIN
	INSERT INTO HREF_GM_TITLE (
						  ID,NAME,CREATE_USER,CREATE_DATE,MOD_USER,MOD_DATE,

						  HACTION,
						  HDATE,
						  HUSER
						 )
	VALUES 				 (

						  NEW.ID,NEW.NAME,NEW.CREATE_USER,NEW.CREATE_DATE,NEW.MOD_USER,NEW.MOD_DATE,

                          1,
						  current_timestamp,
					      NEW.CREATE_USER );

        RETURN NEW;
    END;
$BODY$
  LANGUAGE plpgsql VOLATILE
  COST 100;
ALTER FUNCTION PUBLIC.REF_GM_TITLE_INSERT_TRG()
  OWNER TO PLGM_SERVICE;


DROP TRIGGER IF EXISTS REF_GM_TITLE_INSERT_TRG ON PUBLIC.REF_GM_TITLE;

CREATE TRIGGER REF_GM_TITLE_INSERT_TRG
  BEFORE INSERT
  ON PUBLIC.REF_GM_TITLE
  FOR EACH ROW
  EXECUTE PROCEDURE PUBLIC.REF_GM_TITLE_INSERT_TRG();



-- PUBLIC.REF_GM_TITLE UPDATE TRIGGER --
-- <GENERATED CODE!>

CREATE OR REPLACE FUNCTION PUBLIC.REF_GM_TITLE_UPDATE_TRG()
  RETURNS trigger AS
$BODY$
    BEGIN
	INSERT INTO HREF_GM_TITLE (
						  ID,NAME,CREATE_USER,CREATE_DATE,MOD_USER,MOD_DATE,

						  HACTION,
						  HDATE,
						  HUSER
						 )
	VALUES 			    (
	                      NEW.ID,NEW.NAME,NEW.CREATE_USER,NEW.CREATE_DATE,NEW.MOD_USER,NEW.MOD_DATE,
                          2,
						  current_timestamp,
					      NEW.MOD_USER
					    );

        RETURN NEW;
    END;
$BODY$
  LANGUAGE plpgsql VOLATILE
  COST 100;
ALTER FUNCTION PUBLIC.REF_GM_TITLE_UPDATE_TRG()
  OWNER TO PLGM_SERVICE;

DROP TRIGGER IF EXISTS REF_GM_TITLE_UPDATE_TRG ON PUBLIC.REF_GM_TITLE;

CREATE TRIGGER REF_GM_TITLE_UPDATE_TRG
  BEFORE UPDATE
  ON PUBLIC.REF_GM_TITLE
  FOR EACH ROW
  EXECUTE PROCEDURE PUBLIC.REF_GM_TITLE_UPDATE_TRG();



-- PUBLIC.REF_GM_TITLE DELETE TRIGGER --
-- <GENERATED CODE!>

CREATE OR REPLACE FUNCTION PUBLIC.REF_GM_TITLE_DELETE_TRG()
  RETURNS trigger AS
$BODY$
    BEGIN
    IF TG_OP = 'DELETE' THEN
	INSERT INTO HREF_GM_TITLE (

						  ID,NAME,CREATE_USER,CREATE_DATE,MOD_USER,MOD_DATE,

						  HACTION,
						  HDATE,
						  HUSER
						 )
	VALUES 				(
						  OLD.ID,OLD.NAME,OLD.CREATE_USER,OLD.CREATE_DATE,OLD.MOD_USER,OLD.MOD_DATE,

                          3,
						  current_timestamp,
					      OLD.MOD_USER );
	END IF;

        RETURN OLD;
    END;
$BODY$
  LANGUAGE plpgsql VOLATILE
  COST 100;
ALTER FUNCTION PUBLIC.REF_GM_TITLE_DELETE_TRG()
  OWNER TO PLGM_SERVICE;

DROP TRIGGER IF EXISTS REF_GM_TITLE_DELETE_TRG ON PUBLIC.REF_GM_TITLE;

CREATE TRIGGER REF_GM_TITLE_DELETE_TRG
  BEFORE DELETE
  ON PUBLIC.REF_GM_TITLE
  FOR EACH ROW
  EXECUTE PROCEDURE PUBLIC.REF_GM_TITLE_DELETE_TRG();






-- PUBLIC.REF_TERRITORY_RESPONSIBILITY INSERT TRIGGER --
-- <GENERATED CODE!>
CREATE OR REPLACE FUNCTION PUBLIC.REF_TERRITORY_RESPONSIBILITY_INSERT_TRG()
  RETURNS trigger AS
$BODY$
    BEGIN
	INSERT INTO HREF_TERRITORY_RESPONSIBILITY (
						  ID,NAME,CREATE_USER,CREATE_DATE,MOD_USER,MOD_DATE,

						  HACTION,
						  HDATE,
						  HUSER
						 )
	VALUES 				 (

						  NEW.ID,NEW.NAME,NEW.CREATE_USER,NEW.CREATE_DATE,NEW.MOD_USER,NEW.MOD_DATE,

                          1,
						  current_timestamp,
					      NEW.CREATE_USER );

        RETURN NEW;
    END;
$BODY$
  LANGUAGE plpgsql VOLATILE
  COST 100;
ALTER FUNCTION PUBLIC.REF_TERRITORY_RESPONSIBILITY_INSERT_TRG()
  OWNER TO PLGM_SERVICE;


DROP TRIGGER IF EXISTS REF_TERRITORY_RESPONSIBILITY_INSERT_TRG ON PUBLIC.REF_TERRITORY_RESPONSIBILITY;

CREATE TRIGGER REF_TERRITORY_RESPONSIBILITY_INSERT_TRG
  BEFORE INSERT
  ON PUBLIC.REF_TERRITORY_RESPONSIBILITY
  FOR EACH ROW
  EXECUTE PROCEDURE PUBLIC.REF_TERRITORY_RESPONSIBILITY_INSERT_TRG();



-- PUBLIC.REF_TERRITORY_RESPONSIBILITY UPDATE TRIGGER --
-- <GENERATED CODE!>

CREATE OR REPLACE FUNCTION PUBLIC.REF_TERRITORY_RESPONSIBILITY_UPDATE_TRG()
  RETURNS trigger AS
$BODY$
    BEGIN
	INSERT INTO HREF_TERRITORY_RESPONSIBILITY (
						  ID,NAME,CREATE_USER,CREATE_DATE,MOD_USER,MOD_DATE,

						  HACTION,
						  HDATE,
						  HUSER
						 )
	VALUES 			    (
	                      NEW.ID,NEW.NAME,NEW.CREATE_USER,NEW.CREATE_DATE,NEW.MOD_USER,NEW.MOD_DATE,
                          2,
						  current_timestamp,
					      NEW.MOD_USER
					    );

        RETURN NEW;
    END;
$BODY$
  LANGUAGE plpgsql VOLATILE
  COST 100;
ALTER FUNCTION PUBLIC.REF_TERRITORY_RESPONSIBILITY_UPDATE_TRG()
  OWNER TO PLGM_SERVICE;

DROP TRIGGER IF EXISTS REF_TERRITORY_RESPONSIBILITY_UPDATE_TRG ON PUBLIC.REF_TERRITORY_RESPONSIBILITY;

CREATE TRIGGER REF_TERRITORY_RESPONSIBILITY_UPDATE_TRG
  BEFORE UPDATE
  ON PUBLIC.REF_TERRITORY_RESPONSIBILITY
  FOR EACH ROW
  EXECUTE PROCEDURE PUBLIC.REF_TERRITORY_RESPONSIBILITY_UPDATE_TRG();



-- PUBLIC.REF_TERRITORY_RESPONSIBILITY DELETE TRIGGER --
-- <GENERATED CODE!>

CREATE OR REPLACE FUNCTION PUBLIC.REF_TERRITORY_RESPONSIBILITY_DELETE_TRG()
  RETURNS trigger AS
$BODY$
    BEGIN
    IF TG_OP = 'DELETE' THEN
	INSERT INTO HREF_TERRITORY_RESPONSIBILITY (

						  ID,NAME,CREATE_USER,CREATE_DATE,MOD_USER,MOD_DATE,

						  HACTION,
						  HDATE,
						  HUSER
						 )
	VALUES 				(
						  OLD.ID,OLD.NAME,OLD.CREATE_USER,OLD.CREATE_DATE,OLD.MOD_USER,OLD.MOD_DATE,

                          3,
						  current_timestamp,
					      OLD.MOD_USER );
	END IF;

        RETURN OLD;
    END;
$BODY$
  LANGUAGE plpgsql VOLATILE
  COST 100;
ALTER FUNCTION PUBLIC.REF_TERRITORY_RESPONSIBILITY_DELETE_TRG()
  OWNER TO PLGM_SERVICE;

DROP TRIGGER IF EXISTS REF_TERRITORY_RESPONSIBILITY_DELETE_TRG ON PUBLIC.REF_TERRITORY_RESPONSIBILITY;

CREATE TRIGGER REF_TERRITORY_RESPONSIBILITY_DELETE_TRG
  BEFORE DELETE
  ON PUBLIC.REF_TERRITORY_RESPONSIBILITY
  FOR EACH ROW
  EXECUTE PROCEDURE PUBLIC.REF_TERRITORY_RESPONSIBILITY_DELETE_TRG();






-- PUBLIC.TBL_GRIDMEASURE INSERT TRIGGER --
-- <GENERATED CODE!>
CREATE OR REPLACE FUNCTION PUBLIC.TBL_GRIDMEASURE_INSERT_TRG()
  RETURNS trigger AS
$BODY$
    BEGIN
	INSERT INTO HTBL_GRIDMEASURE (
						  ID,ID_EXT,FK_REF_GM_TITLE,FK_REF_GM_STATUS,FK_REF_BRANCH,FK_REF_BRANCH_LEVEL,FK_REF_TERR_RESP,COST_CENTRE,CREATE_USER,CREATE_USER_DEPARTMENT,CREATE_DATE,MOD_USER,MOD_USER_DEPARTMENT,MOD_DATE,

						  HACTION,
						  HDATE,
						  HUSER
						 )
	VALUES 				 (

						  NEW.ID,NEW.ID_EXT,NEW.FK_REF_GM_TITLE,NEW.FK_REF_GM_STATUS,NEW.FK_REF_BRANCH,NEW.FK_REF_BRANCH_LEVEL,NEW.FK_REF_TERR_RESP,NEW.COST_CENTRE,NEW.CREATE_USER,NEW.CREATE_USER_DEPARTMENT,NEW.CREATE_DATE,NEW.MOD_USER,NEW.MOD_USER_DEPARTMENT,NEW.MOD_DATE,

                          1,
						  current_timestamp,
					      NEW.CREATE_USER );

        RETURN NEW;
    END;
$BODY$
  LANGUAGE plpgsql VOLATILE
  COST 100;
ALTER FUNCTION PUBLIC.TBL_GRIDMEASURE_INSERT_TRG()
  OWNER TO PLGM_SERVICE;


DROP TRIGGER IF EXISTS TBL_GRIDMEASURE_INSERT_TRG ON PUBLIC.TBL_GRIDMEASURE;

CREATE TRIGGER TBL_GRIDMEASURE_INSERT_TRG
  BEFORE INSERT
  ON PUBLIC.TBL_GRIDMEASURE
  FOR EACH ROW
  EXECUTE PROCEDURE PUBLIC.TBL_GRIDMEASURE_INSERT_TRG();



-- PUBLIC.TBL_GRIDMEASURE UPDATE TRIGGER --
-- <GENERATED CODE!>

CREATE OR REPLACE FUNCTION PUBLIC.TBL_GRIDMEASURE_UPDATE_TRG()
  RETURNS trigger AS
$BODY$
    BEGIN
	INSERT INTO HTBL_GRIDMEASURE (
						  ID,ID_EXT,FK_REF_GM_TITLE,FK_REF_GM_STATUS,FK_REF_BRANCH,FK_REF_BRANCH_LEVEL,FK_REF_TERR_RESP,COST_CENTRE,CREATE_USER,CREATE_USER_DEPARTMENT,CREATE_DATE,MOD_USER,MOD_USER_DEPARTMENT,MOD_DATE,

						  HACTION,
						  HDATE,
						  HUSER
						 )
	VALUES 			    (
	                      NEW.ID,NEW.ID_EXT,NEW.FK_REF_GM_TITLE,NEW.FK_REF_GM_STATUS,NEW.FK_REF_BRANCH,NEW.FK_REF_BRANCH_LEVEL,NEW.FK_REF_TERR_RESP,NEW.COST_CENTRE,NEW.CREATE_USER,NEW.CREATE_USER_DEPARTMENT,NEW.CREATE_DATE,NEW.MOD_USER,NEW.MOD_USER_DEPARTMENT,NEW.MOD_DATE,
                          2,
						  current_timestamp,
					      NEW.MOD_USER
					    );

        RETURN NEW;
    END;
$BODY$
  LANGUAGE plpgsql VOLATILE
  COST 100;
ALTER FUNCTION PUBLIC.TBL_GRIDMEASURE_UPDATE_TRG()
  OWNER TO PLGM_SERVICE;

DROP TRIGGER IF EXISTS TBL_GRIDMEASURE_UPDATE_TRG ON PUBLIC.TBL_GRIDMEASURE;

CREATE TRIGGER TBL_GRIDMEASURE_UPDATE_TRG
  BEFORE UPDATE
  ON PUBLIC.TBL_GRIDMEASURE
  FOR EACH ROW
  EXECUTE PROCEDURE PUBLIC.TBL_GRIDMEASURE_UPDATE_TRG();



-- PUBLIC.TBL_GRIDMEASURE DELETE TRIGGER --
-- <GENERATED CODE!>

CREATE OR REPLACE FUNCTION PUBLIC.TBL_GRIDMEASURE_DELETE_TRG()
  RETURNS trigger AS
$BODY$
    BEGIN
    IF TG_OP = 'DELETE' THEN
	INSERT INTO HTBL_GRIDMEASURE (

						  ID,ID_EXT,FK_REF_GM_TITLE,FK_REF_GM_STATUS,FK_REF_BRANCH,FK_REF_BRANCH_LEVEL,FK_REF_TERR_RESP,COST_CENTRE,CREATE_USER,CREATE_USER_DEPARTMENT,CREATE_DATE,MOD_USER,MOD_USER_DEPARTMENT,MOD_DATE,

						  HACTION,
						  HDATE,
						  HUSER
						 )
	VALUES 				(
						  OLD.ID,OLD.ID_EXT,OLD.FK_REF_GM_TITLE,OLD.FK_REF_GM_STATUS,OLD.FK_REF_BRANCH,OLD.FK_REF_BRANCH_LEVEL,OLD.FK_REF_TERR_RESP,OLD.COST_CENTRE,OLD.CREATE_USER,OLD.CREATE_USER_DEPARTMENT,OLD.CREATE_DATE,OLD.MOD_USER,OLD.MOD_USER_DEPARTMENT,OLD.MOD_DATE,

                          3,
						  current_timestamp,
					      OLD.MOD_USER );
	END IF;

        RETURN OLD;
    END;
$BODY$
  LANGUAGE plpgsql VOLATILE
  COST 100;
ALTER FUNCTION PUBLIC.TBL_GRIDMEASURE_DELETE_TRG()
  OWNER TO PLGM_SERVICE;

DROP TRIGGER IF EXISTS TBL_GRIDMEASURE_DELETE_TRG ON PUBLIC.TBL_GRIDMEASURE;

CREATE TRIGGER TBL_GRIDMEASURE_DELETE_TRG
  BEFORE DELETE
  ON PUBLIC.TBL_GRIDMEASURE
  FOR EACH ROW
  EXECUTE PROCEDURE PUBLIC.TBL_GRIDMEASURE_DELETE_TRG();