DROP TRIGGER acc_actv_last_mod_D
GO
CREATE TRIGGER [dbo].[acc_actv_last_mod_D] ON [dbo].[acc_actv]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'acc_actv'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(activ_id AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER acc_actv_last_mod_IU
GO
CREATE TRIGGER [dbo].[acc_actv_last_mod_IU] ON [dbo].[acc_actv]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'acc_actv'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET acc_actv = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM acc_actv a JOIN inserted i ON a.activ_id = i.activ_id
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER access_last_mod_D
GO
CREATE TRIGGER [dbo].[access_last_mod_D] ON dbo.access
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'access'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(pass_no AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER access_last_mod_IU
GO
CREATE TRIGGER [dbo].[access_last_mod_IU] ON [dbo].[access]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'access'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence
		SET @nKeyVal = next_val,
		    next_val = next_val + @CountIns
	  WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val)
                   VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET access = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a
		SET @nKeyVal = last_mod = @nKeyVal + 1
	  FROM access a
	  JOIN inserted i ON a.pass_no = i.pass_no
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

	UPDATE ac
		SET ac.cstrt_date = i.start_date
	FROM access ac
	JOIN inserted i ON ac.pass_no = i.pass_no
	WHERE i.cstrt_date IS NULL and i.start_date IS NOT NULL ;

return ;   -- Disabled post processing below this point. Reverted back to post processing in middleware.

/* Create the gst_actv log records for "New" and "Modify" guest. */
declare @CountDel        int,
        @xmlInserted     varchar(max),
        @xmlDeleted      varchar(max),
        @xmlChanges      varchar(max),
        @xmlChangeAppend varchar(max),
        @xmlCurrentState varchar(max),
        @cSQL            varchar(8000),
        @Activ_id        numeric(17,0),
        @Site_no         int,
        @pass_no         numeric(17,0),
        @department      char(10),
        @category        char(10),
        @item            char(10),
        @operator        char(6),
        @salespoint      char(6),
        @mod_op          char(6),
        @mod_sp          char(6),
        @cPass_no        varchar(16),
        @Activ_type      int,
        @Tag_line        varchar(80),
        @Date_time       datetime,
        @Op              char(6),
        @Sp              char(6),
        @CRLF            char(2),
        @TAB             char(1),
        @PriorActiv_id   numeric(17,0),
        @PriorChangeDT   datetime,
        @PriorChanged    varchar(max) ;


set @CRLF  = char(13) + char(10) ;
set @TAB   = char(9) ;

select @CountDel = COUNT(*) from Deleted ;
if @CountIns <> 1 return ;     -- make a log entry only when creating or updating a single row, not bulk operations.

set @xmlInserted  = (select top 1 a.*
                     from access a
                     join Inserted i on i.pass_no = a.pass_no
                     for xml path(''), elements absent) ;
if @CountDel = 0
  -- inserting a row, no <Changes> tag to build
  set @xmlChanges  = '' ;
else
  begin
    -- Must manually select specific columns instead of "*" because text/image columns not available in Deleted cursor
    set @xmlDeleted  = (select top 1 pass_no, masterpass, parent_no, swipe_no, addit_no, wtp_no, rfserial, additchar1, additchar2,
                                     addit_no2, addit_no3, last_use, start_date, expires, good_for, validcount, dis_count, total_uses,
                                     usesw_left, week_refr, usest_left, day_refr, points1, points2, money1, money2, blackout_s,
                                     blackout_e, warnings, voided_for, voided_by, shift_ends, department, category, item, amt_paid,
                                     account, operator, salespoint, date_time, val_parent, trans_no, bl_reason, mod_op, mod_sp
                        from Deleted
                        for xml path(''), elements absent) ;

    -- Inspect the text/image columns and add to the "changes to append" variable
    set @xmlChangeAppend = ''
    if update (e_message)
      set @xmlChangeAppend = @xmlChangeAppend + @TAB + @TAB + '<e_message>(Not available)</e_message>' + @CRLF ;

    set @xmlChanges   = dbo.siriusfn_LogChangesToXML(@xmlInserted, @xmlDeleted, @xmlChangeAppend, 'access') ;
  end
set @xmlCurrentState   = dbo.siriusfn_LogCurrentStateToXML(@xmlInserted, 'access') ;

select top 1 @pass_no     = i.pass_no,
             @department  = i.department,
             @category    = i.category,
             @item        = i.item,
             @operator    = i.operator,
             @salespoint  = i.salespoint,
             @mod_op      = i.mod_op,
             @mod_sp      = i.mod_sp
from Inserted i ;

set @Activ_type      = case when @CountDel = 0 then 100 else 101 end ;
set @cPass_no        = rtrim(cast(@pass_no as char(16))) ;
set @Tag_line        = case when @CountDel = 0 then 'New ' else 'Modify ' end + 'Pass #' + rtrim(@cPass_no) + ' ' +
                       rtrim(@department) + ' ' + rtrim(@category) + ' ' + rtrim(@item);
set @Op              = case when datalength(rtrim(@mod_op)) > 0 then @mod_op else @operator end ;
set @Sp              = case when datalength(rtrim(@mod_sp)) > 0 then @mod_sp else @salespoint end ;
set @Date_time       = getdate() ;

-- If there is already a Modify log record for this guest at this location in the last 5 seconds, update that log entry instead
set @PriorActiv_id = 0
set @PriorChanged  = ''
if @Activ_type = 101
begin
  select top 1 @PriorActiv_id  = lf.activ_id,
               @PriorChangeDT  = lf.date_time,
               @PriorChanged   = dbo.siriusfn_Parse('access', dbo.siriusfn_Parse('Changed', lf.details))
             FROM acc_actv lf
            WHERE lf.ref_no         = @cPass_no and
                  lf.activ_type     = @Activ_type and
                  lf.Person         = @Op and
                  lf.Location       = @Sp and
                  datediff(second, COALESCE(lf.date_time, '20100101'), @Date_time) < 5   -- last entry within the last 5 seconds
            ORDER BY lf.date_time desc ;
end

if coalesce(@PriorActiv_id, 0) > 0
begin
  set @xmlChanges = '<Changed> ' + @CRLF + @TAB + '<access>' + @CRLF +
                    dbo.siriusfn_Parse('access', dbo.siriusfn_Parse('Changed', @xmlChanges)) +
                    coalesce(@PriorChanged, '') + @TAB + '</access>' + @CRLF + '</Changed>'  + @CRLF + @CRLF ;
  set @xmlCurrentState = @xmlChanges + @xmlCurrentState ;
  update acc_actv set details = @xmlCurrentState, tag_line = @Tag_line where activ_id = @PriorActiv_id ;
end
else
begin
  select top 1 @Site_no = site_no from prefs ;
  execute dbo.siriussp_get_unique_key2 'K_ACC_ACTV' , @NumberOut = @Activ_id output;
  if @Activ_id = 0
    begin
      raiserror('Cannot fetch a new activity log primary key value.',16,1) ;
      return ;
    end
  set  @Activ_id = @Activ_id * 1000000 + @Site_no ;

  set @xmlCurrentState = @xmlChanges + @xmlCurrentState ;
  execute dbo.siriussp_CreateAccessActivityRecord
            @ActivID     = @Activ_id ,
            @SiteNo      = @Site_no ,
            @ActivType   = @Activ_type ,
            @TagLine     = @Tag_line ,
            @RefNo       = @cPass_no ,
            @Details     = @xmlCurrentState ,
            @Dt          = @Date_time ,
            @Person      = @Op ,
            @Location    = @Sp ;
end
GO

DROP TRIGGER accomdtn_last_mod_D
GO
CREATE trigger [dbo].[accomdtn_last_mod_D] ON [dbo].[accomdtn]
for DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'accomdtn'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
		   SELECT @cTableName AS tablename, CAST(pri_key AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
		BEGIN
		   RAISERROR('Cannot update the DELETES value.',16,1)
		   ROLLBACK TRANSACTION
		   RETURN
		END
		COMMIT TRANSACTION

GO

DROP TRIGGER accomdtn_last_mod_IU
GO
CREATE trigger [dbo].[accomdtn_last_mod_IU] ON [dbo].[accomdtn]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'accomdtn'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET accomdtn = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM accomdtn a JOIN inserted i ON a.pri_key = i.pri_key
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER accounts_last_mod_D
GO
CREATE TRIGGER [dbo].[accounts_last_mod_D] ON [dbo].[accounts]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'accounts'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, acct_name AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER accounts_last_mod_IU
GO
CREATE TRIGGER [dbo].[accounts_last_mod_IU] ON [dbo].[accounts]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'accounts'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
	  UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
	  IF @nKeyVal IS NULL
		 BEGIN
			SET @nKeyVal = 1
			INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
		 END

	  UPDATE updates SET accounts = @nKeyVal + @CountIns - 1
	  IF @@ERROR != 0
		 BEGIN
			RAISERROR('Cannot update the LAST_MOD value.',16,1)
			RETURN
		 END

	  SET @nKeyVal = @nKeyVal - 1
	  UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM accounts a JOIN inserted i ON a.acct_name = i.acct_name
	  IF @@ERROR != 0
		 BEGIN
			RAISERROR('Cannot update the LAST_MOD value.',16,1)
			RETURN
		 END

/*  Remove any record in the deletes table if this key was inserted back in  */
	DELETE FROM deletes WHERE tablename = @cTableName AND key_val IN
	(SELECT acct_name FROM Inserted WHERE acct_name NOT IN (SELECT acct_name FROM Deleted))

GO

DROP TRIGGER accttype_last_mod_D
GO
CREATE TRIGGER [dbo].[accttype_last_mod_D] ON [dbo].[accttype]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'accttype'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(acct_type AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER accttype_last_mod_IU
GO
CREATE TRIGGER [dbo].[accttype_last_mod_IU] ON [dbo].[accttype]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'accttype'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
	  UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
	  IF @nKeyVal IS NULL
		 BEGIN
			SET @nKeyVal = 1
			INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
		 END

	  UPDATE updates SET accttype = @nKeyVal + @CountIns - 1
	  IF @@ERROR != 0
		 BEGIN
			RAISERROR('Cannot update the LAST_MOD value.',16,1)
			RETURN
		 END

	  SET @nKeyVal = @nKeyVal - 1
	  UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM accttype a JOIN inserted i ON a.acct_type = i.acct_type
	  IF @@ERROR != 0
		 BEGIN
			RAISERROR('Cannot update the LAST_MOD value.',16,1)
			RETURN
		 END

GO

DROP TRIGGER addlink_last_mod_D
GO
CREATE TRIGGER [dbo].[addlink_last_mod_D] ON [dbo].[addlink]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'addlink'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(addlink_id AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER addlink_last_mod_IU
GO
CREATE TRIGGER [dbo].[addlink_last_mod_IU] ON [dbo].[addlink]
FOR INSERT,UPDATE
AS
DECLARE @CountIns int,
		@cTableName varchar(10),
		@nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'addlink'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET addlink = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

--Removed Cursor --Omar 7/11/2011
		SET @nKeyVal = @nKeyVal - 1
		UPDATE al
			SET @nKeyVal = last_mod = @nKeyVal + 1
		FROM addlink al JOIN inserted i ON al.addlink_id = i.addlink_id
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the LAST_MOD value.',16,1)
				RETURN
			END

		UPDATE addlink
			SET importadd = 'SADD' + RTRIM(CAST(i.addlink_id AS varchar(16)))
		FROM addlink al
		JOIN inserted i ON al.addlink_id = i.addlink_id
		WHERE i.importadd IS NULL
			  OR LEN(i.importadd) = 0

		UPDATE addlink
			SET importp1 = 'SP1' + RTRIM(CAST(i.addlink_id AS varchar(16)))
		FROM addlink al
		JOIN inserted i ON al.addlink_id = i.addlink_id
		WHERE i.importp1 IS NULL
			  OR LEN(i.importp1) = 0

		UPDATE addlink
			SET importp2 = 'SP2' + RTRIM(CAST(i.addlink_id AS varchar(16)))
		FROM addlink al
		JOIN inserted i ON al.addlink_id = i.addlink_id
		WHERE i.importp2 IS NULL
			  OR LEN(i.importp2) = 0

		UPDATE addlink
			SET importfax = 'SFAX' + RTRIM(CAST(i.addlink_id AS varchar(16)))
		FROM addlink al
		JOIN inserted i ON al.addlink_id = i.addlink_id
		WHERE i.importfax IS NULL
			  OR LEN(i.importfax) = 0

GO

DROP TRIGGER address_last_mod_D
GO
CREATE TRIGGER [dbo].[address_last_mod_D] ON [dbo].[address]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'address'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(address_id AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER address_last_mod_IU
GO
CREATE TRIGGER [dbo].[address_last_mod_IU] ON [dbo].[address]
FOR INSERT,UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'address'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET address = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM address a JOIN inserted i ON a.address_id = i.address_id
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

return ;   -- Disabled post processing below this point. Reverted back to post processing in middleware.

/* Create the gst_actv log records for "Modify" guest address. */
declare @CountDel        int,
        @xmlInserted     varchar(max),
        @xmlDeleted      varchar(max),
        @xmlChanges      varchar(max),
        @xmlChangeAppend varchar(max),
        @xmlCurrentState varchar(max),
        @cSQL            varchar(8000),
        @Activ_id        numeric(17,0),
        @Site_no         int,
        @Guest_no        numeric(17,0),
        @operator        char(6),
        @salespoint      char(6),
        @mod_op          char(6),
        @mod_sp          char(6),
        @cGuest_no       varchar(16),
        @Activ_type      int,
        @Tag_line        varchar(80),
        @Date_time       datetime,
        @Op              char(6),
        @Sp              char(6),
        @CRLF            char(2),
        @TAB             char(1) ;


set @CRLF  = char(13) + char(10) ;
set @TAB   = char(9) ;

select @CountDel = COUNT(*) from Deleted ;
if not(@CountIns = 1 and @CountDel = 1) return ;     -- make a log entry only when updating a single row, not bulk operations.

set @xmlInserted  = (select top 1 a.*
                     from address a
                     join Inserted i on i.address_id = a.address_id
                     for xml path(''), elements absent) ;
if @CountDel = 0
  -- inserting a row, no <Changes> tag to build
  set @xmlChanges  = '' ;
else
  begin
    -- Must manually select specific columns instead of "*" because text/image columns not available in Deleted cursor
    set @xmlDeleted  = (select top 1 address_id, cluster, guest_no, address, address2, city, state, zip, country, cntry_cod, area_code,
                                     phone, phone_ext, cntry_cod2, area_cod2, phone2, phone2_ext, fax_ccode, fax_acode, fax_phone,
                                     fax_ext, company, operator, salespoint, date_time, last_mod, addr_type, mod_op, mod_sp
                        from Deleted
                        for xml path(''), elements absent) ;

    -- Inspect the text/image columns and add to the "changes to append" variable
    set @xmlChangeAppend = ''

    set @xmlChanges   = dbo.siriusfn_LogChangesToXML(@xmlInserted, @xmlDeleted, @xmlChangeAppend, 'address') ;
  end
set @xmlCurrentState   = dbo.siriusfn_LogCurrentStateToXML(@xmlInserted, 'address') ;

select top 1 @Guest_no    = i.guest_no,
             @operator    = i.operator,
             @salespoint  = i.salespoint,
             @mod_op      = i.mod_op,
             @mod_sp      = i.mod_sp
from Inserted i ;

set @Activ_type      = 2 ;
set @Tag_line        = case when @CountDel = 0 then 'New ' else 'Modify ' end + 'Guest Address' ;
set @cGuest_no       = rtrim(cast(@Guest_no as char(16))) ;
set @Op              = case when datalength(rtrim(@mod_op)) > 0 then @mod_op else @operator end ;
set @Sp              = case when datalength(rtrim(@mod_sp)) > 0 then @mod_sp else @salespoint end ;
set @Date_time       = getdate() ;

select top 1 @Site_no = site_no from prefs ;
execute dbo.siriussp_get_unique_key2 'K_GST_ACTV' , @NumberOut = @Activ_id output;
if @Activ_id = 0
  begin
    raiserror('Cannot fetch a new activity log primary key value.',16,1) ;
    return ;
  end
set  @Activ_id = @Activ_id * 1000000 + @Site_no ;

set @xmlCurrentState = @xmlChanges + @xmlCurrentState ;
execute dbo.siriussp_CreateGuestActivityRecord
          @ActivID     = @Activ_id ,
          @GuestNo     = @Guest_no ,
          @SiteNo      = @Site_no ,
          @ActivType   = @Activ_type ,
          @TagLine     = @Tag_line ,
          @RefNo       = @cGuest_no ,
          @Details     = @xmlCurrentState ,
          @Dt          = @Date_time ,
          @Person      = @Op ,
          @Location    = @Sp ;
GO

DROP TRIGGER baselodg_last_mod_D
GO
CREATE TRIGGER [dbo].[baselodg_last_mod_D] ON [dbo].[baselodg]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'baselodg'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(pri_key AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER baselodg_last_mod_IU
GO
CREATE TRIGGER [dbo].[baselodg_last_mod_IU] ON [dbo].[baselodg]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'baselodg'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET baselodg = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM baselodg a JOIN inserted i ON a.pri_key = i.pri_key
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER blackout_last_mod_D
GO
CREATE TRIGGER [dbo].[blackout_last_mod_D] ON [dbo].[blackout]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'blackout'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(blackoutid AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER blackout_last_mod_IU
GO
CREATE TRIGGER [dbo].[blackout_last_mod_IU] ON [dbo].[blackout]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'blackout'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET blackout = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM blackout a JOIN inserted i ON a.blackoutid = i.blackoutid
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER callocat_last_mod_D
GO
CREATE TRIGGER [dbo].[callocat_last_mod_D] ON [dbo].[callocat]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'callocat'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(callocatid AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER callocat_last_mod_IU
GO
CREATE TRIGGER [dbo].[callocat_last_mod_IU] ON [dbo].[callocat]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'callocat'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET callocat = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM callocat a JOIN inserted i ON a.callocatid = i.callocatid
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER calsched_last_mod_D
GO
CREATE TRIGGER [dbo].[calsched_last_mod_D] ON [dbo].[calsched]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'calsched'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(calschedid AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER calsched_last_mod_IU
GO
CREATE TRIGGER [dbo].[calsched_last_mod_IU] ON [dbo].[calsched]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'calsched'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET calsched = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM calsched a JOIN inserted i ON a.calschedid = i.calschedid
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER calsitem_last_mod_D
GO
CREATE TRIGGER [dbo].[calsitem_last_mod_D] ON [dbo].[calsitem]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'calsitem'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(calsitemid AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER calsitem_last_mod_IU
GO
CREATE TRIGGER [dbo].[calsitem_last_mod_IU] ON [dbo].[calsitem]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'calsitem'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET calsitem = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM calsitem a JOIN inserted i ON a.calsitemid = i.calsitemid
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER card_act_last_mod_D
GO
CREATE TRIGGER [dbo].[card_act_last_mod_D] ON [dbo].[card_act]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'card_act'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(pri_key AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER card_act_last_mod_IU
GO
CREATE TRIGGER [dbo].[card_act_last_mod_IU] ON [dbo].[card_act]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'card_act'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET card_act = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM card_act a JOIN inserted i ON a.pri_key = i.pri_key
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER category_last_mod_D
GO
CREATE TRIGGER [dbo].[category_last_mod_D] ON [dbo].[category]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'category'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, department+category AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER category_last_mod_IU
GO
CREATE TRIGGER [dbo].[category_last_mod_IU] ON [dbo].[category]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int,
        @lckmax4sale    bit,
        @lOldckmax4sale bit

SET NOCOUNT ON
SET @cTableName = 'category'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET category = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM category a JOIN inserted i ON a.department = i.department and a.category = i.category
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

/*  Remove any record in the deletes table if this key was inserted back in  */
		DELETE FROM deletes WHERE tablename = @cTableName AND key_val IN
		(SELECT department+category FROM Inserted WHERE department+category NOT IN (SELECT department+category FROM Deleted))


/* The rest of the trigger is to determine if the chkMax4Sale value changed.
   If so, need to kill the Max4SaleCounts table  */

/*  Quit now if nothing to process (i.e. insert) */
if @CountIns = 0 or not exists (select 1 from deleted) return ;

/* If batch updated more than one items row (this should never happen), just kill
   the counts table and let calls to the GetQtyRemaining sproc rebuild it as needed  */
if @CountIns > 1
begin
	truncate table Max4SaleCounts ;
	return ;
end

/* Get the old and new values */
select top 1 @lckmax4sale     = N.ckmax4sale,
             @lOldckmax4sale  = O.ckmax4sale
from Inserted N
inner join Deleted O on N.department = O.department and N.category = O.category

/* If the chkMax4Sale value changed, kill the Max4SaleCounts table  */
if @lckmax4sale <> @lOldckmax4sale
begin
	truncate table Max4SaleCounts ;
end

GO

DROP TRIGGER compprsn_last_mod_D
GO
CREATE TRIGGER [dbo].[compprsn_last_mod_D] ON [dbo].[compprsn]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'compprsn'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(person_no AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER compprsn_last_mod_IU
GO
CREATE TRIGGER [dbo].[compprsn_last_mod_IU] ON [dbo].[compprsn]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'compprsn'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET compprsn = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM compprsn a JOIN inserted i ON a.person_no = i.person_no
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER compreas_last_mod_D
GO
CREATE TRIGGER [dbo].[compreas_last_mod_D] ON [dbo].[compreas]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'compreas'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(reason_no AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER compreas_last_mod_IU
GO
CREATE TRIGGER [dbo].[compreas_last_mod_IU] ON [dbo].[compreas]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'compreas'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET compreas = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM compreas a JOIN inserted i ON a.reason_no = i.reason_no
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER dailycod_last_mod_D
GO
CREATE TRIGGER [dbo].[dailycod_last_mod_D] ON [dbo].[dailycod]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'dailycod'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, month_day AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER dailycod_last_mod_IU
GO
CREATE TRIGGER [dbo].[dailycod_last_mod_IU] ON [dbo].[dailycod]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'dailycod'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET dailycod = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM dailycod a JOIN inserted i ON a.month_day = i.month_day
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

/*  Remove any record in the deletes table if this key was inserted back in  */
		DELETE FROM deletes WHERE tablename = @cTableName AND key_val IN
		(SELECT month_day FROM Inserted WHERE month_day NOT IN (SELECT month_day FROM Deleted))

GO

DROP TRIGGER dci_kits_last_mod_D
GO
CREATE TRIGGER [dbo].[dci_kits_last_mod_D] ON [dbo].[dci_kits]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'dci_kits'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, source_d+source_c+source_i+kit_d+kit_c+kit_i AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER dci_kits_last_mod_IU
GO
CREATE TRIGGER [dbo].[dci_kits_last_mod_IU] ON [dbo].[dci_kits]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'dci_kits'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET dci_kits = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM dci_kits a JOIN inserted i ON a.source_d+a.source_c+a.source_i+a.kit_d+a.kit_c+a.kit_i = i.source_d+i.source_c+i.source_i+i.kit_d+i.kit_c+i.kit_i
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

/*  Remove any record in the deletes table if this key was inserted back in  */
		DELETE FROM deletes WHERE tablename = @cTableName AND key_val IN
		(SELECT source_d+source_c+source_i+kit_d+kit_c+kit_i FROM Inserted WHERE source_d+source_c+source_i+kit_d+kit_c+kit_i NOT IN (SELECT source_d+source_c+source_i+kit_d+kit_c+kit_i FROM Deleted))

GO

DROP TRIGGER dci_liab_last_mod_D
GO
CREATE TRIGGER [dbo].[dci_liab_last_mod_D] ON [dbo].[dci_liab]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'dci_liab'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(pri_key AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER dci_liab_last_mod_IU
GO
CREATE TRIGGER [dbo].[dci_liab_last_mod_IU] ON [dbo].[dci_liab]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'dci_liab'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET dci_liab = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM dci_liab a JOIN inserted i ON a.pri_key = i.pri_key
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER dci_mods_last_mod_D
GO
CREATE TRIGGER [dbo].[dci_mods_last_mod_D] ON [dbo].[dci_mods]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'dci_mods'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, source_d+source_c+source_i+mod_d+mod_c+mod_i AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER dci_mods_last_mod_IU
GO
CREATE TRIGGER [dbo].[dci_mods_last_mod_IU] ON [dbo].[dci_mods]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'dci_mods'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET dci_mods = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM dci_mods a JOIN inserted i ON a.source_d+a.source_c+a.source_i+a.mod_d+a.mod_c+a.mod_i = i.source_d+i.source_c+i.source_i+i.mod_d+i.mod_c+i.mod_i
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

/*  Remove any record in the deletes table if this key was inserted back in  */
		DELETE FROM deletes WHERE tablename = @cTableName AND key_val IN
		(SELECT source_d+source_c+source_i+mod_d+mod_c+mod_i FROM Inserted WHERE source_d+source_c+source_i+mod_d+mod_c+mod_i NOT IN (SELECT source_d+source_c+source_i+mod_d+mod_c+mod_i FROM Deleted))

GO

DROP TRIGGER departme_last_mod_D
GO
CREATE TRIGGER [dbo].[departme_last_mod_D] ON [dbo].[departme]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'departme'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, department AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER departme_last_mod_IU
GO
CREATE TRIGGER [dbo].[departme_last_mod_IU] ON [dbo].[departme]
FOR INSERT, UPDATE
AS
DECLARE @CountIns       int,
        @cTableName     varchar(10),
        @nKeyVal        int,
        @lckmax4sale    bit,
        @lOldckmax4sale bit


SET NOCOUNT ON
SET @cTableName = 'departme'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET departme = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM departme a JOIN inserted i ON a.department = i.department
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

/*  Remove any record in the deletes table if this key was inserted back in  */
		DELETE FROM deletes WHERE tablename = @cTableName AND key_val IN
		(SELECT department FROM Inserted WHERE department NOT IN (SELECT department FROM Deleted))


/* The rest of the trigger is to determine if the chkMax4Sale value changed.
   If so, need to kill the Max4SaleCounts table  */

/*  Quit now if nothing to process (i.e. insert) */
if @CountIns = 0 or not exists (select 1 from deleted) return ;

/* If batch updated more than one items row (this should never happen), just kill
   the counts table and let calls to the GetQtyRemaining sproc rebuild it as needed  */
if @CountIns > 1
begin
	truncate table Max4SaleCounts ;
	return ;
end

/* Get the old and new values */
select top 1 @lckmax4sale     = N.ckmax4sale,
             @lOldckmax4sale  = O.ckmax4sale
from Inserted N
inner join Deleted O on N.department = O.department

/* If the chkMax4Sale value changed, kill the Max4SaleCounts table  */
if @lckmax4sale <> @lOldckmax4sale
begin
	truncate table Max4SaleCounts ;
end

GO

DROP TRIGGER dp_rules_last_mod_D
GO
CREATE TRIGGER [dbo].[dp_rules_last_mod_D] ON [dbo].[dp_rules]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'dp_rules'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(rule_id AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER dp_rules_last_mod_IU
GO
CREATE TRIGGER [dbo].[dp_rules_last_mod_IU] ON [dbo].[dp_rules]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'dp_rules'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET dp_rules = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM dp_rules a JOIN inserted i ON a.rule_id = i.rule_id
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER expndtxt_last_mod_D
GO
CREATE TRIGGER [dbo].[expndtxt_last_mod_D] ON [dbo].[expndtxt]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'expndtxt'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, code AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER expndtxt_last_mod_IU
GO
CREATE TRIGGER [dbo].[expndtxt_last_mod_IU] ON [dbo].[expndtxt]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'expndtxt'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET expndtxt = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM expndtxt a JOIN inserted i ON a.code = i.code
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

/*  Remove any record in the deletes table if this key was inserted back in  */
		DELETE FROM deletes WHERE tablename = @cTableName AND key_val IN
		(SELECT code FROM Inserted WHERE code NOT IN (SELECT code FROM Deleted))

GO

DROP TRIGGER gifttmpl_last_mod_D
GO
CREATE TRIGGER [dbo].[gifttmpl_last_mod_D] ON [dbo].[gifttmpl]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'gifttmpl'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, department+category+item AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER gifttmpl_last_mod_IU
GO
CREATE TRIGGER [dbo].[gifttmpl_last_mod_IU] ON [dbo].[gifttmpl]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'gifttmpl'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET gifttmpl = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM gifttmpl a JOIN inserted i ON a.department = i.department and a.category = i.category and a.item = i.item
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

/*  Remove any record in the deletes table if this key was inserted back in  */
		DELETE FROM deletes WHERE tablename = @cTableName AND key_val IN
		(SELECT department+category+item FROM Inserted WHERE department+category+item NOT IN (SELECT department+category+item FROM Deleted))

GO

DROP TRIGGER gst_actv_last_mod_D
GO
CREATE TRIGGER [dbo].[gst_actv_last_mod_D] ON [dbo].[gst_actv]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'gst_actv'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(activ_id AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER gst_actv_last_mod_IU
GO
CREATE TRIGGER [dbo].[gst_actv_last_mod_IU] ON [dbo].[gst_actv]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'gst_actv'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET gst_actv = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM gst_actv a JOIN inserted i ON a.activ_id = i.activ_id
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER gst_atmp_last_mod_D
GO
CREATE TRIGGER [dbo].[gst_atmp_last_mod_D] ON [dbo].[gst_atmp]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'gst_atmp'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(tmpl_id AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION


GO

DROP TRIGGER gst_atmp_last_mod_IU
GO
CREATE TRIGGER [dbo].[gst_atmp_last_mod_IU] ON [dbo].[gst_atmp]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'gst_atmp'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET gst_atmp = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM gst_atmp a JOIN inserted i ON a.tmpl_id = i.tmpl_id
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER gst_book_CreateLog_IU
GO
CREATE TRIGGER [dbo].[gst_book_CreateLog_IU] ON [dbo].[gst_book]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'gst_book'
SELECT @CountIns = COUNT(*) FROM Inserted

return ;   -- Disabled post processing below this point. Reverted back to post processing in middleware.

/* Create the gst_actv log records for "Modify Booking Prefs". */
declare @CountDel        int,
        @xmlInserted     varchar(max),
        @xmlDeleted      varchar(max),
        @xmlChanges      varchar(max),
        @xmlChangeAppend varchar(max),
        @xmlCurrentState varchar(max),
        @cSQL            varchar(8000),
        @Activ_id        numeric(17,0),
        @Site_no         int,
        @Guest_no        numeric(17,0),
        @operator        char(6),
        @salespoint      char(6),
        @mod_op          char(6),
        @mod_sp          char(6),
        @cGuest_no       varchar(16),
        @Activ_type      int,
        @Tag_line        varchar(80),
        @Date_time       datetime,
        @Op              char(6),
        @Sp              char(6),
        @CRLF            char(2),
        @TAB             char(1),
        @PriorActiv_id   numeric(17,0),
        @PriorChangeDT   datetime,
        @PriorChanged    varchar(max) ;


set @CRLF  = char(13) + char(10) ;
set @TAB   = char(9) ;

select @CountDel = COUNT(*) from Deleted ;
if @CountIns <> 1 return ;     -- make a log entry only when updating a single row, not bulk operations.

set @xmlInserted  = (select top 1 g.*
                     from gst_book g
                     join Inserted i on i.guest_no = g.guest_no
                     for xml path(''), elements absent) ;
if @CountDel = 0
  -- inserting a row, no <Changes> tag to build
  set @xmlChanges  = '' ;
else
  begin
    -- Must manually select specific columns instead of "*" because text/image columns not available in Deleted cursor
    set @xmlDeleted  = (select top 1 guest_no, prefers, sex, tch_level, snb_level, tele_level, misc_level, whichlevel, criteria1,
                                     criteria2, criteria3, criteria4, criteria5, criteria6, criteria7, experience, pref_lvl1,
                                     pref_lvl2, pref_lvl3, pref_lvl4, pref_lvl5, pref_lvl6, pref_lvl7, pref_lvl8, pref_lvl9,
                                     pref_lvl10, pref_lvl12, lsn_locatn, operator, salespoint, date_time, reqststate, base_id,
                                     pref_lvl11, mod_op, mod_sp
                        from Deleted
                        for xml path(''), elements absent) ;

    -- Inspect the text/image columns and add to the "changes to append" variable
    set @xmlChangeAppend = ''

    set @xmlChanges   = dbo.siriusfn_LogChangesToXML(@xmlInserted, @xmlDeleted, @xmlChangeAppend, 'gst_book') ;
  end
set @xmlCurrentState   = dbo.siriusfn_LogCurrentStateToXML(@xmlInserted, 'gst_book') ;

select top 1 @Guest_no    = i.guest_no,
             @operator    = i.operator,
             @salespoint  = i.salespoint,
             @mod_op      = i.mod_op,
             @mod_sp      = i.mod_sp
from Inserted i ;

set @Activ_type      = 20 ;
set @Tag_line        = 'Modify Booking Prefs' ;
set @cGuest_no       = rtrim(cast(@Guest_no as char(16))) ;
set @Op              = case when datalength(rtrim(@mod_op)) > 0 then @mod_op else @operator end ;
set @Sp              = case when datalength(rtrim(@mod_sp)) > 0 then @mod_sp else @salespoint end ;
set @Date_time       = getdate() ;

-- If there is already a Modify log record for this guest at this location in the last 5 seconds, update that log entry instead
set @PriorActiv_id = 0
set @PriorChanged  = ''
if @Activ_type = 20
begin
  select top 1 @PriorActiv_id  = lf.activ_id,
               @PriorChangeDT  = lf.date_time,
               @PriorChanged   = dbo.siriusfn_Parse('gst_book', dbo.siriusfn_Parse('Changed', lf.details))
             FROM gst_actv lf
            WHERE lf.guest_no       = @Guest_no and
                  lf.ref_no         = @cGuest_no and
                  lf.activ_type     = @Activ_type and
                  lf.Person         = @Op and
                  lf.Location       = @Sp and
                  datediff(second, COALESCE(lf.date_time, '20100101'), @Date_time) < 5   -- last entry within the last 5 seconds
            ORDER BY lf.date_time desc ;
end

if coalesce(@PriorActiv_id, 0) > 0
begin
  set @xmlChanges = '<Changed> ' + @CRLF + @TAB + '<gst_book>' + @CRLF +
                    dbo.siriusfn_Parse('gst_book', dbo.siriusfn_Parse('Changed', @xmlChanges)) +
                    coalesce(@PriorChanged, '') + @TAB + '</gst_book>' + @CRLF + '</Changed>'  + @CRLF + @CRLF ;
  set @xmlCurrentState = @xmlChanges + @xmlCurrentState ;
  update gst_actv set details = @xmlCurrentState, tag_line = @Tag_line where activ_id = @PriorActiv_id ;
end
else
begin
  select top 1 @Site_no = site_no from prefs ;
  execute dbo.siriussp_get_unique_key2 'K_GST_ACTV' , @NumberOut = @Activ_id output;
  if @Activ_id = 0
    begin
      raiserror('Cannot fetch a new activity log primary key value.',16,1) ;
      return ;
    end
  set  @Activ_id = @Activ_id * 1000000 + @Site_no ;

  set @xmlCurrentState = @xmlChanges + @xmlCurrentState ;
  execute dbo.siriussp_CreateGuestActivityRecord
            @ActivID     = @Activ_id ,
            @GuestNo     = @Guest_no ,
            @SiteNo      = @Site_no ,
            @ActivType   = @Activ_type ,
            @TagLine     = @Tag_line ,
            @RefNo       = @cGuest_no ,
            @Details     = @xmlCurrentState ,
            @Dt          = @Date_time ,
            @Person      = @Op ,
            @Location    = @Sp ;
end
GO

DROP TRIGGER gst_jrnl_last_mod_D
GO
CREATE TRIGGER [dbo].[gst_jrnl_last_mod_D] ON [dbo].[gst_jrnl]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'gst_jrnl'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(journl_id AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER gst_jrnl_last_mod_IU
GO
CREATE TRIGGER [dbo].[gst_jrnl_last_mod_IU] ON [dbo].[gst_jrnl]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'gst_jrnl'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET gst_jrnl = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM gst_jrnl a JOIN inserted i ON a.journl_id = i.journl_id
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER gst_pass_last_mod_D
GO
CREATE TRIGGER [dbo].[gst_pass_last_mod_D] ON [dbo].[gst_pass]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'gst_pass'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(pass_no AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER gst_pass_last_mod_IU
GO
CREATE TRIGGER [dbo].[gst_pass_last_mod_IU] ON [dbo].[gst_pass]
FOR INSERT, UPDATE
AS
DECLARE @CountIns int,
		@cTableName varchar(10),
		@nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'gst_pass'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET gst_pass = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

	SET @nKeyVal = @nKeyVal - 1
	UPDATE gp
		SET @nKeyVal = last_mod = @nKeyVal + 1
	FROM gst_pass gp JOIN inserted i ON gp.pass_no = i.pass_no
	IF @@ERROR != 0
		BEGIN
			RAISERROR('Cannot update the LAST_MOD value.',16,1)
			RETURN
		END

	UPDATE gp
		SET gp.importpass = 'SPAS' + RTRIM(CAST(i.pass_no AS varchar(16)))
	FROM gst_pass gp
	JOIN inserted i ON gp.pass_no = i.pass_no
	WHERE i.importpass IS NULL
		  OR LEN(i.importpass) = 0 ;

	UPDATE gp
		SET gp.cstrt_date = i.start_date
	FROM gst_pass gp
	JOIN inserted i ON gp.pass_no = i.pass_no
	WHERE i.cstrt_date IS NULL and i.start_date IS NOT NULL ;

return ;   -- Disabled post processing below this point. Reverted back to post processing in middleware.

/* ---------- Create the gst_actv log records for "New" and "Modify" guest. -------------- */
declare @CountDel        int,
        @xmlInserted     varchar(max),
        @xmlDeleted      varchar(max),
        @xmlChanges      varchar(max),
        @xmlChangeAppend varchar(max),
        @xmlCurrentState varchar(max),
        @cSQL            varchar(8000),
        @Activ_id        numeric(17,0),
        @Site_no         int,
        @guest_no        numeric(17,0),
        @pass_no         numeric(17,0),
        @department      char(10),
        @category        char(10),
        @item            char(10),
        @operator        char(6),
        @salespoint      char(6),
        @mod_op          char(6),
        @mod_sp          char(6),
        @cPass_no        varchar(16),
        @Activ_type      int,
        @Tag_line        varchar(80),
        @Date_time       datetime,
        @Op              char(6),
        @Sp              char(6),
        @CRLF            char(2),
        @TAB             char(1),
        @PriorActiv_id   numeric(17,0),
        @PriorChangeDT   datetime,
        @PriorChanged    varchar(max),
        @swipe_no        varchar(22),
        @trans_no        numeric(17,0),
        @points1         int,
        @points2         int,
        @amt_paid        money,
        @voided_for      varchar(15),
        @voided_by       varchar(6) ;

set @CRLF  = char(13) + char(10) ;
set @TAB   = char(9) ;

select @CountDel = COUNT(*) from Deleted ;
if @CountIns <> 1 return ;     -- make a log entry only when creating or updating a single row, not bulk operations.

set @xmlInserted  = (select top 1 g.*
                     from gst_pass g
                     join Inserted i on i.pass_no = g.pass_no
                     for xml path(''), elements absent) ;
if @CountDel = 0
  -- inserting a row, no <Changes> tag to build
  set @xmlChanges  = '' ;
else
  begin
    -- Must manually select specific columns instead of "*" because text/image columns not available in Deleted cursor
    set @xmlDeleted  = (select top 1 pass_no, guest_no, masterpass, swipe_no, addit_no, wtp_no, rfserial, additchar1, additchar2,
                                     addit_no2, addit_no3, val_parent, valprnttyp, last_use, printcount, start_date, expires,
                                     validcount, dis_count, total_uses, usesw_left, week_refr, usest_left, day_refr, points1, points2,
                                     money1, money2, blackout_s, blackout_e, warnings, voided_for, voided_by, shift_ends, trans_no,
                                     mastertran, department, category, item, amt_paid, account, operator, salespoint, date_time, totalcomp,
                                     invoice_no, crlimit, crlimit_dy, dw_active, splimit, splimit_dy, last_mod, card_id, bl_reason,
                                     importpass, level_chg, purch_chg, a_autodep1, a_autocat1, a_autoitm1, a_maxqty1, a_trklqty1, a_autodep2,
                                     a_autocat2, a_autoitm2, a_maxqty2, a_trklqty2, a_autodep3, a_autocat3, a_autoitm3, a_maxqty3, a_trklqty3,
                                     a_autodep4, a_autocat4, a_autoitm4, a_maxqty4, a_trklqty4, a_autodep5, a_autocat5, a_autoitm5, a_maxqty5,
                                     a_trklqty5, a_autodep6, a_autocat6, a_autoitm6, a_maxqty6, a_trklqty6, mod_op, mod_sp
                        from Deleted
                        for xml path(''), elements absent) ;

    -- Inspect the text/image columns and add to the "changes to append" variable
    set @xmlChangeAppend = ''
    if update (a_names)
      set @xmlChangeAppend = @xmlChangeAppend + @TAB + @TAB + '<a_names>(Not available)</a_names>' + @CRLF ;

    set @xmlChanges   = dbo.siriusfn_LogChangesToXML(@xmlInserted, @xmlDeleted, @xmlChangeAppend, 'gst_pass') ;
  end
set @xmlCurrentState   = dbo.siriusfn_LogCurrentStateToXML(@xmlInserted, 'gst_pass') ;

select top 1 @pass_no     = i.pass_no,
             @guest_no    = i.guest_no,
             @department  = i.department,
             @category    = i.category,
             @item        = i.item,
             @operator    = i.operator,
             @salespoint  = i.salespoint,
             @mod_op      = i.mod_op,
             @mod_sp      = i.mod_sp,
             @swipe_no    = i.swipe_no,
             @trans_no    = i.trans_no,
             @points1     = i.points1,
             @points2     = i.points2,
             @amt_paid    = i.amt_paid,
             @voided_for  = i.voided_for,
             @voided_by   = i.voided_by
from Inserted i ;

set @Activ_type      = case when @CountDel = 0 then 100 else 101 end ;
set @cPass_no        = rtrim(cast(@pass_no as char(16))) ;
set @Tag_line        = case when @CountDel = 0 then 'New ' else 'Modify ' end + 'Pass #' + rtrim(@cPass_no) + ' ' +
                       rtrim(@department) + ' ' + rtrim(@category) + ' ' + rtrim(@item);
set @Op              = case when datalength(rtrim(@mod_op)) > 0 then @mod_op else @operator end ;
set @Sp              = case when datalength(rtrim(@mod_sp)) > 0 then @mod_sp else @salespoint end ;
set @Date_time       = getdate() ;

-- If there is already a Modify log record for this guest at this location in the last 5 seconds, update that log entry instead
set @PriorActiv_id = 0
set @PriorChanged  = ''
if @Activ_type = 101
begin
  select top 1 @PriorActiv_id  = lf.activ_id,
               @PriorChangeDT  = lf.date_time,
               @PriorChanged   = dbo.siriusfn_Parse('gst_pass', dbo.siriusfn_Parse('Changed', lf.details))
             FROM gst_actv lf
            WHERE lf.guest_no       = @guest_no and
                  lf.ref_no         = @cPass_no and
                  lf.activ_type     = @Activ_type and
                  lf.Person         = @Op and
                  lf.Location       = @Sp and
                  datediff(second, COALESCE(lf.date_time, '20100101'), @Date_time) < 5   -- last entry within the last 5 seconds
            ORDER BY lf.date_time desc ;
end

if coalesce(@PriorActiv_id, 0) > 0
begin
  set @xmlChanges = '<Changed> ' + @CRLF + @TAB + '<gst_pass>' + @CRLF +
                    dbo.siriusfn_Parse('gst_pass', dbo.siriusfn_Parse('Changed', @xmlChanges)) +
                    coalesce(@PriorChanged, '') + @TAB + '</gst_pass>' + @CRLF + '</Changed>'  + @CRLF + @CRLF ;
  set @xmlCurrentState = @xmlChanges + @xmlCurrentState ;
  update gst_actv set details = @xmlCurrentState, tag_line = @Tag_line where activ_id = @PriorActiv_id ;
end
else
begin
  select top 1 @Site_no = site_no from prefs ;
  execute dbo.siriussp_get_unique_key2 'K_GST_ACTV' , @NumberOut = @Activ_id output;
  if @Activ_id = 0
    begin
      raiserror('Cannot fetch a new activity log primary key value.',16,1) ;
      return ;
    end
  set  @Activ_id = @Activ_id * 1000000 + @Site_no ;

  set @xmlCurrentState = @xmlChanges + @xmlCurrentState ;
  execute dbo.siriussp_CreateGuestActivityRecord
            @ActivID     = @Activ_id ,
            @GuestNo     = @guest_no ,
            @SiteNo      = @Site_no ,
            @ActivType   = @Activ_type ,
            @TagLine     = @Tag_line ,
            @RefNo       = @cPass_no ,
            @Details     = @xmlCurrentState ,
            @Dt          = @Date_time ,
            @Person      = @Op ,
            @Location    = @Sp ;
end

/* ------------ Update the links in the gst_card table if necessary ---------- */
declare @NewCard_num    varchar(19),
        @CardCard_num   varchar(19),
        @CardGuest_no   numeric(17,0),
        @CardCard_id    numeric(17,0)
if update(swipe_no) and datalength(rtrim(@swipe_no)) > 0
begin
  set @NewCard_num   = left(dbo.siriusfn_NumbersOnly(@swipe_no), 19) ;
  select top 1 @CardCard_id   = gc.card_id,
               @CardGuest_no  = gc.guest_no,
               @CardCard_num  = gc.card_num
  from gst_card gc
  where gc.card_num  = @NewCard_num ;

  if (@CardCard_id > 0 and rtrim(@CardCard_num) = rtrim(@NewCard_num) and @CardGuest_no = @guest_no)
  begin
    set @cTableName = 'gst_pass' ;  -- nothing to do, execute a bogus statement
  end
  else
  begin
    if @CardCard_id > 0 and rtrim(@CardCard_num) = rtrim(@NewCard_num) and @CardGuest_no <> @guest_no
    begin
      -- the card record already exists, but is assigned to another guest, re-assign that cardnum to the this guest
      update gst_card set guest_no = @guest_no where card_num = @NewCard_num ;
      update gst_pass set card_id = 0, swipe_no='' where swipe_no = @NewCard_num and guest_no = @CardGuest_no ;
      update gst_pass set card_id = @CardCard_id where pass_no = @pass_no ;
    end
    else
    begin
      -- no cardnum link exists, create a new gst_card record
      select top 1 @Site_no = site_no from prefs ;
      execute dbo.siriussp_get_unique_key2 'K_GST_CARD' , @NumberOut = @CardCard_id output;
      if @CardCard_id = 0
      begin
        raiserror('Cannot fetch a new gst_card primary key value.',16,1) ;
        return ;
      end
      set  @CardCard_id = @CardCard_id * 1000000 + @Site_no ;
      insert into gst_card (card_id, guest_no, card_num, date_time, person, location) values
                           (@CardCard_id, @guest_no, @NewCard_num, getdate(), @Op, @Sp) ;

      update gst_pass set card_id = @CardCard_id where pass_no = @pass_no ;
    end
  end
end


/* ---------------- On an insert, seed the unitvalu table with starting values if necessary ------------- */
declare @t_uvalue1      bit,
        @t_uvalue2      bit,
        @UV_id          numeric(17,0),
        @unit_value     money ;
if @CountDel = 0
begin
  select top 1 @t_uvalue1   = t_uvalue1,
               @t_uvalue2   = t_uvalue2
  from template
  where department = @department and category = @category and item = @item ;

  if @t_uvalue1 = 1
  begin
    select top 1 @Site_no = site_no from prefs ;
    execute dbo.siriussp_get_unique_key2 'K_UNITVALU' , @NumberOut = @UV_id output;
    if @UV_id = 0
    begin
      raiserror('Cannot fetch a new unitvalu primary key value.',16,1) ;
      return ;
    end
    set @UV_id = @UV_id * 1000000 + @Site_no ;

    if @points1 = 0
      set @unit_value = 0 ;
    else
      set @unit_value = round(@amt_paid / @points1, 4) ;

    insert into unitvalu (uv_id, pass_no, trans_no, oneortwo, units, unit_bal, amount, unit_value, operator, salespoint, date_time) values
                          (@UV_id, @pass_no, @trans_no, 1, @points1, @points1, @amt_paid, @unit_value, @Op, @Sp, getdate()) ;
  end

  if @t_uvalue2 = 1
  begin
    select top 1 @Site_no = site_no from prefs ;
    execute dbo.siriussp_get_unique_key2 'K_UNITVALU' , @NumberOut = @UV_id output;
    if @UV_id = 0
    begin
      raiserror('Cannot fetch a new unitvalu primary key value.',16,1) ;
      return ;
    end
    set @UV_id = @UV_id * 1000000 + @Site_no ;

    if @points2 = 0
      set @unit_value = 0 ;
    else
      set @unit_value = round(@amt_paid / @points2, 4) ;

    insert into unitvalu (uv_id, pass_no, trans_no, oneortwo, units, unit_bal, amount, unit_value, operator, salespoint, date_time) values
                          (@UV_id, @pass_no, @trans_no, 2, @points2, @points2, @amt_paid, @unit_value, @Op, @Sp, getdate()) ;
  end

end

/* ------------ On an update, have to void pass seats if this pass is voided ---------- */
if (update(voided_for) or update(voided_by)) and (datalength(rtrim(@voided_for)) > 0 or datalength(rtrim(@voided_by)) > 0)
begin
  execute dbo.siriussp_rsVoidPassSeats
            @pass_no     = @pass_no ,
            @Salespoint  = @Sp,
            @Operator    = @Op
end
GO

DROP TRIGGER gst_rent_last_mod_D
GO
CREATE TRIGGER [dbo].[gst_rent_last_mod_D] ON [dbo].[gst_rent]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'gst_rent'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(guest_no AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER gst_rent_last_mod_IU
GO
CREATE TRIGGER [dbo].[gst_rent_last_mod_IU] ON [dbo].[gst_rent]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'gst_rent'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET gst_rent = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM gst_rent a JOIN inserted i ON a.guest_no = i.guest_no
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

return ;   -- Disabled post processing below this point. Reverted back to post processing in middleware.

/* Create the gst_actv log records for "Modify Rental Prefs". */
declare @CountDel        int,
        @xmlInserted     varchar(max),
        @xmlDeleted      varchar(max),
        @xmlChanges      varchar(max),
        @xmlChangeAppend varchar(max),
        @xmlCurrentState varchar(max),
        @cSQL            varchar(8000),
        @Activ_id        numeric(17,0),
        @Site_no         int,
        @Guest_no        numeric(17,0),
        @first_name      varchar(15),
        @last_name       varchar(20),
        @operator        char(6),
        @salespoint      char(6),
        @mod_op          char(6),
        @mod_sp          char(6),
        @cGuest_no       varchar(16),
        @Activ_type      int,
        @Tag_line        varchar(80),
        @Date_time       datetime,
        @Op              char(6),
        @Sp              char(6),
        @CRLF            char(2),
        @TAB             char(1),
        @PriorActiv_id   numeric(17,0),
        @PriorChangeDT   datetime,
        @PriorChanged    varchar(max) ;


set @CRLF  = char(13) + char(10) ;
set @TAB   = char(9) ;

select @CountDel = COUNT(*) from Deleted ;
if @CountIns <> 1 return ;     -- make a log entry only when updating a single row, not bulk operations.

set @xmlInserted  = (select top 1 g.*
                     from gst_rent g
                     join Inserted i on i.guest_no = g.guest_no
                     for xml path(''), elements absent) ;
if @CountDel = 0
  -- inserting a row, no <Changes> tag to build
  set @xmlChanges  = '' ;
else
  begin
    -- Must manually select specific columns instead of "*" because text/image columns not available in Deleted cursor
    set @xmlDeleted  = (select top 1 guest_no, height, weight, height_m, weight_m, shoesize, shoewidth, type_skier, size_1,
                                     size_2, size_3, size_4, size_5, size_6, level_1, level_2, level_3, level_4, level_5,
                                     level_6, type_1, type_2, type_3, type_4, type_5, type_6, rentblock, stance, stnceangle,
                                     operator, salespoint, date_time, last_mod, stangle_r, stangle_l, last_use, mod_op, mod_sp
                        from Deleted
                        for xml path(''), elements absent) ;

    -- Inspect the text/image columns and add to the "changes to append" variable
    set @xmlChangeAppend = ''
    if update (message)
      set @xmlChangeAppend = @xmlChangeAppend + @TAB + @TAB + '<message>(Not available)</message>' + @CRLF ;
    if update (notes)
      set @xmlChangeAppend = @xmlChangeAppend + @TAB + @TAB + '<notes>(Not available)</notes>' + @CRLF ;

    set @xmlChanges   = dbo.siriusfn_LogChangesToXML(@xmlInserted, @xmlDeleted, @xmlChangeAppend, 'gst_rent') ;
  end
set @xmlCurrentState   = dbo.siriusfn_LogCurrentStateToXML(@xmlInserted, 'gst_rent') ;

select top 1 @Guest_no    = i.guest_no,
             @operator    = i.operator,
             @salespoint  = i.salespoint,
             @mod_op      = i.mod_op,
             @mod_sp      = i.mod_sp
from Inserted i ;

set @Activ_type      = 30 ;
set @Tag_line        = 'Modify Rental Prefs' ;
set @cGuest_no       = rtrim(cast(@Guest_no as char(16))) ;
set @Op              = case when datalength(rtrim(@mod_op)) > 0 then @mod_op else @operator end ;
set @Sp              = case when datalength(rtrim(@mod_sp)) > 0 then @mod_sp else @salespoint end ;
set @Date_time       = getdate() ;

-- If there is already a Modify log record for this guest at this location in the last 5 seconds, update that log entry instead
set @PriorActiv_id = 0
set @PriorChanged  = ''
if @Activ_type = 30
begin
  select top 1 @PriorActiv_id  = lf.activ_id,
               @PriorChangeDT  = lf.date_time,
               @PriorChanged   = dbo.siriusfn_Parse('gst_rent', dbo.siriusfn_Parse('Changed', lf.details))
             FROM gst_actv lf
            WHERE lf.guest_no       = @Guest_no and
                  lf.ref_no         = @cGuest_no and
                  lf.activ_type     = @Activ_type and
                  lf.Person         = @Op and
                  lf.Location       = @Sp and
                  datediff(second, COALESCE(lf.date_time, '20100101'), @Date_time) < 5   -- last entry within the last 5 seconds
            ORDER BY lf.date_time desc ;
end

if coalesce(@PriorActiv_id, 0) > 0
begin
  set @xmlChanges = '<Changed> ' + @CRLF + @TAB + '<gst_rent>' + @CRLF +
                    dbo.siriusfn_Parse('gst_rent', dbo.siriusfn_Parse('Changed', @xmlChanges)) +
                    coalesce(@PriorChanged, '') + @TAB + '</gst_rent>' + @CRLF + '</Changed>'  + @CRLF + @CRLF ;
  set @xmlCurrentState = @xmlChanges + @xmlCurrentState ;
  update gst_actv set details = @xmlCurrentState, tag_line = @Tag_line where activ_id = @PriorActiv_id ;
end
else
begin
  select top 1 @Site_no = site_no from prefs ;
  execute dbo.siriussp_get_unique_key2 'K_GST_ACTV' , @NumberOut = @Activ_id output;
  if @Activ_id = 0
    begin
      raiserror('Cannot fetch a new activity log primary key value.',16,1) ;
      return ;
    end
  set  @Activ_id = @Activ_id * 1000000 + @Site_no ;

  set @xmlCurrentState = @xmlChanges + @xmlCurrentState ;
  execute dbo.siriussp_CreateGuestActivityRecord
            @ActivID     = @Activ_id ,
            @GuestNo     = @Guest_no ,
            @SiteNo      = @Site_no ,
            @ActivType   = @Activ_type ,
            @TagLine     = @Tag_line ,
            @RefNo       = @cGuest_no ,
            @Details     = @xmlCurrentState ,
            @Dt          = @Date_time ,
            @Person      = @Op ,
            @Location    = @Sp ;
end
GO

DROP TRIGGER gst_rltn_last_mod_D
GO
CREATE TRIGGER [dbo].[gst_rltn_last_mod_D] ON [dbo].[gst_rltn]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'gst_rltn'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(pri_key AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER gst_rltn_last_mod_IU
GO
CREATE TRIGGER [dbo].[gst_rltn_last_mod_IU] ON [dbo].[gst_rltn]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'gst_rltn'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET gst_rltn = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM gst_rltn a JOIN inserted i ON a.pri_key = i.pri_key
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER guests_last_mod_D
GO
CREATE TRIGGER [dbo].[guests_last_mod_D] ON [dbo].[guests]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'guests'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(guest_no AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER guests_last_mod_IU
GO
CREATE TRIGGER [dbo].[guests_last_mod_IU] ON [dbo].[guests]
FOR INSERT, UPDATE
AS
DECLARE @CountIns int,
		@cTableName varchar(10),
		@cKeyVal numeric(17,0),
		@cweb_user varchar(100),
		@nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'guests'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET guests = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END
		SET @nKeyVal = @nKeyVal - 1
		UPDATE g
			SET @nKeyVal = last_mod = @nKeyVal + 1
		FROM guests g
		JOIN inserted i ON g.guest_no = i.guest_no
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the LAST_MOD value.',16,1)
				RETURN
			END

		UPDATE g
			SET importid = 'SIMP' + RTRIM(CAST(i.guest_no AS varchar(16)))
		FROM guests g
		JOIN inserted i ON g.guest_no = i.guest_no
		WHERE i.importid IS NULL
			  OR LEN(i.importid) = 0

		UPDATE g
			SET import2nd = 'S2ND' + RTRIM(CAST(i.guest_no AS varchar(16)))
		FROM guests g
		JOIN inserted i ON g.guest_no = i.guest_no
		WHERE i.import2nd IS NULL
			  OR LEN(i.import2nd) = 0

		UPDATE g
			SET importir = 'SIR' + RTRIM(CAST(i.guest_no AS varchar(16)))
		FROM guests g
		JOIN inserted i ON g.guest_no = i.guest_no
		WHERE i.importir IS NULL
			  OR LEN(i.importir) = 0

		UPDATE g
			SET importeml = 'SEML' + RTRIM(CAST(i.guest_no AS varchar(16)))
		FROM guests g
		JOIN inserted i ON g.guest_no = i.guest_no
		WHERE i.importeml IS NULL
			  OR LEN(i.importeml) = 0

/*  Make sure a non-empty web_user value is unique for INSERTs and UPDATEs (do this only for a single record INSERT/UPDATE such AS FROM SalesEZ) */
IF @CountIns = 1
	BEGIN
		SELECT @cKeyVal = guest_no, @cweb_user = web_user FROM inserted
		IF len(@cweb_user) > 0
		BEGIN
			IF exists (SELECT guest_no FROM guests WHERE web_user = @cweb_user and guest_no <> @cKeyVal)
			BEGIN
				RAISERROR('The web user name is not unique  Guest record not saved.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		END
	END

return ;   -- Disabled post processing below this point. Reverted back to post processing in middleware.

/* Create the gst_actv log records for "New" and "Modify" guest. */
declare @CountDel        int,
        @xmlInserted     varchar(max),
        @xmlDeleted      varchar(max),
        @xmlChanges      varchar(max),
        @xmlChangeAppend varchar(max),
        @xmlCurrentState varchar(max),
        @cSQL            varchar(8000),
        @Activ_id        numeric(17,0),
        @Site_no         int,
        @Guest_no        numeric(17,0),
        @first_name      varchar(15),
        @last_name       varchar(20),
        @operator        char(6),
        @salespoint      char(6),
        @mod_op          char(6),
        @mod_sp          char(6),
        @cGuest_no       varchar(16),
        @Activ_type      int,
        @Tag_line        varchar(80),
        @Date_time       datetime,
        @Op              char(6),
        @Sp              char(6),
        @CRLF            char(2),
        @TAB             char(1),
        @PriorActiv_id   numeric(17,0),
        @PriorChangeDT   datetime,
        @PriorChanged    varchar(max) ;


set @CRLF  = char(13) + char(10) ;
set @TAB   = char(9) ;

select @CountDel = COUNT(*) from Deleted ;
if @CountIns <> 1 return ;     -- make a log entry only when creating or updating a single row, not bulk operations.

set @xmlInserted  = (select top 1 g.*
                     from guests g
                     join Inserted i on i.guest_no = g.guest_no
                     for xml path(''), elements absent) ;
if @CountDel = 0
  -- inserting a row, no <Changes> tag to build
  set @xmlChanges  = '' ;
else
  begin
    -- Must manually select specific columns instead of "*" because text/image columns not available in Deleted cursor
    set @xmlDeleted  = (select top 1 guest_no, parent_no, addit_no, addit_no2, trans_no, guestgroup, salute, first_name, last_name,
                                     mid_name, suffix, e_mail, birth_date, gender, cc_swipe, cc_number, card_id, mug_date, check_bx1,
                                     check_bx2, check_bx3, check_bx4, check_bx5, check_bx6, check_bx7, check_bx8, check_bx9, check_bx10,
                                     check_bx11, check_bx12, check_bx13, check_bx14, check_bx15, number_1, number_2, number_3, number_4,
                                     number_5, text_1, text_2, text_3, text_4, text_5, text_6, text_7, text_8, ltext_1, ltext_2, ltext_3,
                                     ltext_4, ltext_5, date_1, datetime_1, web_user, importid, import2nd, importir, importeml, guest_2nd,
                                     salute2, firstname2, lastname2, midname2, suffix2, salespoint, operator, date_time, last_mod,
                                     gfwdstatus, guest_id, relation, role_no, acct_name, vipcode, height, weight, height_m, weight_m,
                                     no_mail, no_email, no_phone, addr_pref, mod_sp, mod_op
                        from Deleted
                        for xml path(''), elements absent) ;

    -- Inspect the text/image columns and add to the "changes to append" variable
    set @xmlChangeAppend = ''
    if update (mug_shot)
      set @xmlChangeAppend = @xmlChangeAppend + @TAB + @TAB + '<mug_shot>(Not available)</mug_shot>' + @CRLF ;
    if update (e_message)
      set @xmlChangeAppend = @xmlChangeAppend + @TAB + @TAB + '<e_message>(Not available)</e_message>' + @CRLF ;
    if update (notes)
      set @xmlChangeAppend = @xmlChangeAppend + @TAB + @TAB + '<notes>(Not available)</notes>' + @CRLF ;
    if update (memo_1)
      set @xmlChangeAppend = @xmlChangeAppend + @TAB + @TAB + '<memo_1>(Not available)</memo_1>' + @CRLF ;
    if update (memo_2)
      set @xmlChangeAppend = @xmlChangeAppend + @TAB + @TAB + '<memo_2>(Not available)</memo_2>' + @CRLF ;
    if update (memo_3)
      set @xmlChangeAppend = @xmlChangeAppend + @TAB + @TAB + '<memo_3>(Not available)</memo_3>' + @CRLF ;

    set @xmlChanges   = dbo.siriusfn_LogChangesToXML(@xmlInserted, @xmlDeleted, @xmlChangeAppend, 'guests') ;
  end
set @xmlCurrentState   = dbo.siriusfn_LogCurrentStateToXML(@xmlInserted, 'guests') ;

select top 1 @Guest_no    = i.guest_no,
             @first_name  = i.first_name,
             @last_name   = i.last_name,
             @operator    = i.operator,
             @salespoint  = i.salespoint,
             @mod_op      = i.mod_op,
             @mod_sp      = i.mod_sp
from Inserted i ;

set @Activ_type      = case when @CountDel = 0 then 1 else 2 end ;
set @Tag_line        = case when @CountDel = 0 then 'New ' else 'Modify ' end + 'Guest ' + rtrim(@first_name) + ' ' + rtrim(@last_name) ;
set @cGuest_no       = rtrim(cast(@Guest_no as char(16))) ;
set @Op              = case when datalength(rtrim(@mod_op)) > 0 then @mod_op else @operator end ;
set @Sp              = case when datalength(rtrim(@mod_sp)) > 0 then @mod_sp else @salespoint end ;
set @Date_time       = getdate() ;

-- If there is already a Modify log record for this guest at this location in the last 5 seconds, update that log entry instead
set @PriorActiv_id = 0
set @PriorChanged  = ''
if @Activ_type = 2
begin
  select top 1 @PriorActiv_id  = lf.activ_id,
               @PriorChangeDT  = lf.date_time,
               @PriorChanged   = dbo.siriusfn_Parse('guests', dbo.siriusfn_Parse('Changed', lf.details))
             FROM gst_actv lf
            WHERE lf.guest_no       = @Guest_no and
                  lf.ref_no         = @cGuest_no and
                  lf.activ_type     = @Activ_type and
                  lf.Person         = @Op and
                  lf.Location       = @Sp and
                  datediff(second, COALESCE(lf.date_time, '20100101'), @Date_time) < 5   -- last entry within the last 5 seconds
            ORDER BY lf.date_time desc ;
end

if coalesce(@PriorActiv_id, 0) > 0
begin
  set @xmlChanges = '<Changed> ' + @CRLF + @TAB + '<guests>' + @CRLF +
                    dbo.siriusfn_Parse('guests', dbo.siriusfn_Parse('Changed', @xmlChanges)) +
                    coalesce(@PriorChanged, '') + @TAB + '</guests>' + @CRLF + '</Changed>'  + @CRLF + @CRLF ;
  set @xmlCurrentState = @xmlChanges + @xmlCurrentState ;
  update gst_actv set details = @xmlCurrentState, tag_line = @Tag_line where activ_id = @PriorActiv_id ;
end
else
begin
  select top 1 @Site_no = site_no from prefs ;
  execute dbo.siriussp_get_unique_key2 'K_GST_ACTV' , @NumberOut = @Activ_id output;
  if @Activ_id = 0
    begin
      raiserror('Cannot fetch a new activity log primary key value.',16,1) ;
      return ;
    end
  set  @Activ_id = @Activ_id * 1000000 + @Site_no ;

  set @xmlCurrentState = @xmlChanges + @xmlCurrentState ;
  execute dbo.siriussp_CreateGuestActivityRecord
            @ActivID     = @Activ_id ,
            @GuestNo     = @Guest_no ,
            @SiteNo      = @Site_no ,
            @ActivType   = @Activ_type ,
            @TagLine     = @Tag_line ,
            @RefNo       = @cGuest_no ,
            @Details     = @xmlCurrentState ,
            @Dt          = @Date_time ,
            @Person      = @Op ,
            @Location    = @Sp ;
end

/* ------------ On an update, cascade change to guest name in other tables ---------- */
if @CountDel > 0 and (update(first_name) or update(last_name))
begin
  declare @oldFirst_name      varchar(15),
          @oldLast_name       varchar(20) ;

  select top 1 @oldFirst_name    = d.first_name,
               @oldLast_name     = d.last_name
  from Deleted d ;

  update resrvatn set first_name = @first_name, last_name = @last_name
  where guest_no = @Guest_no and first_name = @oldFirst_name and last_name = @oldLast_name ;

  update sh_save set first_name = @first_name, last_name = @last_name
  where guest_no = @Guest_no and first_name = @oldFirst_name and last_name = @oldLast_name ;

end
GO

DROP TRIGGER i_items_last_mod_D
GO
CREATE TRIGGER [dbo].[i_items_last_mod_D] ON [dbo].[i_items]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'i_items'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(invent_id AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER i_items_last_mod_IU
GO
CREATE TRIGGER [dbo].[i_items_last_mod_IU] ON [dbo].[i_items]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'i_items'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET i_items = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM i_items a JOIN inserted i ON a.invent_id = i.invent_id
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER i_mcode_last_mod_D
GO
CREATE TRIGGER [dbo].[i_mcode_last_mod_D] ON [dbo].[i_mcode]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'i_mcode'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(pri_key AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER i_mcode_last_mod_IU
GO
CREATE TRIGGER [dbo].[i_mcode_last_mod_IU] ON [dbo].[i_mcode]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'i_mcode'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET i_mcode = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM i_mcode a JOIN inserted i ON a.pri_key = i.pri_key
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER i_vendor_last_mod_D
GO
CREATE TRIGGER [dbo].[i_vendor_last_mod_D] ON [dbo].[i_vendor]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'i_vendor'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(vendor_id AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER i_vendor_last_mod_IU
GO
CREATE TRIGGER [dbo].[i_vendor_last_mod_IU] ON [dbo].[i_vendor]
FOR INSERT,UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'i_vendor'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET i_vendor = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM i_vendor a JOIN inserted i ON a.vendor_id = i.vendor_id
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER IHCxfer_last_mod_D
GO
CREATE TRIGGER [dbo].[IHCxfer_last_mod_D] ON [dbo].[IHCxfer]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'IHCxfer'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(pri_key AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER IHCxfer_last_mod_IU
GO
CREATE TRIGGER [dbo].[IHCxfer_last_mod_IU] ON [dbo].[IHCxfer]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'IHCxfer'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET IHCxfer = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM IHCxfer a JOIN inserted i ON a.pri_key = i.pri_key
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER invoices_last_mod_D
GO
CREATE TRIGGER [dbo].[invoices_last_mod_D] ON [dbo].[invoices]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'invoices'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(invoice_no AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER invoices_last_mod_IU
GO
CREATE TRIGGER [dbo].[invoices_last_mod_IU] ON [dbo].[invoices]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'invoices'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET invoices = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM invoices a JOIN inserted i ON a.invoice_no = i.invoice_no
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER itempics_last_mod_D
GO
CREATE TRIGGER [dbo].[itempics_last_mod_D] ON [dbo].[itempics]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'itempics'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, department+category+item AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER itempics_last_mod_IU
GO
CREATE TRIGGER [dbo].[itempics_last_mod_IU] ON [dbo].[itempics]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'itempics'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET itempics = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM itempics a JOIN inserted i ON a.department = i.department and a.category = i.category and a.item = i.item
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

/*  Remove any record in the deletes table if this key was inserted back in  */
		DELETE FROM deletes WHERE tablename = @cTableName AND key_val IN
		(SELECT department+category+item FROM Inserted WHERE department+category+item NOT IN (SELECT department+category+item FROM Deleted))

GO

DROP TRIGGER items_last_mod_D
GO
CREATE TRIGGER [dbo].[items_last_mod_D] ON dbo.items
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'items'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, department+category+item AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER itemtree_last_mod_D
GO
CREATE TRIGGER [dbo].[itemtree_last_mod_D] ON [dbo].[itemtree]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'itemtree'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(node_id AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER itemtree_last_mod_IU
GO
CREATE TRIGGER [dbo].[itemtree_last_mod_IU] ON [dbo].[itemtree]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'itemtree'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET itemtree = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM itemtree a JOIN inserted i ON a.node_id = i.node_id
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER l_forms_last_mod_D
GO
CREATE TRIGGER [dbo].[l_forms_last_mod_D] ON [dbo].[l_forms]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'l_forms'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(pri_key AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER l_forms_last_mod_IU
GO
CREATE TRIGGER [dbo].[l_forms_last_mod_IU] ON [dbo].[l_forms]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'l_forms'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET l_forms = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM l_forms a JOIN inserted i ON a.pri_key = i.pri_key
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER Language_last_mod_D
GO

create trigger [dbo].[Language_last_mod_D] ON [dbo].[Language]
for delete
as
declare @cTableName varchar(8)

set nocount on
set @cTableName = 'Language'
if not exists (select * from deleted) return;

/*  Add a record to the deletes table for DELETEs  */
begin transaction

   insert into deletes (tablename, key_val)
      select @cTableName as tablename, cast(LanguageID as varchar) as key_val
        from deleted

   update updates
      set deletes = isnull((select top 1 last_mod from deletes order by last_mod desc), 0)

   if @@ERROR != 0
      begin
         raiserror('Cannot update the DELETES value.' , 16 , 1)
         rollback transaction
         return
      end
commit transaction

GO

DROP TRIGGER Language_last_mod_IU
GO

create trigger [dbo].[Language_last_mod_IU] ON [dbo].[Language]
for insert, update
as
declare @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

set nocount on
set @cTableName = 'Language'
select @CountIns = count(*) from Inserted
if @CountIns = 0 return;

/*  Update the last_mod for INSERTs and UPDATEs  */
update sequence set @nKeyVal = next_val, next_val = next_val + @CountIns where name = @cTableName
if @nKeyVal is null
   begin
      set @nKeyVal = 1
      insert into sequence (name, next_val) values (@cTableName, @CountIns + 1)
   end

update updates set language = @nKeyVal + @CountIns - 1
if @@ERROR != 0
   begin
      raiserror('Cannot update the LAST_MOD value.', 16, 1)
      return
   end

set @nKeyVal = @nKeyVal - 1
update a set @nKeyVal = last_mod = @nKeyVal + 1 from Language a JOIN inserted i ON a.LanguageID = i.LanguageID
if @@ERROR != 0
   begin
      raiserror('Cannot update the LAST_MOD value.', 16, 1)
      return
   end

/*  Remove any record in the deletes table if this key was inserted back in  */
delete from deletes where tablename = @cTableName and key_val in
    (select left(LanguageID, 100) from Inserted where LanguageID not in (select LanguageID from Deleted))

GO

DROP TRIGGER layouts_last_mod_D
GO
CREATE TRIGGER [dbo].[layouts_last_mod_D] ON [dbo].[Layouts]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'layouts'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, layoutname AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER layouts_last_mod_IU
GO
CREATE TRIGGER [dbo].[layouts_last_mod_IU] ON [dbo].[Layouts]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'layouts'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET layouts = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM layouts a JOIN inserted i ON a.layoutname = i.layoutname
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

/*  Remove any record in the deletes table if this key was inserted back in  */
		DELETE FROM deletes WHERE tablename = @cTableName AND key_val IN
		(SELECT layoutname FROM Inserted WHERE layoutname NOT IN (SELECT layoutname FROM Deleted))

GO

DROP TRIGGER Licenses_last_mod_D
GO

CREATE TRIGGER [dbo].[Licenses_last_mod_D] ON [dbo].[Licenses]
FOR DELETE
AS
DECLARE @cTableName varchar(8);

SET NOCOUNT ON;

IF NOT EXISTS (
		SELECT *
		FROM deleted
		)
	RETURN;

SET @cTableName = 'Licenses'

/*  Add a record to the deletes table for DELETEs  */
BEGIN TRY
	BEGIN TRANSACTION

	INSERT INTO dbo.deletes (
		tablename
		,key_val
		)
	SELECT @cTableName AS tablename
		,cast(SettingID AS VARCHAR) AS key_val
	FROM deleted

	UPDATE dbo.updates
	SET deletes = isnull((
				SELECT TOP (1) last_mod
				FROM dbo.deletes
				ORDER BY last_mod DESC
				), 0)

	COMMIT TRANSACTION
END TRY

BEGIN CATCH
	IF @@TRANCOUNT > 0
		ROLLBACK TRANSACTION

	RAISERROR (
			'Cannot update the DELETES value.'
			,16
			,1
			)
END CATCH

GO

DROP TRIGGER Licenses_last_mod_IU
GO

CREATE TRIGGER [dbo].[Licenses_last_mod_IU] ON [dbo].[Licenses]
FOR INSERT
	,UPDATE
AS
DECLARE @CountIns INT
	,@cTableName varchar(10)
	,@nKeyVal INT;

SET NOCOUNT ON;
SET @cTableName = 'Licenses';

SELECT @CountIns = count(*)
FROM inserted;

IF @CountIns = 0
	RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
UPDATE dbo.sequence
SET @nKeyVal = next_val
	,next_val = next_val + @CountIns
WHERE NAME = @cTableName

IF @nKeyVal IS NULL
BEGIN
	SET @nKeyVal = 1

	INSERT INTO dbo.sequence (
		NAME
		,next_val
		)
	VALUES (
		@cTableName
		,@CountIns + 1
		)
END

UPDATE dbo.updates
SET Licenses = @nKeyVal + @CountIns - 1

IF @@error != 0
BEGIN
	RAISERROR (
			'Cannot update the Licenses value in Updates.'
			,16
			,1
			)

	RETURN
END

SET @nKeyVal = @nKeyVal - 1;

UPDATE s
SET @nKeyVal = last_mod = @nKeyVal + 1
FROM dbo.Licenses s
JOIN inserted i ON s.SettingID = i.SettingID

IF @@error != 0
BEGIN
	RAISERROR (
			'Cannot update the LAST_MOD value in Licenses.'
			,16
			,1
			);

	RETURN;
END

GO

DROP TRIGGER max4sale_last_mod_D
GO
CREATE TRIGGER [dbo].[max4sale_last_mod_D] ON [dbo].[max4sale]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'max4sale'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(id AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER max4sale_last_mod_IU
GO
CREATE TRIGGER [dbo].[max4sale_last_mod_IU] ON [dbo].[max4sale]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @CountDel   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'max4sale'
SELECT @CountIns = COUNT(*) FROM Inserted
SELECT @CountDel = COUNT(*) FROM Deleted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET max4sale = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM max4sale a JOIN inserted i ON a.id = i.id
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END


/*  On an update, kill any related Max4SaleCounts child rows for updated Max4Sale restrictions.
    Calls to GetQtyRemaining sproc will rebuild them. */
IF @CountDel <> 0
    delete from dbo.Max4SaleCounts
    from dbo.Max4SaleCounts as mc
    inner join Inserted as i on mc.Max4SaleID = i.id ;

return

GO

DROP TRIGGER meet_loc_last_mod_D
GO
CREATE TRIGGER [dbo].[meet_loc_last_mod_D] ON [dbo].[meet_loc]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'meet_loc'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(pri_key AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER meet_loc_last_mod_IU
GO
CREATE TRIGGER [dbo].[meet_loc_last_mod_IU] ON [dbo].[meet_loc]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'meet_loc'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET meet_loc = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM meet_loc a JOIN inserted i ON a.pri_key = i.pri_key
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER mktgcode_last_mod_D
GO
CREATE TRIGGER [dbo].[mktgcode_last_mod_D] ON [dbo].[mktgcode]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'mktgcode'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(pri_key AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER mktgcode_last_mod_IU
GO
CREATE TRIGGER [dbo].[mktgcode_last_mod_IU] ON [dbo].[mktgcode]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'mktgcode'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET mktgcode = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM mktgcode a JOIN inserted i ON a.pri_key = i.pri_key
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER operator_last_mod_D
GO
CREATE TRIGGER [dbo].[operator_last_mod_D] ON [dbo].[operator]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'operator'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, op_code AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER operator_last_mod_IU
GO
CREATE TRIGGER [dbo].[operator_last_mod_IU] ON [dbo].[operator]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'operator'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET operator = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM operator a JOIN inserted i ON a.op_code = i.op_code
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

/*  Remove any record in the deletes table if this key was inserted back in  */
		DELETE FROM deletes WHERE tablename = @cTableName AND key_val IN
		(SELECT op_code FROM Inserted WHERE op_code NOT IN (SELECT op_code FROM Deleted))

GO

DROP TRIGGER passlink_last_mod_D
GO
CREATE TRIGGER [dbo].[passlink_last_mod_D] ON [dbo].[passlink]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'passlink'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, pASs_d+pASs_c+pASs_i+item_d+item_c+item_i AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER passlink_last_mod_IU
GO
CREATE TRIGGER [dbo].[passlink_last_mod_IU] ON [dbo].[passlink]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'passlink'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET passlink = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM passlink a JOIN inserted i ON a.pASs_d = i.pASs_d and a.pASs_c = i.pASs_c and a.pASs_i = i.pASs_i and
                                                                                         a.item_d = i.item_d and a.item_c = i.item_c and a.item_i = i.item_i
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

/*  Remove any record in the deletes table if this key was inserted back in  */
		DELETE FROM deletes WHERE tablename = @cTableName AND key_val IN
		(SELECT pASs_d+pASs_c+pASs_i+item_d+item_c+item_i FROM Inserted WHERE pASs_d+pASs_c+pASs_i+item_d+item_c+item_i NOT IN (SELECT pASs_d+pASs_c+pASs_i+item_d+item_c+item_i FROM Deleted))

GO

DROP TRIGGER pkup_loc_last_mod_D
GO
CREATE TRIGGER [dbo].[pkup_loc_last_mod_D] ON [dbo].[pkup_loc]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'pkup_loc'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(pri_key AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER pkup_loc_last_mod_IU
GO
CREATE TRIGGER [dbo].[pkup_loc_last_mod_IU] ON [dbo].[pkup_loc]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'pkup_loc'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET pkup_loc = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM pkup_loc a JOIN inserted i ON a.pri_key = i.pri_key
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER pmt_type_last_mod_D
GO
CREATE TRIGGER [dbo].[pmt_type_last_mod_D] ON [dbo].[pmt_type]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'pmt_type'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(pmtype_no AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER pmt_type_last_mod_IU
GO
CREATE TRIGGER [dbo].[pmt_type_last_mod_IU] ON [dbo].[pmt_type]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'pmt_type'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET pmt_type = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM pmt_type a JOIN inserted i ON a.pmtype_no = i.pmtype_no
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER pp_rules_last_mod_D
GO
CREATE TRIGGER [dbo].[pp_rules_last_mod_D] ON [dbo].[pp_rules]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'pp_rules'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(pprule_id AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER pp_rules_last_mod_IU
GO
CREATE TRIGGER [dbo].[pp_rules_last_mod_IU] ON [dbo].[pp_rules]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'pp_rules'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET pp_rules = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM pp_rules a JOIN inserted i ON a.pprule_id = i.pprule_id
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER prefix_last_mod_D
GO
CREATE TRIGGER [dbo].[prefix_last_mod_D] ON [dbo].[prefix]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'prefix'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, prefix AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER prefix_last_mod_IU
GO
CREATE TRIGGER [dbo].[prefix_last_mod_IU] ON [dbo].[prefix]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'prefix'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET prefix = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM prefix a JOIN inserted i ON a.prefix = i.prefix
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

/*  Remove any record in the deletes table if this key was inserted back in  */
		DELETE FROM deletes WHERE tablename = @cTableName AND key_val IN
		(SELECT prefix FROM Inserted WHERE prefix NOT IN (SELECT prefix FROM Deleted))

GO

DROP TRIGGER prefs_ac_last_mod_IU
GO
CREATE TRIGGER [dbo].[prefs_ac_last_mod_IU] ON [dbo].[prefs_ac]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'prefs_ac'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET prefs_ac = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM prefs_ac a JOIN inserted i ON a.pri_key = i.pri_key
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER prefs_bk_last_mod_IU
GO
CREATE TRIGGER [dbo].[prefs_bk_last_mod_IU] ON [dbo].[prefs_bk]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'prefs_bk'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET prefs_bk = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM prefs_bk a JOIN inserted i ON a.pri_key = i.pri_key
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER prefs_cc_last_mod_IU
GO
CREATE TRIGGER [dbo].[prefs_cc_last_mod_IU] ON [dbo].[prefs_cc]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'prefs_cc'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET prefs_cc = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM prefs_cc a JOIN inserted i ON a.pri_key = i.pri_key
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER prefs_gs_last_mod_IU
GO
CREATE TRIGGER [dbo].[prefs_gs_last_mod_IU] ON [dbo].[prefs_gs]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'prefs_gs'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET prefs_gs = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM prefs_gs a JOIN inserted i ON a.pri_key = i.pri_key
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER prefs_last_mod_IU
GO
CREATE TRIGGER [dbo].[prefs_last_mod_IU] ON [dbo].[prefs]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'prefs'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET prefs = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM prefs a JOIN inserted i ON a.pri_key = i.pri_key
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER prefs_rl_last_mod_IU
GO
CREATE TRIGGER [dbo].[prefs_rl_last_mod_IU] ON [dbo].[prefs_rl]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'prefs_rl'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET prefs_rl = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM prefs_rl a JOIN inserted i ON a.pri_key = i.pri_key
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER prefs_rt_last_mod_IU
GO
CREATE TRIGGER [dbo].[prefs_rt_last_mod_IU] ON [dbo].[prefs_rt]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'prefs_rt'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET prefs_rt = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM prefs_rt a JOIN inserted i ON a.pri_key = i.pri_key
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER prefs_rz_last_mod_IU
GO
CREATE TRIGGER [dbo].[prefs_rz_last_mod_IU] ON [dbo].[prefs_rz]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'prefs_rz'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET prefs_rz = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM prefs_rz a JOIN inserted i ON a.pri_key = i.pri_key
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER prefs_sl_last_mod_IU
GO
CREATE TRIGGER [dbo].[prefs_sl_last_mod_IU] ON [dbo].[prefs_sl]
FOR INSERT, UPDATE
AS
DECLARE @CountIns       int,
        @CountDel       int,
        @cTableName     varchar(10),
        @nKeyVal        int,
        @nMax4Saved     tinyint,
        @lUseCounts     bit,
        @nOldMax4Saved  tinyint,
        @lOldUseCounts  bit

SET NOCOUNT ON
SET @cTableName = 'prefs_sl'
SELECT @CountIns = count(*) FROM Inserted
select @CountDel = count(*) from Deleted ;
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
IF @nKeyVal IS NULL
BEGIN
   SET @nKeyVal = 1
   INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
END

UPDATE updates SET prefs_sl = @nKeyVal + @CountIns - 1
IF @@ERROR != 0
BEGIN
   RAISERROR('Cannot update the LAST_MOD value.',16,1)
   RETURN
END

SET @nKeyVal = @nKeyVal - 1
UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM prefs_sl a JOIN inserted i ON a.pri_key = i.pri_key
IF @@ERROR != 0
BEGIN
   RAISERROR('Cannot update the LAST_MOD value.',16,1)
   RETURN
END

/* The rest of the trigger is to determine if the Max4Saved or UseCounts values changed.
   If so, need to kill the Max4SaleCounts and Pts4SaleCounts tables  */

/*  Quit now if nothing to process (i.e. insert) */
if @CountIns = 0 or @CountDel = 0 return ;

/* If batch updated more than one prefs_sl row (this should never happen), just kill
   the counts table and let calls to the GetQtyRemaining sproc rebuild it as needed  */
if @CountIns > 1 or @CountDel > 1
begin
	truncate table Max4SaleCounts ;
	truncate table Pts4SaleCounts ;
	return ;
end

/* Get the old and new values */
select top 1 @nMax4Saved     = N.Max4_Saved,
             @lUseCounts     = N.UseCounts,
             @nOldMax4Saved  = O.Max4_Saved,
             @lOldUseCounts  = O.UseCounts
from Inserted N
inner join Deleted O on N.pri_key = O.pri_key

/* If the Max4Saved or UseCounts values changed.  If so, kill the Max4SaleCounts table  */
if @nMax4Saved <> @nOldMax4Saved or @lUseCounts <> @lOldUseCounts
begin
	truncate table Max4SaleCounts ;
	truncate table Pts4SaleCounts ;
	return ;
end

/* For extra performance, disable the transact/tr_save triggers if triggered counts switch is changed */
if @CountDel > 0 and @lUseCounts <> @lOldUseCounts
begin
	set transaction isolation level read committed ;
	if @lUseCounts = 0
	begin
		alter table transact disable trigger transact_Max4SaleCount_D ;
		alter table transact disable trigger transact_Max4SaleCount_I ;
		alter table transact disable trigger transact_Max4SaleCount_U ;
		alter table transact disable trigger transact_Pts4SaleCount_D ;
		alter table transact disable trigger transact_Pts4SaleCount_I ;
		alter table transact disable trigger transact_Pts4SaleCount_U ;
		alter table tr_save  disable trigger tr_save_Max4SaleCount_D ;
		alter table tr_save  disable trigger tr_save_Max4SaleCount_I ;
		alter table tr_save  disable trigger tr_save_Max4SaleCount_U ;
		alter table tr_save  disable trigger tr_save_Pts4SaleCount_D ;
		alter table tr_save  disable trigger tr_save_Pts4SaleCount_I ;
		alter table tr_save  disable trigger tr_save_Pts4SaleCount_U ;
	end
	else
	begin
		alter table transact enable trigger transact_Max4SaleCount_D ;
		alter table transact enable trigger transact_Max4SaleCount_I ;
		alter table transact enable trigger transact_Max4SaleCount_U ;
		alter table transact enable trigger transact_Pts4SaleCount_D ;
		alter table transact enable trigger transact_Pts4SaleCount_I ;
		alter table transact enable trigger transact_Pts4SaleCount_U ;
		alter table tr_save  enable trigger tr_save_Max4SaleCount_D ;
		alter table tr_save  enable trigger tr_save_Max4SaleCount_I ;
		alter table tr_save  enable trigger tr_save_Max4SaleCount_U ;
		alter table tr_save  enable trigger tr_save_Pts4SaleCount_D ;
		alter table tr_save  enable trigger tr_save_Pts4SaleCount_I ;
		alter table tr_save  enable trigger tr_save_Pts4SaleCount_U ;
	end
	set transaction isolation level read uncommitted ;
end
return ;

GO

DROP TRIGGER printers_last_mod_D
GO
CREATE TRIGGER [dbo].[printers_last_mod_D] ON [dbo].[printers]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'printers'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(pri_key AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER printers_last_mod_IU
GO
CREATE TRIGGER [dbo].[printers_last_mod_IU] ON [dbo].[printers]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'printers'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET printers = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM printers a JOIN inserted i ON a.pri_key = i.pri_key
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER prof_ctr_last_mod_D
GO
CREATE TRIGGER [dbo].[prof_ctr_last_mod_D] ON [dbo].[prof_ctr]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'prof_ctr'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(pr_ctr_no AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER prof_ctr_last_mod_IU
GO
CREATE TRIGGER [dbo].[prof_ctr_last_mod_IU] ON [dbo].[prof_ctr]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'prof_ctr'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET prof_ctr = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM prof_ctr a JOIN inserted i ON a.pr_ctr_no = i.pr_ctr_no
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER pts4sale_IU
GO
CREATE TRIGGER [dbo].[pts4sale_IU] ON [dbo].[pts4sale]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @CountDel   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'pts4sale'
SELECT @CountIns = COUNT(*) FROM Inserted
SELECT @CountDel = COUNT(*) FROM Deleted
IF @CountIns = 0 RETURN;

/*  On an update, kill any related Pts4SaleCounts child rows for updated Pts4Sale restrictions.
    Calls to GetQtyRemaining sproc will rebuild them. */
IF @CountDel <> 0
    delete from dbo.Pts4SaleCounts
    from dbo.Pts4SaleCounts as mc
    inner join Inserted as i on mc.Pts4SaleID = i.Pts4SaleID ;

return

GO

DROP TRIGGER r_bindng_last_mod_D
GO
CREATE TRIGGER [dbo].[r_bindng_last_mod_D] ON [dbo].[r_bindng]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'r_bindng'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(pri_key AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER r_bindng_last_mod_IU
GO
CREATE TRIGGER [dbo].[r_bindng_last_mod_IU] ON [dbo].[r_bindng]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'r_bindng'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET r_bindng = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM r_bindng a JOIN inserted i ON a.pri_key = i.pri_key
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER r_bmodel_last_mod_D
GO
CREATE TRIGGER [dbo].[r_bmodel_last_mod_D] ON [dbo].[r_bmodel]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'r_bmodel'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(pri_key AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER r_bmodel_last_mod_IU
GO
CREATE TRIGGER [dbo].[r_bmodel_last_mod_IU] ON [dbo].[r_bmodel]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'r_bmodel'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET r_bmodel = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM r_bmodel a JOIN inserted i ON a.pri_key = i.pri_key
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER r_entals_last_mod_D
GO
CREATE TRIGGER [dbo].[r_entals_last_mod_D] ON [dbo].[r_entals]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'r_entals'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(track_no AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER r_entals_last_mod_IU
GO
CREATE TRIGGER [dbo].[r_entals_last_mod_IU] ON [dbo].[r_entals]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'r_entals'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET r_entals = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM r_entals a JOIN inserted i ON a.track_no = i.track_no
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER r_eqpmfg_last_mod_D
GO
CREATE TRIGGER [dbo].[r_eqpmfg_last_mod_D] ON [dbo].[r_eqpmfg]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'r_eqpmfg'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(reqpmfg_id AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER r_eqpmfg_last_mod_IU
GO
CREATE TRIGGER [dbo].[r_eqpmfg_last_mod_IU] ON [dbo].[r_eqpmfg]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'r_eqpmfg'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET r_eqpmfg = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM r_eqpmfg a JOIN inserted i ON a.reqpmfg_id = i.reqpmfg_id
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER r_eqpmod_last_mod_D
GO
CREATE TRIGGER [dbo].[r_eqpmod_last_mod_D] ON [dbo].[r_eqpmod]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'r_eqpmod'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(reqpmod_id AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER r_eqpmod_last_mod_IU
GO
CREATE TRIGGER [dbo].[r_eqpmod_last_mod_IU] ON [dbo].[r_eqpmod]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'r_eqpmod'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET r_eqpmod = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM r_eqpmod a JOIN inserted i ON a.reqpmod_id = i.reqpmod_id
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER r_header_last_mod_D
GO
CREATE TRIGGER [dbo].[r_header_last_mod_D] ON [dbo].[r_header]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'r_header'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(rental_no AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER r_header_last_mod_IU
GO
CREATE TRIGGER [dbo].[r_header_last_mod_IU] ON [dbo].[r_header]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'r_header'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET r_header = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM r_header a JOIN inserted i ON a.rental_no = i.rental_no
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER r_hist_last_mod_D
GO
CREATE TRIGGER [dbo].[r_hist_last_mod_D] ON [dbo].[r_hist]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'r_hist'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(track_no AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER r_hist_last_mod_IU
GO
CREATE TRIGGER [dbo].[r_hist_last_mod_IU] ON [dbo].[r_hist]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'r_hist'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET r_hist = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM r_hist a JOIN inserted i ON a.track_no = i.track_no
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER r_invent_last_mod_D
GO
CREATE TRIGGER [dbo].[r_invent_last_mod_D] ON [dbo].[r_invent]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'r_invent'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(equip_tag AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER r_invent_last_mod_IU
GO
CREATE TRIGGER [dbo].[r_invent_last_mod_IU] ON [dbo].[r_invent]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'r_invent'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET r_invent = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM r_invent a JOIN inserted i ON a.equip_tag = i.equip_tag
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER r_levels_last_mod_D
GO
CREATE TRIGGER [dbo].[r_levels_last_mod_D] ON [dbo].[r_levels]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'r_levels'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(level_code AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER r_levels_last_mod_IU
GO
CREATE TRIGGER [dbo].[r_levels_last_mod_IU] ON [dbo].[r_levels]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'r_levels'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET r_levels = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM r_levels a JOIN inserted i ON a.level_code = i.level_code
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER r_mreasn_last_mod_D
GO
CREATE TRIGGER [dbo].[r_mreasn_last_mod_D] ON [dbo].[r_mreasn]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'r_mreasn'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(reason_id AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER r_mreasn_last_mod_IU
GO
CREATE TRIGGER [dbo].[r_mreasn_last_mod_IU] ON [dbo].[r_mreasn]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'r_mreasn'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET r_mreasn = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM r_mreasn a JOIN inserted i ON a.reason_id = i.reason_id
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER r_packgs_last_mod_D
GO
CREATE TRIGGER [dbo].[r_packgs_last_mod_D] ON [dbo].[r_packgs]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'r_packgs'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(pri_key AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER r_packgs_last_mod_IU
GO
CREATE TRIGGER [dbo].[r_packgs_last_mod_IU] ON [dbo].[r_packgs]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'r_packgs'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET r_packgs = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM r_packgs a JOIN inserted i ON a.pri_key = i.pri_key
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER r_rules_last_mod_D
GO
CREATE TRIGGER [dbo].[r_rules_last_mod_D] ON [dbo].[r_rules]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'r_rules'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(rule_id AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER r_rules_last_mod_IU
GO
CREATE TRIGGER [dbo].[r_rules_last_mod_IU] ON [dbo].[r_rules]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'r_rules'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET r_rules = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM r_rules a JOIN inserted i ON a.rule_id = i.rule_id
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER r_shops_last_mod_D
GO
CREATE TRIGGER [dbo].[r_shops_last_mod_D] ON [dbo].[r_shops]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'r_shops'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(shop_no AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER r_shops_last_mod_IU
GO
CREATE TRIGGER [dbo].[r_shops_last_mod_IU] ON [dbo].[r_shops]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'r_shops'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET r_shops = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM r_shops a JOIN inserted i ON a.shop_no = i.shop_no
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER r_types_last_mod_D
GO
CREATE TRIGGER [dbo].[r_types_last_mod_D] ON [dbo].[r_types]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'r_types'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(typeid AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER r_types_last_mod_IU
GO
CREATE TRIGGER [dbo].[r_types_last_mod_IU] ON [dbo].[r_types]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'r_types'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET r_types = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM r_types a JOIN inserted i ON a.typeid = i.typeid
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER refreasn_last_mod_D
GO
CREATE TRIGGER [dbo].[refreasn_last_mod_D] ON [dbo].[refreasn]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'refreasn'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(reason_id AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER refreasn_last_mod_IU
GO
CREATE TRIGGER [dbo].[refreasn_last_mod_IU] ON [dbo].[refreasn]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'refreasn'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET refreasn = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM refreasn a JOIN inserted i ON a.reason_id = i.reason_id
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER relation_last_mod_D
GO
create trigger [dbo].[relation_last_mod_D] ON [dbo].[relation]
for DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'relation'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
		   SELECT @cTableName AS tablename, CAST(pri_key AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
		BEGIN
		   RAISERROR('Cannot update the DELETES value.',16,1)
		   ROLLBACK TRANSACTION
		   RETURN
		END
		COMMIT TRANSACTION

GO

DROP TRIGGER relation_last_mod_IU
GO
CREATE trigger [dbo].[relation_last_mod_IU] ON [dbo].[relation]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'relation'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET relation = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM relation a JOIN inserted i ON a.pri_key = i.pri_key
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER res_facl_last_mod_D
GO
CREATE TRIGGER [dbo].[res_facl_last_mod_D] ON [dbo].[res_facl]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'res_facl'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(facl_no AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER res_facl_last_mod_IU
GO
CREATE TRIGGER [dbo].[res_facl_last_mod_IU] ON [dbo].[res_facl]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'res_facl'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET res_facl = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM res_facl a JOIN inserted i ON a.facl_no = i.facl_no
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER res_schd_last_mod_D
GO
CREATE TRIGGER [dbo].[res_schd_last_mod_D] ON [dbo].[res_schd]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'res_schd'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(res_no AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER res_schd_last_mod_IU
GO
CREATE TRIGGER [dbo].[res_schd_last_mod_IU] ON [dbo].[res_schd]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'res_schd'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET res_schd = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM res_schd a JOIN inserted i ON a.res_no = i.res_no
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER res_stat_last_mod_D
GO
CREATE TRIGGER [dbo].[res_stat_last_mod_D] ON [dbo].[res_stat]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'res_stat'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(res_status AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER res_stat_last_mod_IU
GO
CREATE TRIGGER [dbo].[res_stat_last_mod_IU] ON [dbo].[res_stat]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'res_stat'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET res_stat = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM res_stat a JOIN inserted i ON a.res_status = i.res_status
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

/*  Remove any record in the deletes table if this key was inserted back in  */
		DELETE FROM deletes WHERE tablename = @cTableName AND key_val IN
		(SELECT CAST(res_status AS varchar(60)) FROM Inserted WHERE res_status NOT IN (SELECT res_status FROM Deleted))

GO

DROP TRIGGER resrvatn_last_mod_D
GO
CREATE TRIGGER [dbo].[resrvatn_last_mod_D] ON [dbo].[resrvatn]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'resrvatn'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(reserv_no AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER resrvatn_last_mod_IU
GO
CREATE TRIGGER [dbo].[resrvatn_last_mod_IU] ON [dbo].[resrvatn]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'resrvatn'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET resrvatn = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM resrvatn a JOIN inserted i ON a.reserv_no = i.reserv_no
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER s_quest_last_mod
GO
CREATE TRIGGER [dbo].[s_quest_last_mod] ON [dbo].[s_quest]
FOR INSERT, UPDATE, DELETE
AS
declare @CountIns   int,
        @CountDel   int,
        @cTableName varchar(8),
        @nKeyVal    int

set nocount on
set @cTableName = 's_quest'
select @CountIns = COUNT(*) from Inserted
select @CountDel = COUNT(*) from Deleted

/*  Update the last_mod for INSERTs and UPDATEs  */
if @CountIns > 0
   begin
      update sequence set @nKeyVal = next_val, next_val = next_val + @CountIns where name = @cTableName
      if @nKeyVal is null
         begin
            set @nKeyVal = 1
            insert into sequence (name, next_val) values (@cTableName, @CountIns + 1)
         end

      update updates set s_quest = @nKeyVal + @CountIns - 1
      if @@ERROR != 0
         begin
            raiserror('Cannot update the LAST_MOD value.',16,1)
            return
         end

      set @nKeyVal = @nKeyVal - 1
      update a set @nKeyVal = last_mod = @nKeyVal + 1 from s_quest a join inserted i on a.quest_id = i.quest_id
      if @@ERROR != 0
         begin
            raiserror('Cannot update the LAST_MOD value.',16,1)
            return
         end
   end

/*  Add a record to the deletes table for DELETEs  */
if @CountIns = 0 and @CountDel > 0
	begin
		begin transaction
		insert into deletes (tablename, key_val)
			select @cTableName as tablename, cast(quest_id as varchar(60)) as key_val from Deleted
		update updates set deletes = isnull((select top 1 last_mod from deletes order by last_mod desc), 0)
		if @@ERROR != 0
			begin
				raiserror('Cannot update the DELETES value.',16,1)
				rollback transaction
				return
			end
		commit transaction
	end

GO

DROP TRIGGER s_resp_last_mod
GO
CREATE TRIGGER [dbo].[s_resp_last_mod] ON [dbo].[s_resp]
FOR INSERT, UPDATE, DELETE
AS
declare @CountIns   int,
        @CountDel   int,
        @cTableName varchar(8),
        @nKeyVal    int

set nocount on
set @cTableName = 's_resp'
select @CountIns = COUNT(*) from Inserted
select @CountDel = COUNT(*) from Deleted

/*  Update the last_mod for INSERTs and UPDATEs  */
if @CountIns > 0
   begin
      update sequence set @nKeyVal = next_val, next_val = next_val + @CountIns where name = @cTableName
      if @nKeyVal is null
         begin
            set @nKeyVal = 1
            insert into sequence (name, next_val) values (@cTableName, @CountIns + 1)
         end

      update updates set s_resp = @nKeyVal + @CountIns - 1
      if @@ERROR != 0
         begin
            raiserror('Cannot update the LAST_MOD value.',16,1)
            return
         end

      set @nKeyVal = @nKeyVal - 1
      update a set @nKeyVal = last_mod = @nKeyVal + 1 from s_resp a join inserted i on a.resp_id = i.resp_id
      if @@ERROR != 0
         begin
            raiserror('Cannot update the LAST_MOD value.',16,1)
            return
         end
   end

/*  Add a record to the deletes table for DELETEs  */
if @CountIns = 0 and @CountDel > 0
	begin
		begin transaction
		insert into deletes (tablename, key_val)
			select @cTableName as tablename, cast(resp_id as varchar(60)) as key_val from Deleted
		update updates set deletes = isnull((select top 1 last_mod from deletes order by last_mod desc), 0)
		if @@ERROR != 0
			begin
				raiserror('Cannot update the DELETES value.',16,1)
				rollback transaction
				return
			end
		commit transaction
	end

GO

DROP TRIGGER s_sgslnk_last_mod
GO
CREATE TRIGGER [dbo].[s_sgslnk_last_mod] ON [dbo].[s_sgslnk]
FOR INSERT, UPDATE, DELETE
AS
declare @CountIns   int,
        @CountDel   int,
        @cTableName varchar(8),
        @nKeyVal    int

set nocount on
set @cTableName = 's_sgslnk'
select @CountIns = COUNT(*) from Inserted
select @CountDel = COUNT(*) from Deleted

/*  Update the last_mod for INSERTs and UPDATEs  */
if @CountIns > 0
   begin
      update sequence set @nKeyVal = next_val, next_val = next_val + @CountIns where name = @cTableName
      if @nKeyVal is null
         begin
            set @nKeyVal = 1
            insert into sequence (name, next_val) values (@cTableName, @CountIns + 1)
         end

      update updates set s_sgslnk = @nKeyVal + @CountIns - 1
      if @@ERROR != 0
         begin
            raiserror('Cannot update the LAST_MOD value.',16,1)
            return
         end

      set @nKeyVal = @nKeyVal - 1
      update a set @nKeyVal = last_mod = @nKeyVal + 1 from s_sgslnk a join inserted i on a.link_id = i.link_id
      if @@ERROR != 0
         begin
            raiserror('Cannot update the LAST_MOD value.',16,1)
            return
         end
   end

/*  Add a record to the deletes table for DELETEs  */
if @CountIns = 0 and @CountDel > 0
	begin
		begin transaction
		insert into deletes (tablename, key_val)
			select @cTableName as tablename, cast(link_id as varchar(60)) as key_val from Deleted
		update updates set deletes = isnull((select top 1 last_mod from deletes order by last_mod desc), 0)
		if @@ERROR != 0
			begin
				raiserror('Cannot update the DELETES value.',16,1)
				rollback transaction
				return
			end
		commit transaction
	end

GO

DROP TRIGGER s_sqlink_last_mod
GO
CREATE TRIGGER [dbo].[s_sqlink_last_mod] ON [dbo].[s_sqlink]
FOR INSERT, UPDATE, DELETE
AS
declare @CountIns   int,
        @CountDel   int,
        @cTableName varchar(8),
        @nKeyVal    int

set nocount on
set @cTableName = 's_sqlink'
select @CountIns = COUNT(*) from Inserted
select @CountDel = COUNT(*) from Deleted

/*  Update the last_mod for INSERTs and UPDATEs  */
if @CountIns > 0
   begin
      update sequence set @nKeyVal = next_val, next_val = next_val + @CountIns where name = @cTableName
      if @nKeyVal is null
         begin
            set @nKeyVal = 1
            insert into sequence (name, next_val) values (@cTableName, @CountIns + 1)
         end

      update updates set s_sqlink = @nKeyVal + @CountIns - 1
      if @@ERROR != 0
         begin
            raiserror('Cannot update the LAST_MOD value.',16,1)
            return
         end

      set @nKeyVal = @nKeyVal - 1
      update a set @nKeyVal = last_mod = @nKeyVal + 1 from s_sqlink a join inserted i on a.pri_key = i.pri_key
      if @@ERROR != 0
         begin
            raiserror('Cannot update the LAST_MOD value.',16,1)
            return
         end
   end

/*  Add a record to the deletes table for DELETEs  */
if @CountIns = 0 and @CountDel > 0
	begin
		begin transaction
		insert into deletes (tablename, key_val)
			select @cTableName as tablename, cast(pri_key as varchar(60)) as key_val from Deleted
		update updates set deletes = isnull((select top 1 last_mod from deletes order by last_mod desc), 0)
		if @@ERROR != 0
			begin
				raiserror('Cannot update the DELETES value.',16,1)
				rollback transaction
				return
			end
		commit transaction
	end

GO

DROP TRIGGER s_survey_last_mod
GO
CREATE TRIGGER [dbo].[s_survey_last_mod] ON [dbo].[s_survey]
FOR INSERT, UPDATE, DELETE
AS
declare @CountIns   int,
        @CountDel   int,
        @cTableName varchar(8),
        @nKeyVal    int

set nocount on
set @cTableName = 's_survey'
select @CountIns = COUNT(*) from Inserted
select @CountDel = COUNT(*) from Deleted

/*  Update the last_mod for INSERTs and UPDATEs  */
if @CountIns > 0
   begin
      update sequence set @nKeyVal = next_val, next_val = next_val + @CountIns where name = @cTableName
      if @nKeyVal is null
         begin
            set @nKeyVal = 1
            insert into sequence (name, next_val) values (@cTableName, @CountIns + 1)
         end

      update updates set s_survey = @nKeyVal + @CountIns - 1
      if @@ERROR != 0
         begin
            raiserror('Cannot update the LAST_MOD value.',16,1)
            return
         end

      set @nKeyVal = @nKeyVal - 1
      update a set @nKeyVal = last_mod = @nKeyVal + 1 from s_survey a join inserted i on a.survey_id = i.survey_id
      if @@ERROR != 0
         begin
            raiserror('Cannot update the LAST_MOD value.',16,1)
            return
         end
   end

/*  Add a record to the deletes table for DELETEs  */
if @CountIns = 0 and @CountDel > 0
	begin
		begin transaction
		insert into deletes (tablename, key_val)
			select @cTableName as tablename, cast(survey_id as varchar(60)) as key_val from Deleted
		update updates set deletes = isnull((select top 1 last_mod from deletes order by last_mod desc), 0)
		if @@ERROR != 0
			begin
				raiserror('Cannot update the DELETES value.',16,1)
				rollback transaction
				return
			end
		commit transaction
	end

GO

DROP TRIGGER sales_pt_last_mod_D
GO
CREATE TRIGGER [dbo].[sales_pt_last_mod_D] ON dbo.sales_pt
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'sales_pt'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, salespoint AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER sales_pt_last_mod_IU
GO
CREATE TRIGGER [dbo].[sales_pt_last_mod_IU] ON dbo.sales_pt
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'sales_pt'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET sales_pt = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM sales_pt a JOIN inserted i ON a.salespoint = i.salespoint
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

/*  Remove any record in the deletes table if this key was inserted back in  */
		DELETE FROM deletes WHERE tablename = @cTableName AND key_val IN
		(SELECT salespoint FROM Inserted WHERE salespoint NOT IN (SELECT salespoint FROM Deleted))

GO

DROP TRIGGER sec_acct_last_mod_D
GO
CREATE TRIGGER [dbo].[sec_acct_last_mod_D] ON [dbo].[sec_acct]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'sec_acct'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(pri_key AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER sec_acct_last_mod_IU
GO
CREATE TRIGGER [dbo].[sec_acct_last_mod_IU] ON [dbo].[sec_acct]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'sec_acct'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET sec_acct = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM sec_acct a JOIN inserted i ON a.pri_key = i.pri_key
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER sec_mbrs_last_mod_D
GO
CREATE TRIGGER [dbo].[sec_mbrs_last_mod_D] ON [dbo].[sec_mbrs]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'sec_mbrs'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(pri_key AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER sec_mbrs_last_mod_IU
GO
CREATE TRIGGER [dbo].[sec_mbrs_last_mod_IU] ON [dbo].[sec_mbrs]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'sec_mbrs'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET sec_mbrs = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM sec_mbrs a JOIN inserted i ON a.pri_key = i.pri_key
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER sec_rght_last_mod_D
GO
CREATE TRIGGER [dbo].[sec_rght_last_mod_D] ON [dbo].[sec_rght]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'sec_rght'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(pri_key AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER sec_rght_last_mod_IU
GO
CREATE TRIGGER [dbo].[sec_rght_last_mod_IU] ON [dbo].[sec_rght]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'sec_rght'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET sec_rght = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM sec_rght a JOIN inserted i ON a.pri_key = i.pri_key
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER sec_spcl_last_mod_D
GO
CREATE TRIGGER [dbo].[sec_spcl_last_mod_D] ON [dbo].[sec_spcl]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'sec_spcl'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(pri_key AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER sec_spcl_last_mod_IU
GO
CREATE TRIGGER [dbo].[sec_spcl_last_mod_IU] ON [dbo].[sec_spcl]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'sec_spcl'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET sec_spcl = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM sec_spcl a JOIN inserted i ON a.pri_key = i.pri_key
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER Settings_last_mod_D
GO


create trigger [dbo].[Settings_last_mod_D]
on [dbo].[Settings]
for delete
as
	declare @cTableName varchar(8)

	set nocount on
	if not exists (select * from deleted) return;
	set @cTableName = 'Settings'

	/*  Add a record to the deletes table for DELETEs  */
	begin transaction
	insert into dbo.deletes (tablename, key_val)
	select @cTableName as tablename, cast(SettingID as varchar) as key_val from deleted

	update dbo.updates set deletes = isnull((select top 1 last_mod from dbo.deletes order by last_mod desc), 0)

	if @@error != 0
	   begin
	      raiserror('Cannot update the DELETES value.' , 16 , 1)
	      rollback transaction
	      return
	   end

	commit transaction


GO

DROP TRIGGER Settings_last_mod_IU
GO


create trigger [dbo].[Settings_last_mod_IU]
on [dbo].[Settings]
for  insert, update
as
	declare  @CountIns    int
	       , @cTableName  varchar(10)
	       , @nKeyVal     int

	set nocount on
	set @cTableName = 'Settings'
	select @CountIns = count(*) from inserted
	if @CountIns = 0 return;

	/*  Update the last_mod for INSERTs and UPDATEs  */
	update dbo.sequence set @nKeyVal = next_val, next_val = next_val + @CountIns where name = @cTableName

	if @nKeyVal is null
	   begin
	      set @nKeyVal = 1
	      insert into dbo.sequence (name, next_val) values (@cTableName, @CountIns + 1)
	   end

	update dbo.updates set Settings = @nKeyVal + @CountIns - 1

	if @@error != 0
	   begin
	      raiserror('Cannot update the LAST_MOD value in Updates.' , 16 , 1)
	      return
	   end

	set @nKeyVal = @nKeyVal - 1

	update s set @nKeyVal = last_mod = @nKeyVal + 1
	  from dbo.Settings s join inserted i on s.SettingID = i.SettingID

	if @@error != 0
	   begin
	      raiserror('Cannot update the LAST_MOD value in Settings.' , 16 , 1)
	      return
	   end


GO

DROP TRIGGER sp_link_last_mod_D
GO
CREATE TRIGGER [dbo].[sp_link_last_mod_D] ON [dbo].[sp_link]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'sp_link'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(link_id AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER sp_link_last_mod_IU
GO
CREATE TRIGGER [dbo].[sp_link_last_mod_IU] ON [dbo].[sp_link]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'sp_link'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET sp_link = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM sp_link a JOIN inserted i ON a.link_id = i.link_id
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER specials_last_mod_D
GO
CREATE TRIGGER [dbo].[specials_last_mod_D] ON [dbo].[specials]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'specials'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, name AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER specials_last_mod_IU
GO
CREATE TRIGGER [dbo].[specials_last_mod_IU] ON [dbo].[specials]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'specials'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET specials = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM specials a JOIN inserted i ON a.name = i.name
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

/*  Remove any record in the deletes table if this key was inserted back in  */
		DELETE FROM deletes WHERE tablename = @cTableName AND key_val IN
		(SELECT name FROM Inserted WHERE name NOT IN (SELECT name FROM Deleted))

GO

DROP TRIGGER speclink_last_mod_D
GO
CREATE TRIGGER [dbo].[speclink_last_mod_D] ON [dbo].[speclink]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'speclink'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, special+department+category+item AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER speclink_last_mod_IU
GO
CREATE TRIGGER [dbo].[speclink_last_mod_IU] ON [dbo].[speclink]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'speclink'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET speclink = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM speclink a JOIN inserted i ON a.special = i.special and a.department = i.department and
                                                                                         a.category = i.category and a.item = i.item
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

/*  Remove any record in the deletes table if this key was inserted back in  */
		DELETE FROM deletes WHERE tablename = @cTableName AND key_val IN
		(SELECT special+department+category+item FROM Inserted WHERE special+department+category+item NOT IN (SELECT special+department+category+item FROM Deleted))

GO

DROP TRIGGER specmktg_last_mod_D
GO
CREATE TRIGGER [dbo].[specmktg_last_mod_D] ON [dbo].[specmktg]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'specmktg'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(pri_key AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER specmktg_last_mod_IU
GO
CREATE TRIGGER [dbo].[specmktg_last_mod_IU] ON [dbo].[specmktg]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'specmktg'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET specmktg = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM specmktg a JOIN inserted i ON a.pri_key = i.pri_key
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER specsrce_last_mod_D
GO
CREATE TRIGGER [dbo].[specsrce_last_mod_D] ON [dbo].[specsrce]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'specsrce'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(pri_key AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER specsrce_last_mod_IU
GO
CREATE TRIGGER [dbo].[specsrce_last_mod_IU] ON [dbo].[specsrce]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'specsrce'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET specsrce = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM specsrce a JOIN inserted i ON a.pri_key = i.pri_key
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER srcecode_last_mod_D
GO
CREATE TRIGGER [dbo].[srcecode_last_mod_D] ON [dbo].[srcecode]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'srcecode'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(pri_key AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER srcecode_last_mod_IU
GO
CREATE TRIGGER [dbo].[srcecode_last_mod_IU] ON [dbo].[srcecode]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'srcecode'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET srcecode = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM srcecode a JOIN inserted i ON a.pri_key = i.pri_key
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER template_last_mod_D
GO
CREATE TRIGGER [dbo].[template_last_mod_D] ON dbo.template
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'template'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, department+category+item AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER template_last_mod_IU
GO
CREATE TRIGGER [dbo].[template_last_mod_IU] ON dbo.template
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'template'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET template = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM template a JOIN inserted i ON a.department = i.department and a.category = i.category and a.item = i.item
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

/*  Remove any record in the deletes table if this key was inserted back in  */
		DELETE FROM deletes WHERE tablename = @cTableName AND key_val IN
		(SELECT department+category+item FROM Inserted WHERE department+category+item NOT IN (SELECT department+category+item FROM Deleted))

GO

DROP TRIGGER tipouts_last_mod_D
GO
CREATE TRIGGER [dbo].[tipouts_last_mod_D] ON [dbo].[tipouts]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'tipouts'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(pri_key AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER tipouts_last_mod_IU
GO
CREATE TRIGGER [dbo].[tipouts_last_mod_IU] ON [dbo].[tipouts]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'tipouts'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET tipouts = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM tipouts a JOIN inserted i ON a.pri_key = i.pri_key
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER tr_save_last_mod_D
GO
CREATE TRIGGER [dbo].[tr_save_last_mod_D] ON [dbo].[tr_save]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON ;
set transaction isolation level read uncommitted ;

SET @cTableName = 'tr_save'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(trans_no AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER tr_save_last_mod_IU
GO
CREATE TRIGGER [dbo].[tr_save_last_mod_IU] ON [dbo].[tr_save]
FOR INSERT, UPDATE
AS
DECLARE @CountIns int,
		@cTableName varchar(10),
	    @nKeyVal    int

SET NOCOUNT ON ;
set transaction isolation level read uncommitted ;

SET @cTableName = 'tr_save'
SELECT @CountIns = COUNT(*) FROM Inserted WHERE Cal_Sched = 1
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
--Removed Cursor --Omar 7/11/2011
	  UPDATE sequence
		  SET @nKeyVal = next_val, next_val = next_val + @CountIns
	  WHERE name = @cTableName
	  IF @nKeyVal IS NULL
	  BEGIN
		 SET @nKeyVal = 1
		 INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
	  END

	  UPDATE updates SET tr_save = @nKeyVal + @CountIns - 1
	  IF @@ERROR != 0
		 BEGIN
			RAISERROR('Cannot update the LAST_MOD value.',16,1)
			RETURN
		 END

		UPDATE ts SET last_mod = @nKeyVal + @CountIns - 1
		FROM tr_save ts
		JOIN inserted i ON ts.trans_no = i.trans_no
		WHERE i.Cal_Sched = 1
		IF @@ERROR != 0
		BEGIN
			RAISERROR('Cannot update the LAST_MOD value.',16,1)
			RETURN
		END

GO

DROP TRIGGER units_last_mod_D
GO
CREATE TRIGGER [dbo].[units_last_mod_D] ON [dbo].[units]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'units'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(UnitID AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER units_last_mod_IU
GO
CREATE TRIGGER [dbo].[units_last_mod_IU] ON [dbo].[units]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'units'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET units = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM units a JOIN inserted i ON a.UnitID = i.UnitID
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER usercod1_last_mod_D
GO
CREATE TRIGGER [dbo].[usercod1_last_mod_D] ON [dbo].[usercod1]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'usercod1'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(pri_key AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER usercod1_last_mod_IU
GO
CREATE TRIGGER [dbo].[usercod1_last_mod_IU] ON [dbo].[usercod1]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'usercod1'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET usercod1 = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM usercod1 a JOIN inserted i ON a.pri_key = i.pri_key
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER usercod2_last_mod_D
GO
CREATE TRIGGER [dbo].[usercod2_last_mod_D] ON [dbo].[usercod2]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'usercod2'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(pri_key AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER usercod2_last_mod_IU
GO
CREATE TRIGGER [dbo].[usercod2_last_mod_IU] ON [dbo].[usercod2]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'usercod2'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET usercod2 = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM usercod2 a JOIN inserted i ON a.pri_key = i.pri_key
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER usercod3_last_mod_D
GO
CREATE TRIGGER [dbo].[usercod3_last_mod_D] ON [dbo].[usercod3]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'usercod3'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(pri_key AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER usercod3_last_mod_IU
GO
CREATE TRIGGER [dbo].[usercod3_last_mod_IU] ON [dbo].[usercod3]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'usercod3'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET usercod3 = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM usercod3 a JOIN inserted i ON a.pri_key = i.pri_key
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO

DROP TRIGGER wrapcode_last_mod_D
GO
CREATE TRIGGER [dbo].[wrapcode_last_mod_D] ON [dbo].[wrapcode]
FOR DELETE
AS
DECLARE @cTableName varchar(8)

SET NOCOUNT ON
SET @cTableName = 'wrapcode'
IF NOT EXISTS (SELECT * FROM deleted) RETURN;

/*  Add a record to the deletes table for DELETEs  */
		BEGIN TRANSACTION
		INSERT INTO deletes (tablename, key_val)
			SELECT @cTableName AS tablename, CAST(pri_key AS varchar(60)) AS key_val FROM Deleted
		UPDATE updates SET deletes = ISNULL((SELECT TOP 1 last_mod FROM deletes ORDER BY last_mod DESC), 0)
		IF @@ERROR != 0
			BEGIN
				RAISERROR('Cannot update the DELETES value.',16,1)
				ROLLBACK TRANSACTION
				RETURN
			END
		COMMIT TRANSACTION

GO

DROP TRIGGER wrapcode_last_mod_IU
GO
CREATE TRIGGER [dbo].[wrapcode_last_mod_IU] ON [dbo].[wrapcode]
FOR INSERT, UPDATE
AS
DECLARE @CountIns   int,
        @cTableName varchar(10),
        @nKeyVal    int

SET NOCOUNT ON
SET @cTableName = 'wrapcode'
SELECT @CountIns = COUNT(*) FROM Inserted
IF @CountIns = 0 RETURN;

/*  Update the last_mod for INSERTs and UPDATEs  */
      UPDATE sequence SET @nKeyVal = next_val, next_val = next_val + @CountIns WHERE name = @cTableName
      IF @nKeyVal IS NULL
         BEGIN
            SET @nKeyVal = 1
            INSERT INTO sequence (name, next_val) VALUES (@cTableName, @CountIns + 1)
         END

      UPDATE updates SET wrapcode = @nKeyVal + @CountIns - 1
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

      SET @nKeyVal = @nKeyVal - 1
      UPDATE a SET @nKeyVal = last_mod = @nKeyVal + 1 FROM wrapcode a JOIN inserted i ON a.pri_key = i.pri_key
      IF @@ERROR != 0
         BEGIN
            RAISERROR('Cannot update the LAST_MOD value.',16,1)
            RETURN
         END

GO