--------------------------------------------------------------------------------
-- UpdateObjectInJobRow
PRINT N'Creating [dbo].[UpdateObjectInJobRow]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateObjectInJobRow]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateObjectInJobRow]
GO

	CREATE PROCEDURE [dbo].[UpdateObjectInJobRow]
			   @row_id uniqueidentifier,
			   @row_job_id uniqueidentifier,
			   @row_object_id uniqueidentifier,
			   @row_folder_id uniqueidentifier,
			   @row_vss_options xml,
			   @row_approx_size bigint,
			   @row_location nvarchar(1024),
			   @row_type int,
			   @row_disk_filter nvarchar(max),
			   @row_update_vmx bit,
			   @platform int,
			   @row_order_no int,
			   @row_ex_options xml
		
	AS
	BEGIN
		SET NOCOUNT ON;
		UPDATE [dbo].[ObjectsInJobs] SET
			   [job_id]			=@row_job_id,
			   [object_id]		=@row_object_id,
			   [folder_id]		=@row_folder_id,
			   [vss_options]	=@row_vss_options,
			   [approx_size]	=@row_approx_size,
			   [location]		=@row_location,
			   [type]			=@row_type,
			   [disk_filter]	=@row_disk_filter,
			   [update_vmx]		=@row_update_vmx,
			   [platform]       =@platform,
			   [order_no]		=@row_order_no,
			   [ex_options]		=@row_ex_options
				where [id] = @row_id

	END	
	
GO

--------------------------------------------------------------------------------
-- GetObjectInJobByJobIdAndObjectId
PRINT N'Creating [dbo].[GetObjectInJobByJobIdAndObjectId]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetObjectInJobByJobIdAndObjectId]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetObjectInJobByJobIdAndObjectId]
GO

	CREATE PROCEDURE [dbo].[GetObjectInJobByJobIdAndObjectId]
		@row_job_id uniqueidentifier,
		@row_object_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT * from [dbo].[ObjectsInJobs]  oj 
		LEFT JOIN [dbo].[JobVssCredentials] vc ON oj.id = vc.oij_id
		LEFT JOIN [dbo].[Credentials] c ON c.id = vc.credentials_id
	    where  oj.[job_id] = @row_job_id AND  oj.[object_id] = @row_object_id
	END
	
GO

--------------------------------------------------------------------------------
-- GetObjectsInJobsAll
PRINT N'Creating [dbo].[GetObjectsInJobsAll]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetObjectsInJobsAll]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetObjectsInJobsAll]
GO

	CREATE PROCEDURE [dbo].[GetObjectsInJobsAll]
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT * from [dbo].[ObjectsInJobs]  oj 
		LEFT JOIN [dbo].[JobVssCredentials] vc ON oj.id = vc.oij_id
		LEFT JOIN [dbo].[Credentials] c ON c.id = vc.credentials_id 
		order by order_no asc
	END
	
GO

--------------------------------------------------------------------------------
-- GetBackupsOnHost
PRINT N'Creating [dbo].[GetBackupsOnHost]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetBackupsOnHost]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetBackupsOnHost]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetBackupsOnHost]
		@host_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT * from [dbo].[Backup.Model.Backups] where [job_target_host_id] = @host_id
	END
	
GO

--------------------------------------------------------------------------------
-- GetFoldersForHost
PRINT N'Creating [dbo].[GetFoldersForHost]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetFoldersForHost]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetFoldersForHost]
GO

	CREATE PROCEDURE [dbo].[GetFoldersForHost]
		@row_host_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT * from [dbo].[Folder_Host] where [host_id] = @row_host_id
	END

GO

--------------------------------------------------------------------------------
-- SetHostParentIdNull
PRINT N'Creating [dbo].[SetHostParentIdNull]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[SetHostParentIdNull]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[SetHostParentIdNull]
GO

	CREATE PROCEDURE [dbo].[SetHostParentIdNull]
		@row_host_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		UPDATE 
			[dbo].[Hosts] 
		SET 
			[parent_id] = NULL,
			[usn] = @usn
		where [id] = @row_host_id
	END

GO

--------------------------------------------------------------------------------
-- GetObjectsInBackupsForBackup
PRINT N'Creating [dbo].[GetObjectsInBackupsForBackup]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetObjectsInBackupsForBackup]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetObjectsInBackupsForBackup]
GO

	CREATE PROCEDURE [dbo].[GetObjectsInBackupsForBackup]
		@row_backup_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT * from [dbo].[ObjectsInBackups] where [dbo].[ObjectsInBackups].[backup_id] = @row_backup_id
	END

GO

--------------------------------------------------------------------------------
-- GetObjectsInBackupsForObject
PRINT N'Creating [dbo].[GetObjectsInBackupsForObject]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetObjectsInBackupsForObject]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetObjectsInBackupsForObject]
GO

	CREATE PROCEDURE [dbo].[GetObjectsInBackupsForObject]
		@row_object_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT * from [dbo].[ObjectsInBackups] where [dbo].[ObjectsInBackups].[object_id] = @row_object_id
	END

GO

--------------------------------------------------------------------------------
-- GetObjectsInJobsForJob
PRINT N'Creating [dbo].[GetObjectsInJobsForJob]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetObjectsInJobsForJob]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetObjectsInJobsForJob]
GO

	CREATE PROCEDURE [dbo].[GetObjectsInJobsForJob]
		@row_job_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT * from [dbo].[ObjectsInJobs]  oj 
		LEFT JOIN [dbo].[JobVssCredentials] vc ON oj.id = vc.oij_id
		LEFT JOIN [dbo].[Credentials] c ON c.id = vc.credentials_id 
		where oj.[job_id] = @row_job_id order by order_no asc
	END

GO

--------------------------------------------------------------------------------
-- GetObjectsInJobsForObject
PRINT N'Creating [dbo].[GetObjectsInJobsForObject]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetObjectsInJobsForObject]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetObjectsInJobsForObject]
GO

	CREATE PROCEDURE [dbo].[GetObjectsInJobsForObject]
		@row_object_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT * from [dbo].[ObjectsInJobs]  oj 
		LEFT JOIN [dbo].[JobVssCredentials] vc ON oj.id = vc.oij_id
		LEFT JOIN [dbo].[Credentials] c ON c.id = vc.credentials_id 
		where oj.[object_id] = @row_object_id order by order_no asc
	END

GO

--------------------------------------------------------------------------------
-- AddSoapCredsRow
PRINT N'Creating [dbo].[AddSoapCredsRow]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[AddSoapCredsRow]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[AddSoapCredsRow]
GO

	CREATE PROCEDURE [dbo].[AddSoapCredsRow]
			   @row_id uniqueidentifier,
			   @row_host_id uniqueidentifier,
			   @row_port int,
			   @row_creds_id uniqueidentifier,
			   @row_savepassword bit,
			   @row_useproxy bit,
			   @row_proxyip nvarchar(50),
			   @row_proxyport int,
			   @row_enabled bit
	AS
	BEGIN
		SET NOCOUNT ON;
		INSERT INTO [dbo].[Soap_creds]
			   ([id]
			   ,[host_id]
			   ,[port]
			   ,[creds]
			   ,[savepassword]
			   ,[useproxy]
			   ,[proxyip]
			   ,[proxyport]
			   ,[enabled])
		 VALUES
			   (@row_id,
			   @row_host_id,
			   @row_port,
			   @row_creds_id,
			   @row_savepassword,
			   @row_useproxy,
			   @row_proxyip,
			   @row_proxyport,
			   @row_enabled)
	END	

GO

--------------------------------------------------------------------------------
-- GetSoapCreds
PRINT N'Creating [dbo].[GetSoapCreds]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetSoapCreds]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetSoapCreds]
GO

	CREATE PROCEDURE [dbo].[GetSoapCreds]
		@row_host_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT sc.id, sc.host_id,sc.port,sc.savepassword,sc.useproxy, sc.proxyip, sc.proxyport,sc.enabled, sc.creds, c.[user_name],c.[password]
		FROM [dbo].[Soap_creds] as sc INNER JOIN Credentials as c ON c.id = sc.creds 
		WHERE [host_id] = @row_host_id
	END

GO

--------------------------------------------------------------------------------
-- UpdateSoapCredsRow
PRINT N'Creating [dbo].[UpdateSoapCredsRow]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateSoapCredsRow]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateSoapCredsRow]
GO

	CREATE PROCEDURE [dbo].[UpdateSoapCredsRow]
			   @row_id uniqueidentifier,
			   @row_host_id uniqueidentifier,
			   @row_creds_id uniqueidentifier,
			   @row_port int,
			   @row_savepassword bit,
			   @row_useproxy bit,
			   @row_proxyip nvarchar(50),
			   @row_proxyport int,
			   @row_enabled bit
	AS
	BEGIN
		SET NOCOUNT ON;
		UPDATE [dbo].[Soap_creds] SET
			   [host_id]		=@row_host_id,
			   [port]			=@row_port,
			   [creds]			=@row_creds_id,
			   [savepassword]	=@row_savepassword,
			   [useproxy]		=@row_useproxy,
			   [proxyip]		=@row_proxyip,
			   [proxyport]		=@row_proxyport,
			   [enabled]		=@row_enabled
				where [id] = @row_id
	END	

GO

--------------------------------------------------------------------------------
-- AddSshCredsRow
PRINT N'Creating [dbo].[AddSshCredsRow]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[AddSshCredsRow]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[AddSshCredsRow]
GO

	CREATE PROCEDURE [dbo].[AddSshCredsRow]
			   @row_id uniqueidentifier,
			   @row_host_id uniqueidentifier,
			   @row_creds_id uniqueidentifier,
			   @row_savepassword bit,
			   @row_elevatetoroot bit,
			   @row_rootpassword nvarchar(512),
			   @row_port int,
			   @row_startftport int,
			   @row_endftport int,
			   @row_buffersize int,
			   @row_isftserver bit,
			   @row_timeout int,
			   @row_adjust_firewall bit,
			   @row_auto_sudo bit,
			   @row_enabled bit	
	AS
	BEGIN
		SET NOCOUNT ON;
		INSERT INTO [dbo].[Ssh_creds]
			   ([id]
			   ,[host_id]
			   ,[creds]
			   ,[savepassword]
			   ,[elevatetoroot]
			   ,[rootpassword]
			   ,[port]
			   ,[startftport]
			   ,[endftport]
			   ,[buffersize]
			   ,[isftserver]
			   ,[timeout]
			   ,[adjust_firewall]
			   ,[auto_sudo]
			   ,[enabled])
		 VALUES
			   (@row_id,
			   @row_host_id,
			   @row_creds_id,
			   @row_savepassword,
			   @row_elevatetoroot,
			   @row_rootpassword,
			   @row_port,
			   @row_startftport,
			   @row_endftport,
			   @row_buffersize,
			   @row_isftserver,
			   @row_timeout,
			   @row_adjust_firewall,
			   @row_auto_sudo,
			   @row_enabled)
	END	

GO

--------------------------------------------------------------------------------
-- UpdateSshCredsRow
PRINT N'Creating [dbo].[UpdateSshCredsRow]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateSshCredsRow]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateSshCredsRow]
GO

	CREATE PROCEDURE [dbo].[UpdateSshCredsRow]
			   @row_id uniqueidentifier,
			   @row_host_id uniqueidentifier,
			   @row_creds_id uniqueidentifier,
			   @row_savepassword bit,
			   @row_elevatetoroot bit,
			   @row_rootpassword nvarchar(512),
			   @row_port int,
			   @row_startftport int,
			   @row_endftport int,
			   @row_buffersize int,
			   @row_isftserver bit,
			   @row_timeout int,
			   @row_adjust_firewall bit,
			   @row_auto_sudo bit,
			   @row_enabled bit
	AS
	BEGIN
		SET NOCOUNT ON;
		UPDATE [dbo].[Ssh_creds] SET
			   [host_id]			=@row_host_id,
			   [creds]				=@row_creds_id,
			   [savepassword]		=@row_savepassword,
			   [elevatetoroot]		=@row_elevatetoroot,
			   [rootpassword]		=@row_rootpassword,
			   [port]				=@row_port,
			   [startftport]		=@row_startftport,
			   [endftport]			=@row_endftport,
			   [buffersize]			=@row_buffersize,
			   [isftserver]			=@row_isftserver,
			   [timeout]			=@row_timeout,
			   [adjust_firewall]	=@row_adjust_firewall,
			   [auto_sudo]			=@row_auto_sudo,
			   [enabled]			=@row_enabled
				WHERE [id] = @row_id
	END	

GO

--------------------------------------------------------------------------------
-- GetSshCreds
PRINT N'Creating [dbo].[GetSshCreds]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetSshCreds]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetSshCreds]
GO

	CREATE PROCEDURE [dbo].[GetSshCreds]
		@row_host_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT sc.id, sc.host_id,sc.savepassword, sc.elevatetoroot,sc.rootpassword,sc.port, sc.startftport, sc.endftport,
sc.buffersize, sc.isftserver, sc.timeout, sc.adjust_firewall, sc.auto_sudo, sc.enabled, sc.creds, c.[user_name], c.[password]
        FROM [dbo].[Ssh_creds] as sc INNER JOIN [dbo].[Credentials] as c ON c.id = sc.creds 
        WHERE [host_id] = @row_host_id
	END

GO

--------------------------------------------------------------------------------
-- AddFolderRow
PRINT N'Creating [dbo].[AddFolderRow]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[AddFolderRow]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[AddFolderRow]
GO

	CREATE PROCEDURE [dbo].[AddFolderRow]
		@row_id uniqueidentifier,
		@row_parent_id uniqueidentifier,
		@row_name nvarchar(255),
		@row_description nvarchar(1024),
		@row_platform int
	AS
	BEGIN
		SET NOCOUNT ON;
		INSERT INTO [dbo].[Folders]
			   ([id]
			   ,[parent_id]
			   ,[name]
			   ,[description]
			   ,[platform])
		 VALUES
			   (@row_id,
				@row_parent_id,
				@row_name,
				@row_description,
				@row_platform)
	END	

GO

--------------------------------------------------------------------------------
-- UpdateFolderRow
PRINT N'Creating [dbo].[UpdateFolderRow]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateFolderRow]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateFolderRow]
GO

	CREATE PROCEDURE [dbo].[UpdateFolderRow]
		@row_id uniqueidentifier,
		@row_parent_id uniqueidentifier,
		@row_name nvarchar(255),
		@row_description nvarchar(1024),
		@row_platform int
	AS
	BEGIN
		SET NOCOUNT ON;
		UPDATE [dbo].[Folders] SET
			   [parent_id] = @row_parent_id,
			   [name]	   = @row_name,
			   [description] = @row_description,
			   [platform] = @row_platform
			   where [id] = @row_id
	END	

GO

--------------------------------------------------------------------------------
-- GetFolder
PRINT N'Creating [dbo].[GetFolder]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetFolder]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetFolder]
GO

	CREATE PROCEDURE [dbo].[GetFolder]
		@row_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT * from [dbo].[Folders] where [id] = @row_id
	END

GO

--------------------------------------------------------------------------------
-- GetFoldersAll
PRINT N'Creating [dbo].[GetFoldersAll]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetFoldersAll]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetFoldersAll]
GO

	CREATE PROCEDURE [dbo].[GetFoldersAll]
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT * from [dbo].[Folders]
	END

GO

--------------------------------------------------------------------------------
-- GetSubFolders
PRINT N'Creating [dbo].[GetSubFolders]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetSubFolders]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetSubFolders]
GO

	CREATE PROCEDURE [dbo].[GetSubFolders]
		@row_folder_id uniqueidentifier,
		@row_platform int
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT 
			* 
		FROM 
			[dbo].[Folders] 
		WHERE 
			[parent_id] = @row_folder_id 
			AND [id] <> [parent_id]
			AND [platform] = ISNULL(@row_platform, [platform])
	END
GO

--------------------------------------------------------------------------------
-- GetFoldersForFolder
PRINT N'Creating [dbo].[GetFoldersForFolder]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetFoldersForFolder]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetFoldersForFolder]
GO

	CREATE PROCEDURE [dbo].[GetFoldersForFolder]
		@row_folder_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[Folder_Host] where [folder_id] = @row_folder_id
	END

GO

--------------------------------------------------------------------------------
-- AddLicensedHostRow
PRINT N'Creating [dbo].[AddLicensedHostRow]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[AddLicensedHostRow]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[AddLicensedHostRow]
GO

	CREATE PROCEDURE [dbo].[AddLicensedHostRow]
			   @row_id uniqueidentifier,
			   @row_uuid nvarchar(255),
			   @row_name nvarchar(255),
			   @row_cpu int,
			   @row_cores int,
			   @row_type INT,
			   @row_lic_edition int,
			   @row_is_licensed bit
	AS
	BEGIN
		SET NOCOUNT ON;

		INSERT INTO [dbo].[LicensedHosts]
			   ([id]
			   ,[uuid]
			   ,[name]
			   ,[cpu]
			   ,[type]
			   ,[lic_edition]
			   ,[is_licensed]
			   ,[cores])
		 VALUES
			   (@row_id,
			   @row_uuid,
			   @row_name,
			   @row_cpu,
			   @row_type,
			   @row_lic_edition,
			   @row_is_licensed,
			   @row_cores
			   )
	END	

GO

--------------------------------------------------------------------------------
-- UpdateLicensedHostRow
PRINT N'Creating [dbo].[UpdateLicensedHostRow]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateLicensedHostRow]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateLicensedHostRow]
GO

	CREATE PROCEDURE [dbo].[UpdateLicensedHostRow]
			   @row_id uniqueidentifier,
			   @row_uuid nvarchar(255),
			   @row_name nvarchar(255),
			   @row_cpu int,
			   @row_cores int,
			   @row_type int,
			   @row_lic_edition int,
			   @row_is_licensed bit
	AS
	BEGIN
		SET NOCOUNT ON;

		UPDATE [dbo].[LicensedHosts] SET
			   [uuid] = @row_uuid,
			   [name] = @row_name,
			   [cpu]  = @row_cpu,
			   [cores] = @row_cores,
			   [type] = @row_type,
			   [lic_edition] = @row_lic_edition,
			   [is_licensed] = @row_is_licensed
				WHERE [id] = @row_id
	END	

GO

--------------------------------------------------------------------------------
-- GetLicensedHost
PRINT N'Creating [dbo].[GetLicensedHost]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetLicensedHost]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetLicensedHost]
GO

	CREATE PROCEDURE [dbo].[GetLicensedHost]
		@row_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * FROM [dbo].[LicensedHosts] where [id] = @row_id
	END

GO

--------------------------------------------------------------------------------
-- GetLicensedHostByUUID
PRINT N'Creating [dbo].[GetLicensedHostByUUID]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetLicensedHostByUUID]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetLicensedHostByUUID]
GO

	CREATE PROCEDURE [dbo].[GetLicensedHostByUUID]
		@row_uuid nvarchar(255)
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * FROM [dbo].[LicensedHosts] where [uuid] = @row_uuid
	END

GO

--------------------------------------------------------------------------------
-- GetLicensedHostsAll
PRINT N'Creating [dbo].[GetLicensedHostsAll]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetLicensedHostsAll]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetLicensedHostsAll]
GO

	CREATE PROCEDURE [dbo].[GetLicensedHostsAll]
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * FROM [dbo].[LicensedHosts]
	END

GO

--------------------------------------------------------------------------------
-- DeleteHost
PRINT N'Creating [dbo].[DeleteHost]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DeleteHost]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[DeleteHost]
GO

	CREATE PROCEDURE [dbo].[DeleteHost]
		@row_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		DELETE FROM [dbo].[Hosts] WHERE [id] = @row_id
	END

GO

--------------------------------------------------------------------------------
-- DeleteObjectInJob
PRINT N'Creating [dbo].[DeleteObjectInJob]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DeleteObjectInJob]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[DeleteObjectInJob]
GO

	CREATE PROCEDURE [dbo].[DeleteObjectInJob]
		@row_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		DELETE FROM [dbo].[ObjectsInJobs] WHERE [id] = @row_id
	END

GO

--------------------------------------------------------------------------------
-- AddOption
PRINT N'Creating [dbo].[AddOption]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[AddOption]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[AddOption]
GO

	CREATE PROCEDURE [dbo].[AddOption]
		@row_id uniqueidentifier,
		@row_name nvarchar(50),
		@row_value xml
	AS
	BEGIN
		SET NOCOUNT ON;

		INSERT INTO [dbo].[Options] 
			([id],
			[name], 
			[value]) 
		VALUES 
			(@row_id, 
			@row_name, 
			@row_value)
	END

GO

--------------------------------------------------------------------------------
-- SetOption
PRINT N'Creating [dbo].[SetOption]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[SetOption]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[SetOption]
GO

	CREATE PROCEDURE [dbo].[SetOption]
		@row_id uniqueidentifier,
		@row_value xml
	AS
	BEGIN
		SET NOCOUNT ON;

		UPDATE [dbo].[Options] SET [value] = @row_value WHERE [id] = @row_id
	END

GO

--------------------------------------------------------------------------------
-- GetOption
PRINT N'Creating [dbo].[GetOption]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetOption]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetOption]
GO

	CREATE PROCEDURE [dbo].[GetOption]
		@row_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT [value] FROM [dbo].[Options] WHERE [id] = @row_id
	END

GO

--------------------------------------------------------------------------------
-- ClearSessionInfos
PRINT N'Creating [dbo].[ClearSessionInfos]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[ClearSessionInfos]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[ClearSessionInfos]
GO

	CREATE PROCEDURE [dbo].[ClearSessionInfos]
		@row_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		UPDATE [dbo].[Backup.Model.BackupTaskSessions] 
		SET
			[object_id] = NULL,
			[usn]       = @usn
		where [id] = @row_id 
	END

GO

--------------------------------------------------------------------------------
-- DeleteObjectInBackup
PRINT N'Creating [dbo].[DeleteObjectInBackup]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DeleteObjectInBackup]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[DeleteObjectInBackup]
GO

	CREATE PROCEDURE [dbo].[DeleteObjectInBackup]
		@row_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		DELETE FROM [ObjectsInBackups] where [id]  = @row_id 
	END

GO

--------------------------------------------------------------------------------
-- DeleteBackup
PRINT N'Creating [dbo].[DeleteBackup]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DeleteBackup]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[DeleteBackup]
GO

	CREATE PROCEDURE [dbo].[DeleteBackup]
		@row_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		DELETE FROM [Backups] where [id] = @row_id 
	END
	
GO

--------------------------------------------------------------------------------
-- DeleteLicensedHost
PRINT N'Creating [dbo].[DeleteLicensedHost]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DeleteLicensedHost]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[DeleteLicensedHost]
GO

	CREATE PROCEDURE [dbo].[DeleteLicensedHost]
		@row_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		delete from [dbo].[HostsByJobs]
		where uuid = (select uuid from [LicensedHosts] where [id] = @row_id)

		DELETE FROM [LicensedHosts] where [id] = @row_id 
	END

GO

--------------------------------------------------------------------------------
-- GetSessionInfosForObject
PRINT N'Creating [dbo].[GetSessionInfosForObject]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetSessionInfosForObject]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetSessionInfosForObject]
GO

	CREATE PROCEDURE [dbo].[GetSessionInfosForObject]
		@row_object_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[Backup.Model.BackupTaskSessions] where [object_id] = @row_object_id 
	END

GO

--------------------------------------------------------------------------------
-- GetSbTaskSessionInfosForObject
PRINT N'Creating [dbo].[GetSbTaskSessionInfosForObject]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetSbTaskSessionInfosForObject]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetSbTaskSessionInfosForObject]
GO

	CREATE PROCEDURE [dbo].[GetSbTaskSessionInfosForObject]
		@row_object_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[Backup.Model.SbTaskSessions] where [object_id] = @row_object_id 
	END

GO

--------------------------------------------------------------------------------
-- GetLastNonRetrySession
PRINT N'Creating [dbo].[GetLastNonRetrySession]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetLastNonRetrySession]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetLastNonRetrySession]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetLastNonRetrySession]
		@row_sess_id uniqueidentifier
	AS
	BEGIN

		select nrs.*, nrbs.*
		from
			[dbo].[Backup.Model.JobSessions] nrs,
					[dbo].[Backup.Model.BackupJobSessions] nrbs,
			(
				SELECT js.id, 
					   row_number() over (order by js.creation_time desc) rn
				FROM
					[dbo].[Backup.Model.JobSessions] js,
					[dbo].[Backup.Model.BackupJobSessions] bjs,
					(select job_id, creation_time from [dbo].[Backup.Model.JobSessions] where id = @row_sess_id) cs
				where
					bjs.id = js.id and
					js.job_id = cs.job_id and
					js.creation_time <= cs.creation_time and
					bjs.is_retry = 0
			) s(id, rn)
		where
			nrs.id = s.id and 
					nrs.id = nrbs.id and
			s.rn = 1

	END

GO

--------------------------------------------------------------------------------
-- DeleteObject
PRINT N'Creating [dbo].[DeleteObject]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DeleteObject]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[DeleteObject]
GO

	CREATE PROCEDURE [dbo].[DeleteObject]
		@row_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		DELETE FROM [dbo].[BObjects] WHERE [id] = @row_id
	END

GO

-------------------------------------------------------------------------------
PRINT N'Creating [dbo].[UpdateObjectsUniqueKeyHashs]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateObjectsUniqueKeyHashs]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateObjectsUniqueKeyHashs]
GO
CREATE PROCEDURE [dbo].[UpdateObjectsUniqueKeyHashs]
	@host_instance_id nvarchar(255)
AS
BEGIN
	SET NOCOUNT ON;
	
	DECLARE @host_id uniqueidentifier;
	SELECT @host_id = [id] FROM [dbo].[Hosts] h WHERE h.host_instance_id = @host_instance_id;
	
	if @host_id IS NULL
		RAISERROR(N'Host do not exist in database.', 9, 1 );
	
	declare @usn bigint
	exec [dbo].[IncrementUsn] @usn OUTPUT;
	UPDATE [dbo].[BObjects]  
	SET 
		[unique_key_hash] = [dbo].[fn.Backup.MakeObjectHash]( [object_id], @host_instance_id ),
		[usn] = @usn
	WHERE [host_id] = @host_id;
END
GO

-------------------------------------------------------------------------------
PRINT N'Creating [dbo].[UpdateObjectUniqueKeyHash]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateObjectUniqueKeyHash]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateObjectUniqueKeyHash]
GO
CREATE PROCEDURE [dbo].[UpdateObjectUniqueKeyHash]
	@rootHostId uniqueidentifier,
	@objectId uniqueidentifier = '00000000-0000-0000-0000-000000000000' 
AS
BEGIN
	SET NOCOUNT ON;

	declare @usn bigint
	exec [dbo].[IncrementUsn] @usn OUTPUT;

	UPDATE [dbo].[BObjects] 
	SET 
		[dbo].[BObjects].[unique_key_hash] = [dbo].[fn.Backup.MakeObjectHash]( [dbo].[BObjects].[object_id], [dbo].[Hosts].[host_instance_id]),
		[dbo].[BObjects].[usn] = @usn
	FROM 
		[dbo].[BObjects] JOIN [dbo].[Hosts] ON [dbo].[BObjects].[host_id] = [dbo].[Hosts].[id]
	WHERE 
		[dbo].[Hosts].[id] = @rootHostId AND
		([dbo].[BObjects].[id] = @objectId OR @objectId = '00000000-0000-0000-0000-000000000000')
END
GO

--------------------------------------------------------------------------------
-- UpdateObjectRow
PRINT N'Creating [dbo].[UpdateObjectRow]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateObjectRow]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateObjectRow]
GO

	CREATE PROCEDURE [dbo].[UpdateObjectRow]
		@row_id uniqueidentifier,
		@row_type int,
		@row_host_id uniqueidentifier,
		@row_object_name nvarchar(2000),
		@row_object_id nvarchar(2000),
		@row_viobject_type nvarchar(50),
		@row_guest_os xml,
		@row_path nvarchar(400),
		@platform int,
		@uuid nvarchar(256),
		@displayName nvarchar(2000)
	AS
	BEGIN
		SET NOCOUNT ON;

		UPDATE [dbo].[BObjects] SET
			   [type]			=@row_type,
			   [host_id]		=@row_host_id,
			   [object_name]	=@row_object_name,
			   [object_id]		=@row_object_id,
			   [viobject_type]	=@row_viobject_type,
			   [guest_os]		=@row_guest_os,
			   [path]			=@row_path,
			   [platform]       =@platform,
			   [uuid]           =@uuid,
			   [display_name]	= SUBSTRING( @displayName,0, 255 )
		WHERE [id] = @row_id

		EXEC UpdateObjectUniqueKeyHash @row_host_id, @row_id
	END

GO

--------------------------------------------------------------------------------
-- GetObjectsInJobsForFolder
PRINT N'Creating [dbo].[GetObjectsInJobsForFolder]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetObjectsInJobsForFolder]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetObjectsInJobsForFolder]
GO

	CREATE PROCEDURE [dbo].[GetObjectsInJobsForFolder]
		@row_folder_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[ObjectsInJobs]  oj 
		LEFT JOIN [dbo].[JobVssCredentials] vc ON oj.id = vc.oij_id
		LEFT JOIN [dbo].[Credentials] c ON c.id = vc.credentials_id
		where oj.[folder_id] = @row_folder_id order by order_no asc
	END

GO

--------------------------------------------------------------------------------
-- DeleteFolder
PRINT N'Creating [dbo].[DeleteFolder]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DeleteFolder]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[DeleteFolder]
GO

	CREATE PROCEDURE [dbo].[DeleteFolder]
		@row_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		DELETE FROM [dbo].[Folders] WHERE [id] = @row_id
	END

GO

--------------------------------------------------------------------------------
-- SetJobIdNullInBackup
PRINT N'Creating [dbo].[SetJobIdNullInBackup]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[SetJobIdNullInBackup]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[SetJobIdNullInBackup]
GO

	CREATE PROCEDURE [dbo].[SetJobIdNullInBackup]
		@row_backup_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		UPDATE [dbo].[Backup.Model.Backups] SET [job_id] = NULL where [id] = @row_backup_id
	END

GO

--------------------------------------------------------------------------------
-- SetJobIdNullInSession
PRINT N'Creating [dbo].[SetJobIdNullInSession]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[SetJobIdNullInSession]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[SetJobIdNullInSession]
GO

	CREATE PROCEDURE [dbo].[SetJobIdNullInSession]
		@row_session_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		UPDATE [dbo].[Backup.Model.JobSessions] SET [job_id] = NULL, [usn] = @usn where [id] = @row_session_id
		
	END

GO

--------------------------------------------------------------------------------
-- DeleteJob
PRINT N'Creating [dbo].[DeleteJob]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DeleteJob]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[DeleteJob]
GO

	CREATE PROCEDURE [dbo].[DeleteJob]
		@row_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		DELETE FROM [dbo].[BJobs] WHERE [id] = @row_id
	END

GO

--------------------------------------------------------------------------------
-- DeleteSession
PRINT N'Creating [dbo].[DeleteSession]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DeleteSession]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[DeleteSession]
GO

	CREATE PROCEDURE [dbo].[DeleteSession]
		@row_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		
		DELETE FROM [dbo].[Backup.Model.BackupJobSessions] WHERE [id] = @row_id
		DELETE FROM [dbo].[Backup.Model.JobSessions] WHERE [id] = @row_id
		DELETE FROM [dbo].[Events.JobSessionEvents] WHERE [job_session_id]=@row_id
		
	END

GO

--------------------------------------------------------------------------------
-- DeleteSessionInfo
PRINT N'Creating [dbo].[DeleteSessionInfo]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DeleteSessionInfo]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[DeleteSessionInfo]
GO

	CREATE PROCEDURE [dbo].[DeleteSessionInfo]
		@row_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		DELETE FROM [dbo].[Backup.Model.BackupTaskSessions] WHERE [id] = @row_id
		DELETE FROM [dbo].[Events.TaskSessionEvents] WHERE [task_session_id]=@row_id
	END

GO

--------------------------------------------------------------------------------
-- DeleteSoapCreds
PRINT N'Creating [dbo].[DeleteSoapCreds]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DeleteSoapCreds]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[DeleteSoapCreds]
GO

	CREATE PROCEDURE [dbo].[DeleteSoapCreds]
		@row_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		DELETE FROM [dbo].[Soap_creds] WHERE [id] = @row_id
	END

GO

--------------------------------------------------------------------------------
-- DeleteSshCreds
PRINT N'Creating [dbo].[DeleteSshCreds]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DeleteSshCreds]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[DeleteSshCreds]
GO

CREATE PROCEDURE [dbo].[DeleteSshCreds]
	@row_id uniqueidentifier
AS
BEGIN
	SET NOCOUNT ON;

	DELETE FROM [dbo].[Ssh_creds] WHERE [id] = @row_id
END

GO

--------------------------------------------------------------------------------
-- GetObject
PRINT N'Creating [dbo].[GetObject]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetObject]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetObject]
GO

	CREATE PROCEDURE [dbo].[GetObject]
		@row_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[BObjects] where [dbo].[BObjects].[id] = @row_id
	END

GO

--------------------------------------------------------------------------------
-- AddAccountRow
PRINT N'Creating [dbo].[AddAccountRow]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[AddAccountRow]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[AddAccountRow]
GO

	CREATE PROCEDURE [dbo].[AddAccountRow]
				@row_id uniqueidentifier,
			   @row_name nvarchar(50),
			   @row_sid nvarchar(100),
			   @row_nt4_name nvarchar(100),
			   @row_type int
	AS
	BEGIN
		SET NOCOUNT ON;

		INSERT INTO [dbo].[Backup.Security.Accounts]
			   ([id]
			   ,[name]
			   ,[sid]
			   ,[nt4_name]
			   ,[type])
		 VALUES
			   (@row_id,
			   @row_name,
			   @row_sid,
			   @row_nt4_name,
			   @row_type)
	END	

GO

--------------------------------------------------------------------------------
-- UpdateAccountRow
PRINT N'Creating [dbo].[UpdateAccountRow]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateAccountRow]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateAccountRow]
GO

	CREATE PROCEDURE [dbo].[UpdateAccountRow]
		@row_id uniqueidentifier,
		@row_name nvarchar(50),
		@row_sid nvarchar(100),
		@row_nt4_name nvarchar(100),
		@row_type int
	AS
	BEGIN
		SET NOCOUNT ON;

		UPDATE [dbo].[Backup.Security.Accounts] SET
			   [name]		=@row_name,
			   [sid]		=@row_sid,
			   [nt4_name]	=@row_nt4_name,
			   [type]		=@row_type
				where [id] = @row_id
	END
	
GO

--------------------------------------------------------------------------------
-- GetAccountBySid
PRINT N'Creating [dbo].[GetAccountBySid]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetAccountBySid]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetAccountBySid]
GO

	CREATE PROCEDURE [dbo].[GetAccountBySid]
		@row_sid nvarchar(100)
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[Backup.Security.Accounts] where [sid] = @row_sid
	END

GO

--------------------------------------------------------------------------------
-- GetAccountById
PRINT N'Creating [dbo].[GetAccountById]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetAccountById]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetAccountById]
GO

	CREATE PROCEDURE [dbo].[GetAccountById]
		@row_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[Backup.Security.Accounts] where [id] = @row_id
	END

GO

--------------------------------------------------------------------------------
-- UpdateRoleRow
PRINT N'Creating [dbo].[UpdateRoleRow]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateRoleRow]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateRoleRow]
GO

	CREATE PROCEDURE [dbo].[UpdateRoleRow]
			   @row_id uniqueidentifier,
			   @row_name nvarchar(50)
	AS
	BEGIN
		SET NOCOUNT ON;

		UPDATE [dbo].[Backup.Security.Roles] SET
			   [name]		=@row_name
				where [id] = @row_id
	END

GO

--------------------------------------------------------------------------------
-- AddRoleRow
PRINT N'Creating [dbo].[AddRoleRow]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[AddRoleRow]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[AddRoleRow]
GO

	CREATE PROCEDURE [dbo].[AddRoleRow]
		@row_id uniqueidentifier,
		@row_name nvarchar(50)
	AS
	BEGIN
		SET NOCOUNT ON;

		INSERT INTO [dbo].[Backup.Security.Roles]
			   ([id],  
				[name])
			   VALUES
				(@row_id,
				@row_name)
	END
	
GO

--------------------------------------------------------------------------------
-- GetRoleById
PRINT N'Creating [dbo].[GetRoleById]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetRoleById]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetRoleById]
GO

	CREATE PROCEDURE [dbo].[GetRoleById]
		@row_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[Backup.Security.Roles] where [id] = @row_id
	END

GO

--------------------------------------------------------------------------------
-- GetRolesAll
PRINT N'Creating [dbo].[GetRolesAll]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetRolesAll]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetRolesAll]
GO

	CREATE PROCEDURE [dbo].[GetRolesAll]
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[Backup.Security.Roles]
	END

GO

--------------------------------------------------------------------------------
-- GetAccountsAll
PRINT N'Creating [dbo].[GetAccountsAll]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetAccountsAll]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetAccountsAll]
GO

	CREATE PROCEDURE [dbo].[GetAccountsAll]
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[Backup.Security.Accounts]
	END

GO

--------------------------------------------------------------------------------
-- AddRoleAccountRow
PRINT N'Creating [dbo].[AddRoleAccountRow]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[AddRoleAccountRow]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[AddRoleAccountRow]
GO

	CREATE PROCEDURE [dbo].[AddRoleAccountRow]
		@row_id uniqueidentifier,
		@row_role_id uniqueidentifier,
		@row_account_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		INSERT INTO [dbo].[Backup.Security.RoleAccounts]
			   ([id],
				[role_id],
				[account_id])
			   VALUES
				(@row_id,
				@row_role_id,
				@row_account_id)
	END

GO

--------------------------------------------------------------------------------
-- UpdateRoleAccountRow
PRINT N'Creating [dbo].[UpdateRoleAccountRow]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateRoleAccountRow]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateRoleAccountRow]
GO

	CREATE PROCEDURE [dbo].[UpdateRoleAccountRow]
			   @row_id uniqueidentifier,
			   @row_role_id uniqueidentifier,
			   @row_account_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		UPDATE [dbo].[Backup.Security.RoleAccounts] SET
				[role_id]		=@row_role_id,
				[account_id]	=@row_account_id
				WHERE [id] = @row_id

	END

GO

--------------------------------------------------------------------------------
-- GetRoleAccountByRoleId
PRINT N'Creating [dbo].[GetRoleAccountByRoleId]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetRoleAccountByRoleId]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetRoleAccountByRoleId]
GO

	CREATE PROCEDURE [dbo].[GetRoleAccountByRoleId]
			   @row_role_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * FROM [Backup.Security.RoleAccounts] WHERE [role_id] = @row_role_id

	END

GO

--------------------------------------------------------------------------------
-- GetRoleAccountByAccountId
PRINT N'Creating [dbo].[GetRoleAccountByAccountId]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetRoleAccountByAccountId]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetRoleAccountByAccountId]
GO

	CREATE PROCEDURE [dbo].[GetRoleAccountByAccountId]
			   @row_account_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * FROM [Backup.Security.RoleAccounts] WHERE [account_id] = @row_account_id

	END

GO

--------------------------------------------------------------------------------
-- GetRoleAccount
PRINT N'Creating [dbo].[GetRoleAccount]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetRoleAccount]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetRoleAccount]
GO

	CREATE PROCEDURE [dbo].[GetRoleAccount]
		@row_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * FROM [Backup.Security.RoleAccounts] WHERE [id] = @row_id

	END

GO

--------------------------------------------------------------------------------
-- DeleteRoleAccount
PRINT N'Creating [dbo].[DeleteRoleAccount]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DeleteRoleAccount]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[DeleteRoleAccount]
GO

	CREATE PROCEDURE [dbo].[DeleteRoleAccount]
		@row_role_id uniqueidentifier,
		@row_account_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		DELETE FROM [Backup.Security.RoleAccounts] WHERE [role_id] = @row_role_id AND [account_id] = @row_account_id

	END

GO

--------------------------------------------------------------------------------
-- DeleteAccount
PRINT N'Creating [dbo].[DeleteAccount]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DeleteAccount]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[DeleteAccount]
GO

	CREATE PROCEDURE [dbo].[DeleteAccount]
           @row_id uniqueidentifier
	AS
	BEGIN
	SET NOCOUNT ON;

	DELETE FROM [Backup.Security.Accounts] WHERE [id] = @row_id

	END
	
GO

--------------------------------------------------------------------------------
-- AddHostRow
PRINT N'Creating [dbo].[AddHostRow]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[AddHostRow]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[AddHostRow]
GO

	CREATE PROCEDURE [dbo].[AddHostRow]
		@row_id uniqueidentifier,
		@row_type int,
		@row_name nvarchar(255),
		@row_ip nvarchar(50),
		@row_parent_id uniqueidentifier,
		@row_info nvarchar(255),
		@row_description nvarchar(1024),
		@row_protocol int,
		@row_reference nvarchar(1024),
		@row_api_version int,
		@row_win_creds xml,
		@row_options xml,
		@row_physical_host_id uniqueidentifier,
		@row_credentials_id uniqueidentifier,
		@is_unavailable bit,
		@host_instance_id nvarchar(255),
		@host_unique_id nvarchar(255)
	AS
	BEGIN
		SET NOCOUNT ON;

		INSERT INTO [dbo].[Hosts]
			   ([id]
			   ,[type]
			   ,[name]
			   ,[ip]
			   ,[parent_id]
			   ,[info]
			   ,[description]
			   ,[protocol]
			   ,[reference]
			   ,[api_version]
			   ,[win_creds]
			   ,[options]
			   ,[physical_host_id]
			   ,[credentials_id]
			   ,[is_unavailable]
			   ,[host_instance_id]
			   ,[host_unique_id])
		 VALUES
			   (@row_id,
				@row_type,
				@row_name,
				@row_ip,
				@row_parent_id,
				@row_info,
				@row_description,
				@row_protocol,
				@row_reference,
				@row_api_version,
				@row_win_creds,
				@row_options,
				@row_physical_host_id,
				@row_credentials_id,
				@is_unavailable,
				@host_instance_id,
				@host_unique_id)
	END	

GO

--------------------------------------------------------------------------------
-- UpdateHostRow
PRINT N'Creating [dbo].[UpdateHostRow]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateHostRow]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateHostRow]
GO

	CREATE PROCEDURE [dbo].[UpdateHostRow]
		@row_id uniqueidentifier,
		@row_type int,
		@row_name nvarchar(255),
		@row_ip nvarchar(50),
		@row_parent_id uniqueidentifier,
		@row_info nvarchar(255),
		@row_description nvarchar(1024),
		@row_protocol int,
		@row_reference nvarchar(1024),
		@row_api_version int,
		@row_win_creds xml,
		@row_options xml,
		@row_physical_host_id uniqueidentifier,
		@row_credentials_id uniqueidentifier,
		@is_unavailable bit,
		@dns_name varchar(255),
		@host_instance_id nvarchar(255),		
		@host_unique_id nvarchar(255)
	AS
	BEGIN
		SET NOCOUNT ON;

		DECLARE @oldHostInstanceId nvarchar(255)
		SELECT @oldHostInstanceId = host_instance_id FROM [dbo].[Hosts] WHERE id = @row_id		

		UPDATE [dbo].[Hosts] SET
			   [type] = @row_type,
			   [name] = @row_name,
			   [ip] = @row_ip,
			   [parent_id] = @row_parent_id,
			   [info] = @row_info,
			   [description] = @row_description,
			   [protocol] = @row_protocol,
			   [reference] = @row_reference,
			   [api_version] = @row_api_version,
			   [win_creds] = @row_win_creds,
			   [options] = @row_options,
			   [physical_host_id] = @row_physical_host_id,
			   [credentials_id] = @row_credentials_id,
			   [is_unavailable] = @is_unavailable,
			   [dns_name] = @dns_name,
			   [host_instance_id] = @host_instance_id,
			   [host_unique_id] = @host_unique_id
			   WHERE [id] = @row_id

		IF (
			ISNULL(@oldHostInstanceId,'00000000-0000-0000-0000-000000000000') <> 
			ISNULL(@host_instance_id,'00000000-0000-0000-0000-000000000000'))
		BEGIN 
			EXEC UpdateObjectUniqueKeyHash	@row_id
		END 
	END	

GO

--------------------------------------------------------------------------------
-- GetHostById
PRINT N'Creating [dbo].[GetHostById]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetHostById]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetHostById]
GO

	CREATE PROCEDURE [dbo].[GetHostById]
		@row_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[Hosts] where [dbo].[Hosts].[id] = @row_id
	END
	
GO

--------------------------------------------------------------------------------
-- GetHostByName
PRINT N'Creating [dbo].[GetHostByName]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetHostByName]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetHostByName]
GO

	CREATE PROCEDURE [dbo].[GetHostByName]
		@row_name nvarchar(255)
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[Hosts] where [dbo].[Hosts].[name] = @row_name
	END

GO

--------------------------------------------------------------------------------
-- GetHostByType
PRINT N'Creating [dbo].[GetHostByType]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetHostByType]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetHostByType]
GO

	CREATE PROCEDURE [dbo].[GetHostByType]
		@row_type int
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[Hosts] where [dbo].[Hosts].[type] = @row_type
	END

GO

--------------------------------------------------------------------------------
-- GetHostsAll
PRINT N'Creating [dbo].[GetHostsAll]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetHostsAll]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetHostsAll]
GO

	CREATE PROCEDURE [dbo].[GetHostsAll]
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[Hosts]
	END

GO

--------------------------------------------------------------------------------
-- GetHostInFolderAll
PRINT N'Creating [dbo].[GetHostInFolderAll]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetHostInFolderAll]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetHostInFolderAll]
GO

	CREATE PROCEDURE [dbo].[GetHostInFolderAll]
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[Folder_Host]
	END

GO

--------------------------------------------------------------------------------
-- DeleteHostInFolder
PRINT N'Creating [dbo].[DeleteHostInFolder]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DeleteHostInFolder]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[DeleteHostInFolder]
GO

	CREATE PROCEDURE [dbo].[DeleteHostInFolder]
		@row_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		DELETE FROM [dbo].[Folder_Host] WHERE [id] = @row_id
	END

GO

--------------------------------------------------------------------------------
-- GetHostInFolderById
PRINT N'Creating [dbo].[GetHostInFolderById]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetHostInFolderById]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetHostInFolderById]
GO

	CREATE PROCEDURE [dbo].[GetHostInFolderById]
		@row_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[Folder_Host] where [id] = @row_id
	END

GO

--------------------------------------------------------------------------------
-- AddHostInFolderRow
PRINT N'Creating [dbo].[AddHostInFolderRow]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[AddHostInFolderRow]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[AddHostInFolderRow]
GO

	CREATE PROCEDURE [dbo].[AddHostInFolderRow]
		@row_id uniqueidentifier,
		@row_folderId uniqueidentifier,
		@row_hostId uniqueidentifier
		
	AS
	BEGIN
		SET NOCOUNT ON;

		INSERT INTO [dbo].[Folder_Host]
			   ([id]
			   ,[folder_id]
			   ,[host_id])
		 VALUES
			   (@row_id,
				@row_folderId,
				@row_hostId)
	END	

GO

--------------------------------------------------------------------------------
-- AddHostByJobRow
PRINT N'Creating [dbo].[AddHostByJobRow]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[AddHostByJobRow]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[AddHostByJobRow]
GO

	CREATE PROCEDURE [dbo].[AddHostByJobRow]
		@row_id uniqueidentifier,
		@row_hostId uniqueidentifier,
		@row_jobId uniqueidentifier,
		@row_uuid nvarchar(255)	
	AS
	BEGIN
		SET NOCOUNT ON;

		INSERT INTO [dbo].[HostsByJobs]
			   ([id]
			   ,[host_id]
			   ,[job_id]
			   ,[uuid])
		 VALUES
			   (@row_id,
				@row_hostId,
				@row_jobId,
				@row_uuid)
	END	

GO

--------------------------------------------------------------------------------
-- GetHostsByJobByJobId
PRINT N'Creating [dbo].[GetHostsByJobByJobId]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetHostsByJobByJobId]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetHostsByJobByJobId]
GO

	CREATE PROCEDURE [dbo].[GetHostsByJobByJobId]
		@job_id uniqueidentifier
	AS
	BEGIN
		select * from [dbo].[HostsByJobs]
		where job_id = @job_id
	END	
	
GO

--------------------------------------------------------------------------------
-- GetHostsByJobByHostId
PRINT N'Creating [dbo].[GetHostsByJobByHostId]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetHostsByJobByHostId]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetHostsByJobByHostId]
GO

	CREATE PROCEDURE [dbo].[GetHostsByJobByHostId]
		@host_id uniqueidentifier
	AS
	BEGIN
		select * from [dbo].[HostsByJobs]
		where host_id = @host_id
	END	

GO

--------------------------------------------------------------------------------
-- DeleteHostByJob
PRINT N'Creating [dbo].[DeleteHostByJob]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DeleteHostByJob]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[DeleteHostByJob]
GO

	CREATE PROCEDURE [dbo].[DeleteHostByJob]
		@id uniqueidentifier
	AS
	BEGIN
		delete [dbo].[HostsByJobs]
		where id = @id
	END	

GO

--------------------------------------------------------------------------------
-- GetHostsByJobByUuid
PRINT N'Creating [dbo].[GetHostsByJobByUuid]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetHostsByJobByUuid]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetHostsByJobByUuid]
GO

	CREATE PROCEDURE [dbo].[GetHostsByJobByUuid]
		@uuid nvarchar(1000)
	AS
	BEGIN
		select * from [dbo].[HostsByJobs]
		where uuid = @uuid
	END	

GO

--------------------------------------------------------------------------------
-- IsHostsByJobExists
PRINT N'Creating [dbo].[IsHostsByJobExists]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[IsHostsByJobExists]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[IsHostsByJobExists]
GO

	CREATE PROCEDURE [dbo].[IsHostsByJobExists]
		@host_id uniqueidentifier,
		@job_id  uniqueidentifier
	AS
	BEGIN

		select (case when count(*) > 0 then CONVERT(bit, 1) else CONVERT(bit, 0) end) is_exist from [dbo].[HostsByJobs]
		where 
			host_id = @host_id and
			job_id  = @job_id
		
	END	

GO

--------------------------------------------------------------------------------
-- GetJobsOnHost
PRINT N'Creating [dbo].[GetJobsOnHost]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetJobsOnHost]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetJobsOnHost]
GO

	CREATE PROCEDURE [dbo].[GetJobsOnHost]
		@row_host_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[BJobs] where [target_host_id] = @row_host_id
	END

GO

--------------------------------------------------------------------------------
-- GetObjectsOnHost
PRINT N'Creating [dbo].[GetObjectsOnHost]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetObjectsOnHost]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetObjectsOnHost]
GO

	CREATE PROCEDURE [dbo].[GetObjectsOnHost]
		@row_host_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[BObjects] where [host_id] = @row_host_id
	END

GO

--------------------------------------------------------------------------------
-- GetSessionControl
PRINT N'Creating [dbo].[GetSessionControl]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetSessionControl]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetSessionControl]
GO

	CREATE PROCEDURE [dbo].[GetSessionControl]
		@row_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
	    
		SELECT [dbo].[Backup.Model.JobSessions].[control] from [dbo].[Backup.Model.JobSessions] where [id] = @row_id
	END

GO

--------------------------------------------------------------------------------
-- AddJobRow
PRINT N'Creating [dbo].[AddJobRow]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[AddJobRow]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[AddJobRow]
GO

	CREATE PROCEDURE [dbo].[AddJobRow]
		@row_id uniqueidentifier,
		@row_type int,
		@row_name nvarchar(255),
		@row_target_host_id uniqueidentifier,
		@row_target_dir nvarchar(2000),
		@row_target_file nvarchar(2000),
		@row_source_proxy_host_id uniqueidentifier,
		@row_target_proxy_host_id uniqueidentifier,
		@row_options xml,
		@row_schedule xml,
		@row_is_deleted bit,
		@row_latest_result int,
		@row_post_command_run_count int,
		@row_vss_options xml,
		@row_vcb_host_id uniqueidentifier,
		@row_target_type int,
		@row_description nvarchar(1024),
		@row_job_source_type int,
		@row_included_size bigint,
		@row_excluded_size bigint,
		@row_schedule_enabled bit,
		@row_platform int,
		@row_backup_repository_id uniqueidentifier,
		@row_initialsync_repository_id uniqueidentifier,
		@row_parent_schedule_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		INSERT INTO [dbo].[BJobs]
			   ([id]
			   ,[type]
			   ,[name]
			   ,[target_host_id]
			   ,[target_dir]
			   ,[target_file]
			   ,[source_proxy_host_id]
			   ,[target_proxy_host_id]
			   ,[options]
			   ,[schedule]
			   ,[is_deleted]
			   ,[latest_result]
			   ,[post_command_run_count]
			   ,[vss_options]
			   ,[vcb_host_id]
			   ,[target_type]
			   ,[description]
			   ,[job_source_type]
			   ,[included_size]
			   ,[excluded_size]
			   ,[schedule_enabled]
			   ,[platform]
			   ,[repository_id]
			   ,[initialsync_repository_id]
			   ,[parent_schedule_id])
		 VALUES
			   (@row_id,
			   @row_type,
			   @row_name,
			   @row_target_host_id,
			   @row_target_dir,
			   @row_target_file,
			   @row_source_proxy_host_id,
			   @row_target_proxy_host_id,
			   @row_options,
			   @row_schedule,
			   @row_is_deleted,
			   @row_latest_result,
			   @row_post_command_run_count,
			   @row_vss_options,
			   @row_vcb_host_id,
			   @row_target_type,
			   @row_description,
			   @row_job_source_type,
			   @row_included_size,
			   @row_excluded_size,
			   @row_schedule_enabled,
			   @row_platform,
			   @row_backup_repository_id,
			   @row_initialsync_repository_id,
			   @row_parent_schedule_id)
	END	

GO

--------------------------------------------------------------------------------
-- GetJobById
PRINT N'Creating [dbo].[GetJobById]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetJobById]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetJobById]
GO

	CREATE PROCEDURE [dbo].[GetJobById]
		@row_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[BJobs] where [dbo].[BJobs].[id] = @row_id
	END

GO

--------------------------------------------------------------------------------
-- GetJobByName
PRINT N'Creating [dbo].[GetJobByName]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetJobByName]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetJobByName]
GO

	CREATE PROCEDURE [dbo].[GetJobByName]
		@row_name nvarchar(255)
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[BJobs] where [dbo].[BJobs].[name] = @row_name
	END

GO

--------------------------------------------------------------------------------
-- UpdateSessionControl
PRINT N'Creating [dbo].[UpdateSessionControl]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateSessionControl]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateSessionControl]
GO

	CREATE PROCEDURE [dbo].[UpdateSessionControl]
			   @row_id uniqueidentifier,
			   @row_control int
	AS
	BEGIN
		SET NOCOUNT ON;

		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		UPDATE [dbo].[Backup.Model.JobSessions] SET           
			   [control] = @row_control,
			   [usn] = @usn
		WHERE [id] = @row_id
		
	END

GO

--------------------------------------------------------------------------------
-- UpdateJobRow
PRINT N'Creating [dbo].[UpdateJobRow]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateJobRow]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateJobRow]
GO

	CREATE PROCEDURE [dbo].[UpdateJobRow]
		@row_id uniqueidentifier,
		@row_type int,
		@row_name nvarchar(255),
		@row_target_host_id uniqueidentifier,
		@row_target_dir nvarchar(2000),
		@row_target_file nvarchar(2000),
		@row_source_proxy_host_id uniqueidentifier,
		@row_target_proxy_host_id uniqueidentifier,
		@row_options xml,
		@row_schedule xml,
		@row_is_deleted bit,
		@row_latest_result int,
		@row_post_command_run_count int,
		@row_vss_options xml,
		@row_vcb_host_id uniqueidentifier,
		@row_target_type int,
		@row_description nvarchar(1024),
		@row_job_source_type int,
		@row_included_size bigint,
		@row_excluded_size bigint,
		@row_schedule_enabled bit,
		@row_platform int,
		@row_backup_repository_id uniqueidentifier,
		@row_initialsync_repository_id uniqueidentifier,
		@row_parent_schedule_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		UPDATE [dbo].[BJobs] SET
			   [type]					=@row_type
			   ,[name]					=@row_name
			   ,[target_host_id]		=@row_target_host_id
			   ,[target_dir]			=@row_target_dir
			   ,[target_file]			=@row_target_file
			   ,[source_proxy_host_id]	=@row_source_proxy_host_id
			   ,[target_proxy_host_id]	=@row_target_proxy_host_id
			   ,[options]				=@row_options
			   ,[schedule]				=@row_schedule
			   ,[is_deleted]			=@row_is_deleted
			   ,[latest_result]			=@row_latest_result
			   ,[post_command_run_count]=@row_post_command_run_count
			   ,[vss_options]			=@row_vss_options
			   ,[vcb_host_id]			=@row_vcb_host_id
			   ,[target_type]			=@row_target_type
			   ,[description]			=@row_description
			   ,[job_source_type]		=@row_job_source_type
			   ,[included_size]			=@row_included_size
			   ,[excluded_size]			=@row_excluded_size
			   ,[schedule_enabled]		=@row_schedule_enabled
			   ,[platform]				=@row_platform
			   ,[repository_id]  =@row_backup_repository_id
			   ,[initialsync_repository_id]  =@row_initialsync_repository_id
			   ,[parent_schedule_id] = @row_parent_schedule_id
			   WHERE [id] = @row_id
	END

GO

--------------------------------------------------------------------------------
-- UpdateJobPostCommandRunCount
PRINT N'Creating [dbo].[UpdateJobPostCommandRunCount]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateJobPostCommandRunCount]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateJobPostCommandRunCount]
GO

	CREATE PROCEDURE [dbo].[UpdateJobPostCommandRunCount]
		@row_id uniqueidentifier,
		@row_post_command_run_count int
	AS
	BEGIN
		SET NOCOUNT ON;

		UPDATE [dbo].[BJobs] SET
			   [post_command_run_count]=@row_post_command_run_count
			   WHERE [id] = @row_id
	END

GO

--------------------------------------------------------------------------------
-- GetJobsAll
PRINT N'Creating [dbo].[GetJobsAll]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetJobsAll]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetJobsAll]
GO

	CREATE PROCEDURE [dbo].[GetJobsAll]
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[BJobs]
	END

GO

--------------------------------------------------------------------------------
-- GetBackupsInJob
PRINT N'Creating [dbo].[GetBackupsInJob]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetBackupsInJob]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetBackupsInJob]
GO

	CREATE PROCEDURE [dbo].[GetBackupsInJob]
		@job_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[Backup.Model.Backups] where [job_id] = @job_id
	END

GO

--------------------------------------------------------------------------------
-- GetBackupById
PRINT N'Creating [dbo].[GetBackupById]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetBackupById]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetBackupById]
GO

	CREATE PROCEDURE [dbo].[GetBackupById]
		@row_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[Backups] where [id] = @row_id
	END

GO

--------------------------------------------------------------------------------
-- GetObjectInBackup
PRINT N'Creating [dbo].[GetObjectInBackup]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetObjectInBackup]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetObjectInBackup]
GO

	CREATE PROCEDURE [dbo].[GetObjectInBackup]
		@row_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[ObjectsInBackups] where [dbo].[ObjectsInBackups].[id] = @row_id
	END

GO

--------------------------------------------------------------------------------
-- GetObjectInBackupAll
PRINT N'Creating [dbo].[GetObjectInBackupAll]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetObjectInBackupAll]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetObjectInBackupAll]
GO

	CREATE PROCEDURE [dbo].[GetObjectInBackupAll]
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[ObjectsInBackups]
	END

GO

--------------------------------------------------------------------------------
-- GetObjectInBackupByObjectIdAndBackupId
PRINT N'Creating [dbo].[GetObjectInBackupByObjectIdAndBackupId]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetObjectInBackupByObjectIdAndBackupId]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetObjectInBackupByObjectIdAndBackupId]
GO

	CREATE PROCEDURE [dbo].[GetObjectInBackupByObjectIdAndBackupId]
		@row_object_id uniqueidentifier,
		@row_backup_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[ObjectsInBackups] where [object_id] = @row_object_id AND [backup_id] = @row_backup_id
	END

GO

--------------------------------------------------------------------------------
-- GetBackupsAll
PRINT N'Creating [dbo].[GetBackupsAll]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetBackupsAll]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetBackupsAll]
GO

	CREATE PROCEDURE [dbo].[GetBackupsAll]
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[Backups]
	END

GO

--------------------------------------------------------------------------------
-- GetObjectsInBackup
PRINT N'Creating [dbo].[GetObjectsInBackup]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetObjectsInBackup]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetObjectsInBackup]
GO

	CREATE PROCEDURE [dbo].[GetObjectsInBackup]
		@row_backup_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[ObjectsInBackups] where [dbo].[ObjectsInBackups].[id] = @row_backup_id
	END

GO

--------------------------------------------------------------------------------
-- UpdateObjectInBackupRow
PRINT N'Creating [dbo].[UpdateObjectInBackupRow]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateObjectInBackupRow]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateObjectInBackupRow]
GO

	CREATE PROCEDURE [dbo].[UpdateObjectInBackupRow]
			@row_id uniqueidentifier,
			@row_object_id uniqueidentifier,
			@row_backup_id uniqueidentifier,
			@row_filename nvarchar(1000),
			@row_is_corrupted bit,
			@row_state int,
			@row_inside_dir nvarchar(400),
			@row_is_full bit,
			@row_creation_time datetime,
			@row_approx_size bigint,
			@row_proccess_id int	
	AS
	BEGIN
		SET NOCOUNT ON;

		UPDATE [dbo].[ObjectsInBackups] SET
			   [object_id]      =@row_object_id,
			   [backup_id]		=@row_backup_id,
			   [filename]		=@row_filename,
			   [is_corrupted]	=@row_is_corrupted,
			   [state]			=@row_state,
			   [inside_dir]		=@row_inside_dir,
			   [is_full]		=@row_is_full,
			   [creation_time]	=@row_creation_time,
			   [approx_size]	=@row_approx_size,
			   [proccess_id]	=@row_proccess_id 
			   where [id] = @row_id

	END	

GO

--------------------------------------------------------------------------------
-- UpdateBackupRow
PRINT N'Creating [dbo].[UpdateBackupRow]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateBackupRow]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateBackupRow]
GO

	CREATE PROCEDURE [dbo].[UpdateBackupRow]
			@row_id uniqueidentifier,
			@row_creation_time datetime,
			@row_is_rollback bit,
			@row_host_id uniqueidentifier,
			@row_linked_rollback uniqueidentifier,
			@row_job_name nvarchar(255),
			@row_job_id uniqueidentifier,
			@row_job_type int,
			@row_is_retry bit,
			@row_file_name nvarchar(255),
			@row_stats xml,
			@row_version int,
			@row_job_source_type int,
			@row_is_last bit	
	AS
	BEGIN
		SET NOCOUNT ON;

		UPDATE [dbo].[Backups] SET
			   [creation_time]    =@row_creation_time,
			   [is_rollback]	  =@row_is_rollback,
			   [host_id]		  =@row_host_id,
			   [linked_rollback]  =@row_linked_rollback,
			   [job_name]		  =@row_job_name,
			   [job_id]			  =@row_job_id,
			   [job_type]		  =@row_job_type,
			   [is_retry]		  =@row_is_retry,
			   [file_name]		  =@row_file_name,
			   [stats]			  =@row_stats,
			   [version]		  =@row_version,
			   [job_source_type]  =@row_job_source_type,
			   [is_last]		  =@row_is_last 
				where [id] = @row_id
	END	

GO

--------------------------------------------------------------------------------
-- GetAllLastBackups
PRINT N'Creating [dbo].[GetAllLastBackups]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetAllLastBackups]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetAllLastBackups]
GO

	CREATE PROCEDURE [dbo].[GetAllLastBackups]
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[Backups] where [id] = [linked_rollback] AND ([job_type] = 0 OR [job_type] = 1)
	END

GO

--------------------------------------------------------------------------------
-- GetAllLastBackupsByType
PRINT N'Creating [dbo].[GetAllLastBackupsByType]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetAllLastBackupsByType]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetAllLastBackupsByType]
GO

	CREATE PROCEDURE [dbo].[GetAllLastBackupsByType]
		@row_type int
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[Backups] where [id] = [linked_rollback] AND [job_type] = @row_type
	END

GO

--------------------------------------------------------------------------------
-- AddObjectRow
PRINT N'Creating [dbo].[AddObjectRow]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[AddObjectRow]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[AddObjectRow]
GO

	CREATE PROCEDURE [dbo].[AddObjectRow]
			   @row_id uniqueidentifier,
			   @row_type int,
			   @row_host_id uniqueidentifier,
			   @row_object_name nvarchar(2000),
			   @row_object_id nvarchar(2000),
			   @row_viobject_type nvarchar(50),
			   @row_guest_os xml,
			   @row_path nvarchar(400),
			   @platform int,
			   @uuid nvarchar(256),
			   @displayName	nvarchar(256)
	AS
	BEGIN
		SET NOCOUNT ON;

		INSERT INTO [dbo].[BObjects]
			   ([id]
			   ,[type]
			   ,[host_id]
			   ,[object_name]
			   ,[object_id]
			   ,[viobject_type]
			   ,[guest_os]
			   ,[path]
			   ,[platform]
			   ,[uuid]
			   ,[display_name])
		 VALUES
			   (@row_id,
			   @row_type,
			   @row_host_id,
			   @row_object_name,
			   @row_object_id,
			   @row_viobject_type,
			   @row_guest_os,
			   @row_path,
			   @platform,
			   @uuid,
			   @displayName)

		EXEC UpdateObjectUniqueKeyHash @row_host_id, @row_id

	END

GO

--------------------------------------------------------------------------------
-- GetObjectByHostIdAndObjectId
PRINT N'Creating [dbo].[GetObjectByHostIdAndObjectId]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetObjectByHostIdAndObjectId]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetObjectByHostIdAndObjectId]
GO

	CREATE PROCEDURE [dbo].[GetObjectByHostIdAndObjectId]
		@row_host_id uniqueidentifier,
		@row_object_id nvarchar(2000)
	AS
	BEGIN
		SET NOCOUNT ON;

		IF (@row_object_id IS NULL)
			SELECT * FROM [dbo].[BObjects] WHERE [host_id] = @row_host_id AND [object_id] IS NULL
		ELSE
			SELECT * FROM [dbo].[BObjects] WHERE [host_id] = @row_host_id AND [object_id] = @row_object_id

	END

GO

--------------------------------------------------------------------------------
-- GetSession
PRINT N'Creating [dbo].[GetSession]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetSession]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetSession]
GO

	CREATE PROCEDURE [dbo].[GetSession]
		@row_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * 
		
		FROM [dbo].[Backup.Model.JobSessions] INNER JOIN [dbo].[Backup.Model.BackupJobSessions] 
			ON [dbo].[Backup.Model.JobSessions].[id] = [dbo].[Backup.Model.BackupJobSessions].[id]
			
		WHERE [dbo].[Backup.Model.JobSessions].[id] = @row_id		
	END

GO

--------------------------------------------------------------------------------
-- UpdateSessionRow
PRINT N'Creating [dbo].[UpdateSessionRow]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateSessionRow]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateSessionRow]
GO

	CREATE PROCEDURE [dbo].[UpdateSessionRow]
			   @row_id uniqueidentifier,
			   @row_creation_time datetime,
			   @row_job_id uniqueidentifier,
			   @row_job_name nvarchar(255),
			   @row_result int,
			   @row_progress int,
			   @row_description text,
			   @row_job_type int,
			   @row_is_retry bit,
			   @row_end_time datetime,
			   @row_operation nvarchar(400),
			   @row_total_objects int,
			   @row_processed_objects int,
			   @row_total_size bigint,
			   @row_total_used_size bigint,
			   @row_processed_size bigint,
			   @row_processed_used_size bigint,
			   @row_job_source_type int,
			   @row_avg_speed bigint,
			   @row_is_startfull bit,
			   @row_transport_type int,
			   @row_state int,
			   @row_lease_id uniqueidentifier,
			   @orig_session_id uniqueidentifier,
			   @cur_point_id uniqueidentifier,
			   @row_run_manually bit,
			   @row_read_size bigint,
			   @row_read_average_size bigint,
			   @row_stored_size bigint,
			   @row_aux_data xml,
			   @row_job_spec xml,
			   @will_be_retried bit,
			   @row_backed_up_size bigint,
			   @row_backup_total_size bigint
	AS
	BEGIN
		SET NOCOUNT ON;
			
		declare @usn bigint
		
		exec [dbo].[IncrementUsn] @usn OUTPUT
		UPDATE [dbo].[Backup.Model.JobSessions] SET
			   [creation_time]		=@row_creation_time,
			   [end_time]			=@row_end_time,
			   [operation]			=@row_operation,
			   [job_id]				=@row_job_id,
			   [job_name]			=@row_job_name,
			   [result]				=@row_result,
			   [progress]			=@row_progress,
			   [description]		=@row_description,
			   [job_type]			=@row_job_type,
			   [state]				=@row_state,
			   [lease_id]			=@row_lease_id,
			   [orig_session_id]	=@orig_session_id,
			   [run_manually]       =@row_run_manually,
			   [aux_data]			=@row_aux_data,
			   [job_spec]			=@row_job_spec,
			   [usn]                =@usn
		WHERE [id] = @row_id  

		exec [dbo].[IncrementUsn] @usn OUTPUT
		UPDATE [dbo].[Backup.Model.BackupJobSessions] SET
			   [is_retry]			 =@row_is_retry,
			   [total_objects]		 =@row_total_objects,
			   [processed_objects]	 =@row_processed_objects,
			   [total_size]			 =@row_total_size,
			   [total_used_size]	 =@row_total_used_size,
			   [processed_size]		 =@row_processed_size,
			   [processed_used_size] =@row_processed_used_size,
			   [job_source_type]	 =@row_job_source_type,
			   [avg_speed]			 =@row_avg_speed,
			   [is_startfull]		 =@row_is_startfull,
			   [transport_type]		 =@row_transport_type,
			   [read_size]			 =@row_read_size,
			   [read_average_size]	 =@row_read_average_size,
			   [stored_size]		 =@row_stored_size,
			   [cur_point_id]		 =
										CASE 
										WHEN EXISTS (SELECT * FROM [dbo].[Backup.Model.Points] WHERE [dbo].[Backup.Model.Points].[id] = @cur_point_id) THEN @cur_point_id
										ELSE null
										END,
			   [usn]                =@usn,
			   [backed_up_size]		=@row_backed_up_size,
			   [backup_total_size]  =@row_backup_total_size,
			   [will_be_retried]	=@will_be_retried
			   WHERE [id] = @row_id
	           
	END	

GO

--------------------------------------------------------------------------------
-- UpdateSessionState
PRINT N'Creating [dbo].[UpdateSessionState]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateSessionState]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateSessionState]
GO

	CREATE PROCEDURE [dbo].[UpdateSessionState]
			   @row_id uniqueidentifier,
			   @row_state int	
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT
		
		UPDATE [dbo].[Backup.Model.JobSessions] SET
			   [state]				=@row_state,
			   [usn]                =@usn
			   WHERE [id] = @row_id
	           
	END	

GO

--------------------------------------------------------------------------------
-- AddSessionInfoRow
PRINT N'Creating [dbo].[AddSessionInfoRow]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[AddSessionInfoRow]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[AddSessionInfoRow]
GO

	CREATE PROCEDURE [dbo].[AddSessionInfoRow]
			   @row_id uniqueidentifier,
			   @row_session_id uniqueidentifier,
			   @row_creation_time datetime,
			   @row_object_name nvarchar(2000),
			   @row_status int,
			   @row_reason ntext,
			   @row_object_id uniqueidentifier,
			   @row_end_time datetime,
			   @row_operation nvarchar(400),
			   @row_total_objects int,
			   @row_processed_objects int,
			   @row_total_size bigint,
			   @row_total_used_size bigint,
			   @row_processed_size bigint,
			   @row_processed_used_size bigint,
			   @row_mode int,
			   @row_avg_speed bigint,
			   @row_change_tracking bit,
			   @row_read_size bigint,
			   @row_read_average_size bigint,
			   @row_stored_size bigint,
			   @row_queued_time datetime,
			   @row_work_details xml,
			   @row_object_platfrom int 
	AS
	BEGIN
		SET NOCOUNT ON;

		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		INSERT INTO [dbo].[Backup.Model.BackupTaskSessions]
			   ([id]
			   ,[session_id]
			   ,[creation_time]
			   ,[object_name]
			   ,[status]
			   ,[reason]
			   ,[object_id]
			   ,[end_time]
			   ,[operation]
			   ,[total_objects]
			   ,[processed_objects]
			   ,[total_size]
			   ,[total_used_size]
			   ,[processed_size]
			   ,[processed_used_size]
			   ,[mode]
			   ,[avg_speed]
			   ,[change_tracking]
			   ,[read_size]
			   ,[read_average_size]
			   ,[stored_size]
			   ,[queued_time]
			   ,[work_details]
			   ,[usn]
			   ,[object_platform])

		 VALUES
			   (@row_id,
			   @row_session_id,
			   @row_creation_time,
			   @row_object_name,
			   @row_status,
			   @row_reason,
			   @row_object_id,
			   @row_end_time,
			   @row_operation,
			   @row_total_objects,
			   @row_processed_objects,
			   @row_total_size,
			   @row_total_used_size,
			   @row_processed_size,
			   @row_processed_used_size,
			   @row_mode,
			   @row_avg_speed,
			   @row_change_tracking,
			   @row_read_size,
			   @row_read_average_size,
			   @row_stored_size,
			   @row_queued_time,
			   @row_work_details,
			   @usn,
			   @row_object_platfrom)
	           
	END	

GO

--------------------------------------------------------------------------------
-- UpdateSessionInfoRow
PRINT N'Creating [dbo].[UpdateSessionInfoRow]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateSessionInfoRow]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateSessionInfoRow]
GO

	CREATE PROCEDURE [dbo].[UpdateSessionInfoRow]
			   @row_id uniqueidentifier,
			   @row_session_id uniqueidentifier,
			   @row_creation_time datetime,
			   @row_object_name nvarchar(2000),
			   @row_status int,
			   @row_object_id uniqueidentifier,
			   @row_end_time datetime,
			   @row_operation nvarchar(400),
			   @row_total_objects int,
			   @row_processed_objects int,
			   @row_total_size bigint,
			   @row_total_used_size bigint,
			   @row_processed_size bigint,
			   @row_processed_used_size bigint,
			   @row_mode int,
			   @row_avg_speed bigint,
			   @row_change_tracking bit,
			   @row_read_size bigint,
			   @row_read_average_size bigint,
			   @row_stored_size bigint,
			   @row_work_details xml
	AS
	BEGIN
		SET NOCOUNT ON;

		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		UPDATE [dbo].[Backup.Model.BackupTaskSessions] SET
			   [session_id]			=@row_session_id,
			   [creation_time]		=@row_creation_time,
			   [object_name]		=@row_object_name,
			   [status]				=@row_status,
			   [object_id]			=@row_object_id,
			   [end_time]			=@row_end_time,
			   [operation]			=@row_operation,
			   [total_objects]		=@row_total_objects,
			   [processed_objects]	=@row_processed_objects,
			   [total_size]			=@row_total_size,
			   [total_used_size]	=@row_total_used_size,
			   [processed_size]		=@row_processed_size,
			   [processed_used_size]=@row_processed_used_size,
			   [mode]				=@row_mode,
			   [avg_speed]			=@row_avg_speed,
			   [change_tracking]	=@row_change_tracking,
			   [read_size]			=@row_read_size,
			   [read_average_size]	=@row_read_average_size,
			   [stored_size]		=@row_stored_size,
			   [work_details]       =@row_work_details,
			   [usn]                =@usn
		WHERE
			[id] = @row_id
	END

GO

--------------------------------------------------------------------------------
-- GetSessionInfo
PRINT N'Creating [dbo].[GetSessionInfo]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetSessionInfo]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetSessionInfo]
GO

	CREATE PROCEDURE [dbo].[GetSessionInfo]
		@row_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[Backup.Model.BackupTaskSessions] where [id] = @row_id
	END

GO

--------------------------------------------------------------------------------
-- GetSessionInfos
PRINT N'Creating [dbo].[GetSessionInfos]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetSessionInfos]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetSessionInfos]
GO

	CREATE PROCEDURE [dbo].[GetSessionInfos]
		@row_session_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[Backup.Model.BackupTaskSessions] where [session_id] = @row_session_id order by [queued_time] ASC
	END

GO

--------------------------------------------------------------------------------
-- GetAllBSessions
PRINT N'Creating [dbo].[GetAllBSessions]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetAllBSessions]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetAllBSessions]
GO

	CREATE PROCEDURE [dbo].[GetAllBSessions]
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * 	
		FROM [dbo].[Backup.Model.JobSessions] INNER JOIN [dbo].[Backup.Model.BackupJobSessions] 
			ON [dbo].[Backup.Model.JobSessions].[id] = [dbo].[Backup.Model.BackupJobSessions].[id]
			
		WHERE [job_type] in (0, 1, 2, 51)
	END

GO

--------------------------------------------------------------------------------
-- GetSessionsForJob
PRINT N'Creating [dbo].[GetSessionsForJob]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetSessionsForJob]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetSessionsForJob]
GO

	CREATE PROCEDURE [dbo].[GetSessionsForJob]
		@row_job_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * 
		
		FROM [dbo].[Backup.Model.JobSessions] INNER JOIN [dbo].[Backup.Model.BackupJobSessions] 
			ON [dbo].[Backup.Model.JobSessions].[id] = [dbo].[Backup.Model.BackupJobSessions].[id]
		
		WHERE [job_id] = @row_job_id
	END

GO

PRINT N'Creating [dbo].[GetBaseSessionsForJob]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetBaseSessionsForJob]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetBaseSessionsForJob]
GO

	CREATE PROCEDURE [dbo].[GetBaseSessionsForJob]
		@row_job_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * 
		
		FROM [dbo].[Backup.Model.JobSessions]
		
		WHERE [job_id] = @row_job_id
	END

GO

--------------------------------------------------------------------------------
-- FindLastJobSession
PRINT N'Creating [dbo].[FindLastJobSession]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[FindLastJobSession]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[FindLastJobSession]
GO

	CREATE PROCEDURE [dbo].[FindLastJobSession]
		@row_job_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT TOP(1) * 
		
		FROM [dbo].[Backup.Model.JobSessions] INNER JOIN [dbo].[Backup.Model.BackupJobSessions] 
			ON [dbo].[Backup.Model.JobSessions].[id] = [dbo].[Backup.Model.BackupJobSessions].[id]
			
			
		WHERE [job_id] = @row_job_id ORDER BY [dbo].[Backup.Model.JobSessions].[creation_time] DESC
	END

GO

--------------------------------------------------------------------------------
-- FindLastJobSessionBase
PRINT N'Creating [dbo].[FindLastJobSessionBase]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[FindLastJobSessionBase]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[FindLastJobSessionBase]
GO

	CREATE PROCEDURE [dbo].[FindLastJobSessionBase]
		@row_job_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT TOP(1) * 	
		FROM [dbo].[Backup.Model.JobSessions] 
		WHERE [job_id] = @row_job_id ORDER BY [dbo].[Backup.Model.JobSessions].[creation_time] DESC
	END
GO

--------------------------------------------------------------------------------
-- GetNextBackup
PRINT N'Creating [dbo].[GetNextBackup]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetNextBackup]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetNextBackup]
GO

	CREATE PROCEDURE [dbo].[GetNextBackup]
		@row_backup_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[Backups] where [id] = (select [linked_rollback] from Backups where [id] = @row_backup_id) AND [id] <> @row_backup_id
	END

GO

--------------------------------------------------------------------------------
-- GetPrevBackup
PRINT N'Creating [dbo].[GetPrevBackup]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetPrevBackup]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetPrevBackup]
GO

	CREATE PROCEDURE [dbo].[GetPrevBackup]
		@row_backup_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[Backups] where [linked_rollback] = @row_backup_id AND [linked_rollback] <> [id]
	END

GO

--------------------------------------------------------------------------------
-- SetBackupStatsNull
PRINT N'Creating [dbo].[SetBackupStatsNull]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[SetBackupStatsNull]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[SetBackupStatsNull]
GO

	CREATE PROCEDURE [dbo].[SetBackupStatsNull]
		@row_backup_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		UPDATE [dbo].[Backups] SET [stats] = NULL where [id] = @row_backup_id
	END

GO

--------------------------------------------------------------------------------
-- AddObjectInJobRow
PRINT N'Creating [dbo].[AddObjectInJobRow]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[AddObjectInJobRow]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[AddObjectInJobRow]
GO

	CREATE PROCEDURE [dbo].[AddObjectInJobRow]
			   @row_id uniqueidentifier,
			   @row_job_id uniqueidentifier,
			   @row_object_id uniqueidentifier,
			   @row_folder_id uniqueidentifier,
			   @row_vss_options xml,
			   @row_approx_size bigint,
			   @row_location nvarchar(1024),
			   @row_type int,
			   @row_disk_filter nvarchar(max),
			   @row_update_vmx bit,
			   @platform int,
			   @row_order_no int,
			   @row_ex_options xml
	AS
	BEGIN
		SET NOCOUNT ON;

		INSERT INTO [dbo].[ObjectsInJobs]
			   ([id]
			   ,[job_id]
			   ,[object_id]
			   ,[folder_id]
			   ,[vss_options]
			   ,[approx_size]
			   ,[location]
			   ,[type]
			   ,[disk_filter]
			   ,[update_vmx]
			   ,[platform]
			   ,[order_no]
			   ,[ex_options])
		 VALUES
			   (@row_id,
			   @row_job_id,
			   @row_object_id,
			   @row_folder_id,
			   @row_vss_options,
			   @row_approx_size,
			   @row_location,
			   @row_type,
			   @row_disk_filter,
			   @row_update_vmx,
			   @platform,
			   @row_order_no,
			   @row_ex_options)
	END	

GO

--------------------------------------------------------------------------------
-- GetObjectInJob
PRINT N'Creating [dbo].[GetObjectInJob]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetObjectInJob]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetObjectInJob]
GO

	CREATE PROCEDURE [dbo].[GetObjectInJob]
		@row_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[ObjectsInJobs]  oj 
		LEFT JOIN [dbo].[JobVssCredentials] vc ON oj.id = vc.oij_id
		LEFT JOIN [dbo].[Credentials] c ON c.id = vc.credentials_id
		where oj.[id] = @row_id
	END

GO

--------------------------------------------------------------------------------
-- AddObjectInBackupRow
PRINT N'Creating [dbo].[AddObjectInBackupRow]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[AddObjectInBackupRow]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[AddObjectInBackupRow]
GO

	CREATE PROCEDURE [dbo].[AddObjectInBackupRow]
			@row_id uniqueidentifier,
			@row_object_id uniqueidentifier,
			@row_backup_id uniqueidentifier,
			@row_filename nvarchar(1000),
			@row_is_corrupted bit,
			@row_state int,
			@row_inside_dir nvarchar(400),
			@row_is_full bit,
			@row_creation_time datetime,
			@row_approx_size bigint,
			@row_proccess_id int	
	AS
	BEGIN
		SET NOCOUNT ON;

		INSERT INTO [dbo].[ObjectsInBackups]
			   ([id]
			   ,[object_id]
			   ,[backup_id]
			   ,[filename]
			   ,[is_corrupted]
			   ,[state]
			   ,[inside_dir]
			   ,[is_full]
			   ,[creation_time]
			   ,[approx_size]
			   ,[proccess_id])
		 VALUES
			   (@row_id,
				@row_object_id,
				@row_backup_id,
				@row_filename,
				@row_is_corrupted,
				@row_state,
				@row_inside_dir,
				@row_is_full,
				@row_creation_time,
				@row_approx_size,
				@row_proccess_id)
	END

GO

--------------------------------------------------------------------------------
-- AddSessionRow
PRINT N'Creating [dbo].[AddSessionRow]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[AddSessionRow]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[AddSessionRow]
GO

	CREATE PROCEDURE [dbo].[AddSessionRow]
			   @row_id uniqueidentifier,
			   @row_creation_time datetime,
			   @row_job_id uniqueidentifier,
			   @row_job_name nvarchar(255),
			   @row_result int,
			   @row_progress int,
			   @row_description text,
			   @row_job_type int,
			   @row_is_retry bit,
			   @row_end_time datetime,
			   @row_operation nvarchar(400),
			   @row_total_objects int,
			   @row_processed_objects int,
			   @row_total_size bigint,
			   @row_total_used_size bigint,
			   @row_processed_size bigint,
			   @row_processed_used_size bigint,
			   @row_job_source_type int,
			   @row_avg_speed bigint,
			   @row_is_startfull bit,
			   @row_transport_type int,
			   @row_state int,
			   @row_lease_id uniqueidentifier,
			   @orig_session_id uniqueidentifier,
			   @row_run_manually bit,
			   @row_read_size bigint,
			   @row_read_average_size bigint,
			   @row_stored_size bigint,
			   @row_aux_data xml,
			   @row_job_spec xml,
			   @will_be_retried bit
			   
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT
	    
		INSERT INTO [dbo].[Backup.Model.JobSessions]
			   ([id]
			   ,[creation_time]
			   ,[job_id]
			   ,[job_name]
			   ,[result]
			   ,[progress]
			   ,[description]
			   ,[job_type]
			   ,[end_time]
			   ,[operation]
			   ,[state]
			   ,[lease_id]
			   ,[orig_session_id]
			   ,[run_manually]
			   ,[aux_data]
			   ,[job_spec]			   
			   ,[usn]
			   )
		 VALUES
			   (@row_id,
			   @row_creation_time,
			   @row_job_id,
			   @row_job_name,
			   @row_result,
			   @row_progress,
			   @row_description,
			   @row_job_type,
			   @row_end_time,
			   @row_operation,
			   @row_state,
			   @row_lease_id,
			   @orig_session_id,  
			   @row_run_manually,
			   @row_aux_data,  
			   @row_job_spec,			   
			   @usn)
				
		INSERT INTO [dbo].[Backup.Model.BackupJobSessions]
			   ([id]
			   ,[is_retry]
			   ,[total_objects]
			   ,[processed_objects]
			   ,[total_size]
			   ,[total_used_size]
			   ,[processed_size]
			   ,[processed_used_size]
			   ,[job_source_type]
			   ,[avg_speed]
			   ,[is_startfull]
			   ,[transport_type]
			   ,[read_size]
			   ,[read_average_size]
			   ,[stored_size]
			   ,[will_be_retried]
			   ,[usn])
		 VALUES
			   (@row_id,
			   @row_is_retry,
			   @row_total_objects,
			   @row_processed_objects,
			   @row_total_size,
			   @row_total_used_size,
			   @row_processed_size,
			   @row_processed_used_size,
			   @row_job_source_type,
			   @row_avg_speed,
			   @row_is_startfull,
			   @row_transport_type,
			   @row_read_size,
			   @row_read_average_size,
			   @row_stored_size,
			   @will_be_retried,
			   @usn)
	           
	END	

GO

--------------------------------------------------------------------------------
-- GetPermissionsByPermission
PRINT N'Creating [dbo].[GetPermissionsByPermission]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetPermissionsByPermission]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetPermissionsByPermission]
GO

	CREATE PROCEDURE [dbo].[GetPermissionsByPermission]
		@row_permission int
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[Backup.Security.RolePermissions] where [dbo].[Backup.Security.RolePermissions].[permission] = @row_permission
	END

GO

--------------------------------------------------------------------------------
-- GetPermissionsBySid
PRINT N'Creating [dbo].[GetPermissionsBySid]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetPermissionsBySid]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetPermissionsBySid]
GO

	CREATE PROCEDURE [dbo].[GetPermissionsBySid]
		@row_sid nvarchar(1000)
	AS
	BEGIN
		SET NOCOUNT ON;

	SELECT 
		[dbo].[Backup.Security.RolePermissions].[id] id,
		[dbo].[Backup.Security.RolePermissions].[role_id] role_id,
		[dbo].[Backup.Security.RolePermissions].[permission] permission
	FROM 
		[dbo].[Backup.Security.Accounts],
		[dbo].[Backup.Security.RoleAccounts],
		[dbo].[Backup.Security.RolePermissions]
	WHERE
		[dbo].[Backup.Security.Accounts].[sid] = @row_sid AND
		[dbo].[Backup.Security.Accounts].[id] = [dbo].[Backup.Security.RoleAccounts].[account_id] AND
		[dbo].[Backup.Security.RoleAccounts].[role_id] = [dbo].[Backup.Security.RolePermissions].[role_id]

	END

GO

--------------------------------------------------------------------------------
-- GetDRTaskSession
PRINT N'Creating [dbo].[GetDRTaskSession]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetDRTaskSession]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetDRTaskSession]
GO

	CREATE PROCEDURE [dbo].[GetDRTaskSession]
				@row_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT * FROM [Backup.Model.SbTaskSessions] WHERE [id] = @row_id   
	END	

GO

--------------------------------------------------------------------------------
-- GetSbTaskSessionsAllForSbSession
PRINT N'Creating [dbo].[GetSbTaskSessionsAllForSbSession]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetSbTaskSessionsAllForSbSession]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetSbTaskSessionsAllForSbSession]
GO

	CREATE PROCEDURE [dbo].[GetSbTaskSessionsAllForSbSession]
				@row_drsession_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT * FROM [Backup.Model.SbTaskSessions] WHERE [drsession_id] = @row_drsession_id   
		order by order_num asc
	END	

GO

--------------------------------------------------------------------------------
-- GetSbTaskSessionsToStartForSbSession
PRINT N'Creating [dbo].[GetSbTaskSessionsToStartForSbSession]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetSbTaskSessionsToStartForSbSession]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetSbTaskSessionsToStartForSbSession]
GO

	CREATE PROCEDURE [dbo].[GetSbTaskSessionsToStartForSbSession]
		@row_drsession_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT * FROM [Backup.Model.SbTaskSessions]
		WHERE
			[drsession_id] = @row_drsession_id and
			[state] = 0 -- pending
		order by order_num asc
	END	

GO

--------------------------------------------------------------------------------
-- GetSbTaskSessionsToStopForSbSession
PRINT N'Creating [dbo].[GetSbTaskSessionsToStopForSbSession]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetSbTaskSessionsToStopForSbSession]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetSbTaskSessionsToStopForSbSession]
GO

	CREATE PROCEDURE [dbo].[GetSbTaskSessionsToStopForSbSession]
		@row_drsession_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT * FROM [Backup.Model.SbTaskSessions]
		WHERE
			[drsession_id] = @row_drsession_id and
			[restore_counter] = 0 and --stop
			[state] != 4 --stopped
		order by order_num asc
	END	

GO

--------------------------------------------------------------------------------
-- AddDRTaskSession
PRINT N'Creating [dbo].[AddDRTaskSession]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[AddDRTaskSession]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[AddDRTaskSession]
GO

	CREATE PROCEDURE [dbo].[AddDRTaskSession]
				@row_id uniqueidentifier,
				@row_drsession_id uniqueidentifier,
				@row_type int,
				@row_object_name nvarchar(max),
				@row_object_id uniqueidentifier,
				@row_oib_id uniqueidentifier,
				@row_overall_status int,
				@row_description nvarchar(max),
				@row_start_time DateTime,
				@row_finish_time DateTime,
				@row_total_steps int,
				@row_processed_steps int,
				@row_powerOn_status int,
				@row_heartbeat_status int,
				@row_ping_status int,
				@row_test_script_status int,
				@row_powerOff_status int,
				@row_test_script_error_code int,
				
				@row_vm_ref nvarchar(max),
				
				@row_percent int,
				@row_apliance_ip nvarchar(80),
				@row_subnet_ip   nvarchar(80),
				@row_subnet_mask nvarchar(80),
				
				@row_vm_external_ip nvarchar(80),
				@row_state int,
				@row_control int,
				@row_oiag_id uniqueidentifier,
				@row_restore_counter int,
				@row_test_scripts_results xml,
				@row_validation_status int
	AS
	BEGIN
		SET NOCOUNT ON;

		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT
		
		INSERT INTO [dbo].[Backup.Model.SbTaskSessions]
			   ([id],
				[drsession_id],
				[type],
				[object_name],
				[object_id],
				[oib_id],
				[overall_status],
				[description],
				[start_time],
				[finish_time],
				[total_steps],
				[processed_steps],
				[powerOn_status],
				[heartbeat_status],
				[ping_status],
				[test_script_status],
				[powerOff_status],
				[test_script_error_code],
				[vm_ref],
				[percent],
				[appliance_ip],
				[subnet_ip],
				[subnet_mask],
				[vm_external_ip],
				[state],
				[control],
				[oiag_id],
				[restore_counter],
				[test_scripts_results],
				[validation_status],
				[usn]
			   )
		 VALUES
				(
				@row_id,
				@row_drsession_id,
				@row_type,
				@row_object_name,
				@row_object_id,
				@row_oib_id,
				@row_overall_status,
				@row_description,
				@row_start_time,
				@row_finish_time,
				@row_total_steps,
				@row_processed_steps,
				@row_powerOn_status,
				@row_heartbeat_status,
				@row_ping_status,
				@row_test_script_status,
				@row_powerOff_status,
				@row_test_script_error_code,
				@row_vm_ref,
				
				@row_percent,			
				@row_apliance_ip,
				@row_subnet_ip,
				@row_subnet_mask,
				
				@row_vm_external_ip,
				@row_state,
				@row_control,
				@row_oiag_id,
				@row_restore_counter,
				@row_test_scripts_results,
				@row_validation_status,
				@usn
				)
	END	
	
GO


--------------------------------------------------------------------------------
-- UpdateDRTaskSession
PRINT N'Creating [dbo].[UpdateDRTaskSession]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateDRTaskSession]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateDRTaskSession]
GO

	CREATE PROCEDURE [dbo].[UpdateDRTaskSession]
				@row_id uniqueidentifier,
				@row_drsession_id uniqueidentifier,
				@row_object_name nvarchar(max),
				@row_object_id uniqueidentifier,
				@row_oib_id uniqueidentifier,
				@row_overall_status int,
				@row_description nvarchar(max),
				@row_start_time DateTime,
				@row_finish_time DateTime,
				@row_total_steps int,
				@row_processed_steps int,
				@row_powerOn_status int,
				@row_heartbeat_status int,
				@row_ping_status int,
				@row_test_script_status int,
				@row_powerOff_status int,
				@row_test_script_error_code int,
				@row_vm_ref nvarchar(max),
				
				@row_percent int,
				@row_apliance_ip nvarchar(80),
				@row_subnet_ip nvarchar(80),
				@row_subnet_mask nvarchar(80),
				
				@row_vm_external_ip nvarchar(80),
				@row_state int,
				@row_control int,
				@row_oiag_id uniqueidentifier,
				@row_test_scripts_results xml,
				@row_validation_status int
	AS
	BEGIN
		SET NOCOUNT ON;

		declare @usn bigint
		
		exec [dbo].[IncrementUsn] @usn OUTPUT
		UPDATE [dbo].[Backup.Model.SbTaskSessions] SET
				[drsession_id]				= @row_drsession_id,
				[object_name]				= @row_object_name,
				[object_id]					= @row_object_id,
				[oib_id]					= @row_oib_id,
				[overall_status]			= @row_overall_status,
				[description]				= @row_description,
				[start_time]				= @row_start_time,
				[finish_time]				= @row_finish_time,
				[total_steps]				= @row_total_steps,
				[processed_steps]			= @row_processed_steps,
				[powerOn_status]			= @row_powerOn_status,
				[heartbeat_status]			= @row_heartbeat_status,
				[ping_status]				= @row_ping_status,
				[test_script_status]		= @row_test_script_status,
				[powerOff_status]			= @row_powerOff_status,
				[test_script_error_code]	= @row_test_script_error_code,
				[vm_ref]					= @row_vm_ref,
				[percent]					= @row_percent,
				
				[appliance_ip]              = @row_apliance_ip,
				[subnet_ip]                 = @row_subnet_ip,
				[subnet_mask]               = @row_subnet_mask,
				
				[vm_external_ip]			= @row_vm_external_ip,
				[state]						= @row_state,
				[control]                   = @row_control,
				[oiag_id]                   = @row_oiag_id,
				[test_scripts_results]		= @row_test_scripts_results,
				[validation_status]			= @row_validation_status,
				[usn]                       = @usn
		where [id] = @row_id
		
	END	

GO

--------------------------------------------------------------------------------
-- DeleteDRTaskSession
PRINT N'Creating [dbo].[DeleteDRTaskSession]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DeleteDRTaskSession]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[DeleteDRTaskSession]
GO

	CREATE PROCEDURE [dbo].[DeleteDRTaskSession]
		@row_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		DELETE FROM [dbo].[Backup.Model.SbTaskSessions] WHERE [id] = @row_id
	END

GO

--------------------------------------------------------------------------------
-- GetVirtualLab
PRINT N'Creating [dbo].[GetVirtualLab]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetVirtualLab]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetVirtualLab]
GO

	CREATE PROCEDURE [dbo].[GetVirtualLab]
				@row_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT * FROM VirtualLabs WHERE [id] = @row_id  
	END	

GO

--------------------------------------------------------------------------------
-- GetVirtualLabsAll
PRINT N'Creating [dbo].[GetVirtualLabsAll]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetVirtualLabsAll]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetVirtualLabsAll]
GO

	CREATE PROCEDURE [dbo].[GetVirtualLabsAll]
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT * FROM VirtualLabs
	END	

GO

--------------------------------------------------------------------------------
-- GetVirtualLabByNameAndPlatform
PRINT N'Creating [dbo].[GetVirtualLabByNameAndPlatform]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetVirtualLabByNameAndPlatform]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetVirtualLabByNameAndPlatform]
GO

	CREATE PROCEDURE [dbo].[GetVirtualLabByNameAndPlatform]
				@row_name nvarchar(255),
				@row_platform int
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT 
			* 
		FROM 
			[dbo].[VirtualLabs]
		WHERE 
			UPPER([name]) = UPPER(@row_name) AND
			[platform] = @row_platform
	END	

GO

--------------------------------------------------------------------------------
-- GetVirtualLabByIdOnHost
PRINT N'Creating [dbo].[GetVirtualLabByIdOnHost]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetVirtualLabByIdOnHost]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetVirtualLabByIdOnHost]
GO

	CREATE PROCEDURE [dbo].[GetVirtualLabByIdOnHost]
		@row_id_onhost uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT top 1 * FROM VirtualLabs WHERE id_onhost = @row_id_onhost
	END	

GO

--------------------------------------------------------------------------------
-- GetVirtualLabByHostId
PRINT N'Creating [dbo].[GetVirtualLabByHostId]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetVirtualLabByHostId]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetVirtualLabByHostId]
GO

	CREATE PROCEDURE [dbo].[GetVirtualLabByHostId]
				@row_host_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT * FROM VirtualLabs WHERE [host_id] = @row_host_id
	END	

GO

--------------------------------------------------------------------------------
-- AddVirtualLabRow
PRINT N'Creating [dbo].[AddVirtualLabRow]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[AddVirtualLabRow]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[AddVirtualLabRow]
GO

	CREATE PROCEDURE [dbo].[AddVirtualLabRow]
				@row_id uniqueidentifier,
				@row_id_onhost uniqueidentifier,
				@row_name nvarchar(255),
				@row_description nvarchar(1024),
				@row_host_id uniqueidentifier,
				@row_vm_ref nvarchar(1024),
				@row_platform int
	AS
	BEGIN
		SET NOCOUNT ON;

		INSERT INTO [dbo].[VirtualLabs]
			   ([id]
			   ,[id_onhost]
			   ,[name]
			   ,[description]
			   ,[host_id]
			   ,[vm_ref]
			   ,[platform])
		 VALUES
			   (@row_id,
			   @row_id_onhost,
			   @row_name,
			   @row_description,
			   @row_host_id,
			   @row_vm_ref,
			   @row_platform)
	END	

GO

--------------------------------------------------------------------------------
-- UpdateVirtualLabRow
PRINT N'Creating [dbo].[UpdateVirtualLabRow]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateVirtualLabRow]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateVirtualLabRow]
GO

	CREATE PROCEDURE [dbo].[UpdateVirtualLabRow]
				@row_id uniqueidentifier,
				@row_id_onhost uniqueidentifier,
				@row_name nvarchar(255),
				@row_description nvarchar(1024),
				@row_host_id uniqueidentifier,
				@row_vm_ref nvarchar(1024),
				@row_platform int
	AS
	BEGIN
		SET NOCOUNT ON;

		UPDATE [dbo].[VirtualLabs] SET
			   [id_onhost]          = @row_id_onhost,
			   [name]				= @row_name,
			   [description]		= @row_description,
			   [host_id]			= @row_host_id,
			   [vm_ref]				= @row_vm_ref,
			   [platform]			= @row_platform
			   where [id] = @row_id      
	           
	END

GO	

--------------------------------------------------------------------------------
-- DeleteVirtualLab
PRINT N'Creating [dbo].[DeleteVirtualLab]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DeleteVirtualLab]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[DeleteVirtualLab]
GO

	CREATE PROCEDURE [dbo].[DeleteVirtualLab]
		@row_id uniqueidentifier
	AS
	BEGIN

		SET NOCOUNT ON;

		DELETE FROM [dbo].[VirtualLabs] WHERE [id] = @row_id
	END

GO

--------------------------------------------------------------------------------
-- AddObjectInApplicationGroup
PRINT N'Creating [dbo].[AddObjectInApplicationGroup]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[AddObjectInApplicationGroup]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[AddObjectInApplicationGroup]
GO

	CREATE PROCEDURE [dbo].[AddObjectInApplicationGroup]
			   @row_id uniqueidentifier,
			   @row_folder_id uniqueidentifier,
			   @row_object_id uniqueidentifier,
			   @row_backup_id uniqueidentifier,
			   @row_order int,
			   @row_guest_os_info xml,
			   @row_effective_memory bigint,
			   @row_options xml
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		INSERT INTO [dbo].[ObjectsInApplicationGroups]
			   ([id]
			   ,[folder_id]
			   ,[object_id]
			   ,[backup_id]
			   ,[order]
			   ,[guest_os_info]
			   ,[effective_memory]
			   ,[options]
			   ,[usn])
		 VALUES
			   (@row_id,
			   @row_folder_id,
			   @row_object_id,
			   @row_backup_id,
			   @row_order,
			   @row_guest_os_info,
			   @row_effective_memory,
			   @row_options,
			   @usn)
	END	

GO

--------------------------------------------------------------------------------
-- UpdateObjectInApplicationGroup
PRINT N'Creating [dbo].[UpdateObjectInApplicationGroup]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateObjectInApplicationGroup]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateObjectInApplicationGroup]
GO

	CREATE PROCEDURE [dbo].[UpdateObjectInApplicationGroup]
			   @row_id uniqueidentifier,
			   @row_folder_id uniqueidentifier,
			   @row_object_id uniqueidentifier,
			   @row_backup_id uniqueidentifier,
			   @row_order int,
			   @row_guest_os_info xml,
			   @row_effective_memory bigint,
			   @row_options xml
	AS
	BEGIN
		SET NOCOUNT ON;

		UPDATE [dbo].[ObjectsInApplicationGroups] SET
			   [folder_id]			   = @row_folder_id,
			   [object_id]			   = @row_object_id,
			   [backup_id]             = @row_backup_id,
			   [order]				   = @row_order,
			   [guest_os_info]		   = @row_guest_os_info,
			   [effective_memory]	   = @row_effective_memory,
			   [options]			   = @row_options
			   WHERE [id] = @row_id
	END	

GO

--------------------------------------------------------------------------------
-- DeleteObjectInApplicationGroup
PRINT N'Creating [dbo].[DeleteObjectInApplicationGroup]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DeleteObjectInApplicationGroup]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[DeleteObjectInApplicationGroup]
GO

	CREATE PROCEDURE [dbo].[DeleteObjectInApplicationGroup]
		@row_id uniqueidentifier
	AS
	BEGIN

		SET NOCOUNT ON;
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT
		
		DELETE FROM [dbo].[ObjectsInApplicationGroups] WHERE [id] = @row_id
		exec [dbo].[InsertTombStone] 'ObjectsInApplicationGroups', @row_id, @usn

	END

GO

--------------------------------------------------------------------------------
-- GetObjectInApplicationGroup
PRINT N'Creating [dbo].[GetObjectInApplicationGroup]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetObjectInApplicationGroup]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetObjectInApplicationGroup]
GO

	CREATE PROCEDURE [dbo].[GetObjectInApplicationGroup]
		@row_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT * from [dbo].[ObjectsInApplicationGroups] where [id] = @row_id
	END

GO

--------------------------------------------------------------------------------
-- GetObjectInApplicationGroupByObjectID
PRINT N'Creating [dbo].[GetObjectInApplicationGroupByObjectID]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetObjectInApplicationGroupByObjectID]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetObjectInApplicationGroupByObjectID]
GO

	CREATE PROCEDURE [dbo].[GetObjectInApplicationGroupByObjectID]
		@row_object_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT * from [dbo].[ObjectsInApplicationGroups] where [object_id] = @row_object_id
	END

GO

--------------------------------------------------------------------------------
-- GetObjectInApplicationGroupByFolderIdAndObjectId
PRINT N'Creating [dbo].[GetObjectInApplicationGroupByFolderIdAndObjectId]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetObjectInApplicationGroupByFolderIdAndObjectId]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetObjectInApplicationGroupByFolderIdAndObjectId]
GO

	CREATE PROCEDURE [dbo].[GetObjectInApplicationGroupByFolderIdAndObjectId]
			   @row_folder_id uniqueidentifier,
			   @row_object_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT * from [dbo].[ObjectsInApplicationGroups] where [folder_id] = @row_folder_id AND [object_id] = @row_object_id
	END

GO

--------------------------------------------------------------------------------
-- GetObjectInApplicationGroupByObjectIdAndBackupId
PRINT N'Creating GetObjectInApplicationGroupByObjectIdAndBackupId'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetObjectInApplicationGroupByObjectIdAndBackupId]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetObjectInApplicationGroupByObjectIdAndBackupId]
GO

	CREATE PROCEDURE [dbo].[GetObjectInApplicationGroupByObjectIdAndBackupId]
			   @row_folder_id uniqueidentifier,
			   @row_object_id uniqueidentifier,
			   @row_backup_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT * from [dbo].[ObjectsInApplicationGroups]
		where [folder_id] = @row_folder_id AND [object_id] = @row_object_id AND [backup_id] = @row_backup_id
	END

GO

--------------------------------------------------------------------------------
-- GetObjectsInApplicationGroup
PRINT N'Creating [dbo].[GetObjectsInApplicationGroup]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetObjectsInApplicationGroup]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetObjectsInApplicationGroup]
GO

	CREATE PROCEDURE [dbo].[GetObjectsInApplicationGroup]
		@row_folder_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT * from [dbo].[ObjectsInApplicationGroups] where [folder_id] = @row_folder_id
	END

GO

--------------------------------------------------------------------------------
-- Backup.Mgmt.RemoveLock
PRINT N'Creating [dbo].[Backup.Mgmt.RemoveLock]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Mgmt.RemoveLock]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Mgmt.RemoveLock]
GO

	CREATE PROCEDURE [dbo].[Backup.Mgmt.RemoveLock]
		@lock_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		
		DELETE FROM [dbo].[Backup.TrackedActions.LockItems]
        WHERE [dbo].[Backup.TrackedActions.LockItems].[lock_id] = @lock_id
        DELETE FROM [dbo].[Backup.TrackedActions.Locks]
        WHERE [dbo].[Backup.TrackedActions.Locks].[id] = @lock_id
	END
	
GO

--------------------------------------------------------------------------------
-- Backup.Mgmt.GetLocksById
PRINT N'Creating [dbo].[Backup.Mgmt.GetLocksById]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Mgmt.GetLocksById]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Mgmt.GetLocksById]
GO

	CREATE PROCEDURE [dbo].[Backup.Mgmt.GetLocksById]
		@leaseid uniqueidentifier	
	AS
	BEGIN
		SET NOCOUNT ON;
		
		SELECT
            [dbo].[Backup.TrackedActions.Locks].[id] as lock_id
        FROM [dbo].[Backup.TrackedActions.Locks]
        WHERE [dbo].[Backup.TrackedActions.Locks].[lease_id] = @leaseid
	END

GO

--------------------------------------------------------------------------------
-- Backup.Mgmt.GetAllLocks
PRINT N'Creating [dbo].[Backup.Mgmt.GetAllLocks]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Mgmt.GetAllLocks]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Mgmt.GetAllLocks]
GO

	CREATE PROCEDURE [dbo].[Backup.Mgmt.GetAllLocks]
	AS
	BEGIN
		SET NOCOUNT ON;
		
		SELECT
			[dbo].[Backup.TrackedActions.Locks].[id] as lock_id,
			[dbo].[Backup.TrackedActions.Locks].[session_id] as session_id,
			[dbo].[Backup.TrackedActions.Locks].[lock_type] as lock_type,
			[dbo].[Backup.TrackedActions.Locks].[lease_id] as lease_id,
			[dbo].[Backup.TrackedActions.LockItems].[lock_item_id] as lock_item_id,
			[session_name] = (SELECT TOP(1) [dbo].[Backup.Model.JobSessions].[job_name] 
								FROM [dbo].[Backup.Model.JobSessions] 
								WHERE [dbo].[Backup.Model.JobSessions].[id] = [dbo].[Backup.TrackedActions.Locks].[session_id] ),

			[session_type] = (SELECT TOP(1) [dbo].[Backup.Model.JobSessions].[job_type] 
								FROM [dbo].[Backup.Model.JobSessions] 
								WHERE [dbo].[Backup.Model.JobSessions].[id] = [dbo].[Backup.TrackedActions.Locks].[session_id] ),
																
			[lock_item_name] = (SELECT TOP(1) [dbo].[Backup.Model.Storages].[file_path]
								FROM [dbo].[Backup.Model.Storages]
								WHERE [dbo].[Backup.Model.Storages].[id] = [dbo].[Backup.TrackedActions.LockItems].[lock_item_id] )
		FROM [dbo].[Backup.TrackedActions.Locks]
		INNER JOIN [dbo].[Backup.TrackedActions.LockItems] ON [dbo].[Backup.TrackedActions.Locks].[id] = [dbo].[Backup.TrackedActions.LockItems].[lock_id]
	END

GO

--------------------------------------------------------------------------------
-- Backup.Mgmt.CreateItemLock
PRINT N'Creating [dbo].[Backup.Mgmt.CreateItemLock]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Mgmt.CreateItemLock]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Mgmt.CreateItemLock]
GO

	CREATE PROCEDURE [dbo].[Backup.Mgmt.CreateItemLock]
		@lock_item_id uniqueidentifier,
		@lock_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		
	INSERT INTO [dbo].[Backup.TrackedActions.LockItems] (lock_id, lock_item_id )
    VALUES( @lock_id, @lock_item_id)
    
	END

GO

--------------------------------------------------------------------------------
-- Backup.Mgmt.CreateLock
PRINT N'Creating [dbo].[Backup.Mgmt.CreateLock]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Mgmt.CreateLock]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Mgmt.CreateLock]
GO

	CREATE PROCEDURE [dbo].[Backup.Mgmt.CreateLock]
		@lock_id uniqueidentifier,
		@session_id uniqueidentifier,
		@lock_type int,		
		@lease_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		
        INSERT INTO [dbo].[Backup.TrackedActions.Locks] (id, lease_id, session_id, lock_type)
        VALUES( @lock_id, @lease_id, @session_id, @lock_type)
    
	END

GO

--------------------------------------------------------------------------------
-- Backup.Mgmt.UpdateLock
PRINT N'Creating [dbo].[Backup.Mgmt.UpdateLock]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Mgmt.UpdateLock]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Mgmt.UpdateLock]
GO

	CREATE PROCEDURE [dbo].[Backup.Mgmt.UpdateLock]
		@lock_id uniqueidentifier,
		@lock_type int
	AS
	BEGIN
		SET NOCOUNT ON;
		
        UPDATE [dbo].[Backup.TrackedActions.Locks]
			SET [dbo].[Backup.TrackedActions.Locks].[lock_type] = @lock_type
        WHERE [dbo].[Backup.TrackedActions.Locks].[id] = @lock_id
    
	END

GO

--------------------------------------------------------------------------------
-- ReportSessionsView
PRINT N'Creating [dbo].[ReportSessionsView]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[ReportSessionsView]') AND type in (N'V'))
	DROP VIEW [dbo].[ReportSessionsView]
GO

	CREATE VIEW [dbo].[ReportSessionsView]
	AS
		SELECT     dbo.[Backup.Model.JobSessions].id, dbo.[Backup.Model.JobSessions].job_name, dbo.[Backup.Model.JobSessions].state, 
						  dbo.[Backup.Model.JobSessions].creation_time, dbo.[Backup.Model.JobSessions].end_time, dbo.[Backup.Model.JobSessions].job_type, 
						  dbo.[Backup.Model.BackupJobSessions].is_startfull, dbo.[Backup.Model.BackupJobSessions].transport_type, dbo.[Backup.Model.JobSessions].operation, dbo.[Backup.Model.BackupJobSessions].processed_objects, 
						  dbo.[Backup.Model.BackupJobSessions].total_objects, dbo.[Backup.Model.JobSessions].result, dbo.[Backup.Model.BackupJobSessions].total_size, dbo.[Backup.Model.BackupJobSessions].total_used_size,
						  dbo.[Backup.Model.BackupJobSessions].processed_size,dbo.[Backup.Model.BackupJobSessions].processed_used_size,
						  dbo.[Backup.Model.JobSessions].progress, dbo.[Backup.Model.BackupJobSessions].is_retry, 
						  dbo.[Backup.Model.BackupJobSessions].avg_speed, dbo.[Backup.Model.BackupJobSessions].read_size, dbo.[Backup.Model.BackupJobSessions].read_average_size, dbo.[Backup.Model.BackupJobSessions].stored_size,
							  (SELECT     COUNT(id) AS Expr1
								FROM          dbo.[Backup.Model.BackupTaskSessions]
								WHERE      (session_id = dbo.[Backup.Model.BackupJobSessions].id) AND (status = 2)) AS failed, 
						  CASE WHEN [dbo].[Backup.Model.JobSessions].[usn] > [dbo].[Backup.Model.BackupJobSessions].[usn] THEN [dbo].[Backup.Model.JobSessions].[usn] ELSE [dbo].[Backup.Model.BackupJobSessions].[usn]
						   END AS usn
	FROM         dbo.[Backup.Model.JobSessions] LEFT OUTER JOIN
						  dbo.[Backup.Model.BackupJobSessions] ON dbo.[Backup.Model.JobSessions].id = dbo.[Backup.Model.BackupJobSessions].id
	WHERE     (dbo.[Backup.Model.JobSessions].job_type IN (0, 1, 2, 8))
	
GO

--------------------------------------------------------------------------------
-- ReportSessionsDeleteView
PRINT N'Creating [dbo].[ReportSessionsDeleteView]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[ReportSessionsDeleteView]') AND type in (N'P'))
	DROP PROCEDURE [dbo].[ReportSessionsDeleteView]
GO

	CREATE PROCEDURE [dbo].[ReportSessionsDeleteView]
		@row_usn bigint
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT uid FROM TombStones WHERE table_name= 'Backup.Model.JobSessions' AND usn > @row_usn
	END
	
GO

--------------------------------------------------------------------------------
-- ReportSbSessionsView
PRINT N'Creating [dbo].[ReportSbSessionsView]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[ReportSbSessionsView]') AND type in (N'V'))
	DROP VIEW [dbo].[ReportSbSessionsView]
GO

	CREATE VIEW [dbo].[ReportSbSessionsView]
	AS
		SELECT    
			[dbo].[Backup.Model.SbSessions].[id],
			[dbo].[Backup.Model.JobSessions].[job_id],
			[dbo].[Backup.Model.JobSessions].[job_name],
			[dbo].[Backup.Model.JobSessions].[result],
			[dbo].[Backup.Model.JobSessions].[operation],
			[dbo].[Backup.Model.JobSessions].[state],
			[dbo].[Backup.Model.JobSessions].[progress],
			[dbo].[Backup.Model.JobSessions].[creation_time],
			[dbo].[Backup.Model.JobSessions].[end_time],
			usn = CASE
				WHEN [dbo].[Backup.Model.JobSessions].[usn] > [dbo].[Backup.Model.SbSessions].[usn]
					THEN [dbo].[Backup.Model.JobSessions].[usn]
				ELSE [dbo].[Backup.Model.SbSessions].[usn]
			END

		FROM [dbo].[Backup.Model.JobSessions] RIGHT JOIN [dbo].[Backup.Model.SbSessions] 
		ON [dbo].[Backup.Model.JobSessions].[id] = [dbo].[Backup.Model.SbSessions].[id]

GO

--------------------------------------------------------------------------------
-- ReportSbSessionsDeleteView
PRINT N'Creating [dbo].[ReportSbSessionsDeleteView]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[ReportSbSessionsDeleteView]') AND type in (N'P'))
	DROP PROCEDURE [dbo].[ReportSbSessionsDeleteView]
GO

	CREATE PROCEDURE [dbo].[ReportSbSessionsDeleteView]
		@row_usn bigint
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT uid FROM TombStones WHERE table_name= 'Backup.Model.JobSessions' AND usn > @row_usn
		UNION
		SELECT uid FROM TombStones WHERE table_name= 'Backup.Model.SbSessions' AND usn > @row_usn
	END

GO

--------------------------------------------------------------------------------
-- ReportSbSessionView
PRINT N'Creating [dbo].[ReportSbSessionView]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[ReportSbSessionView]') AND type in (N'V'))
	DROP VIEW [dbo].[ReportSbSessionView]
GO

	CREATE VIEW [dbo].[ReportSbSessionView]
	AS
		SELECT    
			[dbo].[Backup.Model.SbSessions].[id],
			[dbo].[Backup.Model.JobSessions].[job_id],
			[dbo].[Backup.Model.JobSessions].[job_name],
			[dbo].[Backup.Model.JobSessions].[result],
			[dbo].[Backup.Model.JobSessions].[operation],
			[dbo].[Backup.Model.JobSessions].[state],
			[dbo].[Backup.Model.JobSessions].[progress],
			[dbo].[Backup.Model.JobSessions].[description],
			[dbo].[Backup.Model.JobSessions].[creation_time],
			[dbo].[Backup.Model.JobSessions].[end_time],
			usn = CASE
				WHEN [dbo].[Backup.Model.JobSessions].[usn] > [dbo].[Backup.Model.SbSessions].[usn]
					THEN [dbo].[Backup.Model.JobSessions].[usn]
				ELSE [dbo].[Backup.Model.SbSessions].[usn]
			END

		FROM [dbo].[Backup.Model.JobSessions] RIGHT JOIN [dbo].[Backup.Model.SbSessions] 
		ON [dbo].[Backup.Model.JobSessions].[id] = [dbo].[Backup.Model.SbSessions].[id]
		
GO

--------------------------------------------------------------------------------
-- ReportJobRestoreSessionsView
PRINT N'Creating [dbo].[ReportJobRestoreSessionsView]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[ReportJobRestoreSessionsView]') AND type in (N'V'))
	DROP VIEW [dbo].[ReportJobRestoreSessionsView]
GO

	CREATE VIEW [dbo].[ReportJobRestoreSessionsView]
	AS
		SELECT     
			[id]				= [dbo].[Backup.Model.JobSessions].[id],
			[job_name]			= [dbo].[Backup.Model.JobSessions].[job_name], 
			[state]				= [dbo].[Backup.Model.JobSessions].[state],
			[creation_time]		= [dbo].[Backup.Model.JobSessions].[creation_time],
			[end_time]			= [dbo].[Backup.Model.JobSessions].[end_time],
			[operation]			= [dbo].[Backup.Model.JobSessions].[operation],
			[result]			= [dbo].[Backup.Model.JobSessions].[result],
			[progress]			= [dbo].[Backup.Model.JobSessions].[progress],
			[job_type]			= [dbo].[Backup.Model.JobSessions].[job_type],
			[initiator_name]	= [dbo].[Backup.Model.RestoreJobSessions].[initiator_name],
			[oib_display_name]	= [dbo].[Backup.Model.RestoreJobSessions].[oib_display_name],
			[oib_creation_time]	= [dbo].[Backup.Model.RestoreJobSessions].[oib_creation_time],
			--[sub_type]			= [dbo].[Backup.Model.RestoreJobSessions].[sub_type],
			[usn]				= CASE 
				WHEN [dbo].[Backup.Model.JobSessions].[usn] > [dbo].[Backup.Model.RestoreJobSessions].[usn]
					THEN [dbo].[Backup.Model.JobSessions].[usn]
				ELSE [dbo].[Backup.Model.RestoreJobSessions].[usn]
			END
		FROM [dbo].[Backup.Model.JobSessions] LEFT JOIN [dbo].[Backup.Model.RestoreJobSessions] 
			ON [dbo].[Backup.Model.JobSessions].[id] = [dbo].[Backup.Model.RestoreJobSessions].[id]
			
		WHERE [dbo].[Backup.Model.JobSessions].[job_type] in (4, 5, 6, 7)

GO

--------------------------------------------------------------------------------
-- ReportJobRestoreSessionsDeleteView
PRINT N'Creating [dbo].[ReportJobRestoreSessionsDeleteView]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[ReportJobRestoreSessionsDeleteView]') AND type in (N'P'))
	DROP PROCEDURE [dbo].[ReportJobRestoreSessionsDeleteView]
GO

	CREATE PROCEDURE [dbo].[ReportJobRestoreSessionsDeleteView]
		@row_usn bigint
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT uid FROM TombStones WHERE table_name= 'Backup.Model.JobSessions' AND usn > @row_usn
		UNION
		SELECT uid FROM TombStones WHERE table_name= 'Backup.Model.RestoreJobSessions' AND usn > @row_usn
	END

GO

--------------------------------------------------------------------------------
-- ReportSbTaskSessionView
PRINT N'Creating [dbo].[ReportSbTaskSessionView]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[ReportSbTaskSessionView]') AND type in (N'V'))
	DROP VIEW [dbo].[ReportSbTaskSessionView]
GO

	CREATE VIEW [dbo].[ReportSbTaskSessionView]
	AS
		SELECT     
			drts.[id],
			drts.[type],
			drts.[drsession_id],
			drts.[object_name],
			drts.[object_id],
			drts.[oib_id],
			drts.[overall_status],
			drts.[heartbeat_status],
			drts.[ping_status],
			drts.[validation_status],
			drts.[test_script_status],
			drts.[test_script_error_code],
			drts.[vm_ref],
			drts.[state],
			drts.[vm_external_ip],
			
			drts.[description],
			drts.[usn],
			drts.[order_num]
		FROM
			[dbo].[Backup.Model.SbTaskSessions] drts

GO

--------------------------------------------------------------------------------
-- ReportSbGroupsView
PRINT N'Creating [dbo].[ReportSbGroupsView]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[ReportSbGroupsView]') AND type in (N'V'))
	DROP VIEW [dbo].[ReportSbGroupsView]
GO

	CREATE VIEW [dbo].[ReportSbGroupsView]
	AS
		SELECT
			folders.[id],
			folders.[name],
			folders.[description],
			folders.[platform],
			COUNT (oiags.[id]) vms_count,
			[dbo].[MaxValue] (folders.[usn], MAX(oiags.[usn])) usn
		FROM
			[dbo].[Folders] folders
				join [dbo].[ObjectsInApplicationGroups] oiags ON oiags.[folder_id] = folders.[id]
		WHERE
			folders.[parent_id] = '32E53DC4-62EA-47B4-8E02-88509707D587'
		GROUP BY 
			folders.[id], folders.[name], folders.[description], folders.[platform], folders.[usn]

GO

--------------------------------------------------------------------------------
-- ReportSbGroupsDeleteView
PRINT N'Creating [dbo].[ReportSbGroupsDeleteView]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[ReportSbGroupsDeleteView]') AND type in (N'P'))
	DROP PROCEDURE [dbo].[ReportSbGroupsDeleteView]
GO

	CREATE PROCEDURE [dbo].[ReportSbGroupsDeleteView]
		@row_usn bigint
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT uid, usn FROM TombStones WHERE table_name= 'Folders' AND usn > @row_usn
	END

GO

--------------------------------------------------------------------------------
-- ReportSessionInfoView
PRINT N'Creating [dbo].[ReportSessionInfoView]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[ReportSessionInfoView]') AND type in (N'V'))
	DROP VIEW [dbo].[ReportSessionInfoView]
GO

	CREATE VIEW [dbo].[ReportSessionInfoView]
      AS
            SELECT [dbo].[Backup.Model.BackupTaskSessions].[id]
                    ,[dbo].[Backup.Model.BackupTaskSessions].[session_id]
                    ,[dbo].[Backup.Model.BackupTaskSessions].[creation_time]
                    ,[dbo].[Backup.Model.BackupTaskSessions].[object_name]
                    ,[dbo].[Backup.Model.BackupTaskSessions].[status]
                    ,[dbo].[Backup.Model.BackupTaskSessions].[object_id]
                    ,[dbo].[Backup.Model.BackupTaskSessions].[avg_speed]
                    ,[dbo].[Backup.Model.BackupTaskSessions].[change_tracking] 
                    ,[dbo].[Backup.Model.BackupTaskSessions].[end_time] 
                    ,[dbo].[Backup.Model.BackupTaskSessions].[mode] 
                    ,[dbo].[Backup.Model.BackupTaskSessions].[operation] 
                    ,[dbo].[Backup.Model.BackupTaskSessions].[processed_objects] 
                    ,[dbo].[Backup.Model.BackupTaskSessions].[processed_size]
                    ,[dbo].[Backup.Model.BackupTaskSessions].[processed_used_size]  
                    ,[dbo].[Backup.Model.BackupTaskSessions].[reason] 
                    ,[dbo].[Backup.Model.BackupTaskSessions].[total_objects] 
                    ,[dbo].[Backup.Model.BackupTaskSessions].[total_size] 
					,[dbo].[Backup.Model.BackupTaskSessions].[total_used_size] 
                    ,[dbo].[Backup.Model.BackupTaskSessions].[read_size] 
					,[dbo].[Backup.Model.BackupTaskSessions].[read_average_size] 
                    ,[dbo].[Backup.Model.BackupTaskSessions].[stored_size] 
                    ,[dbo].[Backup.Model.BackupTaskSessions].[queued_time] 
					,[dbo].[Backup.Model.BackupTaskSessions].[object_platform]
                    ,[dbo].[BObjects].[type]
                    ,[dbo].[Backup.Model.BackupTaskSessions].[usn]
              FROM [dbo].[Backup.Model.BackupTaskSessions] LEFT JOIN [dbo].[BObjects] 
              ON [dbo].[Backup.Model.BackupTaskSessions].[object_id] = [dbo].[BObjects].[id]
GO

--------------------------------------------------------------------------------
-- ReportSbJobsView
PRINT N'Creating [dbo].[ReportSbJobsView]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[ReportSbJobsView]') AND type in (N'V'))
	DROP VIEW [dbo].[ReportSbJobsView]
GO

	CREATE VIEW [dbo].[ReportSbJobsView]
	AS
		SELECT  
			[dbo].[BJobs].[id], 
			[dbo].[BJobs].[name], 
			[dbo].[BJobs].[latest_result], 
			[dbo].[BJobs].[description], 
			[dbo].[BJobs].[schedule_enabled],
			[link_with_jobs] = options.query('DRJobOptions/LinkWithJobs').value('.','bit'),
	        
			[virtual_lab_name] = (SELECT TOP(1) [name]
						FROM [dbo].[VirtualLabs]
						WHERE [id] = [target_host_id]),
						
			[app_group_name] = (SELECT TOP(1) [name]
						FROM [dbo].[ObjectsInJobs] LEFT JOIN [dbo].[Folders]
						ON [dbo].[ObjectsInJobs].folder_id = [dbo].[Folders].[id]
						WHERE [dbo].[ObjectsInJobs].[job_id] = [dbo].[BJobs].[id]),
						
			[next_run] = schedule.query('/ScheduleOptions/NextRun').value('.','nvarchar(300)'),
			[schedule_cont] = schedule.query('/ScheduleOptions/OptionsContinuous/Enabled').value('.','bit'),
			
			[dbo].[Backup.Model.JobSessions].[state],
			[dbo].[Backup.Model.JobSessions].[result],
				
			[percent] = [dbo].[Backup.Model.JobSessions].[progress],
	        
			[linked_job] = [dbo].[LinkedJobsString] ([dbo].[BJobs].[id]),	
				
			[usn] = CASE 
				WHEN [dbo].[Backup.Model.JobSessions].[usn] is NULL THEN [dbo].[BJobs].[usn]
				WHEN [dbo].[BJobs].[usn] > [Backup.Model.JobSessions].[usn] THEN [dbo].[BJobs].[usn]			  
				ELSE [dbo].[Backup.Model.JobSessions].[usn]
			END
			
		FROM [dbo].[BJobs] LEFT JOIN [dbo].[Backup.Model.JobSessions] 
		ON [dbo].[Backup.Model.JobSessions].[job_id] = [dbo].[BJobs].[id] AND [creation_time] = (SELECT MAX([creation_time]) FROM [dbo].[Backup.Model.JobSessions] WHERE [job_id] = [dbo].[BJobs].id)
		WHERE [dbo].[BJobs].[type] = 3

GO

--------------------------------------------------------------------------------
-- ReportSbJobsDeleteView
PRINT N'Creating [dbo].[ReportSbJobsDeleteView]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[ReportSbJobsDeleteView]') AND type in (N'P'))
	DROP PROCEDURE [dbo].[ReportSbJobsDeleteView]
GO

	CREATE PROCEDURE [dbo].[ReportSbJobsDeleteView]
		@row_usn bigint
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT uid, usn FROM TombStones WHERE table_name= 'BJobs' AND usn > @row_usn
	END

GO

--------------------------------------------------------------------------------
-- ReportSbVirtualLabsView
PRINT N'Creating [dbo].[ReportSbVirtualLabsView]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[ReportSbVirtualLabsView]') AND type in (N'V'))
	DROP VIEW [dbo].[ReportSbVirtualLabsView]
GO

	CREATE VIEW [dbo].[ReportSbVirtualLabsView]
	AS
		SELECT 
			vLabs.[id],
			vLabs.[name],
			vLabs.[description],
			hosts.[name] host_name,
			hosts.[id] host_id,
			vLabs.[platform],
			vLabs.[usn]
		FROM 
			[dbo].[VirtualLabs] vLabs join [dbo].[Hosts] hosts ON hosts.[id] = vLabs.[host_id]
	  
GO

--------------------------------------------------------------------------------
-- ReportSbVirtualLabsDeleteView
PRINT N'Creating [dbo].[ReportSbVirtualLabsDeleteView]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[ReportSbVirtualLabsDeleteView]') AND type in (N'P'))
	DROP PROCEDURE [dbo].[ReportSbVirtualLabsDeleteView]
GO

	CREATE PROCEDURE [dbo].[ReportSbVirtualLabsDeleteView]
		@row_usn bigint
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT uid, usn FROM TombStones WHERE table_name= 'VirtualLabs' AND usn > @row_usn
	END

GO

--------------------------------------------------------------------------------
-- ReportJobsView
PRINT N'Creating [dbo].[ReportJobsView]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[ReportJobsView]') AND type in (N'V'))
	DROP VIEW [dbo].[ReportJobsView]
GO
create VIEW [dbo].[ReportJobsView]
	AS
		SELECT  
			jobs.[id], 
			jobs.[type], 
			jobs.[name], 
			jobs.[target_type],
			jobs.[repository_id],
			repo.name AS repo_name,
			fpools.name AS full_mediapool_name,
			ipools.name AS incremental_mediapool_name,
			obj_in_job_count = (CASE WHEN jobs.type = 24 THEN
				(SELECT COUNT(*) FROM 
					(SELECT options FROM [Tape.jobs] WHERE id = jobs.id) AS XmlTable(o) CROSS APPLY o.nodes('/TapeJobOptionsBase/Selection/BackupSelectionBase') XmlTableFunction(c)) 
					WHEN jobs.type = 28 THEN
						CASE WHEN (SELECT count(id) FROM LinkedJobs WHERE job_id = jobs.id) <> 0 THEN
							(SELECT count(id) FROM LinkedJobs WHERE job_id = jobs.id)
						ELSE
							(SELECT count(id) FROM LinkedBackupRepositories WHERE job_id = jobs.id)
						END
					when jobs.type IN (3, 51) then 
						(select sum(t) from
						(select count(id) t from LinkedJobs where job_id = jobs.id
						 union all
						 select count(id) from dbo.ObjectsInJobs where (job_id = jobs.id) and (type = 0)) BCJob)
					ELSE
						(SELECT COUNT(id) AS Expr1 FROM dbo.ObjectsInJobs WHERE (job_id = jobs.id) AND (type = 0)) END),
			jobs.[job_source_type],
			[sessions].[state],
			[sessions].[progress], 
			[sessions].[result],
			[sessions].[operation],
			[sessions].[id] as last_session_id,
			[next_run] = jobs.schedule.query('/ScheduleOptions/NextRun').value('.','nvarchar(300)'),
			[schedule_cont] = jobs.schedule.query('/ScheduleOptions/OptionsContinuous/Enabled').value('.','bit'),
			[after_job_schedule] = jobs.schedule.query('/ScheduleOptions/OptionsScheduleAfterJob/IsEnabled').value('.','bit'),
			jobs.[target_dir],
			jobs.[latest_result], 
			jobs.[description], 
			jobs.[schedule_enabled], 
			[run_manually] = jobs.options.query('/JobOptionsRoot/RunManually').value('.','bit'),
			[link_with_jobs] = jobs.options.query('DRJobOptions/LinkWithJobs').value('.','bit'),
			target_host_name = CASE 
				WHEN jobs.[options].query('/JobOptionsRoot/ClusterName').value('.','nvarchar(300)') = '' THEN (SELECT [dbo].[Hosts].[name] FROM [dbo].[Hosts] WHERE [dbo].[Hosts].[id] = jobs.[target_host_id])
				ELSE jobs.[options].query('/JobOptionsRoot/ClusterName').value('.','nvarchar(300)')
			END,
			jobs.[vcb_host_id],
			usn = dbo.MaxValue3(
				ISNULL ((SELECT TOP (1) ref_jobs.usn FROM BJobs ref_jobs WHERE ref_jobs.id = jobs.parent_schedule_id), 0) 			
				, ISNULL ((SELECT TOP (1) tape_jobs.usn FROM [Tape.jobs] tape_jobs WHERE tape_jobs.id = jobs.id), 0) 
				, CASE WHEN (ISNULL([sessions].usn, 0) >= ISNULL(jobs.usn, 0)) AND (ISNULL([sessions].usn, 0) >= ISNULL(tapes.usn, 0))
					  THEN ISNULL([sessions].usn, 0) WHEN (ISNULL(jobs.usn, 0) >= ISNULL([sessions].usn, 0)) AND (ISNULL(jobs.usn, 0) >= ISNULL(tapes.usn, 0)) THEN ISNULL(jobs.usn, 0) ELSE ISNULL(tapes.usn, 0) END),
			(SELECT TOP (1) name
					FROM          dbo.VirtualLabs
					WHERE      (id = jobs.target_host_id)) AS virtual_lab_name,
                    (SELECT     TOP (1) dbo.Folders.name FROM dbo.ObjectsInJobs LEFT JOIN dbo.Folders ON dbo.ObjectsInJobs.folder_id = dbo.Folders.id
                            WHERE      (dbo.ObjectsInJobs.job_id = jobs.id)) AS app_group_name, dbo.LinkedJobsString(jobs.id) AS linked_job, 
			perfomance_rate = (SELECT TOP(1) [dbo].[Backup.Model.BackupJobSessions].[avg_speed] 
								FROM [dbo].[Backup.Model.BackupJobSessions]
								WHERE [dbo].[Backup.Model.BackupJobSessions].[id] = [sessions].[id]),
			jobs.[platform],
			jobs.[parent_schedule_id],
			(select top(1) name as bjname from BJobs bj where bj.id = jobs.parent_schedule_id) as schelule_parent_job_name,
			jobs.[schedule],
			tapes.options.query('/TapeJobOptionsBase/FullSchedule/NextRun' ).value('.', 'nvarchar(300)') AS full_next_run, 
			tapes.options.query('/TapeJobOptionsBase/IncrementalSchedule/NextRun' ).value('.', 'nvarchar(300)') AS incremental_next_run
		FROM [dbo].[BJobs] jobs 
			LEFT JOIN dbo.[Tape.jobs] AS tapes ON jobs.id = tapes.id
			LEFT JOIN [dbo].[Backup.Model.JobSessions] [sessions] ON [sessions].[job_id] = jobs.[id] 
				AND [creation_time] = (SELECT MAX([creation_time]) FROM [dbo].[Backup.Model.JobSessions] WHERE [job_id] = jobs.id)
		LEFT JOIN [dbo].[BackupRepositories] AS repo ON jobs.[repository_id] = repo.id 
		LEFT JOIN [dbo].[Tape.jobs] AS tjobs ON jobs.id = tjobs.id
		LEFT JOIN [dbo].[Tape.media_pools] fpools ON tjobs.full_mediapool_id = fpools.id
		LEFT JOIN [dbo].[Tape.media_pools] ipools ON tjobs.incremental_mediapool_id = ipools.id
		WHERE jobs.[type] in (0, 1, 2, 3, 8, 24, 28, 51,202)	

GO

--------------------------------------------------------------------------------
-- ReportJobsDeleteView
PRINT N'Creating [dbo].[ReportJobsDeleteView]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[ReportJobsDeleteView]') AND type in (N'P'))
	DROP PROCEDURE [dbo].[ReportJobsDeleteView]
GO

	CREATE PROCEDURE [dbo].[ReportJobsDeleteView]
		@row_usn bigint
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT uid, usn FROM TombStones WHERE table_name= 'BJobs' AND usn > @row_usn
	END

GO

--------------------------------------------------------------------------------
-- GetSessionPerfomance
PRINT N'Creating [dbo].[GetSessionPerfomance]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetSessionPerfomance]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetSessionPerfomance]
GO

	CREATE PROCEDURE [dbo].[GetSessionPerfomance]
		@row_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		declare @endTime datetime
		declare @creationTime datetime
		declare @processedSize bigint
		declare @seconds bigint
		declare @result bigint
		declare @status int
		
		set @status = (select [result] from [Backup.Model.JobSessions] where [id] = @row_id)
		set @creationTime = (select [creation_time] from [Backup.Model.JobSessions] where [id] = @row_id)
		set @processedSize = (select [processed_size] from [Backup.Model.BackupJobSessions] where [id] = @row_id)
		if @status = 0 OR @status = 1 OR @status = 2
			BEGIN
				set @endTime = (select [end_time] from [Backup.Model.JobSessions] where [id] = @row_id)
			END
		else
			BEGIN
				set @endTime = GETDATE();
			END
		set @seconds = DateDiff(SECOND, @creationTime, @endTime)
		if @seconds <= 0 
			set @result = 0;
		else
			set @result = @processedSize / @seconds
		select @result
	END

GO

--------------------------------------------------------------------------------
-- GetSessionInfoPerfomance
PRINT N'Creating [dbo].[GetSessionInfoPerfomance]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetSessionInfoPerfomance]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetSessionInfoPerfomance]
GO

	CREATE PROCEDURE [dbo].[GetSessionInfoPerfomance]
		@row_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		declare @endTime datetime
		declare @creationTime datetime
		declare @processedSize bigint
		declare @seconds bigint
		declare @result bigint
		declare @status int
		
		set @status = (select [status] from [Backup.Model.BackupTaskSessions] where [id] = @row_id)
		set @creationTime = (select [creation_time] from [Backup.Model.BackupTaskSessions] where [id] = @row_id)
		set @processedSize = (select [processed_size] from [Backup.Model.BackupTaskSessions] where [id] = @row_id)
		if @status = 0 OR @status = 1 OR @status = 2
			BEGIN
				set @endTime = (select [end_time] from [Backup.Model.BackupTaskSessions] where [id] = @row_id)
			END
		else
			BEGIN
				set @endTime = GETDATE();
			END
		set @seconds = DateDiff(SECOND, @creationTime, @endTime)
		if @seconds <= 0 
			set @result = 0;
		else
			set @result = @processedSize / @seconds
		select @result
	END

GO

--------------------------------------------------------------------------------
-- UpdateJobProgress
PRINT N'Creating [dbo].[UpdateJobProgress]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateJobProgress]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateJobProgress]
GO

	CREATE PROCEDURE [dbo].[UpdateJobProgress]
			   @row_id uniqueidentifier,
			   @row_progress int,
			   @row_total_objects int,
			   @row_processed_objects int,
			   @row_total_size bigint,
			   @row_total_used_size bigint,
			   @row_processed_size bigint,
			   @row_processed_used_size bigint,
			   @row_avg_speed bigint,
			   @row_read_size bigint,
			   @row_read_average_size bigint,
			   @row_stored_size bigint,
			   @row_bottleneck int,
			   @row_source_storage int,
			   @row_source_proxy int,
			   @row_source_network int,
			   @row_target_storage int,
			   @row_target_proxy int,
			   @row_target_network int,
			   @row_source_wan int,
			   @row_target_wan int
			   
	AS
	BEGIN
		SET NOCOUNT ON;

		declare @usn bigint	
		
		exec [dbo].[IncrementUsn] @usn OUTPUT
		UPDATE [dbo].[Backup.Model.BackupJobSessions] SET
			[total_objects]		=@row_total_objects,
			[processed_objects]	=@row_processed_objects,
			[total_size]		=@row_total_size,
			[total_used_size]	=@row_total_used_size,
			[processed_size]	=@row_processed_size,
			[processed_used_size] = @row_processed_used_size,
			[avg_speed]			=@row_avg_speed,
			[read_size]			=@row_read_size,
			[read_average_size] =@row_read_average_size,
			[stored_size]		=@row_stored_size,
			[bottleneck]		=@row_bottleneck,
			[source_storage]	=@row_source_storage,
			[source_proxy]		=@row_source_proxy,
			[source_network]	=@row_source_network,
			[target_storage]	=@row_target_storage,
			[target_proxy]		=@row_target_proxy,
			[target_network]	=@row_target_network,
			[source_wan]	=@row_source_wan,
			[target_wan]	=@row_target_wan,
		   [usn]                =@usn
		   WHERE [id] = @row_id
	       
		exec [dbo].[IncrementUsn] @usn OUTPUT
		UPDATE [dbo].[Backup.Model.JobSessions] SET
		   [progress]			=@row_progress,
		   [usn]                =@usn
		   WHERE [id] = @row_id
	           
	END	

GO

--------------------------------------------------------------------------------
-- UpdateTaskProgress
PRINT N'Creating [dbo].[UpdateTaskProgress]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateTaskProgress]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateTaskProgress]
GO

	CREATE PROCEDURE [dbo].[UpdateTaskProgress]
			   @row_id uniqueidentifier,
			   @row_total_objects int,
			   @row_processed_objects int,
			   @row_total_size bigint,
			   @row_total_used_size bigint,
			   @row_processed_size bigint,
			   @row_processed_used_size bigint,
			   @row_avg_speed bigint,
			   @row_read_size bigint,
			   @row_read_average_size bigint,
			   @row_stored_size bigint,
			   @row_source_storage int,
			   @row_source_proxy int,
			   @row_source_network int,
			   @row_target_storage int,
			   @row_target_proxy int,
			   @row_target_network int,
			   @row_source_wan int,
			   @row_target_wan int
	AS
	BEGIN
		SET NOCOUNT ON;

		declare @usn bigint	
		exec [dbo].[IncrementUsn] @usn OUTPUT
		
		UPDATE [dbo].[Backup.Model.BackupTaskSessions] SET
			   [total_objects]		=@row_total_objects,
			   [processed_objects]	=@row_processed_objects,
			   [total_size]			=@row_total_size,
			   [total_used_size]	=@row_total_used_size,
			   [processed_size]		=@row_processed_size,
			   [processed_used_size]=@row_processed_used_size,
			   [avg_speed]			=@row_avg_speed, 
			   [read_size]			=@row_read_size,
			   [read_average_size]	=@row_read_average_size,
			   [stored_size]		=@row_stored_size,
			   [usn]                =@usn,
			    [source_storage]	=@row_source_storage,
			    [source_proxy]		=@row_source_proxy,
				[source_network]	=@row_source_network,
				[target_storage]	=@row_target_storage,
				[target_proxy]		=@row_target_proxy,
				[target_network]	=@row_target_network,
				[source_wan]	=@row_source_wan,
				[target_wan]	=@row_target_wan
		WHERE
			[id] = @row_id
	END

GO

--------------------------------------------------------------------------------
-- GetCountTodayRunningSessions
PRINT N'Creating [dbo].[GetCountTodayRunningSessions]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetCountTodayRunningSessions]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetCountTodayRunningSessions]
GO

	CREATE PROCEDURE [dbo].[GetCountTodayRunningSessions]
		@job_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		select COUNT(*) 
		
		FROM [dbo].[Backup.Model.JobSessions] LEFT JOIN [dbo].[Backup.Model.BackupJobSessions] 
			ON [dbo].[Backup.Model.JobSessions].[id] = [dbo].[Backup.Model.BackupJobSessions].[id]
		
		where job_id = @job_id AND Year(GETDATE()) = Year([dbo].[Backup.Model.JobSessions].[creation_time]) 
			AND Month(GETDATE()) = Month([dbo].[Backup.Model.JobSessions].[creation_time]) 
			AND Day(GETDATE()) = Day([dbo].[Backup.Model.JobSessions].[creation_time])
	END

GO

--------------------------------------------------------------------------------
-- AddDRJobRow
PRINT N'Creating [dbo].[AddDRJobRow]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[AddDRJobRow]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[AddDRJobRow]
GO

	CREATE PROCEDURE [dbo].[AddDRJobRow]
			   @row_id uniqueidentifier,
			   @row_type int,
			   @row_name nvarchar(255),
			   @row_platform int,
			   @row_target_host_id uniqueidentifier,
			   @row_options xml,
			   @row_schedule xml,
			   @row_description nvarchar(1024),
			   @row_schedule_enabled bit,
			   @row_parent_schedule_id uniqueidentifier          
	AS
	BEGIN
		SET NOCOUNT ON;
		
		INSERT INTO [dbo].[BJobs]
			   ([id]
			   ,[type]
			   ,[name]
			   ,[platform]
			   ,[target_host_id]
			   ,[options]
			   ,[schedule]
			   ,[description]
			   ,[schedule_enabled]
			   ,[parent_schedule_id])
		 VALUES
			   (@row_id,
			   @row_type,
			   @row_name,
			   @row_platform,
			   @row_target_host_id,
			   @row_options,
			   @row_schedule,
			   @row_description,
			   @row_schedule_enabled,
			   @row_parent_schedule_id)
	END	

GO

--------------------------------------------------------------------------------
-- UpdateDRJobRow
PRINT N'Creating [dbo].[UpdateDRJobRow]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateDRJobRow]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateDRJobRow]
GO

	CREATE PROCEDURE [dbo].[UpdateDRJobRow]
			   @row_id uniqueidentifier,
			   @row_type int,
			   @row_name nvarchar(255),
			   @row_platform int,
			   @row_target_host_id uniqueidentifier,
			   @row_options xml,
			   @row_schedule xml,
			   @row_description nvarchar(1024),
			   @row_schedule_enabled bit,
			   @row_parent_schedule_id uniqueidentifier	
	AS
	BEGIN
		SET NOCOUNT ON;

		UPDATE [dbo].[BJobs] SET
			   [type]					=@row_type
			   ,[name]					=@row_name
			   ,[platform]				=@row_platform
			   ,[target_host_id]		=@row_target_host_id
			   ,[options]				=@row_options
			   ,[schedule]				=@row_schedule
			   ,[description]			=@row_description
			   ,[schedule_enabled]		=@row_schedule_enabled
			   ,[parent_schedule_id]    =@row_parent_schedule_id
			   WHERE [id] = @row_id
	END

GO

--------------------------------------------------------------------------------
-- GetJobsByType
PRINT N'Creating [dbo].[GetJobsByType]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetJobsByType]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetJobsByType]
GO

	CREATE PROCEDURE [dbo].[GetJobsByType]
		@row_type int
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT * from [dbo].[BJobs] where [type] = @row_type
	END

GO

--------------------------------------------------------------------------------
-- CountSessionInfosForSessionByStatus
PRINT N'Creating [dbo].[CountSessionInfosForSessionByStatus]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[CountSessionInfosForSessionByStatus]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[CountSessionInfosForSessionByStatus]
GO

	CREATE PROCEDURE [dbo].[CountSessionInfosForSessionByStatus]
		@row_session_id uniqueidentifier,
		@row_status int
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT COUNT(*) from [dbo].[Backup.Model.BackupTaskSessions] where [session_id] = @row_session_id AND [status] = @row_status
	END

GO

--------------------------------------------------------------------------------
-- IsExistsBackupName
PRINT N'Creating [dbo].[IsExistsBackupName]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[IsExistsBackupName]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[IsExistsBackupName]
GO

	CREATE PROCEDURE [dbo].[IsExistsBackupName]
		@row_name nvarchar(255)
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT COUNT(*) from [dbo].[Backups] where [job_name] = @row_name
	END

GO

--------------------------------------------------------------------------------
-- SetJobResult
PRINT N'Creating [dbo].[SetJobResult]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[SetJobResult]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[SetJobResult]
GO

	CREATE PROCEDURE [dbo].[SetJobResult]
		@row_id uniqueidentifier,
		@row_result int
	AS
	BEGIN
		SET NOCOUNT ON;
		UPDATE [dbo].[BJobs] SET [latest_result] = @row_result where [id] = @row_id 
	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.CreatePoint
PRINT N'Creating [dbo].[Backup.Model.CreatePoint]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.CreatePoint]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.CreatePoint]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.CreatePoint]
		@id uniqueidentifier,
		@link_id uniqueidentifier,
		@num numeric(16,10),
		@group_id uniqueidentifier,
		@creation_time datetime,
		@type int,
		@alg  int,
		@backup_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;	
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		INSERT INTO [dbo].[Backup.Model.Points]
			   ([id],
			   [link_id],
			   [num],
			   [creation_time],
			   [type],
			   [alg],
			   [group_id],
			   [backup_id],
			   [usn])
		 VALUES
			   (@id,
				@link_id,
				@num,
				@creation_time,
				@type,
				@alg,
				@group_id,			
				@backup_id,
				@usn)
	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.CreateOib
PRINT N'Creating [dbo].[Backup.Model.CreateOib]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.CreateOib]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.CreateOib]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.CreateOib]
		@id uniqueidentifier,
		@parent_id uniqueidentifier,
		@object_id uniqueidentifier,
		@point_id uniqueidentifier,
		@storage_id uniqueidentifier,
		@link_id uniqueidentifier,
		@is_corrupted bit,
		@is_consistent bit,
		@state int,
		@type int,
		@alg int,
		@inside_dir nvarchar(400),
		@creation_time datetime,
		@vmname nvarchar(1000),
		@guest_os_info xml,
		@memory bigint, 
		@approx_size bigint, 
		@process_id int,
		@has_index bit,
		@has_exchange bit,
		@has_sharepoint bit,
		@has_sql bit,
		@aux_data xml,
		@display_name nvarchar(1000),
		@original_oib_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;	
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		INSERT INTO [dbo].[Backup.Model.OIBs]
			   ([id],
				[parent_id],
				[object_id],
				[point_id],
				[storage_id],
				[link_id],
				[is_corrupted],
				[is_consistent],
				[state],
				[type],
				[alg],
				[inside_dir],
				[creation_time],
				[vmname],
				[guest_os_info],
				[memory],
				[approx_size],
				[process_id],
				[has_index],
				[has_exchange],
				[has_sharepoint],
				[has_sql],
				[aux_data],			
				[usn],
				[display_name],
				[original_oib_id])
		 VALUES
			   (@id,
				@parent_id,
				@object_id,
				@point_id,
				@storage_id,
				@link_id,
				@is_corrupted,
				@is_consistent,
				@state,
				@type,
				@alg,
				@inside_dir,
				@creation_time,
				@vmname,
				@guest_os_info,
				@memory,
				@approx_size,
				@process_id,
				@has_index,
				@has_exchange,
				@has_sharepoint,
				@has_sql,
				@aux_data,			
				@usn,
				@display_name,
				@original_oib_id)
	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.CreateStorage
PRINT N'Creating [dbo].[Backup.Model.CreateStorage]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.CreateStorage]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.CreateStorage]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.CreateStorage]
		@id uniqueidentifier,
		@file_path nvarchar(1000),
		@backup_id uniqueidentifier,
		@host_id uniqueidentifier,
		@creation_time datetime,
		@modification_time datetime,
		@stats xml,
		@version int,
		@block_size int,
		@state int,
		@last_compact_time datetime,
		@gfs_period int,
		@creation_mode int,
		@expiration_date datetime
	AS
	BEGIN
		SET NOCOUNT ON;	
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		INSERT INTO [dbo].[Backup.Model.Storages]
			   ([id],
				[file_path],
				[backup_id],
				[host_id],
				[creation_time],
				[modification_time],
				[stats],
				[version],
				[block_size],
				[state],
				[last_compact_time],
				[gfs_period],
				[creation_mode],
				[expiration_date],
				[usn])
		 VALUES
			   (@id,
				@file_path,
				@backup_id,
				@host_id,
				@creation_time,
				@modification_time,
				@stats,
				@version,
				@block_size,
				@state,
				@last_compact_time,
				@gfs_period,
				@creation_mode,
				@expiration_date,
				@usn)
	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.CreateBackup
PRINT N'Creating [dbo].[Backup.Model.CreateBackup]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.CreateBackup]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.CreateBackup]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.CreateBackup]
		@id uniqueidentifier,
		@job_id uniqueidentifier,
		@job_name nvarchar(255),
		@job_type int,
		@job_source_type int,
		@job_target_type int,
		@job_target_host_id uniqueidentifier,
		@job_target_host_protocol int,
		@repository_id uniqueidentifier,
		@dir_path nvarchar(max),
		@meta_file_name nvarchar(max),
		@platform int,
		@creation_time datetime
	AS
	BEGIN
		SET NOCOUNT ON;	
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT
		
		INSERT INTO [dbo].[Backup.Model.Backups]
			([id],
			 [job_id],
			 [job_name],
			 [job_target_type],
			 [job_source_type],
			 [target_type],
			 [job_target_host_id],
			 [job_target_host_protocol],
			 [usn],
			 [repository_id],
			 [dir_path],
			 [meta_file_name],
			 [platform],
			 [creation_time])
		 VALUES
			(@id,
			 @job_id,
			 @job_name,
			 @job_type,
			 @job_source_type,
			 @job_target_type,
			 @job_target_host_id,
			 @job_target_host_protocol,
			 @usn,
			 @repository_id,
			 @dir_path,
			 @meta_file_name,
			 @platform,
			 @creation_time)
	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.GetEmptyPoints
PRINT N'Creating [dbo].[Backup.Model.GetEmptyPoints]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetEmptyPoints]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetEmptyPoints]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetEmptyPoints]
		@backup_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;	
		select * from
			[dbo].[Backup.Model.Points] p
		where 
			p.backup_id = @backup_id and
			not exists (select * from [dbo].[Backup.Model.OIBs] oib where oib.point_id = p.id)
	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.GetEmptyStorages
PRINT N'Creating [dbo].[Backup.Model.GetEmptyStorages]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetEmptyStorages]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetEmptyStorages]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetEmptyStorages]
		@backupId uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;	
		select s.* from
			[dbo].[Backup.Model.Storages] s
		where 
			s.backup_id = @backupId and
			not exists (select * from [dbo].[Backup.Model.OIBs] oib where oib.storage_id = s.id)
	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.GetStoragesInBackup
PRINT N'Creating [dbo].[Backup.Model.GetStoragesInBackup]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetStoragesInBackup]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetStoragesInBackup]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetStoragesInBackup]
		@backupId uniqueidentifier

	AS
	BEGIN
		SET NOCOUNT ON;
		select s.* from
			[dbo].[Backup.Model.Storages] s
		where 
			s.backup_id = @backupId
	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.GetStoragesInGroup
PRINT N'Creating [dbo].[Backup.Model.GetStoragesInGroup]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetStoragesInGroup]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetStoragesInGroup]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetStoragesInGroup]
		@groupId uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;	
		select s.* from
			[dbo].[Backup.Model.Storages] s,
			[dbo].[Backup.Model.Points] p,
			[dbo].[Backup.Model.OIBs] oibs
		where 
			oibs.point_id = p.id and
			oibs.storage_id = s.id and
			p.group_id = @groupId
		order by p.num desc
	END
	
GO

--------------------------------------------------------------------------------
-- Backup.Model.GetLastStorageInGroup
PRINT N'Creating [dbo].[Backup.Model.GetLastStorageInGroup]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetLastStorageInGroup]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetLastStorageInGroup]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetLastStorageInGroup]
		@groupId uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;	
		select top 1 s.* from
			[dbo].[Backup.Model.Storages] s,
			[dbo].[Backup.Model.Points] p,
			[dbo].[Backup.Model.OIBs] oibs
		where 
			oibs.point_id = p.id and
			oibs.storage_id = s.id and
			p.group_id = @groupId
		order by p.num desc
	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.GetStorageInBackupByFileName
PRINT N'Creating [dbo].[Backup.Model.GetStorageInBackupByFileName]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetStorageInBackupByFileName]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetStorageInBackupByFileName]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetStorageInBackupByFileName]
		@backup_id uniqueidentifier,
		@file_path nvarchar(1000)
	AS
	BEGIN
		SET NOCOUNT ON;	
		select * from 
			[dbo].[Backup.Model.Storages]
		where
			backup_id = @backup_id and
			file_path = @file_path
	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.GetPointsInBackup
PRINT N'Creating [dbo].[Backup.Model.GetPointsInBackup]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetPointsInBackup]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetPointsInBackup]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetPointsInBackup]
		@backupId uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;	
		select p.* from 
			[dbo].[Backup.Model.Points] p
		where 
			p.backup_id = @backupId
		order by p.num
	END
	
GO

--------------------------------------------------------------------------------
-- Backup.Model.DeletePoint
PRINT N'Creating [dbo].[Backup.Model.DeletePoint]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.DeletePoint]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.DeletePoint]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.DeletePoint]
		@id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;	
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT
			
		DELETE [dbo].[Backup.Model.Points] where id = @id
		exec [dbo].[InsertTombStone] 'Backup.Model.Points', @id, @usn
		
		UPDATE [dbo].[Backup.Model.BackupJobSessions]
			SET [dbo].[Backup.Model.BackupJobSessions].[cur_point_id] = null
		WHERE [dbo].[Backup.Model.BackupJobSessions].[cur_point_id] = @id
		
	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.DeleteBackup
PRINT N'Creating [dbo].[Backup.Model.DeleteBackup]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.DeleteBackup]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.DeleteBackup]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.DeleteBackup]
		@id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;	
			
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT
			
		delete [dbo].[Backup.Model.Backups] where id = @id	
		DELETE [dbo].[Backup.Model.SanVolumeBackups] WHERE backup_id = @id	
		
		exec [dbo].[InsertTombStone] 'Backup.Model.Backups', @id, @usn
			
	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.DeleteOIB
PRINT N'Creating [dbo].[Backup.Model.DeleteOIB]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.DeleteOIB]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.DeleteOIB]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.DeleteOIB]
		@id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;		
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT
		
		delete [dbo].[Backup.Model.OIBsFailoverInfo] where oib_id = @id 	
		
		delete [dbo].[Backup.Model.OIBs] where id = @id	
		exec [dbo].[InsertTombStone] 'Backup.Model.OIBs', @id, @usn

	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.GetOibsInPoint
PRINT N'Creating [dbo].[Backup.Model.GetOibsInPoint]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetOibsInPoint]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetOibsInPoint]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetOibsInPoint]
		@pointId uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;	
		select * from [dbo].[Backup.Model.OIBs]
		where point_id = @pointId
	END

GO

--------------------------------------------------------------------------------
-- ReportSessionView
PRINT N'Creating [dbo].[ReportSessionView]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[ReportSessionView]') AND type in (N'V'))
	DROP VIEW [dbo].[ReportSessionView]
GO

	CREATE VIEW [dbo].[ReportSessionView]
	AS
		SELECT     dbo.[Backup.Model.BackupJobSessions].id, dbo.[Backup.Model.JobSessions].job_name, dbo.[Backup.Model.JobSessions].state, 
						  dbo.[Backup.Model.JobSessions].creation_time, dbo.[Backup.Model.JobSessions].end_time, dbo.[Backup.Model.BackupJobSessions].job_source_type, 
						  dbo.[Backup.Model.BackupJobSessions].is_startfull, dbo.[Backup.Model.BackupJobSessions].transport_type, dbo.[Backup.Model.JobSessions].operation, dbo.[Backup.Model.BackupJobSessions].processed_objects, 
						  dbo.[Backup.Model.BackupJobSessions].total_objects, dbo.[Backup.Model.JobSessions].result, dbo.[Backup.Model.BackupJobSessions].total_size, dbo.[Backup.Model.BackupJobSessions].total_used_size, 
						  dbo.[Backup.Model.BackupJobSessions].processed_size,dbo.[Backup.Model.BackupJobSessions].processed_used_size,
						  dbo.[Backup.Model.JobSessions].progress, dbo.[Backup.Model.BackupJobSessions].is_retry, 
						  dbo.[Backup.Model.BackupJobSessions].avg_speed, dbo.[Backup.Model.JobSessions].description, dbo.[Backup.Model.BackupJobSessions].read_size, dbo.[Backup.Model.BackupJobSessions].read_average_size, 
						  dbo.[Backup.Model.BackupJobSessions].stored_size, dbo.[Backup.Model.BackupJobSessions].bottleneck, 
						  dbo.[Backup.Model.BackupJobSessions].[source_storage],
						  dbo.[Backup.Model.BackupJobSessions].[source_proxy],
						  dbo.[Backup.Model.BackupJobSessions].[source_network],
						  dbo.[Backup.Model.BackupJobSessions].[target_storage],
						  dbo.[Backup.Model.BackupJobSessions].[target_proxy],
						  dbo.[Backup.Model.BackupJobSessions].[target_network],
						  dbo.[Backup.Model.BackupJobSessions].[source_wan],
						  dbo.[Backup.Model.BackupJobSessions].[target_wan],
							  (SELECT     dbo.MaxValue(dbo.[Backup.Model.BackupJobSessions].usn, dbo.[Backup.Model.JobSessions].usn) AS Expr1) AS usn,
							  (SELECT     COUNT(id) AS Expr1
								FROM          dbo.[Backup.Model.BackupTaskSessions]
								WHERE      (session_id = dbo.[Backup.Model.BackupJobSessions].id) AND (status = 0)) AS success,
							  (SELECT     COUNT(id) AS Expr1
								FROM          dbo.[Backup.Model.BackupTaskSessions] AS [Backup.Model.BackupTaskSessions_3]
								WHERE      (session_id = dbo.[Backup.Model.BackupJobSessions].id) AND (status = 2)) AS failed,
							  (SELECT     COUNT(id) AS Expr1
								FROM          dbo.[Backup.Model.BackupTaskSessions] AS [Backup.Model.BackupTaskSessions_2]
								WHERE      (session_id = dbo.[Backup.Model.BackupJobSessions].id) AND (status = 3)) AS warning,
							  (SELECT     COUNT(id) AS Expr1
								FROM          dbo.[Backup.Model.BackupTaskSessions] AS [Backup.Model.BackupTaskSessions_1]
								WHERE      (session_id = dbo.[Backup.Model.BackupJobSessions].id) AND (status = 5)) AS inprogress,

							  (SELECT     COUNT(id) AS Expr1
								FROM          dbo.[Backup.Model.BackupTaskSessions] AS [Backup.Model.BackupTaskSessions_7]
								WHERE      (session_id = dbo.[Backup.Model.BackupJobSessions].id) AND (status = 0) AND (object_platform = 4)) AS skipped_success,
							  (SELECT     COUNT(id) AS Expr1
								FROM          dbo.[Backup.Model.BackupTaskSessions] AS [Backup.Model.BackupTaskSessions_6]
								WHERE      (session_id = dbo.[Backup.Model.BackupJobSessions].id) AND (status = 2) AND (object_platform = 4)) AS skipped_failed,
							  (SELECT     COUNT(id) AS Expr1
								FROM          dbo.[Backup.Model.BackupTaskSessions] AS [Backup.Model.BackupTaskSessions_5]
								WHERE      (session_id = dbo.[Backup.Model.BackupJobSessions].id) AND (status = 3) AND (object_platform = 4)) AS skipped_warning,
							  (SELECT     COUNT(id) AS Expr1
								FROM          dbo.[Backup.Model.BackupTaskSessions] AS [Backup.Model.BackupTaskSessions_4]
								WHERE      (session_id = dbo.[Backup.Model.BackupJobSessions].id) AND (status = 5) AND (object_platform = 4)) AS skipped_inprogress,

						  dbo.[Backup.Model.JobSessions].log_xml,
						  dbo.[Backup.Model.JobSessions].job_type,
						  dbo.[Backup.Model.JobSessions].job_id
	FROM         dbo.[Backup.Model.BackupJobSessions] RIGHT OUTER JOIN
						  dbo.[Backup.Model.JobSessions] ON dbo.[Backup.Model.BackupJobSessions].id = dbo.[Backup.Model.JobSessions].id

GO

--------------------------------------------------------------------------------
-- Backup.Model.GetBackupsForJobAndRepository
PRINT N'Creating [dbo].[Backup.Model.GetBackupsForJobAndRepository]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetBackupsForJobAndRepository]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetBackupsForJobAndRepository]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetBackupsForJobAndRepository]
		@jobId uniqueidentifier,
		@repositoryId uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;	
		select * from 
			[dbo].[Backup.Model.Backups]
		where 
			job_id = @jobId and
			IsNull(repository_id, '00000000-0000-0000-0000-000000000000') = @repositoryId				
	END
	
GO

--------------------------------------------------------------------------------
-- Backup.Model.GetBackupsForJob
PRINT N'Creating [dbo].[Backup.Model.GetBackupsForJob]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetBackupsForJob]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetBackupsForJob]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetBackupsForJob]
		@jobId uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;	
		select * from 
			[dbo].[Backup.Model.Backups]
		where
			job_id = @jobId	
	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.GetBackup
PRINT N'Creating [dbo].[Backup.Model.GetBackup]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetBackup]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetBackup]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetBackup]
		@id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;	
		select * from 
			[dbo].[Backup.Model.Backups]
		where
			[id] = @id
	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.GetBackupsAll
PRINT N'Creating [dbo].[Backup.Model.GetBackupsAll]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetBackupsAll]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetBackupsAll]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetBackupsAll]
	AS
	BEGIN
		SET NOCOUNT ON;	
		select * from 
			[dbo].[Backup.Model.Backups]
	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.GetBackupsByTargetType
PRINT N'Creating [dbo].[Backup.Model.GetBackupsByTargetType]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetBackupsByTargetType]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetBackupsByTargetType]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetBackupsByTargetType]
		@target_type int
	AS
	BEGIN
		SET NOCOUNT ON;	
		select 
			* 
		from 
			[dbo].[Backup.Model.Backups]
		where 
			[target_type] = @target_type
	END

GO


--------------------------------------------------------------------------------
-- Backup.Model.GetLastPointInBackup
PRINT N'Creating [dbo].[Backup.Model.GetLastPointInBackup]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetLastPointInBackup]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetLastPointInBackup]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetLastPointInBackup]
		@backupId uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;	
		select top 1 * from [dbo].[Backup.Model.Points]
		where backup_id = @backupId
		order by num desc
	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.GetPoint
PRINT N'Creating [dbo].[Backup.Model.GetPoint]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetPoint]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetPoint]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetPoint]
		@id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;	
		select * from [dbo].[Backup.Model.Points]
		where id = @id
	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.GetPreviousPoint
PRINT N'Creating [dbo].[Backup.Model.GetPreviousPoint]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetPreviousPoint]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetPreviousPoint]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetPreviousPoint]
		@id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;	
		;WITH CurrentPoint (id, num, backup_id)
		AS
		(
			select id, num, backup_id from 
				[dbo].[Backup.Model.Points] 
			where 
				id = @id
		)
		select top 1 pp.* from 
			[dbo].[Backup.Model.Points] pp,
			CurrentPoint cp
		where
			pp.backup_id = cp.backup_id and
			pp.num < cp.num	
		order by pp.num desc
	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.GetPreviousPointsByLink
PRINT N'Creating [dbo].[Backup.Model.GetPreviousPointsByLink]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetPreviousPointsByLink]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetPreviousPointsByLink]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetPreviousPointsByLink]
		@id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;	
		select * 
			from [dbo].[Backup.Model.Points]
		where 
			link_id = @id
	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.GetNextPointByLink
PRINT N'Creating [dbo].[Backup.Model.GetNextPointByLink]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetNextPointByLink]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetNextPointByLink]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetNextPointByLink]
		@id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;	
		select * 
			from [dbo].[Backup.Model.Points]
		where id = 
			(
			select link_id from [dbo].[Backup.Model.Points] where id = @id
			)
	END
	
GO

--------------------------------------------------------------------------------
-- Backup.Model.GetPointsOnDay
PRINT N'Creating [dbo].[Backup.Model.GetPointsOnDay]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetPointsOnDay]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetPointsOnDay]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetPointsOnDay]
		@year  int,
		@month int,
		@day   int,
		@type  int,
		@backup_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;	
		select * from [dbo].[Backup.Model.Points]
		where DATEPART(day,   creation_time) = @day and
			  DATEPART(month, creation_time) = @month and
			  DATEPART(year,  creation_time) = @year and
			  type = @type and
			  backup_id = @backup_id
	END
	
GO

--------------------------------------------------------------------------------
-- Backup.Model.GetLastOibInBackup
PRINT N'Creating [dbo].[Backup.Model.GetLastOibInBackup]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetLastOibInBackup]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetLastOibInBackup]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetLastOibInBackup]
		@objectId uniqueidentifier,
		@backupId uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;	
		select top 1 oib.* from 
			[dbo].[Backup.Model.OIBs] oib,
			[dbo].[Backup.Model.Points] p
		where
			oib.point_id = p.id and
			oib.object_id = @objectId and
			p.backup_id = @backupId 
		order by p.num desc 
	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.GetDependentOibs
PRINT N'Creating [dbo].[Backup.Model.GetDependentOibs]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetDependentOibs]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetDependentOibs]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetDependentOibs]
		@id   uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;	
		select * from 
			[dbo].[Backup.Model.OIBs]
		where
			link_id = @id
	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.GetDependentOibsRec
PRINT N'Creating [dbo].[Backup.Model.GetDependentOibsRec]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetDependentOibsRec]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetDependentOibsRec]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetDependentOibsRec]
		@id   uniqueidentifier,
		@type int
	AS
	BEGIN
		SET NOCOUNT ON;	

		DECLARE @rn INT
		SET @rn = 1

		DECLARE @ch TABLE (id UNIQUEIDENTIFIER, parent_id UNIQUEIDENTIFIER, rn int)
		INSERT @ch(id, parent_id, rn)
		SELECT id, null, @rn from [dbo].[Backup.Model.OIBs] where id = @id

		WHILE @@RowCount <> 0
		BEGIN
			set @rn = @rn + 1
			INSERT @ch(id, parent_id, rn)
			select b.id, bc.id, @rn from [dbo].[Backup.Model.OIBs] b, @ch bc
			where b.link_id = bc.id AND bc.rn = @rn - 1
		END


		select oib.* from 
			[dbo].[Backup.Model.OIBs] oib,
			@ch ch
		where 
			ch.id = oib.id and
			oib.type = @type and
			ch.rn > 1
		order by ch.rn
	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.GetLastOibsFromBackup
PRINT N'Creating [dbo].[Backup.Model.GetLastOibsFromBackup]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetLastOibsFromBackup]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetLastOibsFromBackup]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetLastOibsFromBackup]
		@backup_id   uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;	
		
		select *
		from 
		(	
			SELECT oibs.*, ROW_NUMBER() over (partition by oibs.object_id order by pnts.num desc) rn FROM  
				[dbo].[Backup.Model.OIBs] oibs,
				[dbo].[Backup.Model.Points] pnts
			where
				oibs.point_id = pnts.id and
				backup_id = @backup_id
		) o
		where o.rn = 1
		
	END

GO



--------------------------------------------------------------------------------
-- Backup.Model.GetOibsByOriginalOibId
PRINT N'Creating [dbo].[Backup.Model.GetOibsByOriginalOibId]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetOibsByOriginalOibId]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetOibsByOriginalOibId]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetOibsByOriginalOibId]
		@original_oib_id   uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;	
		
		select *
		from [dbo].[Backup.Model.OIBs] oibs
		where oibs.[original_oib_id] = @original_oib_id
		
	END
GO



--------------------------------------------------------------------------------
-- Backup.Model.GetStorage
PRINT N'Creating [dbo].[Backup.Model.GetStorage]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetStorage]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetStorage]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetStorage]
		@id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		select * from [dbo].[Backup.Model.Storages] where id = @id
	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.GetOib
PRINT N'Creating [dbo].[Backup.Model.GetOib]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetOib]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetOib]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetOib]
		@id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;	
		select * from [dbo].[Backup.Model.OIBs] where id = @id
	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.UpdateOib
PRINT N'Creating [dbo].[Backup.Model.UpdateOib]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.UpdateOib]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.UpdateOib]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.UpdateOib]
		@id uniqueidentifier,
		@parent_id uniqueidentifier,
		@object_id uniqueidentifier,
		@point_id uniqueidentifier,
		@storage_id uniqueidentifier,
		@link_id uniqueidentifier,
		@is_corrupted bit,
		@is_consistent bit,
		@state int,
		@type int,
		@alg int,
		@inside_dir nvarchar(400),
		@creation_time datetime,
		@vmname nvarchar(1000),
		@guest_os_info xml,
		@memory bigint, 
		@approx_size bigint, 
		@process_id int,
		@has_index bit,
		@has_exchange bit,
		@has_sharepoint bit,
		@has_sql bit,
		@aux_data xml,
		@display_name nvarchar(1000)	
	AS
	BEGIN
		SET NOCOUNT ON;	
		
		UPDATE [dbo].[Backup.Model.OIBs] SET            
				object_id = @object_id,
				parent_id = @parent_id,
				point_id = @point_id,
				storage_id = @storage_id,
				link_id = @link_id,
				is_corrupted = @is_corrupted,
				is_consistent = @is_consistent,
				state = @state,
				type = @type,
				alg  = @alg,
				inside_dir = @inside_dir,
				creation_time = @creation_time,
				vmname = @vmname,
				guest_os_info = @guest_os_info,
				memory = @memory,
				approx_size = @approx_size,
				process_id = @process_id,
				has_index = @has_index,
				has_exchange = @has_exchange,
				has_sharepoint = @has_sharepoint,
				has_sql = @has_sql,
				aux_data = @aux_data,
				display_name = @display_name			
		where id = @id
	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.GetStorageInHost
PRINT N'Creating [dbo].[Backup.Model.GetStorageInHost]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetStorageInHost]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetStorageInHost]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetStorageInHost]
		@hostId uniqueidentifier,
		@filePath nvarchar(1000)
	AS
	BEGIN
		SET NOCOUNT ON;	
		select * from [dbo].[Backup.Model.Storages]
		where 
			file_path = @filePath and
			host_id   = @hostId
	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.GetOibsChain
PRINT N'Creating [dbo].[Backup.Model.GetOibsChain]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetOibsChain]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetOibsChain]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetOibsChain]
		@id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;	
		select oib.* from 
			[dbo].[Backup.Model.FnGetOibsChain] (@id) ch,
			[dbo].[Backup.Model.OIBs] oib
		where 
			ch.id = oib.id
		order by ch.rn asc
	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.GetOibsFileNames
PRINT N'Creating [dbo].[Backup.Model.GetOibsFileNames]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetOibsFileNames]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetOibsFileNames]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetOibsFileNames]
		@oibIds xml
	AS
	BEGIN
		SET NOCOUNT ON;	
		select stg.file_path from 
			[dbo].[Backup.Model.OIBs] oib,
			[dbo].[Backup.Model.Storages] stg,
			(
				SELECT ROW_NUMBER() OVER (ORDER BY (SELECT 1)) as rn, y.id.value('.','uniqueidentifier') id
				FROM @oibIds.nodes('/root/id') as y(id)
			) oibIds
		where 
			oib.storage_id = stg.id and
			oib.id = oibIds.id
			order by rn
	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.UpdatePoint
PRINT N'Creating [dbo].[Backup.Model.UpdatePoint]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.UpdatePoint]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.UpdatePoint]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.UpdatePoint]
		@id uniqueidentifier,
		@link_id uniqueidentifier,
		@num numeric(16,10),
		@group_id uniqueidentifier,
		@creation_time datetime,
		@type int,
		@alg  int,
		@backup_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;	
		
		update [dbo].[Backup.Model.Points]
		set
			link_id = @link_id,
			num = @num,
			group_id = @group_id,
			creation_time = @creation_time,
			type = @type,
			alg = @alg,
			backup_id = @backup_id
		where id = @id

	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.UpdatePointType
PRINT N'Creating [dbo].[Backup.Model.UpdatePointType]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.UpdatePointType]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.UpdatePointType]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.UpdatePointType]
		@id uniqueidentifier,
		@type int
	AS
	BEGIN
		SET NOCOUNT ON;	
		update [dbo].[Backup.Model.Points]
		set type = @type
		where id = @id
	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.UpdatePointAlgorithm
PRINT N'Creating [dbo].[Backup.Model.UpdatePointAlgorithm]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.UpdatePointAlgorithm]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.UpdatePointAlgorithm]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.UpdatePointAlgorithm]
		@id uniqueidentifier,
		@alg int
	AS
	BEGIN
		SET NOCOUNT ON;	
		update [dbo].[Backup.Model.Points]
		set alg = @alg
		where id = @id
	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.UpdatePointLinkId
PRINT N'Creating [dbo].[Backup.Model.UpdatePointLinkId]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.UpdatePointLinkId]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.UpdatePointLinkId]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.UpdatePointLinkId]
		@id uniqueidentifier,
		@link_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;	
		update [dbo].[Backup.Model.Points]
		set link_id = @link_id
		where id = @id
	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.UpdatePointGroupId
PRINT N'Creating [dbo].[Backup.Model.UpdatePointGroupId]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.UpdatePointGroupId]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.UpdatePointGroupId]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.UpdatePointGroupId]
		@id uniqueidentifier,
		@group_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;	
		update [dbo].[Backup.Model.Points]
		set group_id = @group_id
		where id = @id
	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.UpdatePointNum
PRINT N'Creating [dbo].[Backup.Model.UpdatePointNum]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.UpdatePointNum]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.UpdatePointNum]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.UpdatePointNum]
		@id uniqueidentifier,
		@num numeric(16,10)
	AS
	BEGIN
		SET NOCOUNT ON;	
		update [dbo].[Backup.Model.Points]
		set num = @num
		where id = @id
	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.UpdateStorageStats
PRINT N'Creating [dbo].[Backup.Model.UpdateStorageStats]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.UpdateStorageStats]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.UpdateStorageStats]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.UpdateStorageStats]
		@id uniqueidentifier,
		@stats xml
	AS
	BEGIN
		SET NOCOUNT ON;	
		update [dbo].[Backup.Model.Storages]
		set stats = @stats
		where id = @id
	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.UpdateStorageCreationTimeFilePath
PRINT N'Creating [dbo].[Backup.Model.UpdateStorageCreationTimeFilePath]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.UpdateStorageCreationTimeFilePath]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.UpdateStorageCreationTimeFilePath]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.UpdateStorageCreationTimeFilePath]
		@id uniqueidentifier,
		@creation_time datetime,
		@file_path nvarchar(1000)
	AS
	BEGIN
		SET NOCOUNT ON;	
		update [dbo].[Backup.Model.Storages]
		set
			creation_time = @creation_time,
			file_path = @file_path
		where id = @id
	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.UpdateStorageCreationTime
PRINT N'Creating [dbo].[Backup.Model.UpdateStorageCreationTime]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.UpdateStorageCreationTime]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.UpdateStorageCreationTime]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.UpdateStorageCreationTime]
		@id uniqueidentifier,
		@creation_time datetime
	AS
	BEGIN
		SET NOCOUNT ON;	
		update [dbo].[Backup.Model.Storages]
		set
			creation_time = @creation_time,
			modification_time = @creation_time
		where id = @id
	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.UpdateOibState
PRINT N'Creating [dbo].[Backup.Model.UpdateOibState]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.UpdateOibState]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.UpdateOibState]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.UpdateOibState]
		@id uniqueidentifier,
		@state int
	AS
	BEGIN
		SET NOCOUNT ON;	
		update [dbo].[Backup.Model.OIBs]
		set state = @state
		where id = @id
	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.GetOibInPoint
PRINT N'Creating [dbo].[Backup.Model.GetOibInPoint]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetOibInPoint]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetOibInPoint]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetOibInPoint]
		@pointId  uniqueidentifier,
		@objectId uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;	
		select top 1 * from 
			[dbo].[Backup.Model.OIBs]
		where
			object_id = @objectId and
			point_id  = @pointId
	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.DeleteStorage
PRINT N'Creating [dbo].[Backup.Model.DeleteStorage]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.DeleteStorage]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.DeleteStorage]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.DeleteStorage]
		@id  uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;	
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		delete
			[dbo].[Backup.Model.Storages] 
		where
			id = @id
		
		DELETE 
			[dbo].[Backup.Model.SanSnapshotStorages]
		WHERE
			storage_id = @id	
			
		exec [dbo].[InsertTombStone] 'Backup.Model.Storages', @id, @usn

	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.UpdateBackup
PRINT N'Creating [dbo].[Backup.Model.UpdateBackup]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.UpdateBackup]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.UpdateBackup]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.UpdateBackup]
		@id uniqueidentifier,
		@job_id uniqueidentifier,
		@job_name nvarchar(255),
		@job_type int,
		@job_source_type int,
		@job_target_type int,
		@job_target_host_id uniqueidentifier,
		@job_target_host_protocol int,
		@repository_id uniqueidentifier,
		@dir_path nvarchar(max),
		@meta_file_name nvarchar(max),
		@platform int,
		@creation_time datetime
	AS
	BEGIN
		SET NOCOUNT ON;	
		update [dbo].[Backup.Model.Backups] 
		set 
			job_id   = @job_id,
			job_name = @job_name,
			job_target_type = @job_type,
			job_source_type = @job_source_type,
			target_type = @job_target_type,
			job_target_host_id = @job_target_host_id,
			job_target_host_protocol = @job_target_host_protocol,
			repository_id = @repository_id,
			dir_path = @dir_path,
			meta_file_name = @meta_file_name,
			platform = @platform,
			creation_time = @creation_time
		where
			id = @id
	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.UpdateStorage
PRINT N'Creating [dbo].[Backup.Model.UpdateStorage]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.UpdateStorage]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.UpdateStorage]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.UpdateStorage]
		@id  uniqueidentifier,
		@file_path nvarchar(1000),    
		@backup_id uniqueidentifier,
		@host_id uniqueidentifier,
		@creation_time datetime,
   		@modification_time datetime,
		@stats xml,
		@version int,
		@block_size int,
		@state int,
		@last_compact_time datetime,
		@gfs_period int,
		@creation_mode int,
		@expiration_date datetime
	AS
	BEGIN
		SET NOCOUNT ON;	
		update [dbo].[Backup.Model.Storages] 
		set 
			file_path = @file_path,
			backup_id = @backup_id,
			host_id = @host_id,
			creation_time = @creation_time,
			modification_time = @modification_time,
			stats = @stats,
			version = @version,
			block_size = @block_size,
			state = @state,
			last_compact_time = @last_compact_time,
			gfs_period = @gfs_period,
			creation_mode = @creation_mode,
			expiration_date = @expiration_date
		where
			id = @id
	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.GetLastUncorruptedOib
PRINT N'Creating [dbo].[Backup.Model.GetLastUncorruptedOib]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetLastUncorruptedOib]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetLastUncorruptedOib]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetLastUncorruptedOib]
		@object_id uniqueidentifier,
		@job_target_type int
	AS
	BEGIN
		SET NOCOUNT ON;	
		select top 1 oib.* from 
			[dbo].[Backup.Model.OIBs] oib,
			[dbo].[Backup.Model.Points] pnt,
			[dbo].[Backup.Model.Backups] _backup,
			[dbo].[BObjects] obj	
		where 
			oib.point_id = pnt.id and
			pnt.backup_id = _backup.id and
			_backup.job_target_type = @job_target_type and
			oib.object_id = obj.id and	
			oib.is_corrupted = 0 and
			obj.id = @object_id
		order by oib.creation_time desc
	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.GetLastOib
PRINT N'Creating [dbo].[Backup.Model.GetLastOib]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetLastOib]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetLastOib]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetLastOib]
		@object_id uniqueidentifier,
		@job_target_type int
	AS
	BEGIN
		SET NOCOUNT ON;	
		select top 1 oib.* from 
			[dbo].[Backup.Model.OIBs] oib,
			[dbo].[Backup.Model.Points] pnt,
			[dbo].[Backup.Model.Backups] _backup,
			[dbo].[BObjects] obj	
		where 
			oib.point_id = pnt.id and
			pnt.backup_id = _backup.id and
			_backup.job_target_type = @job_target_type and
			oib.object_id = obj.id and	
			obj.id = @object_id
		order by oib.creation_time desc
	END
	
GO

--------------------------------------------------------------------------------
-- Backup.Model.GetOibClosestToTime
PRINT N'Creating [dbo].[Backup.Model.GetOibClosestToTime]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetOibClosestToTime]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetOibClosestToTime]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetOibClosestToTime]
		@object_id uniqueidentifier,
		@job_target_type int,
		@restorePointTime datetime
	AS
	BEGIN
		SET NOCOUNT ON;	
		select top 1 oib.* from 
			[dbo].[Backup.Model.OIBs] oib,
			[dbo].[Backup.Model.Points] pnt,
			[dbo].[Backup.Model.Backups] _backup,
			[dbo].[BObjects] obj
		where 
			oib.point_id = pnt.id
			and pnt.backup_id = _backup.id
			and _backup.job_target_type = job_target_type
			and oib.object_id = obj.id
			and obj.id = @object_id
		order by abs(datediff(second, @restorePointTime, pnt.creation_time)) asc
	END
	
GO

--------------------------------------------------------------------------------
-- Backup.Model.GetOibInBackupClosestToTime
PRINT N'Creating [dbo].[Backup.Model.GetOibInBackupClosestToTime]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetOibInBackupClosestToTime]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetOibInBackupClosestToTime]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetOibInBackupClosestToTime]
		@object_id uniqueidentifier,
		@backup_id uniqueidentifier,
		@restorePointTime datetime
	AS
	BEGIN
		SET NOCOUNT ON;	
		select top 1 oib.* from 
			[dbo].[Backup.Model.OIBs] oib,
			[dbo].[Backup.Model.Points] pnt
		where 
			oib.point_id = pnt.id
			and pnt.backup_id = @backup_id
			and oib.object_id = @object_id
			and pnt.creation_time <= @restorePointTime
		order by abs(datediff(second, @restorePointTime, pnt.creation_time)) asc
	END
	
GO

--------------------------------------------------------------------------------
-- Backup.Model.GetLastOibInGroup
PRINT N'Creating [dbo].[Backup.Model.GetLastOibInGroup]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetLastOibInGroup]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetLastOibInGroup]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetLastOibInGroup]
		@object_id uniqueidentifier,
		@group_id  uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;	
		select top 1 oib.* from 
			[dbo].[Backup.Model.OIBs] oib,
			[dbo].[Backup.Model.Points] pnt,
			[dbo].[BObjects] obj	
		where 
			oib.point_id = pnt.id and
			oib.object_id = obj.id and	
			obj.id = @object_id and
			pnt.group_id = @group_id
		order by pnt.num desc
	END
	
GO

--------------------------------------------------------------------------------
-- Backup.Model.GetFirstStorageInPoint
PRINT N'Creating [dbo].[Backup.Model.GetFirstStorageInPoint]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetFirstStorageInPoint]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetFirstStorageInPoint]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetFirstStorageInPoint]
		@point_id  uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;	
		select top 1 stg.* from 
			[dbo].[Backup.Model.OIBs] oib,
			[dbo].[Backup.Model.Points] pnt,
			[dbo].[Backup.Model.Storages] stg
		where 
			oib.point_id   = pnt.id and
			oib.storage_id = stg.id and	
			pnt.id = @point_id 
	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.GetStoragesInPoint
PRINT N'Creating [dbo].[Backup.Model.GetStoragesInPoint]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetStoragesInPoint]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetStoragesInPoint]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetStoragesInPoint]
		@point_id  uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;	
		select stg.* from 
			[dbo].[Backup.Model.OIBs] oib,
			[dbo].[Backup.Model.Points] pnt,
			[dbo].[Backup.Model.Storages] stg
		where 
			oib.point_id   = pnt.id and
			oib.storage_id = stg.id and	
			pnt.id = @point_id 
	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.GetCorruptedOibsInGroup
PRINT N'Creating [dbo].[Backup.Model.GetCorruptedOibsInGroup]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetCorruptedOibsInGroup]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetCorruptedOibsInGroup]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetCorruptedOibsInGroup]
		@group_id  uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;	
		select oib.* from 
			[dbo].[Backup.Model.OIBs] oib,
			[dbo].[Backup.Model.Points] pnt
		where 
			pnt.group_id = @group_id and
			oib.point_id = pnt.id and
			oib.is_corrupted = 1
		order by pnt.num asc
	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.GetFullOibInGroup
PRINT N'Creating [dbo].[Backup.Model.GetFullOibInGroup]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetFullOibInGroup]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetFullOibInGroup]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetFullOibInGroup]
		@object_id uniqueidentifier,
		@group_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;	
		select oib.* from 
			[dbo].[Backup.Model.OIBs] oib,	
			[dbo].[Backup.Model.Points] pnt
		where 
			pnt.group_id = @group_id and	
			oib.object_id = @object_id and
			oib.point_id = pnt.id and	
			oib.type = 0
	END
	
GO

--------------------------------------------------------------------------------
-- Backup.Model.GetOibsInStorage
PRINT N'Creating [dbo].[Backup.Model.GetOibsInStorage]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetOibsInStorage]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetOibsInStorage]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetOibsInStorage]
		@storage_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;	
		select oib.* from 
			[dbo].[Backup.Model.OIBs] oib
		where 
			oib.storage_id = @storage_id		
	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.IsStorageEmpty
PRINT N'Creating [dbo].[Backup.Model.IsStorageEmpty]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.IsStorageEmpty]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.IsStorageEmpty]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.IsStorageEmpty]
		@id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;	
		declare @retval bit
		select @retval = (case when oibcnt.val > 0 then 0 else 1 end) from
		(
		select count(*) val from 
			[dbo].[Backup.Model.OIBs] oib
		where 
			oib.storage_id = @id
		) oibcnt	
		select @retval empty
	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.GetDependentPoints
PRINT N'Creating [dbo].[Backup.Model.GetDependentPoints]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetDependentPoints]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetDependentPoints]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetDependentPoints]
		@id   uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;	
		select * from 
			[dbo].[Backup.Model.Points]
		where 
			id <> @id and
			group_id = 
			(
				select group_id from [dbo].[Backup.Model.Points] where id = @id
			)
		order by num
	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.PointHasOibs
PRINT N'Creating [dbo].[Backup.Model.PointHasOibs]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.PointHasOibs]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.PointHasOibs]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.PointHasOibs]
		@point_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;	
		
		SELECT 
			(CASE WHEN COUNT(*) = 0 THEN 'False' ELSE 'True' END) val
		FROM
			[dbo].[Backup.Model.OIBs] oib
		WHERE oib.point_id = @point_id
	END

GO

--------------------------------------------------------------------------------
-- GetDRRole
PRINT N'Creating [dbo].[GetDRRole]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetDRRole]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetDRRole]
GO

	CREATE PROCEDURE [dbo].[GetDRRole]
				@row_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT * FROM [dbo].[DRRoles] WHERE [id] = @row_id   
	END	

GO

--------------------------------------------------------------------------------
-- AddDRRole
PRINT N'Creating [dbo].[AddDRRole]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[AddDRRole]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[AddDRRole]
GO

	CREATE PROCEDURE [dbo].[AddDRRole]
		@row_id [uniqueidentifier],
		@row_name nvarchar(max),
		@row_effective_memory [bigint],
		@row_boot_delay int,
		@row_test_script_file_full_name nvarchar(max)
	AS
	BEGIN
		SET NOCOUNT ON;

		INSERT INTO [dbo].[DRRoles]
			   (
				[id],
				[name],
				[effective_memory],
				[boot_delay],
				[test_script_file_full_name]
			   )
		 VALUES
			   (
				@row_id,
				@row_name,
				@row_effective_memory,
				@row_boot_delay,
				@row_test_script_file_full_name
			   )
	END	

GO

--------------------------------------------------------------------------------
-- UpdateDRRole
PRINT N'Creating [dbo].[UpdateDRRole]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateDRRole]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateDRRole]
GO

	CREATE PROCEDURE [dbo].[UpdateDRRole]
		@row_id [uniqueidentifier],
		@row_name nvarchar(max),
		@row_effective_memory [bigint],
		@row_boot_delay int,
		@row_test_script_file_full_name nvarchar(max)
	AS
	BEGIN
		SET NOCOUNT ON;
		UPDATE [dbo].[DRRoles] SET
			[name]							= @row_name,
			[effective_memory]				= @row_effective_memory,
			[boot_delay]					= @row_boot_delay,
			[test_script_file_full_name]	= @row_test_script_file_full_name
		where [id] = @row_id
	END	
	
GO

--------------------------------------------------------------------------------
-- DeleteDRRole
PRINT N'Creating [dbo].[DeleteDRRole]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DeleteDRRole]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[DeleteDRRole]
GO

	CREATE PROCEDURE [dbo].[DeleteDRRole]
		@row_id uniqueidentifier
	AS
	BEGIN

		SET NOCOUNT ON;

		DELETE FROM [dbo].[DRRoles] WHERE [id] = @row_id
	END

GO

--------------------------------------------------------------------------------
-- GetDRRolesAll
PRINT N'Creating [dbo].[GetDRRolesAll]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetDRRolesAll]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetDRRolesAll]
GO

	CREATE PROCEDURE [dbo].[GetDRRolesAll]
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT * FROM [dbo].[DRRoles]
	END	

GO

--------------------------------------------------------------------------------
-- GetDRRoleByName
PRINT N'Creating [dbo].[GetDRRoleByName]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetDRRoleByName]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetDRRoleByName]
GO

	CREATE PROCEDURE [dbo].[GetDRRoleByName]
				@row_name nvarchar(max)
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT * FROM [dbo].[DRRoles] WHERE [name] = @row_name
	END	

GO

--------------------------------------------------------------------------------
-- AddPermissionBySid
PRINT N'Creating [dbo].[AddPermissionBySid]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[AddPermissionBySid]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[AddPermissionBySid]
GO

	CREATE PROCEDURE [dbo].[AddPermissionBySid]
		@sid nvarchar(1000),
		@name nvarchar(1000),
		@nt4_name nvarchar(1000)
	AS
	BEGIN
		SET NOCOUNT ON;	
		
		IF EXISTS(SELECT * FROM [dbo].[Backup.Security.Accounts] WHERE [sid] = @sid)
			RETURN
		ELSE
		BEGIN 
		
			DECLARE @localAdminsAccountId uniqueidentifier
			SELECT @localAdminsAccountId = NEWID()

			DECLARE @BackupAdminRoleId uniqueidentifier
			SELECT @BackupAdminRoleId = '5FF0E0EB-45CF-48cc-9677-7613FC79BC11'
			
			--DECLARE @RepCollectorRoleId uniqueidentifier
			--SELECT @RepCollectorRoleId = '3C5720EC-BADB-4a66-B1EC-EB4037DAD657'
			
			
			INSERT INTO [dbo].[Backup.Security.Accounts]( [id], [name], [sid], [nt4_name], [type])
			VALUES ( @localAdminsAccountId, @name, @sid, @nt4_name, 1 )
			
			INSERT INTO [dbo].[Backup.Security.RoleAccounts]( [id], [role_id], [account_id] )
			VALUES( NEWID(), @BackupAdminRoleId, @localAdminsAccountId )		
			
			--INSERT INTO [dbo].[Backup.Security.RoleAccounts]( [id], [role_id], [account_id] )
			--VALUES( NEWID(), @RepCollectorRoleId, @localAdminsAccountId )	
		END
	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.GetOibsFromBackupForObject
PRINT N'Creating [dbo].[Backup.Model.GetOibsFromBackupForObject]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetOibsFromBackupForObject]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetOibsFromBackupForObject]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetOibsFromBackupForObject]
		@row_backup_id uniqueidentifier,
		@row_object_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;	
		SELECT oibs.* FROM 
			[dbo].[Backup.Model.OIBs] oibs,
			[dbo].[Backup.Model.Points] p
		WHERE 
			oibs.point_id  = p.id and
			oibs.object_id = @row_object_id AND 
			p.backup_id  = @row_backup_id
		ORDER BY p.num		
	END

GO

--------------------------------------------------------------------------------
-- GetLinkedJobs
PRINT N'Creating [dbo].[GetLinkedJobs]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetLinkedJobs]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetLinkedJobs]
GO

	CREATE PROCEDURE [dbo].[GetLinkedJobs]
				@row_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT * FROM [dbo].[LinkedJobs] WHERE [id] = @row_id   
	END	

GO

--------------------------------------------------------------------------------
-- AddLinkedJobs
PRINT N'Creating [dbo].[AddLinkedJobs]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[AddLinkedJobs]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[AddLinkedJobs]
GO

	CREATE PROCEDURE [dbo].[AddLinkedJobs]
		@row_id [uniqueidentifier],
		@row_job_id [uniqueidentifier],
		@row_linked_job_id [uniqueidentifier]
	AS
	BEGIN
		SET NOCOUNT ON;

		INSERT INTO [dbo].[LinkedJobs]
			   (
				[id],
				[job_id],
				[linked_job_id]
			   )
		 VALUES
			   (
				@row_id,
				@row_job_id,
				@row_linked_job_id
			   )
	END	

GO

--------------------------------------------------------------------------------
-- UpdateLinkedJobs
PRINT N'Creating [dbo].[UpdateLinkedJobs]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateLinkedJobs]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateLinkedJobs]
GO

	CREATE PROCEDURE [dbo].[UpdateLinkedJobs]
		@row_id [uniqueidentifier],
		@row_job_id [uniqueidentifier],
		@row_linked_job_id [uniqueidentifier]
	AS
	BEGIN
		SET NOCOUNT ON;
		UPDATE [dbo].[LinkedJobs] SET
			[job_id]			= @row_job_id,
			[linked_job_id]		= @row_linked_job_id
		where [id] = @row_id
	END	
	
GO

--------------------------------------------------------------------------------
-- DeleteLinkedJobs
PRINT N'Creating [dbo].[DeleteLinkedJobs]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DeleteLinkedJobs]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[DeleteLinkedJobs]
GO

	CREATE PROCEDURE [dbo].[DeleteLinkedJobs]
		@row_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		DELETE FROM [dbo].[LinkedJobs] WHERE [id] = @row_id
	END

GO

--------------------------------------------------------------------------------
-- GetLinkedJobsAll
PRINT N'Creating [dbo].[GetLinkedJobsAll]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetLinkedJobsAll]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetLinkedJobsAll]
GO

	CREATE PROCEDURE [dbo].[GetLinkedJobsAll]
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT * FROM [dbo].[LinkedJobs]
	END	

GO

--------------------------------------------------------------------------------
-- GetLinkedJobsByJobId
PRINT N'Creating [dbo].[GetLinkedJobsByJobId]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetLinkedJobsByJobId]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetLinkedJobsByJobId]
GO

	CREATE PROCEDURE [dbo].[GetLinkedJobsByJobId]
				@row_job_id [uniqueidentifier]
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT * FROM [dbo].[LinkedJobs] WHERE [job_id] = @row_job_id
	END	

GO

--------------------------------------------------------------------------------
-- DeleteLinkedJobsByJobId
PRINT N'Creating [dbo].[DeleteLinkedJobsByJobId]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DeleteLinkedJobsByJobId]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[DeleteLinkedJobsByJobId]
GO

	CREATE PROCEDURE [dbo].[DeleteLinkedJobsByJobId]
				@row_job_id [uniqueidentifier]
	AS
	BEGIN
		SET NOCOUNT ON;
		DELETE FROM [dbo].[LinkedJobs] WHERE [job_id] = @row_job_id
	END	

GO

--------------------------------------------------------------------------------
-- DeleteLinkedJobsByLinkedJobId
PRINT N'Creating [dbo].[DeleteLinkedJobsByLinkedJobId]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DeleteLinkedJobsByLinkedJobId]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[DeleteLinkedJobsByLinkedJobId]
GO

	CREATE PROCEDURE [dbo].[DeleteLinkedJobsByLinkedJobId]
				@row_linked_job_id [uniqueidentifier]
	AS
	BEGIN
		SET NOCOUNT ON;
		DELETE FROM [dbo].[LinkedJobs] WHERE [linked_job_id] = @row_linked_job_id
	END	

GO

--------------------------------------------------------------------------------
-- UpdateBaseJobProgress
PRINT N'Creating [dbo].[UpdateBaseJobProgress]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateBaseJobProgress]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateBaseJobProgress]
GO

	CREATE PROCEDURE [dbo].[UpdateBaseJobProgress]
			   @row_id uniqueidentifier,
			   @row_progress int
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @usn bigint
		
		exec [dbo].[IncrementUsn] @usn OUTPUT
		UPDATE [dbo].[Backup.Model.JobSessions] SET
		   [progress]			=@row_progress,
		   [usn]                =@usn
		   WHERE [id] = @row_id
	    
	END	
	
GO

--------------------------------------------------------------------------------
-- AddJobRestoreSessionInfoRow
PRINT N'Creating [dbo].[AddJobRestoreSessionInfoRow]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[AddJobRestoreSessionInfoRow]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[AddJobRestoreSessionInfoRow]
GO

	CREATE PROCEDURE [dbo].[AddJobRestoreSessionInfoRow]
			   @row_id uniqueidentifier,
			   @row_session_id uniqueidentifier,
			   @row_object_name nvarchar(2000),
			   @row_object_id uniqueidentifier,
			   @row_status int,
			   @row_reason ntext,           
			   @row_creation_time datetime,
			   @row_end_time datetime,
			   @row_operation nvarchar(400),
			   @row_process xml,
			   @row_work_details xml
	AS
	BEGIN
		SET NOCOUNT ON;

		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT
		
		INSERT INTO [dbo].[Backup.Model.RestoreTaskSessions]
			   ([id]
			   ,[session_id]
			   ,[object_name]
			   ,[object_id]
			   ,[status]
			   ,[reason]
			   ,[creation_time]
			   ,[end_time]
			   ,[operation]
			   ,[process]
			   ,[usn]
			   ,[work_details])
		 VALUES
			   (@row_id,
			   @row_session_id,
			   @row_object_name,
			   @row_object_id,
			   @row_status,
			   @row_reason,
			   @row_creation_time,
			   @row_end_time,
			   @row_operation,
			   @row_process,
			   @usn,
			   @row_work_details)
	END	
	
GO

--------------------------------------------------------------------------------
-- UpdateJobRestoreSessionInfoRow
PRINT N'Creating [dbo].[UpdateJobRestoreSessionInfoRow]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateJobRestoreSessionInfoRow]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateJobRestoreSessionInfoRow]
GO

	CREATE PROCEDURE [dbo].[UpdateJobRestoreSessionInfoRow]
			   @row_id uniqueidentifier,
			   @row_session_id uniqueidentifier,
			   @row_object_name nvarchar(2000),
			   @row_object_id uniqueidentifier,
			   @row_status int,
			   @row_reason ntext,           
			   @row_creation_time datetime,
			   @row_end_time datetime,
			   @row_operation nvarchar(400),
			   @row_process xml,
			   @row_work_details xml	
	AS
	BEGIN
		SET NOCOUNT ON;

		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		UPDATE [dbo].[Backup.Model.RestoreTaskSessions] SET
			   [session_id]			=@row_session_id,
			   [object_id]			=@row_object_id,
			   [object_name]		=@row_object_name,
			   [status]				=@row_status,
			   [reason]				=@row_reason,
			   [creation_time]		=@row_creation_time,
			   [end_time]			=@row_end_time,
			   [operation]			=@row_operation,
			   [process]			=@row_process,
			   [usn]                =@usn,
			   [work_details]       =@row_work_details
			   WHERE [id] = @row_id
	END

GO

--------------------------------------------------------------------------------
-- UpdateJobRestoreSessionInfoProgress
PRINT N'Creating [dbo].[UpdateJobRestoreSessionInfoProgress]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateJobRestoreSessionInfoProgress]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateJobRestoreSessionInfoProgress]
GO

	CREATE PROCEDURE [dbo].[UpdateJobRestoreSessionInfoProgress]
			   @row_id uniqueidentifier,
			   @row_process xml
	AS
	BEGIN
		SET NOCOUNT ON;

		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		UPDATE [dbo].[Backup.Model.RestoreTaskSessions] SET
			   [process]			=@row_process,
			   [usn]                =@usn
			   WHERE [id] = @row_id
	END

GO

--------------------------------------------------------------------------------
-- DeleteJobRestoreSessionInfo
PRINT N'Creating [dbo].[DeleteJobRestoreSessionInfo]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DeleteJobRestoreSessionInfo]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[DeleteJobRestoreSessionInfo]
GO

	CREATE PROCEDURE [dbo].[DeleteJobRestoreSessionInfo]
		@row_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		DELETE FROM [dbo].[Backup.Model.RestoreTaskSessions] WHERE [id] = @row_id
		DELETE FROM [dbo].[ItemRestoreAudits] WHERE [restore_session_id] = @row_id
	END
	
GO

--------------------------------------------------------------------------------
-- GetJobRestoreSessionInfo
PRINT N'Creating [dbo].[GetJobRestoreSessionInfo]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetJobRestoreSessionInfo]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetJobRestoreSessionInfo]
GO

	CREATE PROCEDURE [dbo].[GetJobRestoreSessionInfo]
		@row_session_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[Backup.Model.RestoreTaskSessions] where [session_id] = @row_session_id
	END

GO

--------------------------------------------------------------------------------
-- FindJobRestoreSessionInfo
PRINT N'Creating [dbo].[FindJobRestoreSessionInfo]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[FindJobRestoreSessionInfo]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[FindJobRestoreSessionInfo]
GO

	CREATE PROCEDURE [dbo].[FindJobRestoreSessionInfo]
		@row_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[Backup.Model.RestoreTaskSessions] where [id] = @row_id
	END

GO

--------------------------------------------------------------------------------
-- GetJobRestoreSessionsAll
PRINT N'Creating [dbo].[GetJobRestoreSessionsAll]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetJobRestoreSessionsAll]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetJobRestoreSessionsAll]
GO

	CREATE PROCEDURE [dbo].[GetJobRestoreSessionsAll]
	AS
	BEGIN
		SET NOCOUNT ON;

		Select 
			[dbo].[Backup.Model.JobSessions].[id],
			[dbo].[Backup.Model.JobSessions].[creation_time],
			[dbo].[Backup.Model.JobSessions].[end_time],
			[dbo].[Backup.Model.JobSessions].[job_name],
			[dbo].[Backup.Model.JobSessions].[job_type],
			[dbo].[Backup.Model.JobSessions].[job_id],
			[dbo].[Backup.Model.JobSessions].[result],
			[dbo].[Backup.Model.JobSessions].[description],
			[dbo].[Backup.Model.JobSessions].[operation],
			[dbo].[Backup.Model.JobSessions].[state],
			[dbo].[Backup.Model.JobSessions].[lease_id],
			[dbo].[Backup.Model.RestoreJobSessions].[action],
			[dbo].[Backup.Model.RestoreJobSessions].[options],
			[dbo].[Backup.Model.RestoreJobSessions].[initiator_sid],
			[dbo].[Backup.Model.RestoreJobSessions].[initiator_name],	
			[dbo].[Backup.Model.RestoreJobSessions].[reason],
			[dbo].[Backup.Model.RestoreJobSessions].[platform],
			[dbo].[Backup.Model.RestoreJobSessions].[multi_restore_id],
			[dbo].[Backup.Model.RestoreJobSessions].[restore_type],
			[dbo].[Backup.Model.RestoreJobSessions].[oib_id],
			[dbo].[Backup.Model.RestoreJobSessions].[state_xml],
			[dbo].[Backup.Model.RestoreJobSessions].[is_internal],
			[dbo].[Backup.Model.RestoreJobSessions].[oib_display_name],
			[dbo].[Backup.Model.RestoreJobSessions].[oib_creation_time],
			[dbo].[Backup.Model.RestoreJobSessions].[sub_type]
			
		from [dbo].[Backup.Model.JobSessions] LEFT JOIN [dbo].[Backup.Model.RestoreJobSessions] 
			on [dbo].[Backup.Model.JobSessions].[id] = [dbo].[Backup.Model.RestoreJobSessions].[id]
			
		WHERE [dbo].[Backup.Model.JobSessions].[job_type] in (4,5,6,7,9,10,11,12,13,14,15,16,17,41,42,48)
		
		ORDER BY
			[creation_time] DESC
	END
	
GO

--------------------------------------------------------------------------------
-- AddJobRestoreSessionRow
PRINT N'Creating [dbo].[AddJobRestoreSessionRow]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[AddJobRestoreSessionRow]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[AddJobRestoreSessionRow]
GO

	CREATE PROCEDURE [dbo].[AddJobRestoreSessionRow]
			   @row_id uniqueidentifier,
			   @row_job_id uniqueidentifier,
			   @row_job_name nvarchar(255),
			   @row_job_type int,
			   @row_result int,
			   @row_description text,
			   @row_operation nvarchar(400),
			   @row_state int,
			   @row_action int,           
			   @row_creation_time datetime,
			   @row_end_time datetime,
			   @row_options xml,
			   @row_initiator_sid nvarchar(255),
			   @row_initiator_name nvarchar(255),
			   @row_reason nvarchar(max),
			   @row_lease_id uniqueidentifier,
			   @row_platform int,
			   @row_multi_restore_id uniqueidentifier,
			   @row_restore_type int,
			   @row_oib_id uniqueidentifier,
			   @row_state_xml xml,
			   @is_internal bit,
			   @oib_display_name nvarchar(2000),
			   @oib_creation_time datetime
	AS
	BEGIN
		SET NOCOUNT ON;

		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		INSERT INTO [dbo].[Backup.Model.JobSessions]
			   ([id]
			  ,[job_id]
			  ,[job_name]
			  ,[job_type]
			  ,[result]
			  ,[description]
			  ,[operation]
			  ,[state]
			  ,[creation_time]
			  ,[end_time]
			  ,[lease_id]
			  ,[usn]
			  )
		 VALUES
			   (@row_id,
				@row_job_id,
				@row_job_name,
				@row_job_type,
				@row_result,
				@row_description,
				@row_operation,
				@row_state,
				@row_creation_time,
				@row_end_time,
				@row_lease_id,
				@usn
				)

		INSERT INTO [dbo].[Backup.Model.RestoreJobSessions]
			   ([id]
			  ,[action]
			  ,[options]
			  ,[initiator_sid]
			  ,[initiator_name]
			  ,[reason]
			  ,[platform]
			  ,[multi_restore_id]
			  ,[restore_type]
			  ,[oib_id]
			  ,[usn]
			  ,[state_xml]
			  ,[is_internal]
			  ,[oib_display_name]
			  ,[oib_creation_time])
		 VALUES
			   (@row_id,
				@row_action,
				@row_options,
				@row_initiator_sid,
				@row_initiator_name,
				@row_reason,
				@row_platform,
				@row_multi_restore_id,
				@row_restore_type,
				@row_oib_id,
				@usn,
				@row_state_xml,
				@is_internal,
				SUBSTRING( @oib_display_name, 0, 255 ),
				@oib_creation_time)			
	END	
	
GO

--------------------------------------------------------------------------------
-- UpdateJobRestoreSessionRow
PRINT N'Creating [dbo].[UpdateJobRestoreSessionRow]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateJobRestoreSessionRow]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateJobRestoreSessionRow]
GO

	CREATE PROCEDURE [dbo].[UpdateJobRestoreSessionRow]
			   @row_id uniqueidentifier,
			   @row_job_id uniqueidentifier,
			   @row_job_name nvarchar(255),
			   @row_job_type int,
			   @row_result int,
			   @row_description text,
			   @row_operation nvarchar(400),
			   @row_state int,
			   @row_action int,           
			   @row_creation_time datetime,
			   @row_end_time datetime,
			   @row_options xml,
			   @row_initiator_sid nvarchar(255),
			   @row_initiator_name nvarchar(255),
			   @row_reason nvarchar(max),
			   @row_lease_id uniqueidentifier,
			   @row_multi_restore_id uniqueidentifier,
			   @row_restore_type int,
			   @row_oib_id uniqueidentifier,
			   @row_state_xml xml
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @usn bigint
		
		exec [dbo].[IncrementUsn] @usn OUTPUT
		UPDATE [dbo].[Backup.Model.JobSessions] SET
			   [job_id]		  	    =@row_job_id,
			   [job_name]			=@row_job_name,
			   [job_type] 		    =@row_job_type,
			   [result]			    =@row_result,
			   [description]		=@row_description,
			   [operation]			=@row_operation,
			   [state]			    =@row_state,
			   [creation_time]		=@row_creation_time,
			   [end_time]			=@row_end_time,
			   [lease_id]			=@row_lease_id,
			   [usn]                =@usn
			   WHERE [id] = @row_id  
	           
		exec [dbo].[IncrementUsn] @usn OUTPUT
		UPDATE [dbo].[Backup.Model.RestoreJobSessions] SET
			   [action]				=@row_action,
			   [options]			=@row_options,
			   [initiator_sid]		=@row_initiator_sid,
			   [initiator_name]		=@row_initiator_name,
			   [reason]				=@row_reason,
			   [multi_restore_id]	=@row_multi_restore_id,
			   [restore_type]		=@row_restore_type,
			   [oib_id]				=@row_oib_id,
			   [usn]				=@usn,
			   [state_xml]          =@row_state_xml
			   WHERE [id] = @row_id   
			       
				
	END
	
GO

--------------------------------------------------------------------------------
-- DeleteJobRestoreSession
PRINT N'Creating [dbo].[DeleteJobRestoreSession]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DeleteJobRestoreSession]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[DeleteJobRestoreSession]
GO

	CREATE PROCEDURE [dbo].[DeleteJobRestoreSession]
		@row_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
			
		DELETE FROM [dbo].[Backup.Model.JobSessions] WHERE [id] = @row_id
		DELETE FROM [dbo].[Backup.Model.RestoreJobSessions] WHERE [id] = @row_id
		DELETE FROM [dbo].[ItemRestoreAudits] WHERE [restore_session_id]= @row_id
				
	END

GO

--------------------------------------------------------------------------------
-- GetJobRestoreSession
PRINT N'Creating [dbo].[GetJobRestoreSession]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetJobRestoreSession]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetJobRestoreSession]
GO

	CREATE PROCEDURE [dbo].[GetJobRestoreSession]
		@row_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		Select 
			[dbo].[Backup.Model.JobSessions].[id],
			[dbo].[Backup.Model.JobSessions].[job_name],
			[dbo].[Backup.Model.JobSessions].[job_id],
			[dbo].[Backup.Model.JobSessions].[job_type],
			[dbo].[Backup.Model.JobSessions].[creation_time],
			[dbo].[Backup.Model.JobSessions].[end_time],
			[dbo].[Backup.Model.JobSessions].[result],
			[dbo].[Backup.Model.JobSessions].[description],
			[dbo].[Backup.Model.JobSessions].[operation],
			[dbo].[Backup.Model.JobSessions].[state],
			[dbo].[Backup.Model.JobSessions].[lease_id],
			[dbo].[Backup.Model.RestoreJobSessions].[action],
			[dbo].[Backup.Model.RestoreJobSessions].[options],
			[dbo].[Backup.Model.RestoreJobSessions].[initiator_sid],
			[dbo].[Backup.Model.RestoreJobSessions].[initiator_name],
			[dbo].[Backup.Model.RestoreJobSessions].[reason],
			[dbo].[Backup.Model.RestoreJobSessions].[platform],
			[dbo].[Backup.Model.RestoreJobSessions].[multi_restore_id],
			[dbo].[Backup.Model.RestoreJobSessions].[restore_type],
			[dbo].[Backup.Model.RestoreJobSessions].[oib_id],
			[dbo].[Backup.Model.RestoreJobSessions].[state_xml],
			[dbo].[Backup.Model.RestoreJobSessions].[is_internal],			
			[dbo].[Backup.Model.RestoreJobSessions].[oib_display_name],
			[dbo].[Backup.Model.RestoreJobSessions].[oib_creation_time],
			[dbo].[Backup.Model.RestoreJobSessions].[sub_type]

		from [dbo].[Backup.Model.JobSessions] LEFT JOIN [dbo].[Backup.Model.RestoreJobSessions] 
			on [dbo].[Backup.Model.JobSessions].[id] = [dbo].[Backup.Model.RestoreJobSessions].[id]
			
		Where [dbo].[Backup.Model.JobSessions].[id] = @row_id
	END

GO

--------------------------------------------------------------------------------
-- GetDrJobSessionsAll
PRINT N'Creating [dbo].[GetDrJobSessionsAll]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetDrJobSessionsAll]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetDrJobSessionsAll]
GO

	CREATE PROCEDURE [dbo].[GetDrJobSessionsAll]
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT 
			*	
		FROM 
			[dbo].[Backup.Model.JobSessions] js, [dbo].[Backup.Model.SbSessions] drs
		WHERE
			js.id = drs.id AND	[job_type] = 3
			
	END

GO

--------------------------------------------------------------------------------
-- AddDrJobSessionRow
PRINT N'Creating [dbo].[AddDrJobSessionRow]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[AddDrJobSessionRow]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[AddDrJobSessionRow]
GO

	CREATE PROCEDURE [dbo].[AddDrJobSessionRow]
				@row_id uniqueidentifier,
				@row_job_name nvarchar(255),
				@row_creation_time datetime,
				@row_end_time datetime,

				@row_job_id uniqueidentifier,
				@row_result int,
				@row_description text,
				@row_operation nvarchar(400),
				@row_state int,
				@row_lease_id uniqueidentifier,
				@row_app_group_fail bit,
				@row_troubleshoot_mode bit,
	           
				@row_total_operations int,
				@row_processed_operations int,
				@row_successfull_operations int,
				@row_warning_operations int,
				@row_failed_operations int,
				@row_skipped_operations int,
				@row_percent int,
				@row_preferred_date datetime,
				@row_power_off_vm_on_fail bit,
				@row_run_manually bit,
				@row_aux_data xml,
				@row_platform int
	AS
	BEGIN
		SET NOCOUNT ON;

		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT
		
		INSERT INTO [dbo].[Backup.Model.JobSessions]
			   ([id],
				[job_name],
				[job_type],
				[creation_time],
				[end_time],
		  		[job_id],
				[result],
				[description],
				[operation],
				[state],
				[progress],
				[lease_id],
				[app_group_fail],
				[troubleshoot_mode],
				[run_manually],
				[aux_data],
				[usn])
		 VALUES
			   (@row_id,
				@row_job_name,
				3,
				@row_creation_time,
				@row_end_time,
				@row_job_id,
				@row_result,
				@row_description,
				@row_operation,
				@row_state,
				@row_percent,
				@row_lease_id,
				@row_app_group_fail,
				@row_troubleshoot_mode,
				@row_run_manually,
				@row_aux_data,
				@usn)
	    
		INSERT INTO [dbo].[Backup.Model.SbSessions]
			   (
				[id],
				[preferred_date],
				[power_off_vm_on_fail],
				[platform],
				[usn]
			   )
		 VALUES (
				@row_id,
				@row_preferred_date,
				@row_power_off_vm_on_fail,
				@row_platform,
				@usn
			   )
	END	
	
GO

--------------------------------------------------------------------------------
-- UpdateDrJobSessionRow
PRINT N'Creating [dbo].[UpdateDrJobSessionRow]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateDrJobSessionRow]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateDrJobSessionRow]
GO

	CREATE PROCEDURE [dbo].[UpdateDrJobSessionRow]
				@row_id uniqueidentifier,
				@row_job_name nvarchar(255),
				@row_creation_time datetime,
				@row_end_time datetime,           
				@row_job_id uniqueidentifier,
				@row_result int,
				@row_description text,
				@row_operation nvarchar(400),
				@row_state int,
				@row_lease_id uniqueidentifier,
				@row_app_group_fail bit,
				@row_troubleshoot_mode bit,
				@row_total_operations int,
				@row_processed_operations int,
				@row_successfull_operations int,
				@row_warning_operations int,
				@row_failed_operations int,
				@row_skipped_operations int,
				@row_percent int,
				@row_preferred_date datetime,
				@row_power_off_vm_on_fail bit,
				@row_run_manually bit,
				@row_aux_data xml,
				@row_platform int
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @usn bigint
		
		exec [dbo].[IncrementUsn] @usn OUTPUT
		UPDATE [dbo].[Backup.Model.JobSessions] SET
			[job_id]			= @row_job_id,
			[job_name]			= @row_job_name,
			[result]			= @row_result,
			[description]		= @row_description,
			[operation]			= @row_operation,
			[state]				= @row_state,	
			[creation_time]		= @row_creation_time,
			[end_time]			= @row_end_time,
			[progress]          = @row_percent,
			[lease_id]			= @row_lease_id,
			[app_group_fail]    = @row_app_group_fail,
			[troubleshoot_mode] = @row_troubleshoot_mode,
			[run_manually]      = @row_run_manually,	
			[aux_data]          = @row_aux_data,	
			[usn]               = @usn
		WHERE [id] = @row_id  
	           
		exec [dbo].[IncrementUsn] @usn OUTPUT
		UPDATE [dbo].[Backup.Model.SbSessions] SET
			[preferred_date]       = @row_preferred_date,
			[power_off_vm_on_fail] = @row_power_off_vm_on_fail,
			[platform]             = @row_platform,
			[usn]                  = @usn
		WHERE [id] = @row_id

	END	
	
GO

--------------------------------------------------------------------------------
-- UpdateDrJobSessionState
PRINT N'Creating [dbo].[UpdateDrJobSessionState]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateDrJobSessionState]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateDrJobSessionState]
GO

	CREATE PROCEDURE [dbo].[UpdateDrJobSessionState]
				@row_id uniqueidentifier,
				@row_state int
	AS
	BEGIN
		SET NOCOUNT ON;

		declare @usn bigint
		
		exec [dbo].[IncrementUsn] @usn OUTPUT
		UPDATE [dbo].[Backup.Model.JobSessions] SET
			[state]				= @row_state,
			[usn]               = @usn
		WHERE [id] = @row_id
		
	END	
	
GO

--------------------------------------------------------------------------------
-- DeleteDrJobSession
PRINT N'Creating [dbo].[DeleteDrJobSession]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DeleteDrJobSession]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[DeleteDrJobSession]
GO

	CREATE PROCEDURE [dbo].[DeleteDrJobSession]
		@row_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		DELETE FROM [dbo].[Backup.Model.JobSessions] WHERE [id] = @row_id
		DELETE FROM [dbo].[Backup.Model.SbSessions] WHERE [id] = @row_id
		
	END

GO

--------------------------------------------------------------------------------
-- GetDrJobSession
PRINT N'Creating [dbo].[GetDrJobSession]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetDrJobSession]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetDrJobSession]
GO

	CREATE PROCEDURE [dbo].[GetDrJobSession]
		@row_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT
			*
		FROM
			[dbo].[Backup.Model.JobSessions] js
		RIGHT JOIN
			[dbo].[Backup.Model.SbSessions] drs
		ON 
			js.[id] = drs.[id]
		WHERE
			js.[id] = @row_id
	END

GO

--------------------------------------------------------------------------------
-- FindLastDrJobSession
PRINT N'Creating [dbo].[FindLastDrJobSession]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[FindLastDrJobSession]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[FindLastDrJobSession]
GO

	CREATE PROCEDURE [dbo].[FindLastDrJobSession]
		@row_job_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT TOP(1) *
		FROM 
			[dbo].[Backup.Model.JobSessions] js
		LEFT JOIN
			[dbo].[Backup.Model.SbSessions] drs
		ON	
			js.[id] = drs.[id]
		WHERE 
			[job_id] = @row_job_id 
		ORDER BY
			[creation_time] DESC
	END

GO

--------------------------------------------------------------------------------
-- GetDrJobSessionsForDrJob
PRINT N'Creating [dbo].[GetDrJobSessionsForDrJob]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetDrJobSessionsForDrJob]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetDrJobSessionsForDrJob]
GO

	CREATE PROCEDURE [dbo].[GetDrJobSessionsForDrJob]
		@row_job_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT
			*
		FROM
			[dbo].[Backup.Model.JobSessions] js
		RIGHT JOIN
			[dbo].[Backup.Model.SbSessions] drs
		ON js.[id] = drs.[id]
		WHERE
			[job_id] = @row_job_id
	END

GO

--------------------------------------------------------------------------------
-- UpdateDrSessionProgress
PRINT N'Creating [dbo].[UpdateDrSessionProgress]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateDrSessionProgress]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateDrSessionProgress]
GO

	CREATE PROCEDURE [dbo].[UpdateDrSessionProgress]
				@row_id uniqueidentifier,
				@row_progress int
	AS
	BEGIN
		SET NOCOUNT ON;

		declare @usn bigint
		
		exec [dbo].[IncrementUsn] @usn OUTPUT
		UPDATE [dbo].[Backup.Model.JobSessions] SET
			[progress] = @row_progress,
			[usn]      = @usn
		WHERE [id] = @row_id
		
	END	
	
GO

--------------------------------------------------------------------------------
-- GetVirtualLabsCount
PRINT N'Creating [dbo].[GetVirtualLabsCount]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetVirtualLabsCount]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetVirtualLabsCount]
GO

	CREATE PROCEDURE [dbo].[GetVirtualLabsCount]
		@platform int
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT 
			COUNT(*) vl_count 
		FROM 
			[dbo].[VirtualLabs] labs
		WHERE
			labs.[platform] = ISNULL(@platform, labs.[platform])
	END	

GO

--------------------------------------------------------------------------------
-- UpdateHostBiosUuid
PRINT N'Creating [dbo].[UpdateHostBiosUuid]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateHostBiosUuid]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateHostBiosUuid]
GO

	CREATE PROCEDURE [dbo].[UpdateHostBiosUuid]
		@row_id uniqueidentifier,
		@bios_uuid nvarchar(255)
	AS
	BEGIN
		SET NOCOUNT ON;
		UPDATE [dbo].[Hosts] SET
				[bios_uuid] = @bios_uuid			
		WHERE [id] = @row_id
			
	END	

GO

--------------------------------------------------------------------------------
-- FindVmssDatastore
PRINT N'Creating [dbo].[FindVmssDatastore]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[FindVmssDatastore]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[FindVmssDatastore]
GO

	CREATE PROCEDURE [dbo].[FindVmssDatastore]	
			   @host_bios_uuid nvarchar(255)		   		  	
	AS
	BEGIN
		SET NOCOUNT ON;
		    
		SELECT [id], [esx_bios_uuid], [datastore_name] 
		FROM [dbo].[VmssDatastores] WHERE [esx_bios_uuid] = @host_bios_uuid			
	END    

GO

--------------------------------------------------------------------------------
-- CreateVmssDatastore
PRINT N'Creating [dbo].[CreateVmssDatastore]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[CreateVmssDatastore]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[CreateVmssDatastore]
GO

	CREATE PROCEDURE [dbo].[CreateVmssDatastore]	
			   @host_bios_uuid nvarchar(255),		   		  	
			   @datastore_name nvarchar(255) 		   
	AS
	BEGIN
		SET NOCOUNT ON;
				
		INSERT INTO [dbo].[VmssDatastores]( [id], [esx_bios_uuid], [datastore_name])
				VALUES( NEWID(), @host_bios_uuid, @datastore_name )
					
	END    

GO

--------------------------------------------------------------------------------
-- DeleteVmssDatastoreAndUnlinkVms
PRINT N'Creating [dbo].[DeleteVmssDatastoreAndUnlinkVms]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DeleteVmssDatastoreAndUnlinkVms]') AND type in (N'P'))
	DROP PROCEDURE [dbo].[DeleteVmssDatastoreAndUnlinkVms]
GO			

	CREATE PROCEDURE [dbo].[DeleteVmssDatastoreAndUnlinkVms]
		@vmss_datastore_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		
		DELETE FROM [dbo].[VmssDatastores]
		WHERE [id] = @vmss_datastore_id
		
	END

GO

--------------------------------------------------------------------------------
-- CreateVmssVm
PRINT N'Creating [dbo].[CreateVmssVm]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[CreateVmssVm]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[CreateVmssVm]
GO

	CREATE PROCEDURE [dbo].[CreateVmssVm]	
			   @row_id uniqueidentifier,
			   @vm_registration_name nvarchar( 255 ),
			   @registration_host_id uniqueidentifier,
			   @oib uniqueidentifier, 
			   @mount_lease_id uniqueidentifier,
			   @mount_creation_time datetime,				   
			   @session_name nvarchar(255),		   
			   @xml_config  xml,
			   @ui_session_id uniqueidentifier,
			   @object_id uniqueidentifier,
			   @restore_platform int
	AS
	BEGIN
		SET NOCOUNT ON;		
	       
		INSERT INTO [dbo].[VmssVms]
			( [id], [vm_registration_name], [registration_host_id], [oib], [xml_config], [vm_lease_id], [session_id], [mount_state], [ui_session_id], [object_id], [restore_platform] )
		VALUES
			  (@row_id, @vm_registration_name, @registration_host_id, @oib, @xml_config, @mount_lease_id, @row_id, 0, @ui_session_id, @object_id, @restore_platform)
			
	END    

GO

--------------------------------------------------------------------------------
-- DeleteVmssVm
PRINT N'Creating [dbo].[DeleteVmssVm]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DeleteVmssVm]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[DeleteVmssVm]
GO

	CREATE PROCEDURE [dbo].[DeleteVmssVm]	
			   @row_id uniqueidentifier		   	   
	AS
	BEGIN
		SET NOCOUNT ON;
		
		DELETE FROM [dbo].[VmssVms] WHERE [id] = @row_id
					
	END    

GO

--------------------------------------------------------------------------------
-- VmssSessionsView
PRINT N'Creating [dbo].[VmssSessionsView]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[VmssSessionsView]') AND type in (N'V'))
	DROP VIEW [dbo].[VmssSessionsView]
GO

CREATE VIEW [dbo].[VmssSessionsView]
AS
	SELECT	
		vmssVms.[id], 
		vmssVms.[mount_state], 
		vmssVms.[content_restore_state], 
		vmssVms.[content_restore_percent], 
		vmssVms.[vm_registration_name] AS vm_name, 
		vmssVms.[vm_ref],
		vmssVms.[ui_session_id], 
		hosts.[name] AS host_name, 
		vmssVms.[registration_host_id] AS host_id,
		oibs.[creation_time] AS restore_point, 
		objs.[platform], 
		backups.[job_name] AS backup_name, 
		jobSessions.[creation_time] AS dbsession_start_time,
		vmssVms.[object_id],
		oibs.[type] AS oib_type,
		[dbo].[MaxValue](vmssVms.[usn], jobSessions.[usn]) AS usn,
		vmssVms.[restore_platform]
	FROM	
		[dbo].[VmssVms] vmssVms
		INNER JOIN [dbo].[Backup.Model.JobSessions] jobSessions
			ON vmssVms.[id] = jobSessions.[id] 
		INNER JOIN [dbo].[Hosts] hosts
			ON vmssVms.[registration_host_id] = hosts.[id]
		INNER JOIN [dbo].[Backup.Model.OIBs] oibs
			ON vmssVms.[oib] = oibs.[id] 
		INNER JOIN [dbo].[BObjects] objs
			ON oibs.[object_id] = objs.[id] 
		INNER JOIN [dbo].[Backup.Model.Points] points
			ON oibs.[point_id] = points.[id] 
		INNER JOIN [dbo].[Backup.Model.Backups] backups
			ON points.[backup_id] = backups.[id]
GO

--------------------------------------------------------------------------------
-- ReportVmssVmsView
PRINT N'Creating [dbo].[ReportVmssVmsView]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[ReportVmssVmsView]') AND type in (N'V'))
	DROP VIEW [dbo].[ReportVmssVmsView]
GO

	CREATE VIEW [dbo].[ReportVmssVmsView]
	AS
		SELECT   *
		FROM [dbo].[VmssSessionsView]		
		WHERE [dbo].[VmssSessionsView].[mount_state] != 5 AND 
			  [dbo].[VmssSessionsView].[dbsession_start_time] IN
			  ( SELECT MAX([dbo].[VmssSessionsView].[dbsession_start_time])
				FROM [dbo].[VmssSessionsView]
				GROUP BY [dbo].[VmssSessionsView].[ui_session_id]
			  )	
		  
GO

--------------------------------------------------------------------------------
-- ReportVmssVmsDeleteView
PRINT N'Creating [dbo].[ReportVmssVmsDeleteView]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[ReportVmssVmsDeleteView]') AND type in (N'P'))
	DROP PROCEDURE [dbo].[ReportVmssVmsDeleteView]
GO

	CREATE PROCEDURE [dbo].[ReportVmssVmsDeleteView]
		@row_usn bigint
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT uid, usn FROM TombStones WHERE table_name= 'VmssSessionsView' AND usn > @row_usn
	END

GO

--------------------------------------------------------------------------------
-- SetVmssVmMountState
PRINT N'Creating [dbo].[SetVmssVmMountState]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[SetVmssVmMountState]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[SetVmssVmMountState]
GO

	CREATE PROCEDURE [dbo].[SetVmssVmMountState]	
			   @row_id uniqueidentifier,		   
			   @mount_state  int  		   	   
	AS
	BEGIN
		SET NOCOUNT ON;
		
		UPDATE [dbo].[VmssVms]
		SET [dbo].[VmssVms].[mount_state] = @mount_state
		WHERE [dbo].[VmssVms].[id] = @row_id

	END   
	 
GO

--------------------------------------------------------------------------------
-- SetVmssIRControlState
PRINT N'Creating [dbo].[SetVmssIRControlState]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[SetVmssIRControlState]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[SetVmssIRControlState]
GO

	CREATE PROCEDURE [dbo].[SetVmssIRControlState]
			   @row_id uniqueidentifier,
			   @state int
	AS
	BEGIN
		SET NOCOUNT ON;
		UPDATE [dbo].[VmssVms]
		SET [dbo].[VmssVms].[irctl_restore_state] = @state
		WHERE [dbo].[VmssVms].[id] = @row_id
	END   
	 
GO

--------------------------------------------------------------------------------
-- GetVmssIRControlState
PRINT N'Creating [dbo].[GetVmssIRControlState]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetVmssIRControlState]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetVmssIRControlState]
GO

	CREATE PROCEDURE [dbo].[GetVmssIRControlState]
			   @row_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT [dbo].[VmssVms].[irctl_restore_state] FROM [dbo].[VmssVms] WHERE [id] = @row_id
	END
	 
GO

--------------------------------------------------------------------------------
-- FindVmssMount
PRINT N'Creating [dbo].[FindVmssMount]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[FindVmssMount]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[FindVmssMount]
GO

	CREATE PROCEDURE [dbo].[FindVmssMount]	
			   @row_id uniqueidentifier		   		   	   
	AS
	BEGIN
		SET NOCOUNT ON;
		
		SELECT 
			[id], 
			[vm_lease_id], 
			[xml_config],
			[vm_ref],
			[mount_state]
		FROM 
			[dbo].[VmssVms]
		WHERE 
			[dbo].[VmssVms].[id] = @row_id	
							
	END    

GO

--------------------------------------------------------------------------------
-- GetSessionsByLease
PRINT N'Creating [dbo].[GetSessionsByLease]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetSessionsByLease]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetSessionsByLease]
GO

	CREATE PROCEDURE [dbo].[GetSessionsByLease]	
			   @row_lease_id uniqueidentifier		   		   	   
	AS
	BEGIN
		SET NOCOUNT ON;
		
		SELECT *
		FROM [dbo].[Backup.Model.JobSessions]
		WHERE [lease_id] = @row_lease_id AND [state] != -1
		ORDER BY [dbo].[Backup.Model.JobSessions].[creation_time] DESC
							
	END  

GO

--------------------------------------------------------------------------------
-- GetRunningJobSessionsForJob
PRINT N'Creating [dbo].[GetRunningJobSessionsForJob]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetRunningJobSessionsForJob]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetRunningJobSessionsForJob]
GO

	CREATE PROCEDURE [dbo].[GetRunningJobSessionsForJob]	
			   @row_job_id uniqueidentifier		   		   	   
	AS
	BEGIN
		SET NOCOUNT ON;
		
		SELECT *
		FROM [dbo].[Backup.Model.JobSessions]
		WHERE [job_id] = @row_job_id AND [state] != -1 ORDER BY [dbo].[Backup.Model.JobSessions].[creation_time] DESC
							
	END  

GO

--------------------------------------------------------------------------------
-- GetRunningJobSessions
PRINT N'Creating [dbo].[GetRunningJobSessions]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetRunningJobSessions]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetRunningJobSessions]
GO

	CREATE PROCEDURE [dbo].[GetRunningJobSessions]		   	   
	AS
	BEGIN
		SET NOCOUNT ON;
		
		SELECT *
		FROM [dbo].[Backup.Model.JobSessions]
		WHERE [state] != -1 ORDER BY [dbo].[Backup.Model.JobSessions].[creation_time] DESC

	END  

GO

--------------------------------------------------------------------------------
-- GetRunningJobSessionsByType
PRINT N'Creating [dbo].[GetRunningJobSessionsByType]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetRunningJobSessionsByType]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetRunningJobSessionsByType]
GO

	CREATE PROCEDURE [dbo].[GetRunningJobSessionsByType]
		@row_type int
	AS
	BEGIN
		SET NOCOUNT ON;
		
		SELECT *
		FROM [dbo].[Backup.Model.JobSessions]
		WHERE [state] != -1 AND [job_type] = @row_type ORDER BY [dbo].[Backup.Model.JobSessions].[creation_time] DESC

	END  
GO

--------------------------------------------------------------------------------
-- GetSbTaskSessionUsageCounter
PRINT N'Creating [dbo].[GetSbTaskSessionUsageCounter]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetSbTaskSessionUsageCounter]') AND type in (N'P'))
	DROP PROCEDURE [dbo].[GetSbTaskSessionUsageCounter]
GO			

	CREATE PROCEDURE [dbo].[GetSbTaskSessionUsageCounter]
		@row_id uniqueidentifier
	AS
	BEGIN

		select
			restore_counter
		from
			[dbo].[Backup.Model.SbTaskSessions]
		where 
			id = @row_id
		
	END

GO

--------------------------------------------------------------------------------
-- IncrementSbTaskSessionRestoreCounter
PRINT N'Creating [dbo].[IncrementSbTaskSessionRestoreCounter]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[IncrementSbTaskSessionRestoreCounter]') AND type in (N'P'))
	DROP PROCEDURE [dbo].[IncrementSbTaskSessionRestoreCounter]
GO			

	CREATE PROCEDURE [dbo].[IncrementSbTaskSessionRestoreCounter]
		@row_id uniqueidentifier
	AS
	BEGIN
		
		update
			[dbo].[Backup.Model.SbTaskSessions]
		set
			restore_counter = restore_counter + 1
		where 
			id = @row_id
		
	END

GO

--------------------------------------------------------------------------------
-- DecrementSbTaskSessionRestoreCounter
PRINT N'Creating [dbo].[DecrementSbTaskSessionRestoreCounter]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DecrementSbTaskSessionRestoreCounter]') AND type in (N'P'))
	DROP PROCEDURE [dbo].[DecrementSbTaskSessionRestoreCounter]
GO			

	CREATE PROCEDURE [dbo].[DecrementSbTaskSessionRestoreCounter]
		@row_id uniqueidentifier
	AS
	BEGIN

		declare @restore_counter int
		
		select
			@restore_counter = restore_counter
		from
			[dbo].[Backup.Model.SbTaskSessions]
		where 
			id = @row_id
		
		if @restore_counter is not null and @restore_counter > 0
		begin			
		
			set @restore_counter = @restore_counter - 1		
			
			update
				[dbo].[Backup.Model.SbTaskSessions]
			set
				restore_counter = @restore_counter
			where 
				id = @row_id
				
		end
		
	END

GO

--------------------------------------------------------------------------------
-- ResetSbTaskSessionRestoreCounter
PRINT N'Creating [dbo].[ResetSbTaskSessionRestoreCounter]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[ResetSbTaskSessionRestoreCounter]') AND type in (N'P'))
	DROP PROCEDURE [dbo].[ResetSbTaskSessionRestoreCounter]
GO			

	CREATE PROCEDURE [dbo].[ResetSbTaskSessionRestoreCounter]
		@row_id uniqueidentifier
	AS
	BEGIN
		
		update
			[dbo].[Backup.Model.SbTaskSessions]
		set
			restore_counter = 0
		where 
			id = @row_id
		
	END

GO

--------------------------------------------------------------------------------
-- GetSbTaskSessionRestoreCounter
PRINT N'Creating [dbo].[GetSbTaskSessionRestoreCounter]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetSbTaskSessionRestoreCounter]') AND type in (N'P'))
	DROP PROCEDURE [dbo].[GetSbTaskSessionRestoreCounter]
GO			

	CREATE PROCEDURE [dbo].[GetSbTaskSessionRestoreCounter]
		@row_id uniqueidentifier
	AS
	BEGIN
		
		select restore_counter from
			[dbo].[Backup.Model.SbTaskSessions]
		where 
			id = @row_id
		
	END

GO

--------------------------------------------------------------------------------
-- FindHostBiosUuid
PRINT N'Creating [dbo].[FindHostBiosUuid]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[FindHostBiosUuid]') AND type in (N'P'))
	DROP PROCEDURE [dbo].[FindHostBiosUuid]
GO			

	CREATE PROCEDURE [dbo].[FindHostBiosUuid]
		@row_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		
		SELECT [bios_uuid] 
		FROM [dbo].[Hosts]
		WHERE [id] = @row_id
		
		
	END

GO

--------------------------------------------------------------------------------
-- FindTrackedVmMoRefByLease
PRINT N'Creating [dbo].[FindTrackedVmMoRefByLease]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[FindTrackedVmMoRefByLease]') AND type in (N'P'))
	DROP PROCEDURE [dbo].[FindTrackedVmMoRefByLease]
GO			

	CREATE PROCEDURE [dbo].[FindTrackedVmMoRefByLease]
		@lease_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		
		SELECT [vm_moref]
		FROM    [dbo].[Backup.TrackedActions.VmRegistration]
		WHERE  [lease_id] = @lease_id
					
	END

GO

--------------------------------------------------------------------------------
-- GetBaseSession
PRINT N'Creating [dbo].[GetBaseSession]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetBaseSession]') AND type in (N'P'))
	DROP PROCEDURE [dbo].[GetBaseSession]
GO			

	CREATE PROCEDURE [dbo].[GetBaseSession]
		@row_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		
		SELECT *
		FROM    [dbo].[Backup.Model.JobSessions]
		WHERE  [id] = @row_id
					
	END

GO

--------------------------------------------------------------------------------
-- AddSbVerificationRule
PRINT N'Creating [dbo].[AddSbVerificationRule]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[AddSbVerificationRule]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[AddSbVerificationRule]
GO

	CREATE PROCEDURE [dbo].[AddSbVerificationRule]
				@row_id uniqueidentifier,
				@row_job_id uniqueidentifier,
				@row_object_id uniqueidentifier,
				@row_object_type int,
				@row_options xml
	AS
	BEGIN
		SET NOCOUNT ON;

		INSERT INTO [dbo].[SbVerificationRules]
			   ([id]
			   ,[job_id]
			   ,[object_id]
			   ,[object_type]
			   ,[options])
		 VALUES
			   (@row_id,
			   @row_job_id,
			   @row_object_id,
			   @row_object_type,
			   @row_options)
	END	

GO

--------------------------------------------------------------------------------
-- UpdateSbVerificationRule
PRINT N'Creating [dbo].[UpdateSbVerificationRule]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateSbVerificationRule]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateSbVerificationRule]
GO

	CREATE PROCEDURE [dbo].[UpdateSbVerificationRule]
				@row_id uniqueidentifier,
				@row_job_id uniqueidentifier,
				@row_object_id uniqueidentifier,
				@row_object_type int,
				@row_options xml
	AS
	BEGIN
		SET NOCOUNT ON;

		UPDATE [dbo].[SbVerificationRules] SET
			   [job_id]			    = @row_job_id,
			   [object_id]			= @row_object_id,
			   [object_type]		= @row_object_type,
			   [options]			= @row_options
			   WHERE [id] = @row_id
	END	

GO

--------------------------------------------------------------------------------
-- DeleteSbVerificationRule
PRINT N'Creating [dbo].[DeleteSbVerificationRule]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DeleteSbVerificationRule]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[DeleteSbVerificationRule]
GO

	CREATE PROCEDURE [dbo].[DeleteSbVerificationRule]
		@row_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		DELETE FROM [dbo].[SbVerificationRules] WHERE [id] = @row_id
	END

GO

--------------------------------------------------------------------------------
-- GetSbVerificationRule
PRINT N'Creating [dbo].[GetSbVerificationRule]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetSbVerificationRule]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetSbVerificationRule]
GO

	CREATE PROCEDURE [dbo].[GetSbVerificationRule]
		@row_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT * from [dbo].[SbVerificationRules] where [id] = @row_id
	END

GO

--------------------------------------------------------------------------------
-- GetSbVerificationRuleByJobIdAndObjectId
PRINT N'Creating [dbo].[GetSbVerificationRuleByJobIdAndObjectId]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetSbVerificationRuleByJobIdAndObjectId]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetSbVerificationRuleByJobIdAndObjectId]
GO

	CREATE PROCEDURE [dbo].[GetSbVerificationRuleByJobIdAndObjectId]
			   @row_job_id uniqueidentifier,
			   @row_object_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT * from [dbo].[SbVerificationRules] where [job_id] = @row_job_id AND [object_id] = @row_object_id
	END

GO

--------------------------------------------------------------------------------
-- GetSbVerificationRules
PRINT N'Creating [dbo].[GetSbVerificationRules]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetSbVerificationRules]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetSbVerificationRules]
GO

	CREATE PROCEDURE [dbo].[GetSbVerificationRules]
		@row_job_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT * from [dbo].[SbVerificationRules] where [job_id] = @row_job_id
	END

GO

--------------------------------------------------------------------------------
-- DeleteSbVerificationRulesByJobId
PRINT N'Creating [dbo].[DeleteSbVerificationRulesByJobId]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DeleteSbVerificationRulesByJobId]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[DeleteSbVerificationRulesByJobId]
GO

	CREATE PROCEDURE [dbo].[DeleteSbVerificationRulesByJobId]
				@row_job_id [uniqueidentifier]
	AS
	BEGIN
		SET NOCOUNT ON;
		DELETE FROM [dbo].[SbVerificationRules] WHERE [job_id] = @row_job_id
	END	

GO

--------------------------------------------------------------------------------
-- ReportRestoreSessionsAndTaskSessionsView
PRINT N'Creating [dbo].[ReportRestoreSessionsAndTaskSessionsView]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[ReportRestoreSessionsAndTaskSessionsView]') AND type in (N'V'))
	DROP VIEW [dbo].[ReportRestoreSessionsAndTaskSessionsView]
GO

	CREATE VIEW [dbo].[ReportRestoreSessionsAndTaskSessionsView]
	AS
		SELECT     
			[id]				= jobSessions.[id],
			[job_id]			= jobSessions.[job_id],
			[job_name]			= jobSessions.[job_name], 
			[job_type]			= jobSessions.[job_type],
			[creation_time]		= jobSessions.[creation_time],
			[end_time]			= jobSessions.[end_time],
			[state]				= jobSessions.[state],
			[result]			= jobSessions.[result],
			[description]		= jobSessions.[description],
			[operation]			= jobSessions.[operation],
			[progress]			= jobSessions.[progress],

			[object_name]		= jobSessions.[job_name],
			[options]			= restoreJobSessions.[options],
			[reason]			= restoreJobSessions.[reason],
			[initiator_name]	= restoreJobSessions.[initiator_name],
			[multi_restore_id]	= restoreJobSessions.[multi_restore_id],
			[restore_type]		= restoreJobSessions.[restore_type],
			[platform]			= restoreJobSessions.[platform],
			
			[object_id]			= restoreTaskSessions.[object_id],
			[status]			= restoreTaskSessions.[status],
			[task_creation_time]= restoreTaskSessions.[creation_time],
			[task_end_time]		= restoreTaskSessions.[end_time],
			[task_operation]	= restoreTaskSessions.[operation],
			[process]			= restoreTaskSessions.[process],
			
			[vmss_reg_host_id]	= ISNULL(vmssVms.[registration_host_id], '00000000-0000-0000-0000-000000000000'),
			[vmss_vm_ref]		= vmssVms.[vm_ref],
			
			[usn]				= [dbo].[MaxValue3] (jobSessions.[usn],
									restoreJobSessions.[usn],
									restoreTaskSessions.[usn])
				
		FROM 
			([dbo].[Backup.Model.JobSessions] jobSessions 
			LEFT JOIN [dbo].[Backup.Model.RestoreJobSessions] restoreJobSessions
				ON jobSessions.[id] = restoreJobSessions.[id])
			LEFT JOIN [dbo].[Backup.Model.RestoreTaskSessions] restoreTaskSessions
				ON restoreTaskSessions.[session_id] = restoreJobSessions.[id]
			LEFT JOIN [dbo].[VmssVms] vmssVms
				ON vmssVms.[session_id] = jobSessions.[id]
			

		WHERE jobSessions.[job_type] > 3
	
GO

--------------------------------------------------------------------------------
-- GetJobRestoreSessionsStarted
PRINT N'Creating [dbo].[GetJobRestoreSessionsStarted]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetJobRestoreSessionsStarted]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetJobRestoreSessionsStarted]
GO

	CREATE PROCEDURE [dbo].[GetJobRestoreSessionsStarted]
	AS
	BEGIN
		SET NOCOUNT ON;

		Select 
			[dbo].[Backup.Model.JobSessions].[id],
			[dbo].[Backup.Model.JobSessions].[creation_time],
			[dbo].[Backup.Model.JobSessions].[end_time],
			[dbo].[Backup.Model.JobSessions].[job_name],
			[dbo].[Backup.Model.JobSessions].[job_type],
			[dbo].[Backup.Model.JobSessions].[job_id],
			[dbo].[Backup.Model.JobSessions].[result],
			[dbo].[Backup.Model.JobSessions].[description],
			[dbo].[Backup.Model.JobSessions].[operation],
			[dbo].[Backup.Model.JobSessions].[state],
			[dbo].[Backup.Model.JobSessions].[lease_id],
			[dbo].[Backup.Model.RestoreJobSessions].[action],
			[dbo].[Backup.Model.RestoreJobSessions].[options],
			[dbo].[Backup.Model.RestoreJobSessions].[initiator_sid],
			[dbo].[Backup.Model.RestoreJobSessions].[initiator_name],
			[dbo].[Backup.Model.RestoreJobSessions].[reason],
			[dbo].[Backup.Model.RestoreJobSessions].[platform],
			[dbo].[Backup.Model.RestoreJobSessions].[multi_restore_id],
			[dbo].[Backup.Model.RestoreJobSessions].[restore_type],
			[dbo].[Backup.Model.RestoreJobSessions].[oib_id],
			[dbo].[Backup.Model.RestoreJobSessions].[state_xml],
			[dbo].[Backup.Model.RestoreJobSessions].[is_internal],
			[dbo].[Backup.Model.RestoreJobSessions].[oib_display_name],
			[dbo].[Backup.Model.RestoreJobSessions].[oib_creation_time],
			[dbo].[Backup.Model.RestoreJobSessions].[sub_type]

		from [dbo].[Backup.Model.JobSessions] LEFT JOIN [dbo].[Backup.Model.RestoreJobSessions] 
			on [dbo].[Backup.Model.JobSessions].[id] = [dbo].[Backup.Model.RestoreJobSessions].[id]
			
		WHERE [dbo].[Backup.Model.JobSessions].[job_type] in (4,5,6,7,9,10,11,12,13,14,15,16,17) AND
			[dbo].[Backup.Model.JobSessions].[state] != -1
	END

GO

--------------------------------------------------------------------------------
-- GetLockedSessionsBySessionId
PRINT N'Creating [dbo].[GetLockedSessionsBySessionId]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetLockedSessionsBySessionId]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetLockedSessionsBySessionId]
GO

	CREATE PROCEDURE [dbo].[GetLockedSessionsBySessionId]	
			   @row_session_id uniqueidentifier		   		   	   
	AS
	BEGIN
		SET NOCOUNT ON;
		
		SELECT Count([id])
		FROM [dbo].[Backup.TrackedActions.Locks]
		WHERE [session_id] = @row_session_id
							
	END  

GO

--------------------------------------------------------------------------------
-- DropStoppedOldJobSessions
PRINT N'Creating [dbo].[DropStoppedOldJobSessions]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DropStoppedOldJobSessions]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[DropStoppedOldJobSessions]
GO

	CREATE PROCEDURE [dbo].[DropStoppedOldJobSessions]	
			   @retain_days int		   		   	   
	AS
	BEGIN
		SET NOCOUNT ON;
		
		DECLARE @ids AS TABLE (id uniqueidentifier)

		INSERT @ids(id)
			SELECT [id]
			FROM [dbo].[Backup.Model.JobSessions]
			WHERE [end_time] < DATEADD(DAY, -@retain_days, GETDATE()) 
				AND [state] = -1
				AND [end_time] != '1900-01-01 00:00:00.000'

		declare @id uniqueidentifier			
		IF exists (select * from @ids)
		BEGIN
		
			declare id_cursor cursor for select id from @ids
			open id_cursor
		
			fetch next from id_cursor into @id
			while @@FETCH_STATUS = 0
			begin				

				delete from [dbo].[Backup.Model.JobSessions] where [id] =@id
			
				delete from [dbo].[Backup.Model.BackupJobSessions] where [id]=@id
				delete from [dbo].[Events.JobSessionEvents] where [job_session_id]=@id
				delete from [dbo].[Backup.Model.BackupTaskSessions] where [session_id]=@id
				delete from [dbo].[Events.TaskSessionEvents] where [job_session_id]=@id

				delete from [dbo].[Backup.Model.RestoreJobSessions] where [id]=@id
				delete from [dbo].[Backup.Model.RestoreTaskSessions] where [session_id]=@id
				delete from [dbo].[ItemRestoreAudits] where [restore_session_id]=@id
					
				delete from [dbo].[Backup.Model.SbSessions] where [id]=@id
				delete from [dbo].[Backup.Model.SbTaskSessions] where [drsession_id]=@id
			
				delete from [dbo].[VmssVms] where [session_id]=@id

			fetch next from id_cursor into @id
			end
		
		close id_cursor
		deallocate id_cursor

		END							
	END  

GO			

--------------------------------------------------------------------------------
-- AddSessionXmlLog
PRINT N'Creating [dbo].[AddSessionXmlLog]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[AddSessionXmlLog]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[AddSessionXmlLog]
GO

	CREATE PROCEDURE [dbo].[AddSessionXmlLog]	
				@row_session_id uniqueidentifier,
				@row_cookie nvarchar( 100 ),
				@row_time nvarchar(100),
				@row_utc_time nvarchar(100),
				@row_status nvarchar(10),
				@row_style nvarchar(10),
				@row_title nvarchar(512),
				@row_desc nvarchar(512),
				@row_start_time nvarchar(100)
	AS
	BEGIN
		SET NOCOUNT ON;
		--Select log
		DECLARE @myDoc xml 
		SET @myDoc = (SELECT [log_xml]
		FROM [dbo].[Backup.Model.JobSessions]
		WHERE [id] = @row_session_id)

		--Check status for reason
		DECLARE @setReason bit
		SET @setReason = (
			CASE WHEN @myDoc.exist('/Root/Log[@Status = "EFailed"]') = 0 AND (
				@row_status = 'EFailed' OR (@myDoc.exist('/Root/Log[@Status = "EWarning"]') = 0 AND @row_status = 'EWarning')
			) THEN 1 ELSE 0 END
		)

		--Get new log line
		DECLARE @newXmlLogLine xml 	                                                                                          
		SET @newXmlLogLine = N'<Log Id="" Usn="0" Cookie="" Status="" Style="" Time="" UtcTime="" StartTime=""><Title>new</Title><Description>new</Description></Log>'  

		--Calc new id and usn
		DECLARE @new_id bigint 
		declare @new_usn as bigint
		set @new_usn = @myDoc.value('(/Root/@TotalUsn)[1]', 'bigint' ) + 1
		SET @new_id = @myDoc.value('(/Root/@TotalId)[1]', 'bigint' ) + 1

		--Update log line
		SET @newXmlLogLine.modify('replace value of (/Log/@Id)[1] with sql:variable("@new_id")')
		SET @newXmlLogLine.modify('replace value of (/Log/@Usn)[1] with sql:variable("@new_usn")')
		SET @newXmlLogLine.modify('replace value of (/Log/@Cookie)[1] with sql:variable("@row_cookie")')
		SET @newXmlLogLine.modify('replace value of (/Log/@Status)[1] with sql:variable("@row_status")')
		SET @newXmlLogLine.modify('replace value of (/Log/@Style)[1] with sql:variable("@row_style")')
		SET @newXmlLogLine.modify('replace value of (/Log/@Time)[1] with sql:variable("@row_time")')
		SET @newXmlLogLine.modify('replace value of (/Log/@UtcTime)[1] with sql:variable("@row_utc_time")')
		SET @newXmlLogLine.modify('replace value of (/Log/Title[1]/text())[1] with sql:variable("@row_title")')
		SET @newXmlLogLine.modify('replace value of (/Log/Description[1]/text())[1] with sql:variable("@row_desc")')
		SET @newXmlLogLine.modify('replace value of (/Log/@StartTime)[1] with sql:variable("@row_start_time")')

		--Update log
		--SET @myDoc.modify('insert sql:variable("@newXmlLogLine") as last into (/Root)[1]')
		SET @myDoc.modify('replace value of (/Root/@TotalId)[1] with sql:variable("@new_id")')
		SET @myDoc.modify('replace value of (/Root/@TotalUsn)[1] with sql:variable("@new_usn")')
		SET @myDoc = [dbo].f_insert_as_first(@myDoc, @newXmlLogLine)		

		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT		

		--Update log
		IF @setReason = 1 BEGIN
			UPDATE [dbo].[Backup.Model.JobSessions] 
			SET
				[reason] = @row_title,
				[log_xml] = @myDoc,
				[usn]     = @usn
			WHERE [id] = @row_session_id
		END ELSE BEGIN
			UPDATE [dbo].[Backup.Model.JobSessions] 
			SET
				[log_xml] = @myDoc,
				[usn]     = @usn	
			WHERE [id] = @row_session_id		
		END	

		SELECT @new_id as [id]
	end

GO

--------------------------------------------------------------------------------
-- GetSessionXmlLogMaxUsn

PRINT N'Creating [dbo].[GetSessionXmlLogMaxUsn]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetSessionXmlLogMaxUsn]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetSessionXmlLogMaxUsn]
GO

	CREATE PROCEDURE [dbo].[GetSessionXmlLogMaxUsn]	
				@row_session_id uniqueidentifier				
	AS
	BEGIN
		SET NOCOUNT ON;
		
		--Select log
		DECLARE @myDoc xml 
		SET @myDoc = (SELECT [log_xml]
		FROM [dbo].[Backup.Model.JobSessions]
		WHERE [id] = @row_session_id)
		
		
		--Calc new id and usn
		DECLARE @max_usn bigint 
		SET @max_usn = @myDoc.value('(/Root/@TotalUsn)[1]', 'bigint' )
		
			
		SELECT @max_usn as [usn]
	END  

GO

--------------------------------------------------------------------------------
-- UpdateSessionXmlLog
PRINT N'Creating [dbo].[UpdateSessionXmlLog]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateSessionXmlLog]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateSessionXmlLog]
GO

	CREATE PROCEDURE [dbo].[UpdateSessionXmlLog]	
				@row_session_id uniqueidentifier,
				@row_log_id bigint,
				@row_time nvarchar(100),
				@row_utc_time nvarchar(100),
				@row_status nvarchar(10),
				@row_title nvarchar(512),
				@row_desc nvarchar(512)
	AS
	BEGIN
		SET NOCOUNT ON;	
		
		--Select log
		DECLARE @myDoc xml
		SET @myDoc = (SELECT [log_xml]
		FROM [dbo].[Backup.Model.JobSessions]
		WHERE [id] = @row_session_id)

		--Check status for reason
		DECLARE @setReason bit
		SET @setReason = (
			CASE WHEN @myDoc.exist('/Root/Log[@Status = "EFailed"]') = 0 AND (
				@row_status = 'EFailed' OR (@myDoc.exist('/Root/Log[@Status = "EWarning"]') = 0 AND @row_status = 'EWarning')
			) THEN 1 ELSE 0 END
		)
		
		--Get new log line
		DECLARE @newXmlLogLine xml 
		SET @newXmlLogLine = (SELECT @myDoc.query('/Root/Log[@Id = sql:variable("@row_log_id")]'))
		

		--Calc new id and usn
		DECLARE @new_usn bigint
		SET @new_usn = @myDoc.value('(/Root/@TotalUsn)[1]', 'bigint' ) + 1
		
		--Update log line
		SET @newXmlLogLine.modify('replace value of (/Log/@Id)[1] with sql:variable("@row_log_id")')
		SET @newXmlLogLine.modify('replace value of (/Log/@Usn)[1] with sql:variable("@new_usn")')
		SET @newXmlLogLine.modify('replace value of (/Log/@Status)[1] with sql:variable("@row_status")')
		SET @newXmlLogLine.modify('replace value of (/Log/@Time)[1] with sql:variable("@row_time")')
		SET @newXmlLogLine.modify('replace value of (/Log/@UtcTime)[1] with sql:variable("@row_utc_time")')
		SET @newXmlLogLine.modify('replace value of (/Log/Title[1]/text())[1] with sql:variable("@row_title")')
		SET @newXmlLogLine.modify('replace value of (/Log/Description[1]/text())[1] with sql:variable("@row_desc")')


		--Update log
		SET @myDoc.modify('delete (/Root/Log[@Id = sql:variable("@row_log_id")])')
		SET @myDoc.modify('replace value of (/Root/@TotalUsn)[1] with sql:variable("@new_usn")')
		--SET @myDoc.modify('insert sql:variable("@newXmlLogLine") as last into (/Root)[1]')
		SET @myDoc = [dbo].f_insert_as_first(@myDoc, @newXmlLogLine)
			
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT


		--Update log
		IF @setReason = 1 BEGIN
			UPDATE [dbo].[Backup.Model.JobSessions] 
			SET
				[reason] = @row_title,
				[log_xml] = @myDoc,
				[usn]     = @usn
			WHERE [id] = @row_session_id
		END ELSE BEGIN
			UPDATE [dbo].[Backup.Model.JobSessions] 
			SET
				[log_xml] = @myDoc,
				[usn]     = @usn
			WHERE [id] = @row_session_id	
		END
		
		SELECT @new_usn as [usn]
	END  

GO

--------------------------------------------------------------------------------
-- UpdateSessionXmlLogStatus
PRINT N'Creating [dbo].[UpdateSessionXmlLogStatus]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateSessionXmlLogStatus]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateSessionXmlLogStatus]
GO

	CREATE PROCEDURE [dbo].[UpdateSessionXmlLogStatus]	
				@row_session_id uniqueidentifier,		
				@row_log_id bigint,	
				@row_time nvarchar(100),
				@row_utc_time nvarchar(100),
				@row_status nvarchar(10),			
				@row_desc nvarchar(512)
	AS
	BEGIN
		SET NOCOUNT ON;	
		
		--Select log
		DECLARE @myDoc xml
		SET @myDoc = (SELECT [log_xml]
		FROM [dbo].[Backup.Model.JobSessions]
		WHERE [id] = @row_session_id)

		--Check status for reason
		DECLARE @setReason bit
		SET @setReason = (
			CASE WHEN @myDoc.exist('/Root/Log[@Status = "EFailed"]') = 0 AND (
				@row_status = 'EFailed' OR (@myDoc.exist('/Root/Log[@Status = "EWarning"]') = 0 AND @row_status = 'EWarning')
			) THEN 1 ELSE 0 END
		)
		
		--Get new log line
		DECLARE @newXmlLogLine xml 
		SET @newXmlLogLine = (SELECT @myDoc.query('/Root/Log[@Id = sql:variable("@row_log_id")]'))
		
		DECLARE @rowTitle nvarchar(512)
		SET @rowTitle = (SELECT @newXmlLogLine.value('(/Log/Title)[1]', 'nvarchar(512)'))

		--Calc new id and usn
		DECLARE @new_usn bigint
		SET @new_usn = @myDoc.value('(/Root/@TotalUsn)[1]', 'bigint' ) + 1
		
		--Update log line
		SET @newXmlLogLine.modify('replace value of (/Log/@Usn)[1] with sql:variable("@new_usn")')
		SET @newXmlLogLine.modify('replace value of (/Log/@Status)[1] with sql:variable("@row_status")')
		SET @newXmlLogLine.modify('replace value of (/Log/@Time)[1] with sql:variable("@row_time")')
		SET @newXmlLogLine.modify('replace value of (/Log/@UtcTime)[1] with sql:variable("@row_utc_time")')	
		SET @newXmlLogLine.modify('replace value of (/Log/Description[1]/text())[1] with sql:variable("@row_desc")')


		--Update log
		SET @myDoc.modify('delete (/Root/Log[@Id = sql:variable("@row_log_id")])')
		SET @myDoc.modify('replace value of (/Root/@TotalUsn)[1] with sql:variable("@new_usn")')
		--SET @myDoc.modify('insert sql:variable("@newXmlLogLine") as last into (/Root)[1]')
		SET @myDoc = [dbo].f_insert_as_first(@myDoc, @newXmlLogLine)
			
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		--Update log
		IF @setReason = 1 BEGIN
			UPDATE [dbo].[Backup.Model.JobSessions]
			SET
				[reason] = @rowTitle,
				[log_xml] = @myDoc,
				[usn]     = @usn
			WHERE [id] = @row_session_id
		END ELSE BEGIN
			UPDATE [dbo].[Backup.Model.JobSessions] 
			SET
				[log_xml] = @myDoc,
				[usn]     = @usn
			WHERE [id] = @row_session_id	
		END
		
		SELECT @new_usn as [usn]
	END  

GO

--------------------------------------------------------------------------------
-- UpdateSessionXmlLogStatusOnly
PRINT N'Creating [dbo].[UpdateSessionXmlLogStatusOnly]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateSessionXmlLogStatusOnly]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateSessionXmlLogStatusOnly]
GO

	CREATE PROCEDURE [dbo].[UpdateSessionXmlLogStatusOnly]	
				@row_session_id uniqueidentifier,
				@row_log_id bigint,
				@row_status nvarchar(10)
	AS
	BEGIN
		SET NOCOUNT ON;	
		
		--Select log
		DECLARE @myDoc xml
		SET @myDoc = (SELECT [log_xml]
		FROM [dbo].[Backup.Model.JobSessions]
		WHERE [id] = @row_session_id)

		--Check status for reason
		DECLARE @setReason bit
		SET @setReason = (
			CASE WHEN @myDoc.exist('/Root/Log[@Status = "EFailed"]') = 0 AND (
				@row_status = 'EFailed' OR (@myDoc.exist('/Root/Log[@Status = "EWarning"]') = 0 AND @row_status = 'EWarning')
			) THEN 1 ELSE 0 END
		)
		
		--Get new log line
		DECLARE @newXmlLogLine xml 
		SET @newXmlLogLine = (SELECT @myDoc.query('/Root/Log[@Id = sql:variable("@row_log_id")]'))
		
		DECLARE @rowTitle nvarchar(512)
		SET @rowTitle = (SELECT @newXmlLogLine.value('(/Log/Title)[1]', 'nvarchar(512)'))

		--Calc new id and usn
		DECLARE @new_usn bigint
		SET @new_usn = @myDoc.value('(/Root/@TotalUsn)[1]', 'bigint' ) + 1
		
		--Update log line
		SET @newXmlLogLine.modify('replace value of (/Log/@Usn)[1] with sql:variable("@new_usn")')
		SET @newXmlLogLine.modify('replace value of (/Log/@Status)[1] with sql:variable("@row_status")')

		--Update log
		SET @myDoc.modify('delete (/Root/Log[@Id = sql:variable("@row_log_id")])')
		SET @myDoc.modify('replace value of (/Root/@TotalUsn)[1] with sql:variable("@new_usn")')
		SET @myDoc = [dbo].f_insert_as_first(@myDoc, @newXmlLogLine)
			
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		--Update log
		IF @setReason = 1 BEGIN
			UPDATE [dbo].[Backup.Model.JobSessions]
			SET
				[reason] = @rowTitle,
				[log_xml] = @myDoc,
				[usn]     = @usn
			WHERE [id] = @row_session_id
		END ELSE BEGIN
			UPDATE [dbo].[Backup.Model.JobSessions] 
			SET
				[log_xml] = @myDoc,
				[usn]     = @usn
			WHERE [id] = @row_session_id	
		END
		
		
		SELECT @new_usn as [usn]
	END  

GO

--------------------------------------------------------------------------------
-- FindInSessionXmlLog
PRINT N'Creating [dbo].[FindInSessionXmlLog]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[FindInSessionXmlLog]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[FindInSessionXmlLog]
GO

	CREATE PROCEDURE [dbo].[FindInSessionXmlLog]
				@sessionId	uniqueidentifier,			
				@cookie		nvarchar( 255 ),
				@status     nvarchar( 40 )
	AS
	BEGIN
		SET NOCOUNT ON;
		
		DECLARE @recsWithCookie XML
			
		IF @cookie IS NOT NULL AND @cookie <> N'' AND @status IS NOT NULL AND @status <> N''
			BEGIN
				SET @recsWithCookie = (SELECT [log_xml].query('/Root/Log[@Cookie = sql:variable("@cookie")][@Status = sql:variable("@status")]' )
				FROM [dbo].[Backup.Model.JobSessions]
				WHERE [id] = @sessionId )

			END
		ELSE  IF @cookie IS NOT NULL AND @cookie <> N''
				BEGIN
					SET @recsWithCookie = (SELECT [log_xml].query( '/Root/Log[@Cookie = sql:variable("@cookie")]' )
					FROM [dbo].[Backup.Model.JobSessions]
					WHERE [id] = @sessionId )
				
			END
		ELSE
			BEGIN
				SET @recsWithCookie = (SELECT [log_xml].query( '/Root/Log[@Status = sql:variable("@status")]' )
				FROM [dbo].[Backup.Model.JobSessions]
				WHERE [id] = @sessionId )
				
			END
		
		SELECT [Id] = T.Item.value('@Id', 'bigint' )
		FROM  @recsWithCookie.nodes('/Log') AS T(Item)
		
	END  

GO

--------------------------------------------------------------------------------
-- GetSessionXmlLog
PRINT N'Creating [dbo].[GetSessionXmlLog]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetSessionXmlLog]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetSessionXmlLog]
GO

	CREATE PROCEDURE [dbo].[GetSessionXmlLog]	
				@row_session_id uniqueidentifier,
				@row_usn bigint
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @xml_log as xml
		set @xml_log = (select [log_xml] from [dbo].[Backup.Model.JobSessions] where [id] = @row_session_id)

		DECLARE @myDoc xml 
		SET @myDoc = '<Root TotalUsn="0"></Root>'
		
		DECLARE @newXmlLogLine xml
		declare @total_usn as bigint	
		set @newXmlLogLine =  @xml_log.query('/Root/Log[@Usn >= sql:variable("@row_usn")]')
		set @total_usn = @xml_log.value('(/Root/@TotalUsn)[1]', 'bigint' )
						
		SET @newXmlLogLine = '<Logs>' + CONVERT(nvarchar(max), @newXmlLogLine) + '</Logs>'
		SET @myDoc.modify('replace value of (/Root/@TotalUsn)[1] with sql:variable("@total_usn")')
		--SET @myDoc.modify('insert sql:variable("@newXmlLogLine") as last into (/Root)[1]')
		SET @myDoc = [dbo].f_insert_as_first(@myDoc, @newXmlLogLine)
		SELECT @myDoc
	END  

GO

--------------------------------------------------------------------------------
-- AddTaskSessionXmlLog
PRINT N'Creating [dbo].[AddTaskSessionXmlLog]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[AddTaskSessionXmlLog]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[AddTaskSessionXmlLog]
GO

	CREATE PROCEDURE [dbo].[AddTaskSessionXmlLog]	
				@row_session_id uniqueidentifier,
				@row_cookie nvarchar(100),
				@row_time nvarchar(100),
				@row_utc_time nvarchar(100),
				@row_status nvarchar(10),
				@row_style nvarchar(10),
				@row_title nvarchar(512),
				@row_desc nvarchar(512),
				@row_start_time nvarchar(100)
	AS
	BEGIN
		SET NOCOUNT ON;
		
		--Select log
		DECLARE @myDoc xml 
		SET @myDoc = (SELECT [log_xml]
		FROM [dbo].[Backup.Model.SbTaskSessions]
		WHERE [id] = @row_session_id)
		
		--Get new log line
		DECLARE @newXmlLogLine xml 
		SET @newXmlLogLine = N'<Log Id="" Usn="0" Cookie="" Status="" Style="" Time="" UtcTime="" StartTime=""><Title>new</Title><Description>new</Description></Log>'  

		--Calc new id and usn
		DECLARE @new_id bigint 
		SET @new_id = @myDoc.value('(/Root/@TotalId)[1]', 'bigint' ) + 1

		--Update log line
		SET @newXmlLogLine.modify('replace value of (/Log/@Id)[1] with sql:variable("@new_id")')
		SET @newXmlLogLine.modify('replace value of (/Log/@Cookie)[1] with sql:variable("@row_cookie")')
		SET @newXmlLogLine.modify('replace value of (/Log/@Status)[1] with sql:variable("@row_status")')
		SET @newXmlLogLine.modify('replace value of (/Log/@Style)[1] with sql:variable("@row_style")')
		SET @newXmlLogLine.modify('replace value of (/Log/@Time)[1] with sql:variable("@row_time")')
		SET @newXmlLogLine.modify('replace value of (/Log/@UtcTime)[1] with sql:variable("@row_utc_time")')
		SET @newXmlLogLine.modify('replace value of (/Log/Title[1]/text())[1] with sql:variable("@row_title")')
		SET @newXmlLogLine.modify('replace value of (/Log/Description[1]/text())[1] with sql:variable("@row_desc")')
		SET @newXmlLogLine.modify('replace value of (/Log/@StartTime)[1] with sql:variable("@row_start_time")')

		--Update log	
		SET @myDoc.modify('replace value of (/Root/@TotalId)[1] with sql:variable("@new_id")')
		--SET @myDoc.modify('insert sql:variable("@newXmlLogLine") as last into (/Root)[1]')
		SET @myDoc = [dbo].f_insert_as_first(@myDoc, @newXmlLogLine)		
			
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		--Update log
		UPDATE [dbo].[Backup.Model.SbTaskSessions] 
		SET
			[log_xml] = @myDoc,
			[usn]     = @usn
		WHERE [id] = @row_session_id			
		
		SELECT @new_id as [id]
	END  

GO


--------------------------------------------------------------------------------
-- GetTaskSessionXmlLogMaxUsn

PRINT N'Creating [dbo].[GetTaskSessionXmlLogMaxUsn]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetTaskSessionXmlLogMaxUsn]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetTaskSessionXmlLogMaxUsn]
GO

	CREATE PROCEDURE [dbo].[GetTaskSessionXmlLogMaxUsn]	
				@row_session_id uniqueidentifier				
	AS
	BEGIN
		SET NOCOUNT ON;
		
		--Select log
		DECLARE @myDoc xml 
		SET @myDoc = (SELECT [log_xml]
		FROM [dbo].[Backup.Model.SbTaskSessions]
		WHERE [id] = @row_session_id)
		
		
		--Calc new id and usn
		DECLARE @max_usn bigint 
		SET @max_usn = @myDoc.value('(/Root/@TotalId)[1]', 'bigint' )
		
			
		SELECT @max_usn as [usn]
	END  

GO



--------------------------------------------------------------------------------
-- UpdateTaskSessionXmlLog
PRINT N'Creating [dbo].[UpdateTaskSessionXmlLog]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateTaskSessionXmlLog]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateTaskSessionXmlLog]
GO

	CREATE PROCEDURE [dbo].[UpdateTaskSessionXmlLog]	
				@row_session_id uniqueidentifier,
				@row_log_id bigint,
				@row_time nvarchar(100),
				@row_utc_time nvarchar(100),
				@row_status nvarchar(10),
				@row_title nvarchar(512),
				@row_desc nvarchar(512)
	AS
	BEGIN
		SET NOCOUNT ON;	
		
		--Select log
		DECLARE @myDoc xml 
		SET @myDoc = (SELECT [log_xml]
		FROM [dbo].[Backup.Model.SbTaskSessions]
		WHERE [id] = @row_session_id)
		
		--Get new log line
		DECLARE @newXmlLogLine xml 
		SET @newXmlLogLine = (SELECT @myDoc.query('/Root/Log[@Id = sql:variable("@row_log_id")]'))

		--Calc new id and usn
		DECLARE @new_usn bigint 
		SET @new_usn = @myDoc.value('(/Root/@TotalUsn)[1]', 'bigint' ) + 1
		
		--Update log line
		SET @newXmlLogLine.modify('replace value of (/Log/@Usn)[1] with sql:variable("@new_usn")')
		SET @newXmlLogLine.modify('replace value of (/Log/@Status)[1] with sql:variable("@row_status")')
		SET @newXmlLogLine.modify('replace value of (/Log/@Time)[1] with sql:variable("@row_time")')
		SET @newXmlLogLine.modify('replace value of (/Log/@UtcTime)[1] with sql:variable("@row_utc_time")')
		SET @newXmlLogLine.modify('replace value of (/Log/Title[1]/text())[1] with sql:variable("@row_title")')
		SET @newXmlLogLine.modify('replace value of (/Log/Description[1]/text())[1] with sql:variable("@row_desc")')

		--Update log
		SET @myDoc.modify('delete (/Root/Log[@Id = sql:variable("@row_log_id")])')
		SET @myDoc.modify('replace value of (/Root/@TotalUsn)[1] with sql:variable("@new_usn")')
		--SET @myDoc.modify('insert sql:variable("@newXmlLogLine") as last into (/Root)[1]')
		SET @myDoc = [dbo].f_insert_as_first(@myDoc, @newXmlLogLine)	
			
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		--Update log
		UPDATE [dbo].[Backup.Model.SbTaskSessions] 
		SET
			[log_xml] = @myDoc,
			[usn]     = @usn		
		WHERE [id] = @row_session_id	
		
		SELECT @new_usn as [usn]
	END  

GO

--------------------------------------------------------------------------------
-- FindInTaskSessionXmlLog
PRINT N'Creating [dbo].[FindInTaskSessionXmlLog]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[FindInTaskSessionXmlLog]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[FindInTaskSessionXmlLog]
GO

	CREATE PROCEDURE [dbo].[FindInTaskSessionXmlLog]
				@sessionId	uniqueidentifier,			
				@cookie		nvarchar( 255 ),
				@status     nvarchar( 40 )
	AS
	BEGIN
		SET NOCOUNT ON;
		
		DECLARE @recsWithCookie XML
			
		IF @cookie IS NOT NULL AND @cookie <> N'' AND @status IS NOT NULL AND @status <> N''
			BEGIN
				SET @recsWithCookie = (SELECT [log_xml].query('/Root/Log[@Cookie = sql:variable("@cookie")][@Status = sql:variable("@status")]' )
				FROM [dbo].[Backup.Model.SbTaskSessions]
				WHERE [id] = @sessionId )

			END
		ELSE  IF @cookie IS NOT NULL AND @cookie <> N''
				BEGIN
					SET @recsWithCookie = (SELECT [log_xml].query( '/Root/Log[@Cookie = sql:variable("@cookie")]' )
					FROM [dbo].[Backup.Model.SbTaskSessions]
					WHERE [id] = @sessionId )
				
			END
		ELSE
			BEGIN
				SET @recsWithCookie = (SELECT [log_xml].query( '/Root/Log[@Status = sql:variable("@status")]' )
				FROM [dbo].[Backup.Model.SbTaskSessions]
				WHERE [id] = @sessionId )
				
			END
		
		SELECT [Id] = T.Item.value('@Id', 'bigint' )
		FROM  @recsWithCookie.nodes('/Log') AS T(Item)
		
	END  

GO

--------------------------------------------------------------------------------
-- UpdateTaskSessionXmlLogStatus
PRINT N'Creating [dbo].[UpdateTaskSessionXmlLogStatus]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateTaskSessionXmlLogStatus]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateTaskSessionXmlLogStatus]
GO

	CREATE PROCEDURE [dbo].[UpdateTaskSessionXmlLogStatus]	
				@row_session_id uniqueidentifier,		
				@row_log_id bigint,	
				@row_time nvarchar(100),
				@row_utc_time nvarchar(100),
				@row_status nvarchar(10),			
				@row_desc nvarchar(512)
	AS
	BEGIN
		SET NOCOUNT ON;	
		
		--Select log
		DECLARE @myDoc xml
		SET @myDoc = (SELECT [log_xml]
		FROM [dbo].[Backup.Model.SbTaskSessions]
		WHERE [id] = @row_session_id)
		
		--Get new log line
		DECLARE @newXmlLogLine xml 
		SET @newXmlLogLine = (SELECT @myDoc.query('/Root/Log[@Id = sql:variable("@row_log_id")]'))
		

		--Calc new id and usn
		DECLARE @new_usn bigint
		SET @new_usn = @myDoc.value('(/Root/@TotalUsn)[1]', 'bigint' ) + 1
		
		--Update log line
		SET @newXmlLogLine.modify('replace value of (/Log/@Usn)[1] with sql:variable("@new_usn")')
		SET @newXmlLogLine.modify('replace value of (/Log/@Status)[1] with sql:variable("@row_status")')
		SET @newXmlLogLine.modify('replace value of (/Log/@Time)[1] with sql:variable("@row_time")')
		SET @newXmlLogLine.modify('replace value of (/Log/@UtcTime)[1] with sql:variable("@row_utc_time")')	
		SET @newXmlLogLine.modify('replace value of (/Log/Description[1]/text())[1] with sql:variable("@row_desc")')


		--Update log
		SET @myDoc.modify('delete (/Root/Log[@Id = sql:variable("@row_log_id")])')
		SET @myDoc.modify('replace value of (/Root/@TotalUsn)[1] with sql:variable("@new_usn")')
		--SET @myDoc.modify('insert sql:variable("@newXmlLogLine") as last into (/Root)[1]')
		SET @myDoc = [dbo].f_insert_as_first(@myDoc, @newXmlLogLine)
			
		declare @usn bigint

		--Update log
		exec [dbo].[IncrementUsn] @usn OUTPUT
		UPDATE [dbo].[Backup.Model.SbTaskSessions] 
		SET
			[log_xml] = @myDoc,
			[usn]     = @usn
		WHERE [id] = @row_session_id	
		
		SELECT @new_usn as [usn]
	END  
	
GO

--------------------------------------------------------------------------------
-- UpdateTaskSessionXmlLogStatusOnly
PRINT N'Creating [dbo].[UpdateTaskSessionXmlLogStatusOnly]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateTaskSessionXmlLogStatusOnly]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateTaskSessionXmlLogStatusOnly]
GO

	CREATE PROCEDURE [dbo].[UpdateTaskSessionXmlLogStatusOnly]	
				@row_session_id uniqueidentifier,
				@row_log_id bigint,
				@row_status nvarchar(10)
	AS
	BEGIN
		SET NOCOUNT ON;	
		
		--Select log
		DECLARE @myDoc xml
		SET @myDoc = (SELECT [log_xml]
		FROM [dbo].[Backup.Model.SbTaskSessions]
		WHERE [id] = @row_session_id)
		
		--Get new log line
		DECLARE @newXmlLogLine xml 
		SET @newXmlLogLine = (SELECT @myDoc.query('/Root/Log[@Id = sql:variable("@row_log_id")]'))

		--Calc new id and usn
		DECLARE @new_usn bigint
		SET @new_usn = @myDoc.value('(/Root/@TotalUsn)[1]', 'bigint' ) + 1
		
		--Update log line
		SET @newXmlLogLine.modify('replace value of (/Log/@Usn)[1] with sql:variable("@new_usn")')
		SET @newXmlLogLine.modify('replace value of (/Log/@Status)[1] with sql:variable("@row_status")')

		--Update log
		SET @myDoc.modify('delete (/Root/Log[@Id = sql:variable("@row_log_id")])')
		SET @myDoc.modify('replace value of (/Root/@TotalUsn)[1] with sql:variable("@new_usn")')
		SET @myDoc = [dbo].f_insert_as_first(@myDoc, @newXmlLogLine)
			
		declare @usn bigint

		--Update log
		exec [dbo].[IncrementUsn] @usn OUTPUT
		UPDATE [dbo].[Backup.Model.SbTaskSessions] 
		SET
			[log_xml] = @myDoc,
			[usn]     = @usn
		WHERE [id] = @row_session_id	
		
		SELECT @new_usn as [usn]
	END  
	
GO

--------------------------------------------------------------------------------
-- GetTaskSessionXmlLog
PRINT N'Creating [dbo].[GetTaskSessionXmlLog]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetTaskSessionXmlLog]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetTaskSessionXmlLog]
GO

	CREATE PROCEDURE [dbo].[GetTaskSessionXmlLog]	
				@row_session_id uniqueidentifier,
				@row_usn bigint
	AS
	BEGIN
		SET NOCOUNT ON;
		
		DECLARE @myDoc xml 
		SET @myDoc = '<Root TotalUsn="0"></Root>'
		
		DECLARE @newXmlLogLine xml 
		SET @newXmlLogLine = (SELECT [log_xml].query('/Root/Log[@Usn >= sql:variable("@row_usn")]')
		FROM [dbo].[Backup.Model.SbTaskSessions]
		WHERE [id] = @row_session_id)
		
		SET @newXmlLogLine = '<Logs>' + CONVERT(nvarchar(max), @newXmlLogLine) + '</Logs>'
		SET @myDoc.modify('replace value of (/Root/@TotalUsn)[1] with sql:variable("@row_usn")')
		--SET @myDoc.modify('insert sql:variable("@newXmlLogLine") as last into (/Root)[1]')
		SET @myDoc = [dbo].f_insert_as_first(@myDoc, @newXmlLogLine)
		
		SELECT @myDoc
	END  

GO

--------------------------------------------------------------------------------
-- IsFoldersContainHost
PRINT N'Creating [dbo].[IsFoldersContainHost]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[IsFoldersContainHost]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[IsFoldersContainHost]
GO

	CREATE PROCEDURE [dbo].[IsFoldersContainHost]
		@row_host_id uniqueidentifier
	AS
	BEGIN

	select [dbo].[fn.IsFoldersContainHost](@row_host_id) result
		
	END	

GO

--------------------------------------------------------------------------------
-- Backup.Model.GetLastIncrementalPoints
PRINT N'Creating [dbo].[Backup.Model.GetLastIncrementalPoints]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetLastIncrementalPoints]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetLastIncrementalPoints]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetLastIncrementalPoints]	
		@backup_id uniqueidentifier
	AS
	BEGIN

		select * from [dbo].[Backup.Model.Points] pnt
		where
			not exists (select * from [dbo].[Backup.Model.Points] where link_id = pnt.id) and
			pnt.alg = 2 and
			backup_id = @backup_id
		
	END  

GO

--------------------------------------------------------------------------------
-- Backup.Model.GetFullPointInGroup
PRINT N'Creating [dbo].[Backup.Model.GetFullPointInGroup]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetFullPointInGroup]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetFullPointInGroup]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetFullPointInGroup]
		@group_id uniqueidentifier
	AS
	BEGIN

		select * from [dbo].[Backup.Model.Points] pnt
		where
			pnt.type = 0 and
			pnt.group_id = @group_id
		
	END  

GO

--------------------------------------------------------------------------------
-- AddRestoreSessionFilesLogXml
PRINT N'Creating [dbo].[AddRestoreSessionFilesLogXml]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[AddRestoreSessionFilesLogXml]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[AddRestoreSessionFilesLogXml]
GO

	CREATE PROCEDURE [dbo].[AddRestoreSessionFilesLogXml]	
				@row_session_id uniqueidentifier,
				@row_time nvarchar(100),
				@row_status nvarchar(10),
				@row_operation nvarchar(300),
				@row_source_item_name nvarchar(300),
				@row_source_item_path nvarchar(300),
				@row_target_item_name nvarchar(300),
				@row_target_item_path nvarchar(300),
				@row_size bigint,
				@row_host nvarchar(300)
	AS
	BEGIN
		SET NOCOUNT ON;
		
		--Select log
		DECLARE @myDoc xml 
		SET @myDoc = (SELECT [files_log_xml]
		FROM [dbo].[Backup.Model.RestoreJobSessions]
		WHERE [id] = @row_session_id)
		
		--Get new log line
		DECLARE @newXmlLogLine xml 
		SET @newXmlLogLine = N'<Log Id="" Usn="0" Status="" Time="">
									<Operation>new</Operation>
									<SourceItemName>new</SourceItemName>
									<SourceItemPath>new</SourceItemPath>
									<TargetItemName>new</TargetItemName>
									<TargetItemPath>new</TargetItemPath>
									<ItemSize>new</ItemSize>
									<Host>new</Host>
								</Log>'  

		--Calc new id and usn
		DECLARE @new_id bigint 
		SET @new_id = @myDoc.value('(/Root/@TotalId)[1]', 'bigint' ) + 1

		--Update log line
		SET @newXmlLogLine.modify('replace value of (/Log/@Id)[1] with sql:variable("@new_id")')
		SET @newXmlLogLine.modify('replace value of (/Log/@Status)[1] with sql:variable("@row_status")')
		SET @newXmlLogLine.modify('replace value of (/Log/@Time)[1] with sql:variable("@row_time")')
		SET @newXmlLogLine.modify('replace value of (/Log/Operation[1]/text())[1] with sql:variable("@row_operation")')
		SET @newXmlLogLine.modify('replace value of (/Log/SourceItemName[1]/text())[1] with sql:variable("@row_source_item_name")')
		SET @newXmlLogLine.modify('replace value of (/Log/SourceItemPath[1]/text())[1] with sql:variable("@row_source_item_path")')
		SET @newXmlLogLine.modify('replace value of (/Log/TargetItemName[1]/text())[1] with sql:variable("@row_target_item_name")')
		SET @newXmlLogLine.modify('replace value of (/Log/TargetItemPath[1]/text())[1] with sql:variable("@row_target_item_path")')
		SET @newXmlLogLine.modify('replace value of (/Log/ItemSize[1]/text())[1] with sql:variable("@row_size")')
		SET @newXmlLogLine.modify('replace value of (/Log/Host[1]/text())[1] with sql:variable("@row_host")')

		--Update log	
		SET @myDoc.modify('replace value of (/Root/@TotalId)[1] with sql:variable("@new_id")')
		SET @myDoc = [dbo].f_insert_as_first(@myDoc, @newXmlLogLine)		
			
		declare @usn bigint
		
		--Update log
		exec [dbo].[IncrementUsn] @usn OUTPUT
		UPDATE [dbo].[Backup.Model.RestoreJobSessions] 
		SET 
			[files_log_xml] = @myDoc,
			[usn]           = @usn		
		WHERE
			[id] = @row_session_id			
		
		SELECT @new_id as [id]
	END  

GO

--------------------------------------------------------------------------------
-- UpdateRestoreSessionFilesLogXml
PRINT N'Creating [dbo].[UpdateRestoreSessionFilesLogXml]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateRestoreSessionFilesLogXml]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateRestoreSessionFilesLogXml]
GO

	CREATE PROCEDURE [dbo].[UpdateRestoreSessionFilesLogXml]	
				@row_session_id uniqueidentifier,
				@row_log_id bigint,
				@row_time nvarchar(100),
				@row_status nvarchar(10),
				@row_operation nvarchar(300),
				@row_source_item_name nvarchar(300),
				@row_source_item_path nvarchar(300),
				@row_target_item_name nvarchar(300),
				@row_target_item_path nvarchar(300),
				@row_size bigint,
				@row_host nvarchar(300)
	AS
	BEGIN
		SET NOCOUNT ON;	
		
		--Select log
		DECLARE @myDoc xml 
		SET @myDoc = (SELECT [files_log_xml]
		FROM [dbo].[Backup.Model.RestoreJobSessions]
		WHERE [id] = @row_session_id)
		
		--Get new log line
		DECLARE @newXmlLogLine xml 
		SET @newXmlLogLine = (SELECT @myDoc.query('/Root/Log[@Id = sql:variable("@row_log_id")]'))

		--Calc new id and usn
		DECLARE @new_usn bigint 
		SET @new_usn = @myDoc.value('(/Root/@TotalUsn)[1]', 'bigint' ) + 1

		--Update log line
		SET @newXmlLogLine.modify('replace value of (/Log/@Usn)[1] with sql:variable("@new_usn")')
		SET @newXmlLogLine.modify('replace value of (/Log/@Status)[1] with sql:variable("@row_status")')
		SET @newXmlLogLine.modify('replace value of (/Log/@Time)[1] with sql:variable("@row_time")')
		SET @newXmlLogLine.modify('replace value of (/Log/Operation[1]/text())[1] with sql:variable("@row_operation")')
		SET @newXmlLogLine.modify('replace value of (/Log/SourceItemName[1]/text())[1] with sql:variable("@row_source_item_name")')
		SET @newXmlLogLine.modify('replace value of (/Log/SourceItemPath[1]/text())[1] with sql:variable("@row_source_item_path")')
		SET @newXmlLogLine.modify('replace value of (/Log/TargetItemName[1]/text())[1] with sql:variable("@row_target_item_name")')
		SET @newXmlLogLine.modify('replace value of (/Log/TargetItemPath[1]/text())[1] with sql:variable("@row_target_item_path")')
		SET @newXmlLogLine.modify('replace value of (/Log/ItemSize[1]/text())[1] with sql:variable("@row_size")')
		SET @newXmlLogLine.modify('replace value of (/Log/Host[1]/text())[1] with sql:variable("@row_host")')

		--Update log
		SET @myDoc.modify('delete (/Root/Log[@Id = sql:variable("@row_log_id")])')
		SET @myDoc.modify('replace value of (/Root/@TotalUsn)[1] with sql:variable("@new_usn")')
		SET @myDoc = [dbo].f_insert_as_first(@myDoc, @newXmlLogLine)	
			
		declare @usn bigint

		--Update log
		exec [dbo].[IncrementUsn] @usn OUTPUT
		UPDATE [dbo].[Backup.Model.RestoreJobSessions] 
		SET
			[files_log_xml] = @myDoc,
			[usn]           = @usn		
		WHERE [id] = @row_session_id	
		
		SELECT @new_usn as [usn]
	END  

GO

--------------------------------------------------------------------------------
-- GetRestoreSessionFilesLogXml
PRINT N'Creating [dbo].[GetRestoreSessionFilesLogXml]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetRestoreSessionFilesLogXml]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetRestoreSessionFilesLogXml]
GO

	CREATE PROCEDURE [dbo].[GetRestoreSessionFilesLogXml]	
				@row_session_id uniqueidentifier,
				@row_usn bigint
	AS
	BEGIN
		SET NOCOUNT ON;
		
		DECLARE @myDoc xml 
		SET @myDoc = '<Root TotalUsn="0"></Root>'
		
		DECLARE @newXmlLogLine xml 
		SET @newXmlLogLine = (SELECT [files_log_xml].query('/Root/Log[@Usn >= sql:variable("@row_usn")]')
		FROM [dbo].[Backup.Model.RestoreJobSessions]
		WHERE [id] = @row_session_id)
		
		SET @newXmlLogLine = '<Logs>' + CONVERT(nvarchar(max), @newXmlLogLine) + '</Logs>'
		SET @myDoc.modify('replace value of (/Root/@TotalUsn)[1] with sql:variable("@row_usn")')
		SET @myDoc = [dbo].f_insert_as_first(@myDoc, @newXmlLogLine)
		
		SELECT @myDoc
	END  

GO

--------------------------------------------------------------------------------
-- DeleteAllObjectsInApplicationGroup
PRINT N'Creating [dbo].[DeleteAllObjectsInApplicationGroup]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DeleteAllObjectsInApplicationGroup]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[DeleteAllObjectsInApplicationGroup]
GO

	CREATE PROCEDURE [dbo].[DeleteAllObjectsInApplicationGroup]
		@row_folder_id uniqueidentifier
	AS
	BEGIN

		SET NOCOUNT ON;

		declare @oiag as table(id uniqueidentifier)
		
		insert into
			@oiag(id)
		select
			id from [dbo].[ObjectsInApplicationGroups]
		WHERE
			[folder_id] = @row_folder_id
		
		DELETE FROM [dbo].[ObjectsInApplicationGroups] WHERE [folder_id] = @row_folder_id

		declare @id uniqueidentifier
		
		declare oiag_cursor cursor for select id from @oiag
		open oiag_cursor
		
			fetch next from oiag_cursor into @id
			while @@FETCH_STATUS = 0
			begin
				
				declare @usn bigint
				exec [dbo].[IncrementUsn] @usn OUTPUT
				exec [dbo].[InsertTombStone] 'ObjectsInApplicationGroups', @id, @usn
							
				fetch next from oiag_cursor into @id
			end
		
		close oiag_cursor
		deallocate oiag_cursor	
		
	END

GO

--------------------------------------------------------------------------------
-- GetOriginalAndRetryBackupSessions
PRINT N'Creating [dbo].[GetOriginalAndRetryBackupSessions]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetOriginalAndRetryBackupSessions]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetOriginalAndRetryBackupSessions]
GO

	CREATE PROCEDURE [dbo].[GetOriginalAndRetryBackupSessions]
		@forward_ordered bit,
		@orig_session_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * 	
		FROM [dbo].[Backup.Model.JobSessions] INNER JOIN [dbo].[Backup.Model.BackupJobSessions] 
			ON [dbo].[Backup.Model.JobSessions].[id] = [dbo].[Backup.Model.BackupJobSessions].[id]
		WHERE 
			[job_type] in (0, 1, 2, 51, 24, 28) AND
			[dbo].[Backup.Model.JobSessions].[orig_session_id] = @orig_session_id
		ORDER BY
			CASE @forward_ordered
				WHEN 1 THEN  rank() OVER(ORDER BY [dbo].[Backup.Model.JobSessions].[creation_time] ASC)
				ELSE rank() OVER(ORDER BY [dbo].[Backup.Model.JobSessions].[creation_time] DESC)
			END
			
	END

GO

--------------------------------------------------------------------------------
-- UpdateCurrentPointIdInSession
PRINT N'Creating [dbo].[UpdateCurrentPointIdInSession]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateCurrentPointIdInSession]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateCurrentPointIdInSession]
GO

	CREATE PROCEDURE [dbo].[UpdateCurrentPointIdInSession]
		@point_id uniqueidentifier,
		@session_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @usn bigint
		
		exec [dbo].[IncrementUsn] @usn OUTPUT
		UPDATE [dbo].[Backup.Model.BackupJobSessions]
		SET
			[cur_point_id] = @point_id,
			[usn]          = @usn
		WHERE
			[id] = @session_id

	END

GO

--------------------------------------------------------------------------------
-- UpdateHostOptions
PRINT N'Creating [dbo].[UpdateHostOptions]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateHostOptions]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateHostOptions]
GO

	CREATE PROCEDURE [dbo].[UpdateHostOptions]
		@row_id uniqueidentifier,
		@row_options xml
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		UPDATE [dbo].[Hosts] SET
				[options] = @row_options,
				[usn] = @usn
		WHERE [id] = @row_id
			
	END	

GO

--------------------------------------------------------------------------------
-- AddQMSessionRow
PRINT N'Creating [dbo].[AddQMSessionRow]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[AddQMSessionRow]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[AddQMSessionRow]
GO

	CREATE PROCEDURE [dbo].[AddQMSessionRow]
			   @row_id uniqueidentifier,
			   @row_creation_time datetime,
			   @row_job_id uniqueidentifier,
			   @row_job_name nvarchar(255),
			   @row_result int,
			   @row_progress int,
			   @row_description text,
			   @row_job_type int,
			   @row_end_time datetime,
			   @row_operation nvarchar(400),
			   @row_state int,
			   @row_lease_id uniqueidentifier,
			   @orig_session_id uniqueidentifier,
			   @row_run_manually bit,
			   @row_aux_data xml,
			   @row_total_objects int,
			   @row_processed_objects int,
			   @row_total_size bigint,
			   @row_processed_size bigint,
			   @row_avg_speed bigint           
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT
	    
		INSERT INTO [dbo].[Backup.Model.JobSessions]
			   ([id]
			   ,[creation_time]
			   ,[job_id]
			   ,[job_name]
			   ,[result]
			   ,[progress]
			   ,[description]
			   ,[job_type]
			   ,[end_time]
			   ,[operation]
			   ,[state]
			   ,[lease_id]
			   ,[orig_session_id]
			   ,[run_manually]
			   ,[aux_data]
			   ,[usn]
			   )
		 VALUES
			   (@row_id,
			   @row_creation_time,
			   @row_job_id,
			   @row_job_name,
			   @row_result,
			   @row_progress,
			   @row_description,
			   @row_job_type,
			   @row_end_time,
			   @row_operation,
			   @row_state,
			   @row_lease_id,
			   @orig_session_id,  
			   @row_run_manually,
			   @row_aux_data,      
			   @usn)  
		exec [dbo].[IncrementUsn] @usn OUTPUT
	    
		INSERT INTO [dbo].[Backup.Model.QuickMigrationSessions]
			   ([id]
			   ,[total_objects]
			   ,[processed_objects]
			   ,[total_size]
			   ,[processed_size]
			   ,[avg_speed]
			   ,[usn]
			   )
		 VALUES
			   (@row_id,
			   @row_total_objects,
			   @row_processed_objects,
			   @row_total_size,
			   @row_processed_size,
			   @row_avg_speed,         
			   @usn)     
	END	

GO

--------------------------------------------------------------------------------
-- UpdateQMSessionRow
PRINT N'Creating [dbo].[UpdateQMSessionRow]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateQMSessionRow]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateQMSessionRow]
GO

	CREATE PROCEDURE [dbo].[UpdateQMSessionRow]
			   @row_id uniqueidentifier,
			   @row_creation_time datetime,
			   @row_job_id uniqueidentifier,
			   @row_job_name nvarchar(255),
			   @row_result int,
			   @row_progress int,
			   @row_description text,
			   @row_job_type int,
			   @row_end_time datetime,
			   @row_operation nvarchar(400),
			   @row_state int,
			   @row_lease_id uniqueidentifier,
			   @orig_session_id uniqueidentifier,
			   @row_run_manually bit,
			   @row_aux_data xml,
			   @row_total_objects int,
			   @row_processed_objects int,
			   @row_total_size bigint,
			   @row_processed_size bigint,
			   @row_avg_speed bigint
	AS
	BEGIN
		SET NOCOUNT ON;
			
		declare @usn bigint
		
		exec [dbo].[IncrementUsn] @usn OUTPUT
		UPDATE [dbo].[Backup.Model.JobSessions] SET
			   [creation_time]		=@row_creation_time,
			   [end_time]			=@row_end_time,
			   [operation]			=@row_operation,
			   [job_id]				=@row_job_id,
			   [job_name]			=@row_job_name,
			   [result]				=@row_result,
			   [progress]			=@row_progress,
			   [description]		=@row_description,
			   [job_type]			=@row_job_type,
			   [state]				=@row_state,
			   [lease_id]			=@row_lease_id,
			   [orig_session_id]	=@orig_session_id,
			   [run_manually]       =@row_run_manually,
			   [aux_data]			=@row_aux_data,
			   [usn]                =@usn
		   WHERE [id] = @row_id  
	       
		exec [dbo].[IncrementUsn] @usn OUTPUT
		UPDATE [dbo].[Backup.Model.QuickMigrationSessions] SET
			   [total_objects]      =@row_total_objects,
			   [processed_objects]	=@row_processed_objects,
			   [total_size]			=@row_total_size,
			   [processed_size]		=@row_processed_size,
			   [avg_speed]			=@row_avg_speed,
			   [usn]                =@usn
		   WHERE [id] = @row_id  
	           
	END	

GO

--------------------------------------------------------------------------------
-- GetHostByUuid
PRINT N'Creating [dbo].[GetHostByUuid]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetHostByUuid]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetHostByUuid]
GO

	CREATE PROCEDURE [dbo].[GetHostByUuid]
		@row_uuid nvarchar(255)
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[Hosts] where [dbo].[Hosts].[bios_uuid] = @row_uuid
	END

GO

--------------------------------------------------------------------------------
-- GetHostByNameAndRef
PRINT N'Creating [dbo].[GetHostByNameAndRef]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetHostByNameAndRef]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetHostByNameAndRef]
GO

	CREATE PROCEDURE [dbo].[GetHostByNameAndRef]
		@row_name nvarchar(255),
		@row_ref nvarchar(1024)
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * 
		from
			[dbo].[Hosts] h
		where
			h.[name] = @row_name and 
			h.[reference] = @row_ref
			
	END

GO

--------------------------------------------------------------------------------
-- ReportQMSessionsView
PRINT N'Creating [dbo].[ReportQMSessionsView]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[ReportQMSessionsView]') AND type in (N'V'))
	DROP VIEW [dbo].[ReportQMSessionsView]
GO

	CREATE VIEW [dbo].[ReportQMSessionsView]
	AS
		SELECT     
			[dbo].[Backup.Model.JobSessions].[id],
			[dbo].[Backup.Model.JobSessions].[job_name], 
			[dbo].[Backup.Model.JobSessions].[state],
			[dbo].[Backup.Model.JobSessions].[creation_time],
			[dbo].[Backup.Model.JobSessions].[end_time],
			[dbo].[Backup.Model.JobSessions].[job_type],
			[dbo].[Backup.Model.JobSessions].[operation],
			[dbo].[Backup.Model.JobSessions].[result],
			[dbo].[Backup.Model.JobSessions].[progress],
			[dbo].[Backup.Model.JobSessions].[usn]
		FROM [dbo].[Backup.Model.JobSessions] WHERE [job_type] = 8

GO

--------------------------------------------------------------------------------
-- ReportQMSessionsDeleteView
PRINT N'Creating [dbo].[ReportQMSessionsDeleteView]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[ReportQMSessionsDeleteView]') AND type in (N'P'))
	DROP PROCEDURE [dbo].[ReportQMSessionsDeleteView]
GO

	CREATE PROCEDURE [dbo].[ReportQMSessionsDeleteView]
		@row_usn bigint
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT uid FROM TombStones WHERE table_name= 'Backup.Model.JobSessions' AND usn > @row_usn
	END

GO

--------------------------------------------------------------------------------
-- ReportQMSessionView
PRINT N'Creating [dbo].[ReportQMSessionView]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[ReportQMSessionView]') AND type in (N'V'))
	DROP VIEW [dbo].[ReportQMSessionView]
GO

	CREATE VIEW [dbo].[ReportQMSessionView]
	AS
		SELECT     
			[dbo].[Backup.Model.QuickMigrationSessions].[id],
			[dbo].[Backup.Model.JobSessions].[job_name], 
			[dbo].[Backup.Model.JobSessions].[state],
			[dbo].[Backup.Model.JobSessions].[creation_time],
			[dbo].[Backup.Model.JobSessions].[end_time],
			[dbo].[Backup.Model.JobSessions].[operation],
			[dbo].[Backup.Model.QuickMigrationSessions].[processed_objects],
			[dbo].[Backup.Model.QuickMigrationSessions].[total_objects],
			[dbo].[Backup.Model.JobSessions].[result],
			[dbo].[Backup.Model.QuickMigrationSessions].[total_size],
			[dbo].[Backup.Model.QuickMigrationSessions].[processed_size],
			[dbo].[Backup.Model.JobSessions].[progress],
			[dbo].[Backup.Model.QuickMigrationSessions].[avg_speed],
			[dbo].[Backup.Model.JobSessions].[description],
			[dbo].[Backup.Model.QuickMigrationSessions].[usn],
			
			success = (SELECT COUNT([dbo].[Backup.Model.QuickMigrationTaskSessions].[id]) FROM [dbo].[Backup.Model.QuickMigrationTaskSessions] 
						WHERE [dbo].[Backup.Model.QuickMigrationTaskSessions].[session_id] = [dbo].[Backup.Model.QuickMigrationSessions].[id] AND [dbo].[Backup.Model.QuickMigrationTaskSessions].[status] = 0),
			failed = (SELECT COUNT([dbo].[Backup.Model.QuickMigrationTaskSessions].[id]) FROM [dbo].[Backup.Model.QuickMigrationTaskSessions] 
						WHERE [dbo].[Backup.Model.QuickMigrationTaskSessions].[session_id] = [dbo].[Backup.Model.QuickMigrationSessions].[id] AND [dbo].[Backup.Model.QuickMigrationTaskSessions].[status] = 2),
			warning = (SELECT COUNT([dbo].[Backup.Model.QuickMigrationTaskSessions].[id]) FROM [dbo].[Backup.Model.QuickMigrationTaskSessions] 
						WHERE [dbo].[Backup.Model.QuickMigrationTaskSessions].[session_id] = [dbo].[Backup.Model.QuickMigrationSessions].[id] AND [dbo].[Backup.Model.QuickMigrationTaskSessions].[status] = 3),
			inprogress = (SELECT COUNT([dbo].[Backup.Model.QuickMigrationTaskSessions].[id]) FROM [dbo].[Backup.Model.QuickMigrationTaskSessions] 
						WHERE [dbo].[Backup.Model.QuickMigrationTaskSessions].[session_id] = [dbo].[Backup.Model.QuickMigrationSessions].[id] AND [dbo].[Backup.Model.QuickMigrationTaskSessions].[status] = 5)
		FROM [dbo].[Backup.Model.QuickMigrationSessions] RIGHT JOIN [dbo].[Backup.Model.JobSessions]
		ON [dbo].[Backup.Model.QuickMigrationSessions].[id] = [dbo].[Backup.Model.JobSessions].[id]

GO

--------------------------------------------------------------------------------
-- FindObjectByName
PRINT N'Creating [dbo].[FindObjectByName]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[FindObjectByName]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[FindObjectByName]
GO

	CREATE PROCEDURE [dbo].[FindObjectByName]
		@name nvarchar(2000)
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[BObjects] where [dbo].[BObjects].[object_name] = @name
	END

GO

--------------------------------------------------------------------------------
-- AddBaseTaskSessionXmlLog
PRINT N'Creating [dbo].[AddBaseTaskSessionXmlLog]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[AddBaseTaskSessionXmlLog]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[AddBaseTaskSessionXmlLog]
GO

	CREATE PROCEDURE [dbo].[AddBaseTaskSessionXmlLog]	
				@row_session_id uniqueidentifier,
				@row_cookie nvarchar(100),
				@row_time nvarchar(100),
				@row_utc_time nvarchar(100),
				@row_status nvarchar(10),
				@row_style nvarchar(10),
				@row_title nvarchar(512),
				@row_desc nvarchar(512),
				@row_start_time nvarchar(100)
	AS
	BEGIN
		SET NOCOUNT ON;
		
		--Select log
		DECLARE @myDoc xml 
		SET @myDoc = (SELECT [log_xml]
		FROM [dbo].[Backup.Model.BackupTaskSessions]
		WHERE [id] = @row_session_id)

		--Check status for reason
		DECLARE @setReason bit
		SET @setReason = (
			CASE WHEN @myDoc.exist('/Root/Log[@Status = "EFailed"]') = 0 AND (
				@row_status = 'EFailed' OR (@myDoc.exist('/Root/Log[@Status = "EWarning"]') = 0 AND @row_status = 'EWarning')
			) THEN 1 ELSE 0 END
		)
		
		--Get new log line
		DECLARE @newXmlLogLine xml 
		SET @newXmlLogLine = N'<Log Id="" Usn="0" Cookie="" Status="" Style="" Time="" UtcTime="" StartTime=""><Title>new</Title><Description>new</Description></Log>'

		--Calc new id and usn
		DECLARE @new_id bigint 
		SET @new_id = @myDoc.value('(/Root/@TotalId)[1]', 'bigint' ) + 1

		--Update log line
		SET @newXmlLogLine.modify('replace value of (/Log/@Id)[1] with sql:variable("@new_id")')
		SET @newXmlLogLine.modify('replace value of (/Log/@Cookie)[1] with sql:variable("@row_cookie")')
		SET @newXmlLogLine.modify('replace value of (/Log/@Status)[1] with sql:variable("@row_status")')
		SET @newXmlLogLine.modify('replace value of (/Log/@Style)[1] with sql:variable("@row_style")')
		SET @newXmlLogLine.modify('replace value of (/Log/@Time)[1] with sql:variable("@row_time")')
		SET @newXmlLogLine.modify('replace value of (/Log/@UtcTime)[1] with sql:variable("@row_utc_time")')
		SET @newXmlLogLine.modify('replace value of (/Log/Title[1]/text())[1] with sql:variable("@row_title")')
		SET @newXmlLogLine.modify('replace value of (/Log/Description[1]/text())[1] with sql:variable("@row_desc")')
		SET @newXmlLogLine.modify('replace value of (/Log/@StartTime)[1] with sql:variable("@row_start_time")')

		--Update log	
		SET @myDoc.modify('replace value of (/Root/@TotalId)[1] with sql:variable("@new_id")')
		--SET @myDoc.modify('insert sql:variable("@newXmlLogLine") as last into (/Root)[1]')
		SET @myDoc = [dbo].f_insert_as_first(@myDoc, @newXmlLogLine)		
			
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		--Update log
		IF @setReason = 1 BEGIN
			UPDATE [dbo].[Backup.Model.BackupTaskSessions]
			SET
				[reason] = @row_title,
				[log_xml] = @myDoc,
				[usn]     = @usn
			WHERE [id] = @row_session_id
		END ELSE BEGIN
			UPDATE [dbo].[Backup.Model.BackupTaskSessions]
			SET
				[log_xml] = @myDoc,
				[usn]     = @usn
			WHERE [id] = @row_session_id			
		END
		
		SELECT @new_id as [id]
	END  

GO



--------------------------------------------------------------------------------
-- GetBaseTaskSessionXmlLogMaxUsn

PRINT N'Creating [dbo].[GetBaseTaskSessionXmlLogMaxUsn]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetBaseTaskSessionXmlLogMaxUsn]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetBaseTaskSessionXmlLogMaxUsn]
GO

	CREATE PROCEDURE [dbo].[GetBaseTaskSessionXmlLogMaxUsn]	
				@row_session_id uniqueidentifier				
	AS
	BEGIN
		SET NOCOUNT ON;
		
		--Select log
		DECLARE @myDoc xml 
		SET @myDoc = (SELECT [log_xml]
		FROM [dbo].[Backup.Model.BackupTaskSessions]
		WHERE [id] = @row_session_id)
		
		
		--Calc new id and usn
		DECLARE @max_usn bigint 
		SET @max_usn = @myDoc.value('(/Root/@TotalId)[1]', 'bigint' )
		
			
		SELECT @max_usn as [usn]
	END  

GO


--------------------------------------------------------------------------------
-- UpdateBaseTaskSessionXmlLog
PRINT N'Creating [dbo].[UpdateBaseTaskSessionXmlLog]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateBaseTaskSessionXmlLog]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateBaseTaskSessionXmlLog]
GO

	CREATE PROCEDURE [dbo].[UpdateBaseTaskSessionXmlLog]	
				@row_session_id uniqueidentifier,
				@row_log_id bigint,
				@row_time nvarchar(100),
				@row_utc_time nvarchar(100),
				@row_status nvarchar(10),
				@row_title nvarchar(512),
				@row_desc nvarchar(512)
	AS
	BEGIN
		SET NOCOUNT ON;	
		
		--Select log
		DECLARE @myDoc xml 
		SET @myDoc = (SELECT [log_xml]
		FROM [dbo].[Backup.Model.BackupTaskSessions]
		WHERE [id] = @row_session_id)
		
		--Check status for reason
		DECLARE @setReason bit
		SET @setReason = (
			CASE WHEN @myDoc.exist('/Root/Log[@Status = "EFailed"]') = 0 AND (
				@row_status = 'EFailed' OR (@myDoc.exist('/Root/Log[@Status = "EWarning"]') = 0 AND @row_status = 'EWarning')
			) THEN 1 ELSE 0 END
		)
		
		--Get new log line
		DECLARE @newXmlLogLine xml 
		SET @newXmlLogLine = (SELECT @myDoc.query('/Root/Log[@Id = sql:variable("@row_log_id")]'))

		--Calc new id and usn
		DECLARE @new_usn bigint 
		SET @new_usn = @myDoc.value('(/Root/@TotalUsn)[1]', 'bigint' ) + 1

		--Update log line
		SET @newXmlLogLine.modify('replace value of (/Log/@Usn)[1] with sql:variable("@new_usn")')
		SET @newXmlLogLine.modify('replace value of (/Log/@Status)[1] with sql:variable("@row_status")')
		SET @newXmlLogLine.modify('replace value of (/Log/@Time)[1] with sql:variable("@row_time")')
		SET @newXmlLogLine.modify('replace value of (/Log/@UtcTime)[1] with sql:variable("@row_utc_time")')
		SET @newXmlLogLine.modify('replace value of (/Log/Title[1]/text())[1] with sql:variable("@row_title")')
		SET @newXmlLogLine.modify('replace value of (/Log/Description[1]/text())[1] with sql:variable("@row_desc")')

		--Update log
		SET @myDoc.modify('delete (/Root/Log[@Id = sql:variable("@row_log_id")])')
		SET @myDoc.modify('replace value of (/Root/@TotalUsn)[1] with sql:variable("@new_usn")')
		--SET @myDoc.modify('insert sql:variable("@newXmlLogLine") as last into (/Root)[1]')
		SET @myDoc = [dbo].f_insert_as_first(@myDoc, @newXmlLogLine)	
			
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		--Update log
		IF @setReason = 1 BEGIN
			UPDATE [dbo].[Backup.Model.BackupTaskSessions]
			SET
				[reason] = @row_title,
				[log_xml] = @myDoc,
				[usn]     = @usn
			WHERE [id] = @row_session_id
		END ELSE BEGIN
			UPDATE [dbo].[Backup.Model.BackupTaskSessions]
			SET
				[log_xml] = @myDoc,
				[usn]     = @usn
			WHERE [id] = @row_session_id			
		END
		
		SELECT @new_usn as [usn]
	END  
	
GO

--------------------------------------------------------------------------------
-- GetBaseTaskSessionXmlLog
PRINT N'Creating [dbo].[GetBaseTaskSessionXmlLog]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetBaseTaskSessionXmlLog]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetBaseTaskSessionXmlLog]
GO

	CREATE PROCEDURE [dbo].[GetBaseTaskSessionXmlLog]	
				@row_session_id uniqueidentifier,
				@row_usn bigint
	AS
	BEGIN
		SET NOCOUNT ON;
		
		DECLARE @myDoc xml 
		SET @myDoc = '<Root TotalUsn="0"></Root>'
		
		DECLARE @newXmlLogLine xml 
		SET @newXmlLogLine = (SELECT [log_xml].query('/Root/Log[@Usn >= sql:variable("@row_usn")]')
		FROM [dbo].[Backup.Model.BackupTaskSessions]
		WHERE [id] = @row_session_id)
		
		SET @newXmlLogLine = '<Logs>' + CONVERT(nvarchar(max), @newXmlLogLine) + '</Logs>'
		SET @myDoc.modify('replace value of (/Root/@TotalUsn)[1] with sql:variable("@row_usn")')
		--SET @myDoc.modify('insert sql:variable("@newXmlLogLine") as last into (/Root)[1]')
		SET @myDoc = [dbo].f_insert_as_first(@myDoc, @newXmlLogLine)
		
		SELECT @myDoc
	END  

GO

--------------------------------------------------------------------------------
-- FindInBaseTaskSessionXmlLog
PRINT N'Creating [dbo].[FindInBaseTaskSessionXmlLog]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[FindInBaseTaskSessionXmlLog]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[FindInBaseTaskSessionXmlLog]
GO

	CREATE PROCEDURE [dbo].[FindInBaseTaskSessionXmlLog]
				@sessionId	uniqueidentifier,			
				@cookie		nvarchar( 255 ),
				@status     nvarchar( 40 )
	AS
	BEGIN
		SET NOCOUNT ON;
		
		DECLARE @recsWithCookie XML
			
		IF @cookie IS NOT NULL AND @cookie <> N'' AND @status IS NOT NULL AND @status <> N''
			BEGIN
				SET @recsWithCookie = (SELECT [log_xml].query('/Root/Log[@Cookie = sql:variable("@cookie")][@Status = sql:variable("@status")]' )
				FROM [dbo].[Backup.Model.BackupTaskSessions]
				WHERE [id] = @sessionId )

			END
		ELSE  IF @cookie IS NOT NULL AND @cookie <> N''
				BEGIN
					SET @recsWithCookie = (SELECT [log_xml].query( '/Root/Log[@Cookie = sql:variable("@cookie")]' )
					FROM [dbo].[Backup.Model.BackupTaskSessions]
					WHERE [id] = @sessionId )
				
			END
		ELSE
			BEGIN
				SET @recsWithCookie = (SELECT [log_xml].query( '/Root/Log[@Status = sql:variable("@status")]' )
				FROM [dbo].[Backup.Model.BackupTaskSessions]
				WHERE [id] = @sessionId )
				
			END
		
		SELECT [Id] = T.Item.value('@Id', 'bigint' )
		FROM  @recsWithCookie.nodes('/Log') AS T(Item)
		
	END  

GO

--------------------------------------------------------------------------------
-- UpdateBaseTaskSessionXmlLogStatus
PRINT N'Creating [dbo].[UpdateBaseTaskSessionXmlLogStatus]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateBaseTaskSessionXmlLogStatus]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateBaseTaskSessionXmlLogStatus]
GO

	CREATE PROCEDURE [dbo].[UpdateBaseTaskSessionXmlLogStatus]	
				@row_session_id uniqueidentifier,		
				@row_log_id bigint,	
				@row_time nvarchar(100),
				@row_utc_time nvarchar(100),
				@row_status nvarchar(10),			
				@row_desc nvarchar(512)
	AS
	BEGIN
		SET NOCOUNT ON;	
		
		--Select log
		DECLARE @myDoc xml
		SET @myDoc = (SELECT [log_xml]
		FROM [dbo].[Backup.Model.BackupTaskSessions]
		WHERE [id] = @row_session_id)

		--Check status for reason
		DECLARE @setReason bit
		SET @setReason = (
			CASE WHEN @myDoc.exist('/Root/Log[@Status = "EFailed"]') = 0 AND (
				@row_status = 'EFailed' OR (@myDoc.exist('/Root/Log[@Status = "EWarning"]') = 0 AND @row_status = 'EWarning')
			) THEN 1 ELSE 0 END
		)
		
		--Get new log line
		DECLARE @newXmlLogLine xml 
		SET @newXmlLogLine = (SELECT @myDoc.query('/Root/Log[@Id = sql:variable("@row_log_id")]'))
		
		DECLARE @rowTitle nvarchar(512)
		SET @rowTitle = (SELECT @newXmlLogLine.value('(/Log/Title)[1]', 'nvarchar(512)'))

		--Calc new id and usn
		DECLARE @new_usn bigint
		SET @new_usn = @myDoc.value('(/Root/@TotalUsn)[1]', 'bigint' ) + 1
		
		--Update log line
		SET @newXmlLogLine.modify('replace value of (/Log/@Usn)[1] with sql:variable("@new_usn")')
		SET @newXmlLogLine.modify('replace value of (/Log/@Status)[1] with sql:variable("@row_status")')
		SET @newXmlLogLine.modify('replace value of (/Log/@Time)[1] with sql:variable("@row_time")')
		SET @newXmlLogLine.modify('replace value of (/Log/@UtcTime)[1] with sql:variable("@row_utc_time")')	
		SET @newXmlLogLine.modify('replace value of (/Log/Description[1]/text())[1] with sql:variable("@row_desc")')

		--Update log
		SET @myDoc.modify('delete (/Root/Log[@Id = sql:variable("@row_log_id")])')
		SET @myDoc.modify('replace value of (/Root/@TotalUsn)[1] with sql:variable("@new_usn")')
		--SET @myDoc.modify('insert sql:variable("@newXmlLogLine") as last into (/Root)[1]')
		SET @myDoc = [dbo].f_insert_as_first(@myDoc, @newXmlLogLine)
			
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		--Update log
		IF @setReason = 1 BEGIN
			UPDATE [dbo].[Backup.Model.BackupTaskSessions]
			SET
				[reason] = @rowTitle,
				[log_xml] = @myDoc,
				[usn]     = @usn
			WHERE [id] = @row_session_id
		END ELSE BEGIN
			UPDATE [dbo].[Backup.Model.BackupTaskSessions]
			SET
				[log_xml] = @myDoc,
				[usn]     = @usn
			WHERE [id] = @row_session_id			
		END
		
		SELECT @new_usn as [usn]
	END  

GO

--------------------------------------------------------------------------------
-- UpdateBaseTaskSessionXmlLogStatusOnly
PRINT N'Creating [dbo].[UpdateBaseTaskSessionXmlLogStatusOnly]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateBaseTaskSessionXmlLogStatusOnly]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateBaseTaskSessionXmlLogStatusOnly]
GO

	CREATE PROCEDURE [dbo].[UpdateBaseTaskSessionXmlLogStatusOnly]	
				@row_session_id uniqueidentifier,
				@row_log_id bigint,
				@row_status nvarchar(10)
	AS
	BEGIN
		SET NOCOUNT ON;	
		
		--Select log
		DECLARE @myDoc xml
		SET @myDoc = (SELECT [log_xml]
		FROM [dbo].[Backup.Model.BackupTaskSessions]
		WHERE [id] = @row_session_id)
		
		--Check status for reason
		DECLARE @setReason bit
		SET @setReason = (
			CASE WHEN @myDoc.exist('/Root/Log[@Status = "EFailed"]') = 0 AND (
				@row_status = 'EFailed' OR (@myDoc.exist('/Root/Log[@Status = "EWarning"]') = 0 AND @row_status = 'EWarning')
			) THEN 1 ELSE 0 END
		)
		
		--Get new log line
		DECLARE @newXmlLogLine xml 
		SET @newXmlLogLine = (SELECT @myDoc.query('/Root/Log[@Id = sql:variable("@row_log_id")]'))

		DECLARE @rowTitle nvarchar(512)
		SET @rowTitle = (SELECT @newXmlLogLine.value('(/Log/Title)[1]', 'nvarchar(512)'))

		--Calc new id and usn
		DECLARE @new_usn bigint
		SET @new_usn = @myDoc.value('(/Root/@TotalUsn)[1]', 'bigint' ) + 1
		
		--Update log line
		SET @newXmlLogLine.modify('replace value of (/Log/@Usn)[1] with sql:variable("@new_usn")')
		SET @newXmlLogLine.modify('replace value of (/Log/@Status)[1] with sql:variable("@row_status")')

		--Update log
		SET @myDoc.modify('delete (/Root/Log[@Id = sql:variable("@row_log_id")])')
		SET @myDoc.modify('replace value of (/Root/@TotalUsn)[1] with sql:variable("@new_usn")')
		SET @myDoc = [dbo].f_insert_as_first(@myDoc, @newXmlLogLine)
			
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		--Update log
		IF @setReason = 1 BEGIN
			UPDATE [dbo].[Backup.Model.BackupTaskSessions]
			SET
				[reason] = @rowTitle,
				[log_xml] = @myDoc,
				[usn]     = @usn
			WHERE [id] = @row_session_id
		END ELSE BEGIN
			UPDATE [dbo].[Backup.Model.BackupTaskSessions]
			SET
				[log_xml] = @myDoc,
				[usn]     = @usn
			WHERE [id] = @row_session_id			
		END
		
		SELECT @new_usn as [usn]
	END  

GO

--------------------------------------------------------------------------------
-- GetJobProxiesByJobAndType
PRINT N'Creating [dbo].[GetJobProxiesByJobAndType]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetJobProxiesByJobAndType]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetJobProxiesByJobAndType]
GO

	CREATE PROCEDURE [dbo].[GetJobProxiesByJobAndType]
		@job_id uniqueidentifier,
		@type int
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[Backup.Model.JobProxies] WHERE job_id = @job_id AND type = @type
	END

GO

--------------------------------------------------------------------------------
-- GetJobProxiesByJob
PRINT N'Creating [dbo].[GetJobProxiesByJob]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetJobProxiesByJob]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetJobProxiesByJob]
GO

	CREATE PROCEDURE [dbo].[GetJobProxiesByJob]
		@job_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[Backup.Model.JobProxies] WHERE job_id = @job_id
	END

GO

--------------------------------------------------------------------------------
-- AddHostDisk
PRINT N'Creating [dbo].[AddHostDisk]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[AddHostDisk]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[AddHostDisk]
GO

	CREATE PROCEDURE [dbo].[AddHostDisk]
			   @id uniqueidentifier,
			   @host_id uniqueidentifier,
			   @name nvarchar(255),
			   @inquiry nvarchar(1000),
			   @add_type int,
			   @lun int,
			   @path_id int,
			   @target_id int
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		INSERT INTO [dbo].[Backup.Model.HostDisks]
			   ([id]
			   ,[host_id]
			   ,[name]
			   ,[inquiry]
			   ,[add_type]
			   ,[lun]
			   ,[path_id]
			   ,[target_id]
			   ,[usn]
			   )
		 VALUES
			   (@id,
			   @host_id,
			   @name,
			   @inquiry,
			   @add_type,
			   @lun,
			   @path_id,
			   @target_id,
			   @usn
			   )
	END	
	
GO

--------------------------------------------------------------------------------
-- UpdateHostDisk
PRINT N'Creating [dbo].[UpdateHostDisk]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateHostDisk]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateHostDisk]
GO

	CREATE PROCEDURE [dbo].[UpdateHostDisk]
		@id uniqueidentifier,
		@host_id uniqueidentifier,
		@name nvarchar(255),
		@inquiry nvarchar(1000),
		@add_type int,
		@lun int,
		@path_id int,
		@target_id int
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		UPDATE [dbo].[Backup.Model.HostDisks] SET
			   [host_id] = @host_id,
			   [name] = @name,
			   [inquiry]  = @inquiry,
			   [add_type] = @add_type,
			   [lun] = @lun,
			   [path_id] = @path_id,
			   [target_id] = @target_id,
			   [usn] = @usn
		WHERE [id] = @id
	END

GO


--------------------------------------------------------------------------------
-- GetHostDisks
PRINT N'Creating [dbo].[GetHostDisks]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetHostDisks]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetHostDisks]
GO

	CREATE PROCEDURE [dbo].[GetHostDisks]
		@host_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[Backup.Model.HostDisks] WHERE host_id = @host_id
	END

GO

--------------------------------------------------------------------------------
-- DeleteHostDisk
PRINT N'Creating [dbo].[DeleteHostDisk]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DeleteHostDisk]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[DeleteHostDisk]
GO

	CREATE PROCEDURE [dbo].[DeleteHostDisk]
		@id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		DELETE FROM [dbo].[Backup.Model.HostDisks] WHERE [id] = @id
	END

GO

--------------------------------------------------------------------------------
-- DeleteHostDisks
PRINT N'Creating [dbo].[DeleteHostDisks]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DeleteHostDisks]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[DeleteHostDisks]
GO

	CREATE PROCEDURE [dbo].[DeleteHostDisks]
		@host_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		DELETE FROM [dbo].[Backup.Model.HostDisks] WHERE [host_id] = @host_id
	END

GO

--------------------------------------------------------------------------------
-- UpdateSessionResult
PRINT N'Creating [dbo].[UpdateSessionResult]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateSessionResult]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateSessionResult]
GO

	CREATE PROCEDURE [dbo].[UpdateSessionResult]
			   @row_id uniqueidentifier,
			   @row_result int	
	AS
	BEGIN
		SET NOCOUNT ON;
		UPDATE [dbo].[Backup.Model.JobSessions] SET
			   [result]	= @row_result
				where [id] = @row_id

	END

GO

--------------------------------------------------------------------------------
-- AddPhysicalHost
PRINT N'Creating [dbo].[AddPhysicalHost]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[AddPhysicalHost]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[AddPhysicalHost]
GO

	CREATE PROCEDURE [dbo].[AddPhysicalHost]
		@id uniqueidentifier,
		@name nvarchar(max),
		@bios_uuid nvarchar(255),
		@chassis_type int,
		@hardware_info xml,
		@net_info xml,
		@os_type int		
	AS
	BEGIN
		SET NOCOUNT ON;
			
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		INSERT INTO [dbo].[PhysicalHosts]
			   ([id]
			   ,[name]
			   ,[bios_uuid]
			   ,[chassis_type]
			   ,[hardware_info]
			   ,[net_info]
			   ,[os_type]
			   ,[usn])
		 VALUES
			   (@id,
				@name,
				@bios_uuid,
				@chassis_type,
				@hardware_info,
				@net_info,
				@os_type,
				@usn)
	END	
GO

--------------------------------------------------------------------------------
-- UpdatePhysicalHost
PRINT N'Creating [dbo].[UpdatePhysicalHost]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdatePhysicalHost]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdatePhysicalHost]
GO

	CREATE PROCEDURE [dbo].[UpdatePhysicalHost]
		@id uniqueidentifier,
		@name nvarchar(max),
		@bios_uuid nvarchar(255),
		@chassis_type int,
		@hardware_info xml,
		@net_info xml,
		@os_type int
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		UPDATE [dbo].[PhysicalHosts]
		SET
			   [bios_uuid] = @bios_uuid,
			   [name] = @name,
			   [chassis_type] = @chassis_type,
			   [hardware_info] = @hardware_info,
			   [net_info] = @net_info,
			   [os_type] = @os_type,
			   [usn] = @usn
		WHERE [id] = @id
	END	

GO

--------------------------------------------------------------------------------
-- FindPhysicalHostById
PRINT N'Creating [dbo].[FindPhysicalHostById]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[FindPhysicalHostById]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[FindPhysicalHostById]
GO

	CREATE PROCEDURE [dbo].[FindPhysicalHostById]
		@id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[PhysicalHosts] where [dbo].[PhysicalHosts].[id] = @id
	END

GO

--------------------------------------------------------------------------------
-- FindPhysicalHostByBiosUuid
PRINT N'Creating [dbo].[FindPhysicalHostByBiosUuid]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[FindPhysicalHostByBiosUuid]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[FindPhysicalHostByBiosUuid]
GO

	CREATE PROCEDURE [dbo].[FindPhysicalHostByBiosUuid]
		@bios_uuid nvarchar(255)
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[PhysicalHosts] where [dbo].[PhysicalHosts].[bios_uuid] = @bios_uuid
	END

GO

--------------------------------------------------------------------------------
-- DeletePhysicalHost
PRINT N'Creating [dbo].[DeletePhysicalHost]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DeletePhysicalHost]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[DeletePhysicalHost]
GO

	CREATE PROCEDURE [dbo].[DeletePhysicalHost]
		@id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		DELETE FROM [dbo].[PhysicalHosts] WHERE [id] = @id
	END
	
GO

--------------------------------------------------------------------------------
-- AddHostComp
PRINT N'Creating [dbo].[AddHostComp]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[AddHostComp]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[AddHostComp]
GO

	CREATE PROCEDURE [dbo].[AddHostComp]
		@id uniqueidentifier,
		@physical_host_id uniqueidentifier,
		@type int,
		@version nvarchar(255),
		@options xml
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		INSERT INTO [dbo].[HostComponents]
			   ([id]
			   ,[physical_host_id]
			   ,[type]
			   ,[version]
			   ,[options]
			   ,[usn])
		 VALUES
			   (@id,
				@physical_host_id,
				@type,
				@version,
				@options,
				@usn)
	END	

GO

--------------------------------------------------------------------------------
-- UpdateHostComp
PRINT N'Creating [dbo].[UpdateHostComp]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateHostComp]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateHostComp]
GO

	CREATE PROCEDURE [dbo].[UpdateHostComp]
		@id uniqueidentifier,
		@physical_host_id uniqueidentifier,
		@type int,
		@version nvarchar(255),
		@options xml
	AS
	BEGIN
		SET NOCOUNT ON;

		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		UPDATE [dbo].[HostComponents] 
		SET
			[physical_host_id] = @physical_host_id,
			[type] = @type,
			[version] = @version,
			[options] = @options,
			[usn] = @usn
		WHERE [id] = @id
	END	

GO

--------------------------------------------------------------------------------
-- FindHostCompById
PRINT N'Creating [dbo].[FindHostCompById]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[FindHostCompById]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[FindHostCompById]
GO

	CREATE PROCEDURE [dbo].[FindHostCompById]
		@id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[HostComponents] where [dbo].[HostComponents].[id] = @id
	END

GO

--------------------------------------------------------------------------------
-- FindHostCompsByHostId
PRINT N'Creating [dbo].[FindHostCompsByHostId]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[FindHostCompsByHostId]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[FindHostCompsByHostId]
GO

	CREATE PROCEDURE [dbo].[FindHostCompsByHostId]
		@host_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[HostComponents] where [dbo].[HostComponents].[physical_host_id] = @host_id
	END

GO

--------------------------------------------------------------------------------
-- FindHostCompByHostIdAndType
PRINT N'Creating [dbo].[FindHostCompByHostIdAndType]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[FindHostCompByHostIdAndType]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[FindHostCompByHostIdAndType]
GO

	CREATE PROCEDURE [dbo].[FindHostCompByHostIdAndType]
		@host_id uniqueidentifier,
		@type int
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[HostComponents] where [physical_host_id] = @host_id AND [type] = @type
	END

GO

--------------------------------------------------------------------------------
-- DeleteHostComp
PRINT N'Creating [dbo].[DeleteHostComp]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DeleteHostComp]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[DeleteHostComp]
GO

	CREATE PROCEDURE [dbo].[DeleteHostComp]
		@id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		DELETE FROM [dbo].[HostComponents] WHERE [id] = @id
	END

GO

--------------------------------------------------------------------------------
-- AddBackupRepository
PRINT N'Creating [dbo].[AddBackupRepository]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[AddBackupRepository]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[AddBackupRepository]
GO

	CREATE PROCEDURE [dbo].[AddBackupRepository]
		@id uniqueidentifier,
		@name nvarchar(max),
		@description nvarchar(max),
		@type int,
		@host_id uniqueidentifier,
		@mount_host_id uniqueidentifier,
		@path nvarchar(max),
		@options xml,
		@share_creds_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		INSERT INTO [dbo].[BackupRepositories]
			   ([id]
			   ,[name]
			   ,[description]
			   ,[type]
			   ,[host_id]
			   ,[mount_host_id]
			   ,[path]
			   ,[options]
			   ,[usn]
			   ,[share_creds_id])
			   
		 VALUES
			   (@id,
				@name,
				@description,
				@type,
				@host_id,
				@mount_host_id,
				@path,
				@options,
				@usn,
				@share_creds_id)
	END

GO

--------------------------------------------------------------------------------
-- UpdateBackupRepository
PRINT N'Creating [dbo].[UpdateBackupRepository]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateBackupRepository]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateBackupRepository]
GO

	CREATE PROCEDURE [dbo].[UpdateBackupRepository]
			@id uniqueidentifier,
			@name nvarchar(max),
			@description nvarchar(max),
			@type int,
			@host_id uniqueidentifier,
			@mount_host_id uniqueidentifier,
			@path nvarchar(max),
			@options xml,
			@share_creds_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		UPDATE [dbo].[BackupRepositories] 
		SET
			   [name] = @name,
			   [description] = @description,
			   [type] = @type,
			   [host_id] = @host_id,
			   [mount_host_id] = @mount_host_id,
			   [path] = @path,
			   [options] = @options,
			   [usn] = @usn,
			   [share_creds_id] = @share_creds_id
		WHERE [id] = @id
	END
	
GO

--------------------------------------------------------------------------------
-- FindBackupRepositoryById
PRINT N'Creating [dbo].[FindBackupRepositoryById]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[FindBackupRepositoryById]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[FindBackupRepositoryById]
GO

	CREATE PROCEDURE [dbo].[FindBackupRepositoryById]
		@id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[BackupRepositories] where [dbo].[BackupRepositories].[id] = @id
	END

GO

--------------------------------------------------------------------------------
-- GetAllBackupRepositories
PRINT N'Creating [dbo].[GetAllBackupRepositories]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetAllBackupRepositories]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetAllBackupRepositories]
GO

	CREATE PROCEDURE [dbo].[GetAllBackupRepositories]	
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[BackupRepositories] 
		
	END

GO

--------------------------------------------------------------------------------
-- DeleteBackupRepository
PRINT N'Creating [dbo].[DeleteBackupRepository]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DeleteBackupRepository]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[DeleteBackupRepository]
GO

	CREATE PROCEDURE [dbo].[DeleteBackupRepository]
		@id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT	
		
		DELETE FROM [dbo].[BackupRepositories] WHERE [id] = @id
		
		exec [dbo].[InsertTombStone] 'BackupRepositories', @id, @usn
	END
	
GO

--------------------------------------------------------------------------------
-- GetHostsForFolderByType
PRINT N'Creating [dbo].[GetHostsForFolderByType]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetHostsForFolderByType]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetHostsForFolderByType]
GO

	CREATE PROCEDURE [dbo].[GetHostsForFolderByType]
		@folder_id uniqueidentifier,
		@host_type int
	AS
	BEGIN
		SET NOCOUNT ON;

	SELECT 
		[dbo].[Hosts].*
	FROM
		[dbo].[Folder_Host],
		[dbo].[Hosts]
	WHERE
		[dbo].[Folder_Host].[folder_id] = @folder_id AND
		[dbo].[Folder_Host].[host_id] = [dbo].[Hosts].[id] AND
		[dbo].[Hosts].[type] = @host_type
		
	END

GO

--------------------------------------------------------------------------------
-- ReportRepositoriesView
PRINT N'Creating [dbo].[ReportRepositoriesView]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[ReportRepositoriesView]') AND type in (N'V'))
	DROP VIEW [dbo].[ReportRepositoriesView]
GO

	CREATE VIEW [dbo].[ReportRepositoriesView]
	AS
		SELECT     
			[dbo].[BackupRepositories].[id],
			[dbo].[BackupRepositories].[name], 
			[dbo].[BackupRepositories].[description],
			[dbo].[BackupRepositories].[type],
			[dbo].[BackupRepositories].[host_id],
			[dbo].[BackupRepositories].[mount_host_id],
			[dbo].[BackupRepositories].[path],
			[dbo].[BackupRepositories].[options],
			(SELECT top(1) name from [dbo].[Hosts] WHERE [dbo].[Hosts].[id] = [dbo].[BackupRepositories].[host_id]) as [host_name],
			(SELECT [dbo].[fn.IsHostUpgradeRequired]([dbo].[BackupRepositories].[host_id]) | [dbo].[fn.IsHostUpgradeRequired]([dbo].[BackupRepositories].[mount_host_id])) as [is_upgrade_required],
			[dbo].[BackupRepositories].[is_busy],
			[dbo].[BackupRepositories].[is_unavailable],
			[dbo].[BackupRepositories].[is_full],
			[dbo].[fn.GetMaxRepositoryUsn]([dbo].[BackupRepositories].[id]) as [usn],
			[dbo].[BackupRepositories].[free_space]
		FROM [dbo].[BackupRepositories]

GO

--------------------------------------------------------------------------------
-- ReportRepositoriesDeleteView
PRINT N'Creating [dbo].[ReportRepositoriesDeleteView]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[ReportRepositoriesDeleteView]') AND type in (N'P'))
	DROP PROCEDURE [dbo].[ReportRepositoriesDeleteView]
GO

	CREATE PROCEDURE [dbo].[ReportRepositoriesDeleteView]
		@row_usn bigint
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT uid, usn FROM TombStones WHERE table_name= 'BackupRepositories' AND usn > @row_usn
	END

GO

--------------------------------------------------------------------------------
-- GetHostByNameAndType
PRINT N'Creating [dbo].[GetHostByNameAndType]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetHostByNameAndType]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetHostByNameAndType]
GO

	CREATE PROCEDURE [dbo].[GetHostByNameAndType]
		@name nvarchar(max),
		@type int
	AS
	BEGIN
		SET NOCOUNT ON;

	SELECT 
		*
	FROM
		[dbo].[Hosts]
	WHERE
		[dbo].[Hosts].[name] = @name AND
		[dbo].[Hosts].[type] = @type

	END

GO

--------------------------------------------------------------------------------
-- GetCredentials
PRINT N'Creating [dbo].[GetCredentials]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetCredentials]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetCredentials]
GO

	CREATE PROCEDURE [dbo].[GetCredentials]
		@id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT * from [dbo].[Credentials] where [id] = @id
	END

GO

-- EnumerateCredentials
PRINT N'Creating [dbo].[EnumerateCredentials]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[EnumerateCredentials]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[EnumerateCredentials]
GO

	CREATE PROCEDURE [dbo].[EnumerateCredentials]
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT * from [dbo].[Credentials] ORDER BY [user_name]
	END

GO

--------------------------------------------------------------------------------
-- CreateCredentials
PRINT N'Creating [dbo].[CreateCredentials]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[CreateCredentials]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[CreateCredentials]
GO

	CREATE PROCEDURE [dbo].[CreateCredentials]
		@id uniqueidentifier,
		@user_name nvarchar(max),
		@password nvarchar(max),
		@description nvarchar(max),
		@visible bit
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		INSERT INTO [dbo].[Credentials]
			(
				[id],
				[user_name],
				[password],
				[usn],
				[description],
				[visible]
			)
		VALUES
			(
				@id,
				@user_name,
				@password,
				@usn,
				@description,	
				@visible		
			)
	END

GO

--------------------------------------------------------------------------------
-- UpdateCredentials
PRINT N'Creating [dbo].[UpdateCredentials]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateCredentials]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateCredentials]
GO

	CREATE PROCEDURE [dbo].[UpdateCredentials]
		@id uniqueidentifier,
		@user_name nvarchar(max),
		@password nvarchar(max),
		@description nvarchar(max),
		@visible bit
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		UPDATE [dbo].[Credentials] SET
			[user_name] = @user_name,
			[password]  = @password,
			[usn]       = @usn,
			[description] = @description,
			[visible] = @visible
		WHERE [id] = @id
	END

GO

--------------------------------------------------------------------------------
-- DeleteCredentials
PRINT N'Creating [dbo].[DeleteCredentials]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DeleteCredentials]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[DeleteCredentials]
GO

	CREATE PROCEDURE [dbo].[DeleteCredentials]
		@id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		DELETE FROM [dbo].[Credentials] WHERE [id] = @id
	END

GO

--------------------------------------------------------------------------------
-- SetHostCredentials
PRINT N'Creating [dbo].[SetHostCredentials]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[SetHostCredentials]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[SetHostCredentials]
GO

	CREATE PROCEDURE [dbo].[SetHostCredentials]
		@host_id uniqueidentifier,
		@credentials_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT
		
		UPDATE [dbo].[Hosts] SET
			[credentials_id] = @credentials_id,
			[usn]            = @usn
		WHERE [id] = @host_id
	END

GO

--------------------------------------------------------------------------------
-- UpdateSessionEndTime
PRINT N'Creating [dbo].[UpdateSessionEndTime]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateSessionEndTime]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateSessionEndTime]
GO

	CREATE PROCEDURE [dbo].[UpdateSessionEndTime]
			   @row_id uniqueidentifier,
			   @row_end_time datetime	
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT
		
		UPDATE [dbo].[Backup.Model.JobSessions] SET
			   [end_time]			=@row_end_time, 
			   [usn]                =@usn
			   WHERE [id] = @row_id
	           
	END	

GO

--------------------------------------------------------------------------------
-- SetPhysicalHostId
PRINT N'Creating [dbo].[SetPhysicalHostId]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[SetPhysicalHostId]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[SetPhysicalHostId]
GO

	CREATE PROCEDURE [dbo].[SetPhysicalHostId]
		@host_id uniqueidentifier,
		@physical_host_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		UPDATE 
			[dbo].[Hosts] 
		SET 
			[physical_host_id] = @physical_host_id,
			[usn] = @usn
		WHERE [id] = @host_id
	END

GO

--------------------------------------------------------------------------------
-- ReportSessionRetryCountView
PRINT N'Creating [dbo].[ReportSessionRetryCountView]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[ReportSessionRetryCountView]') AND type in (N'V'))
	DROP VIEW [dbo].[ReportSessionRetryCountView]
GO
--------------------------------------------------------------------------------
-- ReportFilteredSessionsView
PRINT N'Creating [dbo].[ReportFilteredSessionsView]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[ReportFilteredSessionsView]') AND type in (N'V'))
	DROP VIEW [dbo].[ReportFilteredSessionsView]
GO

	CREATE VIEW [dbo].[ReportFilteredSessionsView]
	AS
		SELECT  job_sess.id
      , job_sess.job_name
      , job_sess.job_type
      , job_sess.state
      , job_sess.creation_time
      , job_sess.end_time
      , job_sess.operation
      , job_sess.result
      , job_sess.progress
      , job_sess.usn
      , ISNULL(bk_sess.is_retry, 0) AS is_retry
      , ISNULL(bk_sess.is_startfull, 0) AS is_startfull
	  , ISNULL(bk_sess.transport_type, 0) AS transport_type
      , ROW_NUMBER() OVER (PARTITION BY job_sess.orig_session_id ORDER BY job_sess.creation_time ASC) - 1 [retry_count] 
	FROM [Backup.Model.JobSessions] job_sess
      LEFT JOIN [Backup.Model.BackupJobSessions] bk_sess ON job_sess.id = bk_sess.id


GO

--------------------------------------------------------------------------------
-- ReportFilteredSessionsDeleteView
PRINT N'Creating [dbo].[ReportFilteredSessionsDeleteView]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[ReportFilteredSessionsDeleteView]') AND type in (N'P'))
	DROP PROCEDURE [dbo].[ReportFilteredSessionsDeleteView]
GO

	CREATE PROCEDURE [dbo].[ReportFilteredSessionsDeleteView]
		@row_usn bigint
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT uid, usn FROM TombStones WHERE table_name= 'Backup.Model.JobSessions' AND usn > @row_usn
	END
	
GO

--------------------------------------------------------------------------------
-- CreateSessionFilter
PRINT N'Creating [dbo].[CreateSessionFilter]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[CreateSessionFilter]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[CreateSessionFilter]
GO

	CREATE PROCEDURE [dbo].[CreateSessionFilter]
		@row_id uniqueidentifier,
		@row_name nvarchar(max),
		@row_data xml
	AS
	BEGIN
		SET NOCOUNT ON;
			
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		INSERT INTO [dbo].[Backup.Model.Session.Filters]
			   ([id],[name],[data],[usn])
		VALUES
			   (@row_id,@row_name,@row_data,@usn)
	END	

GO

--------------------------------------------------------------------------------
-- GetSessionFilters
PRINT N'Creating [dbo].[GetSessionFilters]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetSessionFilters]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetSessionFilters]
GO

	CREATE PROCEDURE [dbo].[GetSessionFilters]
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[Backup.Model.Session.Filters]
	END

GO

--------------------------------------------------------------------------------
-- DeleteSessionFilter
PRINT N'Creating [dbo].[DeleteSessionFilter]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DeleteSessionFilter]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[DeleteSessionFilter]
GO

	CREATE PROCEDURE [dbo].[DeleteSessionFilter]
		@row_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		DELETE FROM [dbo].[Backup.Model.Session.Filters] WHERE [id] = @row_id
	END

GO

--------------------------------------------------------------------------------
-- SetHostParentId
PRINT N'Creating [dbo].[SetHostParentId]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[SetHostParentId]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[SetHostParentId]
GO

	CREATE PROCEDURE [dbo].[SetHostParentId]
		@host_id uniqueidentifier,
		@parent_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		UPDATE 
			[dbo].[Hosts] 
		SET 
			[parent_id] = @parent_id,
			[usn] = @usn
		where [id] = @host_id
	END

GO

--------------------------------------------------------------------------------
-- UpdateHostReference
PRINT N'Creating [dbo].[UpdateHostReference]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateHostReference]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateHostReference]
GO

	CREATE PROCEDURE [dbo].[UpdateHostReference]
		@host_id uniqueidentifier,
		@reference nvarchar(1024)
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		UPDATE 
			[dbo].[Hosts] 
		SET 
			[reference] = @reference,
			[usn] = @usn
		where [id] = @host_id
	END

GO

--------------------------------------------------------------------------------
-- DeleteHostInFolderByHost
PRINT N'Creating [dbo].[DeleteHostInFolderByHost]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DeleteHostInFolderByHost]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[DeleteHostInFolderByHost]
GO

	CREATE PROCEDURE [dbo].[DeleteHostInFolderByHost]
		@host_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		DELETE FROM [dbo].[Folder_Host] WHERE [host_id] = @host_id
	END

GO

--------------------------------------------------------------------------------
-- AddBackupProxy
PRINT N'Creating [dbo].[AddBackupProxy]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[AddBackupProxy]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[AddBackupProxy]
GO

	CREATE PROCEDURE [dbo].[AddBackupProxy]
		@id uniqueidentifier,
		@name nvarchar(max),
		@description nvarchar(max),
		@type int,
		@host_id uniqueidentifier,
		@options xml,
		@disabled bit
	AS
	BEGIN
		SET NOCOUNT ON;

		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		INSERT INTO [dbo].[BackupProxies]
			   ([id]
			   ,[name]
			   ,[description]
			   ,[type]
			   ,[host_id]
			   ,[options]
			   ,[usn]
			   ,[disabled])
		 VALUES
			   (@id,
				@name,
				@description,
				@type,
				@host_id,
				@options,
				@usn,
				@disabled)
	END

GO

--------------------------------------------------------------------------------
-- UpdateBackupProxy
PRINT N'Creating [dbo].[UpdateBackupProxy]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateBackupProxy]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateBackupProxy]
GO

	CREATE PROCEDURE [dbo].[UpdateBackupProxy]
			@id uniqueidentifier,
			@name nvarchar(max),
			@description nvarchar(max),
			@type int,
			@host_id uniqueidentifier,
			@options xml,
			@disabled bit
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		UPDATE [dbo].[BackupProxies] 
		SET
			   [name] = @name,
			   [description] = @description,
			   [type] = @type,
			   [host_id] = @host_id,
			   [options] = @options,
			   [usn] = @usn,
			   [disabled] = @disabled
		WHERE [id] = @id
	END

GO

--------------------------------------------------------------------------------
-- FindBackupProxyByIdAndType
PRINT N'Creating [dbo].[FindBackupProxyByIdAndType]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[FindBackupProxyByIdAndType]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[FindBackupProxyByIdAndType]
GO

	CREATE PROCEDURE [dbo].[FindBackupProxyByIdAndType]
		@id uniqueidentifier,
		@type int
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[BackupProxies] where [dbo].[BackupProxies].[id] = @id and [dbo].[BackupProxies].[type] = @type
	END
	
GO

--------------------------------------------------------------------------------
-- GetAllBackupProxies
PRINT N'Creating [dbo].[GetAllBackupProxies]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetAllBackupProxies]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetAllBackupProxies]
GO

	CREATE PROCEDURE [dbo].[GetAllBackupProxies]	
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[BackupProxies] 
		
	END

GO

--------------------------------------------------------------------------------
-- DeleteBackupProxy
PRINT N'Creating [dbo].[DeleteBackupProxy]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DeleteBackupProxy]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[DeleteBackupProxy]
GO

	CREATE PROCEDURE [dbo].[DeleteBackupProxy]
		@id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		DELETE FROM [dbo].[BackupProxies] WHERE [id] = @id
	END

GO

--------------------------------------------------------------------------------
-- IsHostRequiredUpgrade
PRINT N'Creating [dbo].[IsHostRequiredUpgrade]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[IsHostRequiredUpgrade]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[IsHostRequiredUpgrade]
GO

	CREATE PROCEDURE [dbo].[IsHostRequiredUpgrade]
		(@hostId uniqueidentifier)
	AS
	BEGIN
		SELECT [dbo].[fn.IsHostUpgradeRequired] (@hostId) retValue
	END

GO

--------------------------------------------------------------------------------
-- IsPhysicalHostRequiredUpgrade
PRINT N'Creating [dbo].[IsPhysicalHostUpgradeRequired]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[IsPhysicalHostUpgradeRequired]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[IsPhysicalHostUpgradeRequired]
GO

	CREATE PROCEDURE [dbo].[IsPhysicalHostUpgradeRequired]
		(@hostId uniqueidentifier)
	AS
	BEGIN
		SELECT [dbo].[fn.IsPhysicalHostUpgradeRequired] (@hostId) retValue
	END

GO

--------------------------------------------------------------------------------
-- ReportBackupProxiesView
PRINT N'Creating [dbo].[ReportBackupProxiesView]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[ReportBackupProxiesView]') AND type in (N'V'))
	DROP VIEW [dbo].[ReportBackupProxiesView]
GO

	CREATE VIEW [dbo].[ReportBackupProxiesView]
	AS
		SELECT     
			proxies.[id],
			proxies.[name], 
			proxies.[description],
			proxies.[type],
			proxies.[host_id],
			proxies.[options],
			[dbo].[MaxValue](hosts.[usn], proxies.[usn]) as [usn],
			proxies.[disabled],
			hosts.[name] as [host_name],
			[dbo].[fn.IsHostUpgradeRequired] (proxies.[host_id]) as [is_upgrade_required],
			proxies.[is_busy],
			proxies.[is_unavailable]
		FROM 
			[dbo].[BackupProxies] proxies LEFT JOIN [dbo].[Hosts] hosts ON proxies.[host_id] = hosts.[id]
		WHERE
			proxies.[type] <> '1'

GO

--------------------------------------------------------------------------------
-- ReportBackupProxiesDeleteView
PRINT N'Creating [dbo].[ReportBackupProxiesDeleteView]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[ReportBackupProxiesDeleteView]') AND type in (N'P'))
	DROP PROCEDURE [dbo].[ReportBackupProxiesDeleteView]
GO

	CREATE PROCEDURE [dbo].[ReportBackupProxiesDeleteView]
		@row_usn bigint
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT uid, usn FROM TombStones WHERE table_name= 'BackupProxies' AND usn > @row_usn
	END
	
GO

--------------------------------------------------------------------------------
-- ResolveHostDbIdByRef
PRINT N'Creating [dbo].[ResolveHostDbIdByRef]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[ResolveHostDbIdByRef]') AND type in (N'P'))
	DROP PROCEDURE [dbo].[ResolveHostDbIdByRef]
GO

	CREATE PROCEDURE [dbo].[ResolveHostDbIdByRef]
		@ref nvarchar(50)
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT 
			[dbo].[Hosts].[id]
		FROM [dbo].[Hosts]
		WHERE [dbo].[Hosts].[reference] = @ref
	END

GO

--------------------------------------------------------------------------------
-- GetAllJobProxies
PRINT N'Creating [dbo].[GetAllJobProxies]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetAllJobProxies]') AND type in (N'P'))
	DROP PROCEDURE [dbo].[GetAllJobProxies]
GO

	CREATE PROCEDURE [dbo].[GetAllJobProxies]
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[Backup.Model.JobProxies]
	END

GO

--------------------------------------------------------------------------------
-- FindBackupProxyByHostAndType
PRINT N'Creating [dbo].[FindBackupProxyByHostAndType]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[FindBackupProxyByHostAndType]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[FindBackupProxyByHostAndType]
GO

	CREATE PROCEDURE [dbo].[FindBackupProxyByHostAndType]
		@host_id uniqueidentifier,
		@type int
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT 
			* 
		FROM 
			[dbo].[BackupProxies] 
		WHERE 
			[dbo].[BackupProxies].[host_id] = @host_id AND
			[dbo].[BackupProxies].[type] = @type
	END

GO

--------------------------------------------------------------------------------
-- UpdateBackupProxyOptions
PRINT N'Creating [dbo].[UpdateBackupProxyOptions]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateBackupProxyOptions]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateBackupProxyOptions]
GO

	CREATE PROCEDURE [dbo].[UpdateBackupProxyOptions]
		@id uniqueidentifier,
		@options xml
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		UPDATE [dbo].[BackupProxies] SET
				[options] = @options,
				[usn] = @usn
		WHERE [id] = @id
			
	END	

GO

--------------------------------------------------------------------------------
-- DeleteJobProxy
PRINT N'Creating [dbo].[DeleteJobProxy]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DeleteJobProxy]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[DeleteJobProxy]
GO

	CREATE PROCEDURE [dbo].[DeleteJobProxy]
		@id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		DELETE FROM [dbo].[Backup.Model.JobProxies] WHERE [id] = @id
	END

GO

--------------------------------------------------------------------------------
-- CreateReplicaMapping
PRINT N'Creating [dbo].[CreateReplicaMapping]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[CreateReplicaMapping]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[CreateReplicaMapping]
GO

	CREATE PROCEDURE [dbo].[CreateReplicaMapping]
		@row_id uniqueidentifier,
		@row_job_id uniqueidentifier,
		@row_obj_id uniqueidentifier,
		@row_mapped_obj_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
			
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		INSERT INTO [dbo].[Backup.Model.VmReplica.Mapping]
			   ([id],[job_id],[obj_id],[mapped_obj_id],[usn])
		VALUES
			   (@row_id,@row_job_id,@row_obj_id,@row_mapped_obj_id,@usn)
	END	

GO

--------------------------------------------------------------------------------
-- GetReplicaMapping
PRINT N'Creating [dbo].[GetReplicaMapping]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetReplicaMapping]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetReplicaMapping]
GO

	CREATE PROCEDURE [dbo].[GetReplicaMapping]
		@row_job_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT * from [dbo].[Backup.Model.VmReplica.Mapping] where [job_id] = @row_job_id
	END

GO

--------------------------------------------------------------------------------
-- FindReplicaMapping
PRINT N'Creating [dbo].[FindReplicaMapping]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[FindReplicaMapping]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[FindReplicaMapping]
GO

	CREATE PROCEDURE [dbo].[FindReplicaMapping]
		@row_job_id uniqueidentifier,
		@row_obj_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT * 
		FROM [dbo].[Backup.Model.VmReplica.Mapping] 
		WHERE [job_id] = @row_job_id AND [obj_id] = @row_obj_id
	END

GO

--------------------------------------------------------------------------------
-- UpdateReplicaMapping
PRINT N'Creating [dbo].[UpdateReplicaMapping]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateReplicaMapping]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateReplicaMapping]
GO

	CREATE PROCEDURE [dbo].[UpdateReplicaMapping]
		@row_id uniqueidentifier,
		@row_job_id uniqueidentifier,
		@row_obj_id uniqueidentifier,
		@row_mapped_obj_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		UPDATE [dbo].[Backup.Model.VmReplica.Mapping] SET
				[job_id] = @row_job_id,
				[obj_id] = @row_obj_id,
				[mapped_obj_id] = @row_mapped_obj_id,
				[usn] = @usn
		WHERE [id] = @row_id
			
	END	

GO

--------------------------------------------------------------------------------
-- DeleteReplicaMapping
PRINT N'Creating [dbo].[DeleteReplicaMapping]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DeleteReplicaMapping]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[DeleteReplicaMapping]
GO

	CREATE PROCEDURE [dbo].[DeleteReplicaMapping]
		@row_job_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		DELETE FROM [dbo].[Backup.Model.VmReplica.Mapping] WHERE [job_id] = @row_job_id
	END

GO

--------------------------------------------------------------------------------
-- AddDisk
PRINT N'Creating [dbo].[AddDisk]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[AddDisk]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[AddDisk]
GO

	CREATE PROCEDURE [dbo].[AddDisk]
			   @id uniqueidentifier,
			   @name nvarchar(255),
			   @controllerInquiry nvarchar(1000),
			   @diskInquiry nvarchar(1000),
			   @diskId nvarchar(255)
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		INSERT INTO [dbo].[Disks]
			   ([id]
			   ,[name]
			   ,[controllerInquiry]
			   ,[diskInquiry]
			   ,[diskId]
			   ,[usn]
			   )
		 VALUES
			   (@id,
			   @name,
			   @controllerInquiry,
			   @diskInquiry,
			   @diskId,
			   @usn
			   )
	END	

GO

--------------------------------------------------------------------------------
-- UpdateDisk
PRINT N'Creating [dbo].[UpdateDisk]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateDisk]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateDisk]
GO

	CREATE PROCEDURE [dbo].[UpdateDisk]
		@id uniqueidentifier,
		@name nvarchar(255),
		@controllerInquiry nvarchar(1000),
		@diskInquiry nvarchar(1000),
		@diskId nvarchar(255)
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		UPDATE [dbo].[Disks] SET
			   [name] = @name,
			   [controllerInquiry]  = @controllerInquiry,
			   [diskInquiry] = @diskInquiry,
			   [diskId] = @diskId,
			   [usn] = @usn
		WHERE [id] = @id
	END

GO

--------------------------------------------------------------------------------
-- GetDisk
PRINT N'Creating [dbo].[GetDisk]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetDisk]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetDisk]
GO

	CREATE PROCEDURE [dbo].[GetDisk]
		@id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT 
			* 
		FROM 
			[dbo].[Disks] 
		WHERE 
			[dbo].[Disks].[id] = @id
	END

GO

--------------------------------------------------------------------------------
-- GetDiskByInquiry
PRINT N'Creating [dbo].[GetDiskByInquiry]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetDiskByInquiry]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetDiskByInquiry]
GO

	CREATE PROCEDURE [dbo].[GetDiskByInquiry]
		@inquiry nvarchar(1000)
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT 
			* 
		FROM 
			[dbo].[Disks] 
		WHERE 
			[dbo].[Disks].diskInquiry = @inquiry
	END

GO

--------------------------------------------------------------------------------
-- GetDiskByControllerInquiry
PRINT N'Creating [dbo].[GetDiskByControllerInquiry]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetDiskByControllerInquiry]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetDiskByControllerInquiry]
GO

	CREATE PROCEDURE [dbo].[GetDiskByControllerInquiry]
		@inquiry nvarchar(1000)
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT 
			* 
		FROM 
			[dbo].[Disks] 
		WHERE 
			[dbo].[Disks].[controllerInquiry] = @inquiry
	END

GO

--------------------------------------------------------------------------------
-- GetDisksByPhysHost
PRINT N'Creating [dbo].[GetDisksByPhysHost]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetDisksByPhysHost]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetDisksByPhysHost]
GO

	CREATE PROCEDURE [dbo].[GetDisksByPhysHost]
		@physhost_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT 
			[dbo].[Disks].* 
		FROM 
			[dbo].[Disks], 
			[dbo].[PhysHost_Disk] 
		WHERE 
			[dbo].[PhysHost_Disk].[physhost_id] = @physhost_id AND
			[dbo].[Disks].[id] = [dbo].[PhysHost_Disk].[disk_id]
	END

GO

--------------------------------------------------------------------------------
-- DeleteDisk
PRINT N'Creating [dbo].[DeleteDisk]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DeleteDisk]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[DeleteDisk]
GO

	CREATE PROCEDURE [dbo].[DeleteDisk]
		@id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		DELETE FROM [dbo].[Disks] WHERE [id] = @id
	END

GO

--------------------------------------------------------------------------------
-- AddPhysHostDisk
PRINT N'Creating [dbo].[AddPhysHostDisk]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[AddPhysHostDisk]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[AddPhysHostDisk]
GO

	CREATE PROCEDURE [dbo].[AddPhysHostDisk]
			   @id uniqueidentifier,
			   @physhost_id uniqueidentifier,
			   @disk_id uniqueidentifier,
			   @port int,
			   @path_id int,
			   @target_id int,
			   @lun int,
			   @add_type int,
			   @vms_count int,
			   @datastore_name nvarchar(max),
			   @is_auto_detected bit,
			   @is_manual_added bit
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		INSERT INTO [dbo].[PhysHost_Disk]
			   ([id]
			   ,[physhost_id]
			   ,[disk_id]
			   ,[port]
			   ,[path_id]
			   ,[target_id]
			   ,[lun]
			   ,[add_type]
			   ,[vms_count]
			   ,[usn]
			   ,[datastore_name]
			   ,[is_auto_detected]
			   ,[is_manual_added]
			   )
		 VALUES
			   (@id,
			   @physhost_id,
			   @disk_id,
			   @port,
			   @path_id,
			   @target_id,
			   @lun,
			   @add_type,
			   @vms_count,
			   @usn,
			   @datastore_name,
			   @is_auto_detected,
			   @is_manual_added
			   )
	END	

GO

--------------------------------------------------------------------------------
-- DeletePhysHostDisk
PRINT N'Creating [dbo].[DeletePhysHostDisk]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DeletePhysHostDisk]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[DeletePhysHostDisk]
GO

	CREATE PROCEDURE [dbo].[DeletePhysHostDisk]
		@id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		DELETE FROM [dbo].[PhysHost_Disk] WHERE [id] = @id
	END

GO

--------------------------------------------------------------------------------
-- GetPhysHostDisksByPhysHost
PRINT N'Creating [dbo].[GetPhysHostDisksByPhysHost]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetPhysHostDisksByPhysHost]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetPhysHostDisksByPhysHost]
GO

	CREATE PROCEDURE [dbo].[GetPhysHostDisksByPhysHost]
		@physhost_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT 
			* 
		FROM 
			[dbo].[PhysHost_Disk] 
		WHERE 
			[dbo].[PhysHost_Disk].[physhost_id] = @physhost_id
	END

GO

--------------------------------------------------------------------------------
-- AddVolume
PRINT N'Creating [dbo].[AddVolume]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[AddVolume]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[AddVolume]
GO

	CREATE PROCEDURE [dbo].[AddVolume]
			   @id uniqueidentifier,
			   @uid uniqueidentifier,
			   @type int,
			   @max_snapshots_count int
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		INSERT INTO [dbo].[Volumes]
			   ([id]
			   ,[uid]
			   ,[type]
			   ,[usn]
			   ,[max_hard_snapshots_count])
		 VALUES
			   (@id,
			   @uid,
			   @type,
			   @usn,
			   @max_snapshots_count
			   )
	END	

GO

--------------------------------------------------------------------------------
-- UpdateVolume
PRINT N'Creating [dbo].[UpdateVolume]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateVolume]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateVolume]
GO

	CREATE PROCEDURE [dbo].[UpdateVolume]
			   @id uniqueidentifier,
			   @uid uniqueidentifier,
			   @type int,
			   @max_snapshots_count int
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		UPDATE [dbo].[Volumes] SET
			   [uid] = @uid,
			   [type]  = @type,
			   [usn] = @usn,
			   [max_hard_snapshots_count] = @max_snapshots_count
		WHERE [id] = @id
	END

GO

--------------------------------------------------------------------------------
-- GetVolume
PRINT N'Creating [dbo].[GetVolume]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetVolume]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetVolume]
GO

	CREATE PROCEDURE [dbo].[GetVolume]
		@id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT 
			* 
		FROM 
			[dbo].[Volumes] 
		WHERE 
			[dbo].[Volumes].[id] = @id
	END

GO

--------------------------------------------------------------------------------
-- GetVolumesByPhysHost
PRINT N'Creating [dbo].[GetVolumesByPhysHost]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetVolumesByPhysHost]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetVolumesByPhysHost]
GO

	CREATE PROCEDURE [dbo].[GetVolumesByPhysHost]
		@physhost_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT 
			[dbo].[Volumes].* 
		FROM 
			[dbo].[Volumes], 
			[dbo].[PhysHost_Volume] 
		WHERE 
			[dbo].[PhysHost_Volume].[physhost_id] = @physhost_id AND
			[dbo].[Volumes].[id] = [dbo].[PhysHost_Volume].[volume_id]
	END

GO

--------------------------------------------------------------------------------
-- GetVolumesByPhysHostAndVolumeType
PRINT N'Creating [dbo].[GetVolumesByPhysHostAndVolumeType]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetVolumesByPhysHostAndVolumeType]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetVolumesByPhysHostAndVolumeType]
GO

	CREATE PROCEDURE [dbo].[GetVolumesByPhysHostAndVolumeType]
		@physhost_id uniqueidentifier,
		@volume_type int
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT 
			[dbo].[Volumes].* 
		FROM 
			[dbo].[Volumes], 
			[dbo].[PhysHost_Volume] 
		WHERE 
			[dbo].[PhysHost_Volume].[physhost_id] = @physhost_id AND
			[dbo].[Volumes].[id] = [dbo].[PhysHost_Volume].[volume_id] AND
			[dbo].[Volumes].[type] = @volume_type
	END

GO

--------------------------------------------------------------------------------
-- GetVolumeByUid
PRINT N'Creating [dbo].[GetVolumeByUid]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetVolumeByUid]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetVolumeByUid]
GO

	CREATE PROCEDURE [dbo].[GetVolumeByUid]
		@uid uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT 
			* 
		FROM 
			[dbo].[Volumes] 
		WHERE 
			[dbo].[Volumes].[uid] = @uid
	END

GO

--------------------------------------------------------------------------------
-- DeleteVolume
PRINT N'Creating [dbo].[DeleteVolume]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DeleteVolume]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[DeleteVolume]
GO

	CREATE PROCEDURE [dbo].[DeleteVolume]
		@id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		DELETE FROM [dbo].[Volumes] WHERE [id] = @id
	END

GO

--------------------------------------------------------------------------------
-- AddPhysHostVolume
PRINT N'Creating [dbo].[AddPhysHostVolume]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[AddPhysHostVolume]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[AddPhysHostVolume]
GO

	CREATE PROCEDURE [dbo].[AddPhysHostVolume]
			   @id uniqueidentifier,
			   @physhost_id uniqueidentifier,
			   @volume_id uniqueidentifier,
			   @mount_point nvarchar(1000),
			   @provider xml,
			   @provider_select_type int,
			   @add_type int,
			   @scsi_bus bigint,
			   @scsi_logical_unit bigint,
			   @scsi_port bigint,
			   @scsi_target_id bigint,
			   @max_snapshots_count int
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		INSERT INTO [dbo].[PhysHost_Volume]
			   ([id]
			   ,[physhost_id]
			   ,[volume_id]
			   ,[mount_point]
			   ,[provider]
			   ,[provider_select_type]
			   ,[add_type]
			   ,[usn]
			   ,[scsi_bus]
			   ,[scsi_logical_unit]
			   ,[scsi_port] 
			   ,[scsi_target_id]
			   ,[max_soft_snapshots_count])
		 VALUES
			   (@id,
			   @physhost_id,
			   @volume_id,
			   @mount_point,
			   @provider,
			   @provider_select_type,
			   @add_type,
			   @usn,
			   @scsi_bus ,
			   @scsi_logical_unit ,
			   @scsi_port ,
			   @scsi_target_id ,
			   @max_snapshots_count)
	END	

GO

--------------------------------------------------------------------------------
-- UpdatePhysHostVolume
PRINT N'Creating [dbo].[UpdatePhysHostVolume]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdatePhysHostVolume]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdatePhysHostVolume]
GO

	CREATE PROCEDURE [dbo].[UpdatePhysHostVolume]
			   @id uniqueidentifier,
			   @physhost_id uniqueidentifier,
			   @volume_id uniqueidentifier,
			   @mount_point nvarchar(1000),
			   @provider xml,
			   @provider_select_type int,
			   @add_type int,
			   @scsi_target_id int,
			   @max_snapshots_count int
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		UPDATE [dbo].[PhysHost_Volume] SET
			   [physhost_id] = @physhost_id,
			   [volume_id] = @volume_id,
			   [mount_point] = @mount_point,
			   [provider] = @provider,
			   [provider_select_type] = @provider_select_type,
			   [add_type] = @add_type,
			   [usn] = @usn,
			   [max_soft_snapshots_count]= @max_snapshots_count
		WHERE [id] = @id
	END

GO

--------------------------------------------------------------------------------
-- SetPhysHostVolumeProvider
PRINT N'Creating [dbo].[SetPhysHostVolumeProvider]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[SetPhysHostVolumeProvider]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[SetPhysHostVolumeProvider]
GO

	CREATE PROCEDURE [dbo].[SetPhysHostVolumeProvider]
			   @id uniqueidentifier,
			   @provider xml,
			   @provider_select_type int,
			   @max_snapshots_count int
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		UPDATE [dbo].[PhysHost_Volume] SET
			   [provider] = @provider,
			   [provider_select_type] = @provider_select_type,
			   [usn] = @usn,
			   [max_soft_snapshots_count] = @max_snapshots_count
		WHERE [id] = @id
	END

GO

--------------------------------------------------------------------------------
-- SetPhysHostVolumeMountPoint
PRINT N'Creating [dbo].[SetPhysHostVolumeMountPoint]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[SetPhysHostVolumeMountPoint]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[SetPhysHostVolumeMountPoint]
GO

	CREATE PROCEDURE [dbo].[SetPhysHostVolumeMountPoint]
			   @id uniqueidentifier,
			   @mount_point nvarchar(1000)
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		UPDATE [dbo].[PhysHost_Volume] SET
			   [mount_point] = @mount_point,
			   [usn] = @usn
		WHERE [id] = @id
	END

GO

--------------------------------------------------------------------------------
-- SetPhysHostDiskScsiId
PRINT N'Creating [dbo].[SetPhysHostDiskScsiId]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[SetPhysHostDiskScsiId]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[SetPhysHostDiskScsiId]
GO

	CREATE PROCEDURE [dbo].[SetPhysHostDiskScsiId]
			   @id uniqueidentifier,
			   @scsi_bus bigint,
			   @scsi_logical_unit bigint,
			   @scsi_port bigint,
			   @scsi_target_id bigint
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		UPDATE [dbo].[PhysHost_Volume] SET
			   [scsi_bus] = @scsi_bus,
			   [scsi_logical_unit] = @scsi_logical_unit,
			   [scsi_port] = @scsi_port,
			   [scsi_target_id] = @scsi_target_id,
			   [usn] = @usn
		WHERE [id] = @id
	END

GO

--------------------------------------------------------------------------------
-- DeletePhysHostVolume
PRINT N'Creating [dbo].[DeletePhysHostVolume]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DeletePhysHostVolume]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[DeletePhysHostVolume]
GO

	CREATE PROCEDURE [dbo].[DeletePhysHostVolume]
		@id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		DELETE FROM [dbo].[PhysHost_Volume] WHERE [id] = @id
	END

GO

--------------------------------------------------------------------------------
-- GetPhysHostVolume
PRINT N'Creating [dbo].[GetPhysHostVolume]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetPhysHostVolume]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetPhysHostVolume]
GO

	CREATE PROCEDURE [dbo].[GetPhysHostVolume]
		@id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT 
			* 
		FROM 
			[dbo].[PhysHost_Volume] 
		WHERE 
			[dbo].[PhysHost_Volume].[id] = @id
	END

GO

--------------------------------------------------------------------------------
-- GetPhysHostVolumesByPhysHost
PRINT N'Creating [dbo].[GetPhysHostVolumesByPhysHost]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetPhysHostVolumesByPhysHost]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetPhysHostVolumesByPhysHost]
GO

	CREATE PROCEDURE [dbo].[GetPhysHostVolumesByPhysHost]
		@physhost_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT 
			* 
		FROM 
			[dbo].[PhysHost_Volume] 
		WHERE 
			[dbo].[PhysHost_Volume].[physhost_id] = @physhost_id
	END

GO

--------------------------------------------------------------------------------
-- GetPhysHostVolumesByPhysHostAndVolume
PRINT N'Creating [dbo].[GetPhysHostVolumesByPhysHostAndVolume]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetPhysHostVolumesByPhysHostAndVolume]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetPhysHostVolumesByPhysHostAndVolume]
GO

	CREATE PROCEDURE [dbo].[GetPhysHostVolumesByPhysHostAndVolume]
		@physhost_id uniqueidentifier,
		@volume_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT 
			* 
		FROM 
			[dbo].[PhysHost_Volume]
		WHERE 
			[dbo].[PhysHost_Volume].[physhost_id] = @physhost_id AND
			[dbo].[PhysHost_Volume].[volume_id] = @volume_id
	END

GO

--------------------------------------------------------------------------------
-- GetPhysicalHostsByVolume
PRINT N'Creating [dbo].[GetPhysicalHostsByVolume]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetPhysicalHostsByVolume]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetPhysicalHostsByVolume]
GO

	CREATE PROCEDURE [dbo].[GetPhysicalHostsByVolume]
		@volume_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT 
			[dbo].[PhysicalHosts].* 
		FROM 
			[dbo].[PhysicalHosts],
			[dbo].[PhysHost_Volume] 
		WHERE 
			[dbo].[PhysHost_Volume].[volume_id] = @volume_id AND
			[dbo].[PhysHost_Volume].[physhost_id] = [dbo].[PhysicalHosts].[id]
	END

GO

--------------------------------------------------------------------------------
-- GetHostsByPhysicalHost
PRINT N'Creating [dbo].[GetHostsByPhysicalHost]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetHostsByPhysicalHost]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetHostsByPhysicalHost]
GO

	CREATE PROCEDURE [dbo].[GetHostsByPhysicalHost]
		@physical_host_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT 
			* 
		FROM 
			[dbo].[Hosts] 
		WHERE 
			[dbo].[Hosts].[physical_host_id] = @physical_host_id
	END

GO

--------------------------------------------------------------------------------
-- GetPhysicalHostByHost
PRINT N'Creating [dbo].[GetPhysicalHostByHost]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetPhysicalHostByHost]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetPhysicalHostByHost]
GO

	CREATE PROCEDURE [dbo].[GetPhysicalHostByHost]
		@host_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT 
			[dbo].[PhysicalHosts].* 
		FROM 
			[dbo].[PhysicalHosts],
			[dbo].[Hosts] 
		WHERE 
			[dbo].[Hosts].[id] = @host_id AND
			[dbo].[Hosts].[physical_host_id] = [dbo].[PhysicalHosts].[id]
	END

GO

--------------------------------------------------------------------------------
-- GetByDiskScsiIds
PRINT N'Creating [dbo].[GetByDiskScsiIds]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetByDiskScsiIds]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetByDiskScsiIds]
GO

	CREATE PROCEDURE [dbo].[GetByDiskScsiIds]
		@lun bigint,
		@port bigint,
		@target bigint
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT 
			* 
		FROM 
			[dbo].[PhysHost_Disk] 
		WHERE 
			[dbo].[PhysHost_Disk].[lun] = @lun AND
			[dbo].[PhysHost_Disk].[port] = @port AND
			[dbo].[PhysHost_Disk].[target_id] = @target
	END

GO

--------------------------------------------------------------------------------
-- GetPhysHostDisksByDiskId
PRINT N'Creating [dbo].[GetPhysHostDisksByDiskId]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetPhysHostDisksByDiskId]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetPhysHostDisksByDiskId]
GO

	CREATE PROCEDURE [dbo].[GetPhysHostDisksByDiskId]
		@disk_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT 
			* 
		FROM 
			[dbo].[PhysHost_Disk] 
		WHERE 
			[dbo].[PhysHost_Disk].[disk_id] = @disk_id
	END

GO

--------------------------------------------------------------------------------
-- GetPhysHostVolumesByVolumeId
PRINT N'Creating [dbo].[GetPhysHostVolumesByVolumeId]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetPhysHostVolumesByVolumeId]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetPhysHostVolumesByVolumeId]
GO

	CREATE PROCEDURE [dbo].[GetPhysHostVolumesByVolumeId]
		@volume_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT 
			* 
		FROM 
			[dbo].[PhysHost_Volume] 
		WHERE 
			[dbo].[PhysHost_Volume].[volume_id] = @volume_id
	END

GO

--------------------------------------------------------------------------------
-- AddJobProxy
PRINT N'Creating [dbo].[AddJobProxy]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[AddJobProxy]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[AddJobProxy]
GO

	CREATE PROCEDURE [dbo].[AddJobProxy]
			   @id uniqueidentifier,
			   @job_id uniqueidentifier,
			   @proxy_id uniqueidentifier,
			   @type int
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		INSERT INTO [dbo].[Backup.Model.JobProxies]
			   ([id]
			   ,[job_id]
			   ,[proxy_id]
			   ,[type]
			   ,[usn]
			   )
		 VALUES
			   (@id,
			   @job_id,
			   @proxy_id,
			   @type,
			   @usn
			   )
	END	

GO

--------------------------------------------------------------------------------
-- UpdateQMTaskProgress
PRINT N'Creating [dbo].[UpdateQMTaskProgress]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateQMTaskProgress]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateQMTaskProgress]
GO

	CREATE PROCEDURE [dbo].[UpdateQMTaskProgress]
			   @row_id uniqueidentifier,
			   @row_total_objects int,
			   @row_processed_objects int,
			   @row_total_size bigint,
			   @row_processed_size bigint,
			   @row_avg_speed bigint
	AS
	BEGIN
		SET NOCOUNT ON;

		declare @usn bigint	
		exec [dbo].[IncrementUsn] @usn OUTPUT
		
		UPDATE [dbo].[Backup.Model.QuickMigrationTaskSessions] SET
			   [total_objects]		=@row_total_objects,
			   [processed_objects]	=@row_processed_objects,
			   [total_size]			=@row_total_size,
			   [processed_size]		=@row_processed_size,
			   [avg_speed]			=@row_avg_speed,
			   [usn]                =@usn
		WHERE
			[id] = @row_id
	END

GO

--------------------------------------------------------------------------------
-- AddQMSessionInfoRow
PRINT N'Creating [dbo].[AddQMSessionInfoRow]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[AddQMSessionInfoRow]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[AddQMSessionInfoRow]
GO

	CREATE PROCEDURE [dbo].[AddQMSessionInfoRow]
			   @row_id uniqueidentifier,
			   @row_session_id uniqueidentifier,
			   @row_creation_time datetime,
			   @row_object_name nvarchar(2000),
			   @row_status int,
			   @row_reason ntext,
			   @row_object_id uniqueidentifier,
			   @row_end_time datetime,
			   @row_operation nvarchar(400),
			   @row_total_objects int,
			   @row_processed_objects int,
			   @row_total_size bigint,
			   @row_processed_size bigint,
			   @row_avg_speed bigint	
	AS
	BEGIN
		SET NOCOUNT ON;

		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		INSERT INTO [dbo].[Backup.Model.QuickMigrationTaskSessions]
			   ([id]
			   ,[session_id]
			   ,[creation_time]
			   ,[object_name]
			   ,[status]
			   ,[reason]
			   ,[object_id]
			   ,[end_time]
			   ,[operation]
			   ,[total_objects]
			   ,[processed_objects]
			   ,[total_size]
			   ,[processed_size]
			   ,[avg_speed]
			   ,[usn])
		 VALUES
			   (@row_id,
			   @row_session_id,
			   @row_creation_time,
			   @row_object_name,
			   @row_status,
			   @row_reason,
			   @row_object_id,
			   @row_end_time,
			   @row_operation,
			   @row_total_objects,
			   @row_processed_objects,
			   @row_total_size,
			   @row_processed_size,
			   @row_avg_speed,
			   @usn)
	END	

GO

--------------------------------------------------------------------------------
-- UpdateQMSessionInfoRow
PRINT N'Creating [dbo].[UpdateQMSessionInfoRow]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateQMSessionInfoRow]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateQMSessionInfoRow]
GO

	CREATE PROCEDURE [dbo].[UpdateQMSessionInfoRow]
			   @row_id uniqueidentifier,
			   @row_session_id uniqueidentifier,
			   @row_creation_time datetime,
			   @row_object_name nvarchar(2000),
			   @row_status int,
			   @row_reason ntext,
			   @row_object_id uniqueidentifier,
			   @row_end_time datetime,
			   @row_operation nvarchar(400),
			   @row_total_objects int,
			   @row_processed_objects int,
			   @row_total_size bigint,
			   @row_processed_size bigint,
			   @row_avg_speed bigint	
	AS
	BEGIN
		SET NOCOUNT ON;

		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		UPDATE [dbo].[Backup.Model.QuickMigrationTaskSessions] SET
			   [session_id]			=@row_session_id,
			   [creation_time]		=@row_creation_time,
			   [object_name]		=@row_object_name,
			   [status]				=@row_status,
			   [reason]				=@row_reason,
			   [object_id]			=@row_object_id,
			   [end_time]			=@row_end_time,
			   [operation]			=@row_operation,
			   [total_objects]		=@row_total_objects,
			   [processed_objects]	=@row_processed_objects,
			   [total_size]			=@row_total_size,
			   [processed_size]		=@row_processed_size,
			   [avg_speed]			=@row_avg_speed,
			   [usn]                =@usn
		WHERE
			[id] = @row_id
	END

GO

--------------------------------------------------------------------------------
-- GetQMSessionInfo
PRINT N'Creating [dbo].[GetQMSessionInfo]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetQMSessionInfo]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetQMSessionInfo]
GO

	CREATE PROCEDURE [dbo].[GetQMSessionInfo]
		@row_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[Backup.Model.QuickMigrationTaskSessions] where [id] = @row_id
	END

GO

--------------------------------------------------------------------------------
-- GetQMSessionInfos
PRINT N'Creating [dbo].[GetQMSessionInfos]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetQMSessionInfos]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetQMSessionInfos]
GO

	CREATE PROCEDURE [dbo].[GetQMSessionInfos]
		@row_session_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[Backup.Model.QuickMigrationTaskSessions] where [session_id] = @row_session_id
	END

GO

--------------------------------------------------------------------------------
-- GetQMSession
PRINT N'Creating [dbo].[GetQMSession]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetQMSession]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetQMSession]
GO

	CREATE PROCEDURE [dbo].[GetQMSession]
		@row_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT *
		FROM [dbo].[Backup.Model.QuickMigrationSessions] RIGHT JOIN [dbo].[Backup.Model.JobSessions]
		ON [dbo].[Backup.Model.QuickMigrationSessions].[id] = [dbo].[Backup.Model.JobSessions].[id]
		WHERE [dbo].[Backup.Model.QuickMigrationSessions].[id] = @row_id
	END

GO

--------------------------------------------------------------------------------
-- ReportQMSessionTaskView
PRINT N'Creating [dbo].[ReportQMSessionTaskView]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[ReportQMSessionTaskView]') AND type in (N'V'))
	DROP VIEW [dbo].[ReportQMSessionTaskView]
GO

	CREATE VIEW [dbo].[ReportQMSessionTaskView]
	AS
		SELECT     
			[dbo].[Backup.Model.QuickMigrationTaskSessions].[id],
			[dbo].[Backup.Model.QuickMigrationTaskSessions].[session_id], 
			[dbo].[Backup.Model.QuickMigrationTaskSessions].[status],
			[dbo].[Backup.Model.QuickMigrationTaskSessions].[creation_time],
			[dbo].[Backup.Model.QuickMigrationTaskSessions].[end_time],
			[dbo].[Backup.Model.QuickMigrationTaskSessions].[object_id],
			[dbo].[Backup.Model.QuickMigrationTaskSessions].[object_name],
			[dbo].[Backup.Model.QuickMigrationTaskSessions].[total_objects],
			[dbo].[Backup.Model.QuickMigrationTaskSessions].[processed_objects],
			[dbo].[Backup.Model.QuickMigrationTaskSessions].[total_size],
			[dbo].[Backup.Model.QuickMigrationTaskSessions].[processed_size],
			[dbo].[Backup.Model.QuickMigrationTaskSessions].[avg_speed],
			[dbo].[Backup.Model.QuickMigrationTaskSessions].[operation],
			[dbo].[Backup.Model.QuickMigrationTaskSessions].[reason],
			[dbo].[Backup.Model.QuickMigrationTaskSessions].[usn]
		FROM [dbo].[Backup.Model.QuickMigrationTaskSessions]

GO

--------------------------------------------------------------------------------
-- ReportQMSessionTaskDeleteView
PRINT N'Creating [dbo].[ReportQMSessionTaskDeleteView]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[ReportQMSessionTaskDeleteView]') AND type in (N'P'))
	DROP PROCEDURE [dbo].[ReportQMSessionTaskDeleteView]
GO

	CREATE PROCEDURE [dbo].[ReportQMSessionTaskDeleteView]
		@row_usn bigint
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT uid FROM TombStones WHERE table_name= 'Backup.Model.QuickMigrationTaskSessions' AND usn > @row_usn
	END

GO

--------------------------------------------------------------------------------
-- AddQMTaskSessionXmlLog
PRINT N'Creating [dbo].[AddQMTaskSessionXmlLog]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[AddQMTaskSessionXmlLog]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[AddQMTaskSessionXmlLog]
GO

	CREATE PROCEDURE [dbo].[AddQMTaskSessionXmlLog]	
				@row_session_id uniqueidentifier,
				@row_cookie nvarchar(100),
				@row_time nvarchar(100),
				@row_utc_time nvarchar(100),
				@row_status nvarchar(10),
				@row_style nvarchar(10),
				@row_title nvarchar(512),
				@row_desc nvarchar(512),
				@row_start_time nvarchar(100)
	AS
	BEGIN
		SET NOCOUNT ON;
		
		--Select log
		DECLARE @myDoc xml 
		SET @myDoc = (SELECT [log_xml]
		FROM [dbo].[Backup.Model.QuickMigrationTaskSessions]
		WHERE [id] = @row_session_id)
		
		--Get new log line
		DECLARE @newXmlLogLine xml 
		SET @newXmlLogLine = N'<Log Id="" Usn="0" Cookie="" Status="" Style="" Time="" UtcTime="" StartTime=""><Title>new</Title><Description>new</Description></Log>'  

		--Calc new id and usn
		DECLARE @new_id bigint 
		SET @new_id = @myDoc.value('(/Root/@TotalId)[1]', 'bigint' ) + 1

		--Update log line
		SET @newXmlLogLine.modify('replace value of (/Log/@Id)[1] with sql:variable("@new_id")')
		SET @newXmlLogLine.modify('replace value of (/Log/@Cookie)[1] with sql:variable("@row_cookie")')
		SET @newXmlLogLine.modify('replace value of (/Log/@Status)[1] with sql:variable("@row_status")')
		SET @newXmlLogLine.modify('replace value of (/Log/@Style)[1] with sql:variable("@row_style")')
		SET @newXmlLogLine.modify('replace value of (/Log/@Time)[1] with sql:variable("@row_time")')
		SET @newXmlLogLine.modify('replace value of (/Log/@UtcTime)[1] with sql:variable("@row_utc_time")')
		SET @newXmlLogLine.modify('replace value of (/Log/Title[1]/text())[1] with sql:variable("@row_title")')
		SET @newXmlLogLine.modify('replace value of (/Log/Description[1]/text())[1] with sql:variable("@row_desc")')
		SET @newXmlLogLine.modify('replace value of (/Log/@StartTime)[1] with sql:variable("@row_start_time")')

		--Update log	
		SET @myDoc.modify('replace value of (/Root/@TotalId)[1] with sql:variable("@new_id")')
		--SET @myDoc.modify('insert sql:variable("@newXmlLogLine") as last into (/Root)[1]')
		SET @myDoc = [dbo].f_insert_as_first(@myDoc, @newXmlLogLine)		
			
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		--Update log
		UPDATE [dbo].[Backup.Model.QuickMigrationTaskSessions] 
		SET
			[log_xml] = @myDoc,
			[usn]     = @usn
		WHERE [id] = @row_session_id			
		
		SELECT @new_id as [id]
	END  

GO


--------------------------------------------------------------------------------
-- GetQMTaskSessionXmlLogMaxUsn

PRINT N'Creating [dbo].[GetQMTaskSessionXmlLogMaxUsn]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetQMTaskSessionXmlLogMaxUsn]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetQMTaskSessionXmlLogMaxUsn]
GO

	CREATE PROCEDURE [dbo].[GetQMTaskSessionXmlLogMaxUsn]	
				@row_session_id uniqueidentifier				
	AS
	BEGIN
		SET NOCOUNT ON;
		
		--Select log
		DECLARE @myDoc xml 
		SET @myDoc = (SELECT [log_xml]
		FROM [dbo].[Backup.Model.QuickMigrationTaskSessions]
		WHERE [id] = @row_session_id)
		
		
		--Calc new id and usn
		DECLARE @max_usn bigint 
		SET @max_usn = @myDoc.value('(/Root/@TotalId)[1]', 'bigint' )
		
			
		SELECT @max_usn as [usn]
	END  
GO



--------------------------------------------------------------------------------
-- UpdateQMTaskSessionXmlLog
PRINT N'Creating [dbo].[UpdateQMTaskSessionXmlLog]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateQMTaskSessionXmlLog]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateQMTaskSessionXmlLog]
GO

	CREATE PROCEDURE [dbo].[UpdateQMTaskSessionXmlLog]	
				@row_session_id uniqueidentifier,
				@row_log_id bigint,
				@row_time nvarchar(100),
				@row_utc_time nvarchar(100),
				@row_status nvarchar(10),
				@row_title nvarchar(512),
				@row_desc nvarchar(512)
	AS
	BEGIN
		SET NOCOUNT ON;	
		
		--Select log
		DECLARE @myDoc xml 
		SET @myDoc = (SELECT [log_xml]
		FROM [dbo].[Backup.Model.QuickMigrationTaskSessions]
		WHERE [id] = @row_session_id)
		
		--Get new log line
		DECLARE @newXmlLogLine xml 
		SET @newXmlLogLine = (SELECT @myDoc.query('/Root/Log[@Id = sql:variable("@row_log_id")]'))

		--Calc new id and usn
		DECLARE @new_usn bigint 
		SET @new_usn = @myDoc.value('(/Root/@TotalUsn)[1]', 'bigint' ) + 1
		
		--Update log line
		SET @newXmlLogLine.modify('replace value of (/Log/@Usn)[1] with sql:variable("@new_usn")')
		SET @newXmlLogLine.modify('replace value of (/Log/@Status)[1] with sql:variable("@row_status")')
		SET @newXmlLogLine.modify('replace value of (/Log/@Time)[1] with sql:variable("@row_time")')
		SET @newXmlLogLine.modify('replace value of (/Log/@UtcTime)[1] with sql:variable("@row_utc_time")')
		SET @newXmlLogLine.modify('replace value of (/Log/Title[1]/text())[1] with sql:variable("@row_title")')
		SET @newXmlLogLine.modify('replace value of (/Log/Description[1]/text())[1] with sql:variable("@row_desc")')

		--Update log
		SET @myDoc.modify('delete (/Root/Log[@Id = sql:variable("@row_log_id")])')
		SET @myDoc.modify('replace value of (/Root/@TotalUsn)[1] with sql:variable("@new_usn")')
		--SET @myDoc.modify('insert sql:variable("@newXmlLogLine") as last into (/Root)[1]')
		SET @myDoc = [dbo].f_insert_as_first(@myDoc, @newXmlLogLine)	
			
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		--Update log
		UPDATE [dbo].[Backup.Model.QuickMigrationTaskSessions] 
		SET
			[log_xml] = @myDoc,
			[usn]     = @usn		
		WHERE [id] = @row_session_id	
		
		SELECT @new_usn as [usn]
	END  

GO

--------------------------------------------------------------------------------
-- GetQMTaskSessionXmlLog
PRINT N'Creating [dbo].[GetQMTaskSessionXmlLog]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetQMTaskSessionXmlLog]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetQMTaskSessionXmlLog]
GO

	CREATE PROCEDURE [dbo].[GetQMTaskSessionXmlLog]	
				@row_session_id uniqueidentifier,
				@row_usn bigint
	AS
	BEGIN
		SET NOCOUNT ON;
		
		DECLARE @myDoc xml 
		SET @myDoc = '<Root TotalUsn="0"></Root>'
		
		DECLARE @newXmlLogLine xml 
		SET @newXmlLogLine = (SELECT [log_xml].query('/Root/Log[@Usn >= sql:variable("@row_usn")]')
		FROM [dbo].[Backup.Model.QuickMigrationTaskSessions]
		WHERE [id] = @row_session_id)
		
		SET @newXmlLogLine = '<Logs>' + CONVERT(nvarchar(max), @newXmlLogLine) + '</Logs>'
		SET @myDoc.modify('replace value of (/Root/@TotalUsn)[1] with sql:variable("@row_usn")')
		--SET @myDoc.modify('insert sql:variable("@newXmlLogLine") as last into (/Root)[1]')
		SET @myDoc = [dbo].f_insert_as_first(@myDoc, @newXmlLogLine)
		
		SELECT @myDoc
	END  

GO

--------------------------------------------------------------------------------
-- FindInQMTaskSessionXmlLog
PRINT N'Creating [dbo].[FindInQMTaskSessionXmlLog]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[FindInQMTaskSessionXmlLog]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[FindInQMTaskSessionXmlLog]
GO

	CREATE PROCEDURE [dbo].[FindInQMTaskSessionXmlLog]
				@sessionId	uniqueidentifier,			
				@cookie		nvarchar( 255 ),
				@status     nvarchar( 40 )
	AS
	BEGIN
		SET NOCOUNT ON;
		
		DECLARE @recsWithCookie XML
			
		IF @cookie IS NOT NULL AND @cookie <> N'' AND @status IS NOT NULL AND @status <> N''
			BEGIN
				SET @recsWithCookie = (SELECT [log_xml].query('/Root/Log[@Cookie = sql:variable("@cookie")][@Status = sql:variable("@status")]' )
				FROM [dbo].[Backup.Model.QuickMigrationTaskSessions]
				WHERE [id] = @sessionId )

			END
		ELSE  IF @cookie IS NOT NULL AND @cookie <> N''
				BEGIN
					SET @recsWithCookie = (SELECT [log_xml].query( '/Root/Log[@Cookie = sql:variable("@cookie")]' )
					FROM [dbo].[Backup.Model.QuickMigrationTaskSessions]
					WHERE [id] = @sessionId )
				
			END
		ELSE
			BEGIN
				SET @recsWithCookie = (SELECT [log_xml].query( '/Root/Log[@Status = sql:variable("@status")]' )
				FROM [dbo].[Backup.Model.QuickMigrationTaskSessions]
				WHERE [id] = @sessionId )
				
			END
		
		SELECT [Id] = T.Item.value('@Id', 'bigint' )
		FROM  @recsWithCookie.nodes('/Log') AS T(Item)
		
	END  

GO

--------------------------------------------------------------------------------
-- UpdateQMTaskSessionXmlLogStatus
PRINT N'Creating [dbo].[UpdateQMTaskSessionXmlLogStatus]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateQMTaskSessionXmlLogStatus]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateQMTaskSessionXmlLogStatus]
GO

	CREATE PROCEDURE [dbo].[UpdateQMTaskSessionXmlLogStatus]	
				@row_session_id uniqueidentifier,		
				@row_log_id bigint,	
				@row_time nvarchar(100),
				@row_utc_time nvarchar(100),
				@row_status nvarchar(10),			
				@row_desc nvarchar(512)
	AS
	BEGIN
		SET NOCOUNT ON;	
		
		--Select log
		DECLARE @myDoc xml
		SET @myDoc = (SELECT [log_xml]
		FROM [dbo].[Backup.Model.QuickMigrationTaskSessions]
		WHERE [id] = @row_session_id)
		
		--Get new log line
		DECLARE @newXmlLogLine xml 
		SET @newXmlLogLine = (SELECT @myDoc.query('/Root/Log[@Id = sql:variable("@row_log_id")]'))
		

		--Calc new id and usn
		DECLARE @new_usn bigint
		SET @new_usn = @myDoc.value('(/Root/@TotalUsn)[1]', 'bigint' ) + 1
		
		--Update log line
		SET @newXmlLogLine.modify('replace value of (/Log/@Usn)[1] with sql:variable("@new_usn")')
		SET @newXmlLogLine.modify('replace value of (/Log/@Status)[1] with sql:variable("@row_status")')
		SET @newXmlLogLine.modify('replace value of (/Log/@Time)[1] with sql:variable("@row_time")')
		SET @newXmlLogLine.modify('replace value of (/Log/@UtcTime)[1] with sql:variable("@row_utc_time")')	
		SET @newXmlLogLine.modify('replace value of (/Log/Description[1]/text())[1] with sql:variable("@row_desc")')


		--Update log
		SET @myDoc.modify('delete (/Root/Log[@Id = sql:variable("@row_log_id")])')
		SET @myDoc.modify('replace value of (/Root/@TotalUsn)[1] with sql:variable("@new_usn")')
		--SET @myDoc.modify('insert sql:variable("@newXmlLogLine") as last into (/Root)[1]')
		SET @myDoc = [dbo].f_insert_as_first(@myDoc, @newXmlLogLine)
			
		declare @usn bigint

		--Update log
		exec [dbo].[IncrementUsn] @usn OUTPUT
		UPDATE [dbo].[Backup.Model.QuickMigrationTaskSessions] 
		SET
			[log_xml] = @myDoc,
			[usn]     = @usn
		WHERE [id] = @row_session_id	
		
		SELECT @new_usn as [usn]
	END  

GO

--------------------------------------------------------------------------------
-- UpdateQMTaskSessionXmlLogStatusOnly
PRINT N'Creating [dbo].[UpdateQMTaskSessionXmlLogStatusOnly]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateQMTaskSessionXmlLogStatusOnly]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateQMTaskSessionXmlLogStatusOnly]
GO

	CREATE PROCEDURE [dbo].[UpdateQMTaskSessionXmlLogStatusOnly]	
				@row_session_id uniqueidentifier,
				@row_log_id bigint,
				@row_status nvarchar(10)
	AS
	BEGIN
		SET NOCOUNT ON;	
		
		--Select log
		DECLARE @myDoc xml
		SET @myDoc = (SELECT [log_xml]
		FROM [dbo].[Backup.Model.QuickMigrationTaskSessions]
		WHERE [id] = @row_session_id)
		
		--Get new log line
		DECLARE @newXmlLogLine xml 
		SET @newXmlLogLine = (SELECT @myDoc.query('/Root/Log[@Id = sql:variable("@row_log_id")]'))
		

		--Calc new id and usn
		DECLARE @new_usn bigint
		SET @new_usn = @myDoc.value('(/Root/@TotalUsn)[1]', 'bigint' ) + 1
		
		--Update log line
		SET @newXmlLogLine.modify('replace value of (/Log/@Usn)[1] with sql:variable("@new_usn")')
		SET @newXmlLogLine.modify('replace value of (/Log/@Status)[1] with sql:variable("@row_status")')

		--Update log
		SET @myDoc.modify('delete (/Root/Log[@Id = sql:variable("@row_log_id")])')
		SET @myDoc.modify('replace value of (/Root/@TotalUsn)[1] with sql:variable("@new_usn")')
		SET @myDoc = [dbo].f_insert_as_first(@myDoc, @newXmlLogLine)
			
		declare @usn bigint

		--Update log
		exec [dbo].[IncrementUsn] @usn OUTPUT
		UPDATE [dbo].[Backup.Model.QuickMigrationTaskSessions] 
		SET
			[log_xml] = @myDoc,
			[usn]     = @usn
		WHERE [id] = @row_session_id	
		
		SELECT @new_usn as [usn]
	END  

GO

--------------------------------------------------------------------------------
-- UpdateQMJobProgress
PRINT N'Creating [dbo].[UpdateQMJobProgress]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateQMJobProgress]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateQMJobProgress]
GO

	CREATE PROCEDURE [dbo].[UpdateQMJobProgress]
			   @row_id uniqueidentifier,
			   @row_progress int,
			   @row_total_objects int,
			   @row_processed_objects int,
			   @row_total_size bigint,
			   @row_processed_size bigint,
			   @row_avg_speed bigint           
	AS
	BEGIN
		SET NOCOUNT ON;

		declare @usn bigint	
		
		exec [dbo].[IncrementUsn] @usn OUTPUT
		UPDATE [dbo].[Backup.Model.QuickMigrationJobSessions] SET
		   [total_objects]		=@row_total_objects,
		   [processed_objects]	=@row_processed_objects,
		   [total_size]			=@row_total_size,
		   [processed_size]		=@row_processed_size,
		   [avg_speed]			=@row_avg_speed,
		   [usn]                =@usn
		   WHERE [id] = @row_id
	       
		exec [dbo].[IncrementUsn] @usn OUTPUT
		UPDATE [dbo].[Backup.Model.JobSessions] SET
		   [progress]			=@row_progress,
		   [usn]                =@usn
		   WHERE [id] = @row_id
	           
	END	

GO

--------------------------------------------------------------------------------
-- GetPhysHostCsvByCluster
PRINT N'Creating [dbo].[GetPhysHostCsvByCluster]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetPhysHostCsvByCluster]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetPhysHostCsvByCluster]
GO

	CREATE PROCEDURE [dbo].[GetPhysHostCsvByCluster]
		@cluster_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
	SELECT
		phv.*
	FROM
		[dbo].[PhysHost_Volume] phv,
		(
		SELECT id, (row_number() over (partition by volume_id order by volume_id)) rn  from [dbo].[PhysHost_Volume]
		) o (id, rn),
		[dbo].[Volumes]
	WHERE
		o.id = phv.id and o.rn = 1 and
		[dbo].[Volumes].[type] = 1 AND
		[dbo].[Volumes].[id] = phv.[volume_id] AND
		phv.[physhost_id] in
		(
		SELECT 
			[dbo].[Hosts].[physical_host_id] 
		FROM 
			[dbo].[Hosts] 
		WHERE 
			[dbo].[Hosts].[parent_id] = @cluster_id
		)
	END

GO

--------------------------------------------------------------------------------
-- GetPhysHostVolumesByPhysHostAndVolumeType
PRINT N'Creating [dbo].[GetPhysHostVolumesByPhysHostAndVolumeType]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetPhysHostVolumesByPhysHostAndVolumeType]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetPhysHostVolumesByPhysHostAndVolumeType]
GO

	CREATE PROCEDURE [dbo].[GetPhysHostVolumesByPhysHostAndVolumeType]
		@physhost_id uniqueidentifier,
		@volume_type int
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT 
			phv.* 
		FROM 
			[dbo].[PhysHost_Volume] phv,
			[dbo].[Volumes] v
		WHERE 
			phv.[physhost_id] = @physhost_id AND
			phv.[volume_id] = v.[id] AND
			v.[type] = @volume_type
	END

GO

--------------------------------------------------------------------------------
-- GetPhysHostVolumesByVolume
PRINT N'Creating [dbo].[GetPhysHostVolumesByVolume]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetPhysHostVolumesByVolume]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetPhysHostVolumesByVolume]
GO

	CREATE PROCEDURE [dbo].[GetPhysHostVolumesByVolume]
		@volume_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT 
			* 
		FROM 
			[dbo].[PhysHost_Volume] 
		WHERE 
			[dbo].[PhysHost_Volume].[volume_id] = @volume_id
	END

GO

--------------------------------------------------------------------------------
-- GetHostByPhysHostAndHostType
PRINT N'Creating [dbo].[GetHostByPhysHostAndHostType]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetHostByPhysHostAndHostType]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetHostByPhysHostAndHostType]
GO

	CREATE PROCEDURE [dbo].[GetHostByPhysHostAndHostType]
		@physhost_id uniqueidentifier,
		@host_type int
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT 
			* 
		FROM
			[dbo].[Hosts] 
		WHERE 
			[dbo].[Hosts].[physical_host_id] = @physhost_id AND
			[dbo].[Hosts].[type] = @host_type
	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.FindTopUncorruptedObjects
PRINT N'Creating [dbo].[Backup.Model.FindTopUncorruptedObjects]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.FindTopUncorruptedObjects]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.FindTopUncorruptedObjects]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.FindTopUncorruptedObjects]
		@count int,
		@obj_type int,
		@target_type int,
		@obj_name_criteria nvarchar(2000)
	AS
	BEGIN
		SET NOCOUNT ON;
					
		SELECT obj.* FROM [dbo].[BObjects] obj WHERE obj.id IN
			(SELECT DISTINCT TOP (@count) obj.id
				FROM [dbo].[BObjects] obj
					INNER JOIN [dbo].[Backup.Model.OIBs] oib ON obj.id = oib.[object_id]
					INNER JOIN [dbo].[Backup.Model.Points] pnt ON oib.point_id = pnt.id
					INNER JOIN [dbo].[Backup.Model.Backups] _backup ON pnt.backup_id = _backup.id
			WHERE obj.[type] = @obj_type AND _backup.target_type = @target_type AND oib.is_corrupted = 0 
				AND obj.[object_name] LIKE '%' + @obj_name_criteria + '%')
		ORDER BY obj.[object_name]
	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.GetBackupsByObjectId
PRINT N'Creating [dbo].[Backup.Model.GetBackupsByObjectId]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetBackupsByObjectId]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetBackupsByObjectId]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetBackupsByObjectId]
		@obj_id uniqueidentifier
	AS
	BEGIN 
		SET NOCOUNT ON;
				
		SELECT DISTINCT _backup.* 
			FROM [Backup.Model.Backups] _backup 
				INNER JOIN [Backup.Model.Points] pnt ON _backup.[id] = pnt.[backup_id]
				INNER JOIN [Backup.Model.OIBs] oib ON pnt.[id] = oib.[point_id]
		WHERE oib.[object_id] = @obj_id
	END

GO

--------------------------------------------------------------------------------
-- SetPhysHostVolumeAddType
PRINT N'Creating [dbo].[SetPhysHostVolumeAddType]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[SetPhysHostVolumeAddType]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[SetPhysHostVolumeAddType]
GO

	CREATE PROCEDURE [dbo].[SetPhysHostVolumeAddType]
			   @id uniqueidentifier,
			   @add_type int
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		UPDATE [dbo].[PhysHost_Volume] SET
			   [add_type] = @add_type,
			   [usn] = @usn
		WHERE [id] = @id
	END

GO

--------------------------------------------------------------------------------
-- GetChildHosts
PRINT N'Creating [dbo].[GetChildHosts]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetChildHosts]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetChildHosts]
GO

	CREATE PROCEDURE [dbo].[GetChildHosts]
		@parent_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT 
			* 
		FROM
			[dbo].[Hosts] 
		WHERE 
			[dbo].[Hosts].[parent_id] = @parent_id
	END

GO

--------------------------------------------------------------------------------
-- UpdateHostDescription
PRINT N'Creating [dbo].[UpdateHostDescription]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateHostDescription]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateHostDescription]
GO

	CREATE PROCEDURE [dbo].[UpdateHostDescription]
		@id uniqueidentifier,
		@description nvarchar(1024)
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		UPDATE [dbo].[Hosts] SET
				[description] = @description,
				[usn] = @usn
		WHERE [id] = @id
			
	END	

GO

--------------------------------------------------------------------------------
-- UpdateBackupProxyDescription
PRINT N'Creating [dbo].[UpdateBackupProxyDescription]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateBackupProxyDescription]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateBackupProxyDescription]
GO

	CREATE PROCEDURE [dbo].[UpdateBackupProxyDescription]
		@id uniqueidentifier,
		@description nvarchar(max)
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		UPDATE [dbo].[BackupProxies] SET
				[description] = @description,
				[usn] = @usn
		WHERE [id] = @id
			
	END	

GO

--------------------------------------------------------------------------------
-- Backup.Model.GetBackupsInRepository
PRINT N'Creating [dbo].[Backup.Model.GetBackupsInRepository]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetBackupsInRepository]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetBackupsInRepository]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetBackupsInRepository]
		@repositoryId uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;	
		select * from 
			[dbo].[Backup.Model.Backups]
		where
			repository_id = @repositoryId		
	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.GetLastUncorruptedOibForObjectInBackup
PRINT N'Creating [dbo].[Backup.Model.GetLastUncorruptedOibForObjectInBackup]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetLastUncorruptedOibForObjectInBackup]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetLastUncorruptedOibForObjectInBackup]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetLastUncorruptedOibForObjectInBackup]
		@object_id uniqueidentifier,
		@backup_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;	
		select top 1 oib.* from 
			[dbo].[Backup.Model.OIBs] oib,
			[dbo].[Backup.Model.Points] pnt,
			[dbo].[BObjects] obj	
		where 
			oib.point_id = pnt.id and
			pnt.backup_id = @backup_id and
			oib.object_id = obj.id and	
			(oib.is_corrupted = 0 and 
			((obj.platform != 4 or obj.Type != 3) or oib.is_consistent = 1)) and
			obj.id = @object_id
		order by oib.creation_time desc
	END


GO

--------------------------------------------------------------------------------
-- UpdatePhysHostDiskVmsCount
PRINT N'Creating [dbo].[UpdatePhysHostDiskVmsCount]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdatePhysHostDiskVmsCount]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdatePhysHostDiskVmsCount]
GO

	CREATE PROCEDURE [dbo].[UpdatePhysHostDiskVmsCount]
			   @id uniqueidentifier,
			   @vms_count int
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		UPDATE [dbo].[PhysHost_Disk] SET
			   [vms_count] = @vms_count,
			   [usn] = @usn
		WHERE [id] = @id
	END

GO

--------------------------------------------------------------------------------
-- UpdatePhysHostDiskDatastoreName
PRINT N'Creating [dbo].[UpdatePhysHostDiskDatastoreName]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdatePhysHostDiskDatastoreName]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdatePhysHostDiskDatastoreName]
GO

	CREATE PROCEDURE [dbo].[UpdatePhysHostDiskDatastoreName]
			   @id uniqueidentifier,
			   @datastore_name nvarchar(max)
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		UPDATE [dbo].[PhysHost_Disk] SET
			   [datastore_name] = @datastore_name,
			   [usn] = @usn
		WHERE [id] = @id
	END

GO

--------------------------------------------------------------------------------
-- GetPhysHostDiskByPhysHostAndDiskId
PRINT N'Creating [dbo].[GetPhysHostDiskByPhysHostAndDiskId]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetPhysHostDiskByPhysHostAndDiskId]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetPhysHostDiskByPhysHostAndDiskId]
GO

	CREATE PROCEDURE [dbo].[GetPhysHostDiskByPhysHostAndDiskId]
		@physhost_id uniqueidentifier,
		@disk_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT 
			* 
		FROM 
			[dbo].[PhysHost_Disk] 
		WHERE 
			[dbo].[PhysHost_Disk].[physhost_id] = @physhost_id AND
			[dbo].[PhysHost_Disk].[disk_id] = @disk_id
	END

GO

--------------------------------------------------------------------------------
-- SetPhysHostDiskAddType
PRINT N'Creating [dbo].[SetPhysHostDiskAddType]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[SetPhysHostDiskAddType]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[SetPhysHostDiskAddType]
GO

	CREATE PROCEDURE [dbo].[SetPhysHostDiskAddType]
			   @id uniqueidentifier,
			   @add_type int
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		UPDATE [dbo].[PhysHost_Disk] SET
			   [add_type] = @add_type,
			   [usn] = @usn
		WHERE [id] = @id
	END

GO

--------------------------------------------------------------------------------
-- UpdatePhysicalHostName
PRINT N'Creating [dbo].[UpdatePhysicalHostName]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdatePhysicalHostName]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdatePhysicalHostName]
GO

	CREATE PROCEDURE [dbo].[UpdatePhysicalHostName]
		@id uniqueidentifier,
		@name nvarchar(max)
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		UPDATE [dbo].[PhysicalHosts]
		SET
			   [name] = @name,
			   [usn] = @usn
		WHERE [id] = @id
	END	

GO

--------------------------------------------------------------------------------
-- UpdatePhysicalHostHardwareInfo
PRINT N'Creating [dbo].[UpdatePhysicalHostHardwareInfo]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdatePhysicalHostHardwareInfo]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdatePhysicalHostHardwareInfo]
GO

	CREATE PROCEDURE [dbo].[UpdatePhysicalHostHardwareInfo]
		@id uniqueidentifier,
		@hardware_info xml
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		UPDATE [dbo].[PhysicalHosts]
		SET
			   [hardware_info] = @hardware_info,
			   [usn] = @usn
		WHERE [id] = @id
	END	

GO

--------------------------------------------------------------------------------
-- UpdatePhysicalHostNetInfo
PRINT N'Creating [dbo].[UpdatePhysicalHostNetInfo]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdatePhysicalHostNetInfo]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdatePhysicalHostNetInfo]
GO

	CREATE PROCEDURE [dbo].[UpdatePhysicalHostNetInfo]
		@id uniqueidentifier,
		@net_info xml
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		UPDATE [dbo].[PhysicalHosts]
		SET
			   [net_info] = @net_info,
			   [usn] = @usn
		WHERE [id] = @id
	END	

GO

--------------------------------------------------------------------------------
-- UpdatePhysicalHostNetInfo
PRINT N'Creating [dbo].[UpdatePhysicalHostOsType]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdatePhysicalHostOsType]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].UpdatePhysicalHostOsType
GO

	CREATE PROCEDURE [dbo].UpdatePhysicalHostOsType
		@id uniqueidentifier,
		@os_type int
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		UPDATE [dbo].[PhysicalHosts]
		SET
			   [os_type] = @os_type,
			   [usn] = @usn
		WHERE [id] = @id
	END	

GO


--------------------------------------------------------------------------------
-- Backup.Mgmt.UnlockItem
PRINT N'Creating [dbo].[Backup.Mgmt.UnlockItem]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Mgmt.UnlockItem]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Mgmt.UnlockItem]
GO

	CREATE PROCEDURE [dbo].[Backup.Mgmt.UnlockItem]
		@lock_item_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

        DELETE FROM 
			[dbo].[Backup.TrackedActions.Leases]
        WHERE 
			[dbo].[Backup.TrackedActions.Leases].[id] in 
				(SELECT 
					[dbo].[Backup.TrackedActions.Locks].[lease_id]
				FROM
					[dbo].[Backup.TrackedActions.Locks],
					[dbo].[Backup.TrackedActions.LockItems]
				WHERE
					[dbo].[Backup.TrackedActions.Locks].[id] = [dbo].[Backup.TrackedActions.LockItems].[lock_id] AND
					[dbo].[Backup.TrackedActions.LockItems].[lock_item_id] = @lock_item_id
				)
        DELETE FROM 
			[dbo].[Backup.TrackedActions.Locks]
        WHERE 
			[dbo].[Backup.TrackedActions.Locks].[id] in 
				(SELECT 
					[dbo].[Backup.TrackedActions.LockItems].[lock_id] 
				FROM
					[dbo].[Backup.TrackedActions.LockItems]
				WHERE
					[dbo].[Backup.TrackedActions.LockItems].[lock_item_id] = @lock_item_id
				)
			
		DELETE FROM 
			[dbo].[Backup.TrackedActions.LockItems]
        WHERE 
			[dbo].[Backup.TrackedActions.LockItems].[lock_item_id] = @lock_item_id
	END

GO

--------------------------------------------------------------------------------
-- CreateJobCredentials
PRINT N'Creating [dbo].[CreateJobCredentials]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[CreateJobCredentials]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[CreateJobCredentials]
GO

	CREATE PROCEDURE [dbo].[CreateJobCredentials]
		@row_id uniqueidentifier,
		@row_job_id uniqueidentifier,
		@row_oij_id uniqueidentifier,
		@row_cred_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
			
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		INSERT INTO [dbo].[JobVssCredentials]
			   ([id],[job_id],[oij_id],[credentials_id],[usn])
		VALUES
			   (@row_id,@row_job_id,@row_oij_id,@row_cred_id,@usn)
	END	

GO

--------------------------------------------------------------------------------
-- DeleteJobCredentials
PRINT N'Creating [dbo].[DeleteJobCredentials]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DeleteJobCredentials]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[DeleteJobCredentials]
GO

	CREATE PROCEDURE [dbo].[DeleteJobCredentials]
		@row_job_id uniqueidentifier,
		@row_oij_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		IF @row_oij_id IS NULL
		BEGIN
		DELETE FROM [dbo].[JobVssCredentials]
			WHERE job_id = @row_job_id AND oij_id IS NULL
		END
		ELSE
		BEGIN
		DELETE FROM [dbo].[JobVssCredentials]
			WHERE job_id = @row_job_id AND oij_id = @row_oij_id
		END
	END

GO

--------------------------------------------------------------------------------
-- GetJobCredentials
PRINT N'Creating [dbo].[GetJobCredentials]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetJobCredentials]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetJobCredentials]
GO

	CREATE PROCEDURE [dbo].[GetJobCredentials]
		@row_job_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT * FROM [dbo].[JobVssCredentials] 
		where [job_id] = @row_job_id
	END

GO

--------------------------------------------------------------------------------
-- FindJobCredentials
PRINT N'Creating [dbo].[FindJobCredentials]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[FindJobCredentials]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[FindJobCredentials]
GO

	CREATE PROCEDURE [dbo].[FindJobCredentials]
		@row_job_id uniqueidentifier,
		@row_oij_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		IF(@row_oij_id IS NULL)
		BEGIN
			SELECT * 
			FROM [dbo].[JobVssCredentials]
			WHERE [job_id] = @row_job_id AND [oij_id] IS NULL
		END
		ELSE
		BEGIN
			SELECT * 
			FROM [dbo].[JobVssCredentials]
			WHERE [job_id] = @row_job_id AND [oij_id] = @row_oij_id
		END
	END

GO

--------------------------------------------------------------------------------
-- AddProxyAgent
PRINT N'Creating [dbo].[AddProxyAgent]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[AddProxyAgent]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[AddProxyAgent]
GO

	CREATE PROCEDURE [dbo].[AddProxyAgent]
			   @session_id uniqueidentifier,	
			   @agent_id uniqueidentifier,			   	   
			   @agent_pid int,			   	   
			   @host_name nvarchar(255),
			   @lease_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		
		INSERT INTO [dbo].[ProxyAgents]
			   ([session_id],[agent_id],[host_name],[pid],[lease_id])
		VALUES
			   (@session_id, @agent_id, @host_name, @agent_pid, @lease_id)           
	END	
	
GO

--------------------------------------------------------------------------------
-- DeleteProxyAgent
PRINT N'Creating [dbo].[DeleteProxyAgent]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DeleteProxyAgent]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[DeleteProxyAgent]
GO

	CREATE PROCEDURE [dbo].[DeleteProxyAgent]
			   @agent_id uniqueidentifier		   	  
	AS
	BEGIN
		SET NOCOUNT ON;
		
		DELETE FROM
				[dbo].[ProxyAgents]
		WHERE
				[agent_id] = @agent_id
				
	END	

GO

--------------------------------------------------------------------------------
-- GetProxyAgentsBySessionId
PRINT N'Creating [dbo].[GetProxyAgentsBySessionId]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetProxyAgentsBySessionId]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetProxyAgentsBySessionId]
GO

	CREATE PROCEDURE [dbo].[GetProxyAgentsBySessionId]
			   @session_id uniqueidentifier		   	  
	AS
	BEGIN
		SET NOCOUNT ON;
		
		SELECT * FROM
				[dbo].[ProxyAgents]
		WHERE
				[session_id] = @session_id			
	END	

GO

--------------------------------------------------------------------------------
-- GetAllProxyAgents
PRINT N'Creating [dbo].[GetAllProxyAgents]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetAllProxyAgents]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetAllProxyAgents]
GO

	CREATE PROCEDURE [dbo].[GetAllProxyAgents]   	  
	AS
	BEGIN
		SET NOCOUNT ON;
		
		SELECT * FROM
				[dbo].[ProxyAgents]	
	END	

GO

--------------------------------------------------------------------------------
-- GetProxyAgentsByLeaseId
PRINT N'Creating [dbo].[GetProxyAgentsByLeaseId]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetProxyAgentsByLeaseId]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetProxyAgentsByLeaseId]
GO

	CREATE PROCEDURE [dbo].[GetProxyAgentsByLeaseId]  
				@lease_id uniqueidentifier	 	  
	AS
	BEGIN
		SET NOCOUNT ON;
		
		SELECT * FROM
				[dbo].[ProxyAgents]	
		WHERE
				[lease_id] = @lease_id		
	END	

GO

--------------------------------------------------------------------------------
-- AddHvVolumeSnapshot
PRINT N'Creating [dbo].[AddHvVolumeSnapshot]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[AddHvVolumeSnapshot]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[AddHvVolumeSnapshot]
GO

	CREATE PROCEDURE [dbo].[AddHvVolumeSnapshot]
			   @session_id uniqueidentifier,	
			   @snapshot_id uniqueidentifier,			   	   
			   @host_name nvarchar(255)
	AS
	BEGIN
		SET NOCOUNT ON;
		
		INSERT INTO [dbo].[HvVolumeSnapshots]
			   ([session_id],[snapshot_id],[host_name])
		VALUES
			   (@session_id,@snapshot_id,@host_name)           
	END	

GO

--------------------------------------------------------------------------------
-- DeleteHvVolumeSnapshot
PRINT N'Creating [dbo].[DeleteHvVolumeSnapshot]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DeleteHvVolumeSnapshot]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[DeleteHvVolumeSnapshot]
GO

	CREATE PROCEDURE [dbo].[DeleteHvVolumeSnapshot]
			   @snapshot_id uniqueidentifier		   	  
	AS
	BEGIN
		SET NOCOUNT ON;
		
		DELETE FROM
				[dbo].[HvVolumeSnapshots]
		WHERE
				[snapshot_id] = @snapshot_id
				
	END	

GO

--------------------------------------------------------------------------------
-- GetHvVolumeSnapshotsBySessionId
PRINT N'Creating [dbo].[GetHvVolumeSnapshotsBySessionId]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetHvVolumeSnapshotsBySessionId]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetHvVolumeSnapshotsBySessionId]
GO

	CREATE PROCEDURE [dbo].[GetHvVolumeSnapshotsBySessionId]
			   @session_id uniqueidentifier		   	  
	AS
	BEGIN
		SET NOCOUNT ON;
		
		SELECT * FROM
				[dbo].[HvVolumeSnapshots]
		WHERE
				[session_id] = @session_id			
	END	

GO

--------------------------------------------------------------------------------
-- Backup.Model.GetOibFailoverInfo
PRINT N'Creating [dbo].[Backup.Model.GetOibFailoverInfo]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetOibFailoverInfo]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetOibFailoverInfo]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetOibFailoverInfo]
			   @oib_id uniqueidentifier		   	  
	AS
	BEGIN
		SET NOCOUNT ON;
		
		SELECT * FROM
				[dbo].[Backup.Model.OIBsFailoverInfo]
		WHERE
				[oib_id] = @oib_id
	END	

GO

--------------------------------------------------------------------------------
-- Backup.Model.SetOibFailovered
PRINT N'Creating [dbo].[Backup.Model.SetOibFailovered]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.SetOibFailovered]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.SetOibFailovered]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.SetOibFailovered]
			   @oib_id uniqueidentifier,
			   @state int,
			   @failback_object_id uniqueidentifier,
			   @failback_aux_data  xml
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @update_usn bigint
		exec [dbo].[IncrementUsn] @update_usn OUTPUT

		INSERT INTO [dbo].[Backup.Model.OIBsFailoverInfo](id, oib_id, failback_object_id,failback_aux_data, usn )
		VALUES( NEWID(), @oib_id, @failback_object_id, @failback_aux_data, @update_usn )

		UPDATE [dbo].[Backup.Model.OIBs]
		SET state = @state,
			usn   = @update_usn
		WHERE id = @oib_id
		
	END	

GO

--------------------------------------------------------------------------------
-- Backup.Model.SetOibFailbackObjectId
PRINT N'Creating [dbo].[Backup.Model.SetOibFailbackObjectId]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.SetOibFailbackObjectId]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.SetOibFailbackObjectId]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.SetOibFailbackObjectId]
			   @oib_id uniqueidentifier,
			   @failback_object_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @update_usn bigint
		exec [dbo].[IncrementUsn] @update_usn OUTPUT
		

		UPDATE [dbo].[Backup.Model.OIBsFailoverInfo]
		SET failback_object_id = @failback_object_id,
			usn = @update_usn
		WHERE oib_id = @oib_id
		
	END	

GO

--------------------------------------------------------------------------------
-- Backup.Model.SetOibFailbackAuxData
PRINT N'Creating [dbo].[Backup.Model.SetOibFailbackAuxData]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.SetOibFailbackAuxData]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.SetOibFailbackAuxData]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.SetOibFailbackAuxData]
			   @oib_id uniqueidentifier,
			   @failback_aux_data xml
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @update_usn bigint
		exec [dbo].[IncrementUsn] @update_usn OUTPUT	

		UPDATE [dbo].[Backup.Model.OIBsFailoverInfo]
		SET failback_aux_data = @failback_aux_data,
			usn = @update_usn
		WHERE oib_id = @oib_id
		
	END	

GO

--------------------------------------------------------------------------------
-- Backup.Model.SetOibUnFailovered
PRINT N'Creating [dbo].[Backup.Model.SetOibUnFailovered]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.SetOibUnFailovered]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.SetOibUnFailovered]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.SetOibUnFailovered]
			   @oib_id uniqueidentifier,
			   @state int
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @OIB_update_usn bigint
		exec [dbo].[IncrementUsn] @OIB_update_usn OUTPUT
			
		DECLARE @failover_info_id uniqueidentifier
		
		SELECT @failover_info_id = [dbo].[Backup.Model.OIBsFailoverInfo].[id]
		FROM    [dbo].[Backup.Model.OIBsFailoverInfo]
		WHERE   [dbo].[Backup.Model.OIBsFailoverInfo].[oib_id] = @oib_id
		
		IF  @failover_info_id IS NOT NULL
		BEGIN		
			DELETE FROM [dbo].[Backup.Model.OIBsFailoverInfo]
			WHERE id = @failover_info_id
			
			exec [dbo].[InsertTombStone] 'Backup.Model.OIBsFailoverInfo', @failover_info_id, @OIB_update_usn
		END	
				
		UPDATE [dbo].[Backup.Model.OIBs]
		SET state = @state,
			usn = @OIB_update_usn
		WHERE id = @oib_id	
		
	END	

GO

--------------------------------------------------------------------------------
-- GetJobsByObjectOibs
PRINT N'Creating [dbo].[GetJobsByObjectOibs]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetJobsByObjectOibs]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetJobsByObjectOibs]
GO

	CREATE PROCEDURE [dbo].[GetJobsByObjectOibs]
		@object_id uniqueidentifier
	AS
	BEGIN
		SELECT [dbo].[BJobs].*
		FROM
			[dbo].[BJobs], [dbo].[Backup.Model.Backups], [dbo].[Backup.Model.Storages],[dbo].[Backup.Model.OIBs]
		WHERE
			[dbo].[BJobs].[id] = [dbo].[Backup.Model.Backups].[job_id] AND
			[dbo].[Backup.Model.Backups].[id] = [dbo].[Backup.Model.Storages].[backup_id] AND
			[dbo].[Backup.Model.Storages].[id] = [dbo].[Backup.Model.OIBs].[storage_id] AND
			[dbo].[Backup.Model.OIBs].[object_id] = @object_id	    
	END

GO

--------------------------------------------------------------------------------
-- GetJobsByObjectOijs
PRINT N'Creating [dbo].[GetJobsByObjectOijs]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetJobsByObjectOijs]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetJobsByObjectOijs]
GO

	CREATE PROCEDURE [dbo].[GetJobsByObjectOijs]
		@object_id uniqueidentifier,
		@oij_type  int
	AS
	BEGIN
		SELECT [dbo].[BJobs].*
		FROM
			[dbo].[BJobs], [dbo].[ObjectsInJobs]
		WHERE
			[dbo].[BJobs].[id] = [dbo].[ObjectsInJobs].[job_id] AND
			[dbo].[ObjectsInJobs].[object_id] = @object_id AND
			[dbo].[ObjectsInJobs].[type] = @oij_type	    
	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.CommitFailbackObject
PRINT N'Creating [dbo].[Backup.Model.CommitFailbackObject]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.CommitFailbackObject]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.CommitFailbackObject]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.CommitFailbackObject]
		@oib_id uniqueidentifier	
	AS
	BEGIN

		BEGIN TRANSACTION failbackobj_commit_transaction
			SET NOCOUNT ON

			DECLARE @failback_object_id uniqueidentifier
			
			SELECT @failback_object_id = [dbo].[Backup.Model.OIBsFailoverInfo].[failback_object_id]
			FROM   [dbo].[Backup.Model.OIBsFailoverInfo]
			WHERE  [dbo].[Backup.Model.OIBsFailoverInfo].[oib_id] = @oib_id AND
				   [dbo].[Backup.Model.OIBsFailoverInfo].[failback_object_id] <> '00000000-0000-0000-0000-000000000000'
				   			
			IF @failback_object_id IS NOT NULL
			BEGIN
				DECLARE @temp_object_id uniqueidentifier
				SELECT  @temp_object_id = NEWID()

				DECLARE @orig_object_id uniqueidentifier
				SELECT @orig_object_id = [dbo].[Backup.Model.OIBs].[object_id]
				FROM [dbo].[Backup.Model.OIBs]
				WHERE [dbo].[Backup.Model.OIBs].[id] = @oib_id


				UPDATE [dbo].[BObjects]
				SET [id] = @temp_object_id
				WHERE [dbo].[BObjects].[id] = @orig_object_id


				declare @orig_obj_usn bigint
				exec [dbo].[IncrementUsn] @orig_obj_usn OUTPUT
				
				UPDATE [dbo].[BObjects]
				SET [id] = @orig_object_id,
					[usn] = @orig_obj_usn
				WHERE [dbo].[BObjects].[id] = @failback_object_id


				declare @failback_obj_usn bigint
				exec [dbo].[IncrementUsn] @failback_obj_usn OUTPUT
				
				UPDATE [dbo].[BObjects]
				SET [id]  = @failback_object_id,
					[usn] = @failback_obj_usn
				WHERE [dbo].[BObjects].[id] = @temp_object_id
				
				
				declare @failover_info_usn bigint
				exec [dbo].[IncrementUsn] @failover_info_usn OUTPUT
											
				UPDATE [dbo].[Backup.Model.OIBsFailoverInfo]
				SET    [failback_object_id] = '00000000-0000-0000-0000-000000000000',
					   [usn] = @failover_info_usn
				WHERE  [dbo].[Backup.Model.OIBsFailoverInfo].[oib_id] = @oib_id		

			END

		COMMIT TRANSACTION failbackobj_commit_transaction
	END
	
GO

--------------------------------------------------------------------------------
-- GetObjectInJobByJobIdObjectIdAndType
PRINT N'Creating [dbo].[GetObjectInJobByJobIdObjectIdAndType]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetObjectInJobByJobIdObjectIdAndType]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetObjectInJobByJobIdObjectIdAndType]
GO

	CREATE PROCEDURE [dbo].[GetObjectInJobByJobIdObjectIdAndType]
		@row_job_id uniqueidentifier,
		@row_object_id uniqueidentifier,
		@oij_type int
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT * from [dbo].[ObjectsInJobs]  oj 
		LEFT JOIN [dbo].[JobVssCredentials] vc ON oj.id = vc.oij_id
		LEFT JOIN [dbo].[Credentials] c ON c.id = vc.credentials_id
		where oj.[job_id] = @row_job_id AND oj.[object_id] = @row_object_id AND oj.[type] = @oij_type
	END
	
GO

--------------------------------------------------------------------------------
-- Backup.Model.FindFailoveredOib
PRINT N'Creating [dbo].[Backup.Model.FindFailoveredOib]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.FindFailoveredOib]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.FindFailoveredOib]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.FindFailoveredOib]
		@backup_id uniqueidentifier,
		@object_id uniqueidentifier		
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT * 
		FROM [dbo].[Backup.Model.OIBs],
		     [dbo].[Backup.Model.Points]
		WHERE 
			 [dbo].[Backup.Model.Points].[id] = [dbo].[Backup.Model.OIBs].[point_id] AND
			 [dbo].[Backup.Model.Points].[backup_id] = @backup_id AND
			 [dbo].[Backup.Model.OIBs].[object_id] = @object_id	AND
			 [dbo].[Backup.Model.OIBs].[state] = 1 -- failed over
	END
	
GO

--------------------------------------------------------------------------------
-- CheckHostCompsActualite
PRINT N'Creating [dbo].[CheckHostCompsActualite]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[CheckHostCompsActualite]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[CheckHostCompsActualite]
GO

	CREATE PROCEDURE [dbo].[CheckHostCompsActualite]
		(@compType int, @distribVer nvarchar(max))
	AS
	BEGIN	
		UPDATE
			[dbo].[HostComponents]
		SET
			[is_up_to_date] = 0
		WHERE
			[dbo].[HostComponents].[Type] = @compType AND
			[dbo].[CompareVersions] (
				[dbo].[HostComponents].[Version], 
				@distribVer) = -1
				
		UPDATE
			[dbo].[HostComponents]
		SET
			[is_up_to_date] = 1
		WHERE
			[dbo].[HostComponents].[Type] = @compType AND
			[dbo].[CompareVersions] (
				[dbo].[HostComponents].[Version], 
				@distribVer) > -1
	END

GO

--------------------------------------------------------------------------------
-- GetHostsRequiredUpgrade
PRINT N'Creating [dbo].[GetHostsRequiredUpgrade]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetHostsRequiredUpgrade]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetHostsRequiredUpgrade]
GO

	CREATE PROCEDURE [dbo].[GetHostsRequiredUpgrade] 
	AS
	BEGIN
		SELECT 
			* 
		FROM 
			[dbo].[Hosts] h
		WHERE
			h.[physical_host_id] IN
			(SELECT c.[physical_host_id] FROM [dbo].[HostComponents] c WHERE c.[is_up_to_date] = 0)
	END

GO

--------------------------------------------------------------------------------
-- CheckActualiteForHostComp
PRINT N'Creating [dbo].[CheckActualiteForHostComp]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[CheckActualiteForHostComp]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[CheckActualiteForHostComp]
GO

	CREATE PROCEDURE [dbo].[CheckActualiteForHostComp]
		(@hostCompId uniqueidentifier, @distribVer nvarchar(max))
	AS
	BEGIN	
		UPDATE
			[dbo].[HostComponents]
		SET
			[is_up_to_date] = 0
		WHERE
			[dbo].[HostComponents].[id] = @hostCompId AND
			[dbo].[CompareVersions] (
				[dbo].[HostComponents].[Version], 
				@distribVer) = -1
				
		UPDATE
			[dbo].[HostComponents]
		SET
			[is_up_to_date] = 1
		WHERE
			[dbo].[HostComponents].[id] = @hostCompId AND
			[dbo].[CompareVersions] (
				[dbo].[HostComponents].[Version], 
				@distribVer) > -1
	END

GO

--------------------------------------------------------------------------------
-- IsObsoleteCompExists
PRINT N'Creating [dbo].[IsObsoleteCompExists]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[IsObsoleteCompExists]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[IsObsoleteCompExists]
GO

	CREATE PROCEDURE [dbo].[IsObsoleteCompExists] 
	AS
	BEGIN
		DECLARE @outOfDateCompsCount int
		SELECT 
			@outOfDateCompsCount = COUNT(*)
		FROM
			[dbo].[HostComponents] c
		WHERE
			c.[is_up_to_date] = 0 

		IF (@outOfDateCompsCount > 0)
			SELECT 1 retValue

		SELECT 0 retValue
	END

GO

--------------------------------------------------------------------------------
-- XmlLogger.GetMaxSeverity
PRINT N'Creating [dbo].[XmlLogger.GetMaxSeverity]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[XmlLogger.GetMaxSeverity]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[XmlLogger.GetMaxSeverity]
GO

	CREATE PROCEDURE [dbo].[XmlLogger.GetMaxSeverity] 
		@row_session_id uniqueidentifier	
	AS
	BEGIN

 		IF (0 < (SELECT [log_xml].value('count(/Root/Log[@Status="EFailed"])', 'nvarchar(max)') FROM [dbo].[Backup.Model.JobSessions] WHERE [id] = @row_session_id))
			SELECT 2;
		ELSE IF (0 < (SELECT [log_xml].value('count(/Root/Log[@Status="EWarning"])', 'nvarchar(max)') FROM [dbo].[Backup.Model.JobSessions] WHERE [id] = @row_session_id))
			SELECT 1;
		ELSE IF (0 < (SELECT [log_xml].value('count(/Root/Log[@Status="ESucceeded"])', 'nvarchar(max)') FROM [dbo].[Backup.Model.JobSessions] WHERE [id] = @row_session_id))
			SELECT 0;
		ELSE
			SELECT -1;
	END
	
GO

--------------------------------------------------------------------------------
-- ReportOibsStatisticView
PRINT N'Creating [dbo].[ReportOibsStatisticView]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[ReportOibsStatisticView]') AND type in (N'V'))
	DROP VIEW [dbo].[ReportOibsStatisticView]
GO

CREATE VIEW ReportOibsStatisticView
AS
SELECT TOP 1000000 backup_id
		, oibs.object_id AS object_id
		, SUM(CASE WHEN oibs.is_corrupted = 0 THEN 1 ELSE 0 END) AS count_valid_oibs
		, SUM(CASE WHEN oibs.is_corrupted = 0 AND oibs.is_consistent = 1 THEN 1 ELSE 0 END) AS count_consistent_oibs
		, CAST(MAX(CASE WHEN oibs.has_exchange = 0 THEN 0 ELSE 1 END) AS BIT) AS has_exchange_in_any_point
		, CAST(MAX(CASE WHEN oibs.has_sharepoint = 0 THEN 0 ELSE 1 END) AS BIT) AS has_sharepoint_in_any_point
		, SUM(oibs.state) AS points_in_running_state
		, MIN(points.creation_time) AS backup_creation_time_min
		, CAST(MAX(CASE WHEN ofip.id IS NULL THEN 0 ELSE 1 END) AS BIT) AS is_failback_pending
		, CAST(MAX(CASE WHEN ofia.id IS NULL THEN 0 ELSE 1 END) AS BIT) AS is_active
		, MAX(oibs.usn) AS oib_usn
		, MAX(ofip.usn) AS oib_failover_usn
		, MAX(points.usn) AS point_usn
FROM  
		[dbo].[Backup.Model.OIBs] oibs 
			INNER JOIN [dbo].[Backup.Model.Points] points ON oibs.point_id = points.id
			LEFT JOIN [dbo].[Backup.Model.OIBsFailoverInfo] ofip ON ofip.[oib_id] = oibs.[id] AND ofip.[failback_object_id] <> '00000000-0000-0000-0000-000000000000'
			LEFT JOIN [dbo].[Backup.Model.OIBsFailoverInfo] ofia ON ofia.[oib_id] = oibs.[id]		
GROUP BY 
	backup_id, oibs.object_id
GO

--------------------------------------------------------------------------------
-- ReportMaxBackupSessionUsn
PRINT N'Creating [dbo].[ReportMaxBackupSessionUsn]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[ReportMaxBackupSessionUsn]') AND type in (N'V'))
	DROP VIEW [dbo].[ReportMaxBackupSessionUsn]
GO

CREATE VIEW ReportMaxBackupSessionUsn
AS
SELECT backup_id, MAX(session_usn) AS session_usn
	FROM (SELECT points.backup_id, MAX(rjs.[usn]) AS session_usn
				FROM [dbo].[Backup.Model.RestoreJobSessions] rjs
					LEFT JOIN [dbo].[Backup.Model.JobSessions] js ON rjs.[id] = js.[id]
					INNER JOIN [dbo].[Backup.Model.OIBs] oibs ON rjs.[oib_id] = oibs.id
					INNER JOIN  [dbo].[Backup.Model.Points] points ON points.id = oibs.point_id
		  GROUP BY points.backup_id
		  UNION
		  SELECT bk.id,  MAX(sess.[usn]) 
				FROM [Backup.Model.JobSessions] sess
					INNER JOIN [Backup.Model.Backups] bk ON sess.job_id = bk.job_id
		  WHERE sess.job_id <> '00000000-0000-0000-0000-000000000000' 
		  GROUP BY bk.id) backups_union
GROUP BY backup_id
GO

--------------------------------------------------------------------------------
-- ReportIndexedOibsView
PRINT N'Creating [dbo].[ReportIndexedOibsView]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[ReportIndexedOibsView]') AND type in (N'V'))
	DROP VIEW [dbo].[ReportIndexedOibsView]
GO

CREATE VIEW ReportIndexedOibsView
AS
SELECT * FROM
(
SELECT points.backup_id
      ,oibs.id AS oib_id
      ,oibs.[object_id]
      ,objs.[type] AS [obj_type]
      ,oibs.[point_id]
      ,oibs.[storage_id]
      ,oibs.[link_id]
      ,oibs.[is_corrupted]
      ,oibs.[is_consistent]
      ,oibs.[state]
      ,oibs.[type]
      ,oibs.[alg]
      ,oibs.[inside_dir]
      ,oibs.[creation_time]
      ,oibs.[vmname]
      ,oibs.[guest_os_info]
      ,oibs.[memory]
      ,oibs.[approx_size]
      ,oibs.[process_id]
      ,oibs.[has_index]
      ,oibs.[aux_data]
      ,oibs.[has_exchange]
	  ,oibs.[has_sharepoint]
      ,oibs.[usn]
      ,oibs.[display_name]
	  ,oibs.[parent_id]
      ,ROW_NUMBER() OVER (PARTITION BY points.backup_id, oibs.object_id ORDER BY [state] DESC, points.num DESC, oibs.[creation_time] DESC) [row_no]
FROM  
	[dbo].[Backup.Model.OIBs] oibs 
		INNER JOIN [dbo].[Backup.Model.Points] points ON oibs.point_id = points.id
		LEFT JOIN [dbo].[BObjects] objs ON oibs.object_id = objs.id
) riov		
WHERE riov.[row_no] = 1		
GO

--------------------------------------------------------------------------------
-- ReportObjectOibsView
PRINT N'Creating [dbo].[ReportObjectOibsView]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[ReportObjectOibsView]') AND type in (N'V'))
	DROP VIEW [dbo].[ReportObjectOibsView]
GO

CREATE VIEW ReportObjectOibsView
AS
SELECT riov.[backup_id]
      ,riov.[oib_id]
      ,riov.[object_id]
      ,riov.[obj_type]
      ,riov.[point_id]
      ,riov.[storage_id]
      ,riov.[link_id]
      ,riov.[is_corrupted]
      ,riov.[is_consistent]
      ,riov.[state]
      ,[dbo].[GetOibState](riov.oib_id) AS oib_state
      ,riov.[type]
      ,riov.[alg]
      ,riov.[inside_dir]
      ,riov.[creation_time]
      ,riov.[vmname]
      ,riov.[display_name]
      ,riov.[guest_os_info]
      ,riov.[memory]
      ,riov.[approx_size]
      ,riov.[process_id]
      ,riov.[has_index]
      ,riov.[aux_data]
      ,riov.[has_exchange]
	  ,riov.[has_sharepoint]
      ,riov.[usn]
	  ,riov.[parent_id]
      ,rosv.backup_creation_time_min
      ,rosv.[count_valid_oibs]
	  ,rosv.[count_consistent_oibs]
      ,rosv.[has_exchange_in_any_point]
	  ,rosv.[has_sharepoint_in_any_point]
      ,rosv.[points_in_running_state]
      ,rosv.[is_failback_pending]
      ,rosv.[is_active]
      ,rosv.oib_usn
      ,rosv.oib_failover_usn
      ,rosv.point_usn
      ,CAST((CASE WHEN tsess.id IS NULL THEN 1 ELSE 0 END) AS BIT) AS is_not_running
FROM [dbo].[ReportIndexedOibsView] riov 
	INNER JOIN [dbo].[ReportOibsStatisticView] rosv ON riov.[object_id] = rosv.[object_id] AND riov.[backup_id] = rosv.[backup_id]
	LEFT JOIN dbo.[Backup.Model.Backups] bk ON riov.[backup_id] = bk.[id]
	LEFT JOIN dbo.[Backup.Model.JobSessions] sess ON sess.[job_id] = bk.[job_id] AND bk.[job_id] <> '00000000-0000-0000-0000-000000000000' AND sess.[state] <> -1
	LEFT JOIN dbo.[Backup.Model.BackupTaskSessions] tsess ON tsess.[session_id] = sess.[id] AND riov.[object_id] = tsess.[object_id] AND tsess.[status] = 5

GO


--------------------------------------------------------------------------------
-- ReportSanBackupsState
PRINT N'Creating [dbo].[ReportSanBackupsState]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[ReportSanBackupsState]') AND type in (N'V'))
	DROP VIEW [dbo].[ReportSanBackupsState]
GO

CREATE VIEW [dbo].[ReportSanBackupsState]
AS 
SELECT 
	back.id AS backup_id
	,(plugin.[enabled] & plugin.compatible) AS is_accessible
	,plugin.usn AS plugin_usn
FROM [dbo].[Backup.Model.Backups] back
	INNER JOIN [dbo].[Backup.Model.SanVolumeBackups] volback ON back.id = volback.backup_id
	INNER JOIN [dbo].[Backup.Model.SanVolumes] vol ON volback.volume_id = vol.id
	INNER JOIN [dbo].[Hosts] host ON vol.[host_id] = host.id
	INNER JOIN [dbo].[Backup.Model.SanHostsPlugins] hostpl  ON host.id = hostpl.[host_id]
	INNER JOIN [dbo].[Backup.Model.Plugins] plugin  ON plugin.id = hostpl.plugin_id
GO

--------------------------------------------------------------------------------
-- ReportBackupsView
PRINT N'Creating [dbo].[ReportBackupsView]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[ReportBackupsView]') AND type in (N'V'))
	DROP VIEW [dbo].[ReportBackupsView]
GO

CREATE VIEW [dbo].[ReportBackupsView]
AS
SELECT DISTINCT 
      back.id AS backup_id,
      repo.name AS rep_name,
      ISNULL(back.job_id, '00000000-0000-0000-0000-000000000000') AS job_id
      ,back.repository_id
      ,back.job_name
      ,back.job_target_type
      ,back.job_source_type
      ,back.target_type 
      ,back.platform
      ,roov.[oib_id]
      ,roov.[object_id]
      ,roov.[obj_type]
      ,roov.[point_id]
      ,ISNULL(roov.[storage_id], '00000000-0000-0000-0000-000000000000') AS storage_id
      ,roov.[link_id]
      ,roov.[is_corrupted]
      ,roov.[is_consistent]
      ,roov.[state]
      ,roov.[oib_state]
      ,roov.[type]
      ,roov.[alg]
      ,roov.[inside_dir]
      ,roov.[creation_time] AS last_oib_creation_time
      ,roov.[vmname]
      ,roov.[display_name]	
      ,CONVERT(nvarchar(MAX), roov.[guest_os_info]) AS [guest_os_info]
      ,roov.[memory]
      ,roov.[approx_size]
      ,roov.[process_id]
      ,roov.[has_index]
      ,CONVERT(nvarchar(MAX), roov.[aux_data]) AS [aux_data] 
      ,roov.backup_creation_time_min
      ,roov.[count_valid_oibs]
	  ,roov.[count_consistent_oibs]
      ,roov.[has_exchange_in_any_point]
	   ,roov.[has_sharepoint_in_any_point]
      ,roov.[points_in_running_state]
      ,roov.[is_failback_pending]
      ,roov.[is_active]
      ,roov.[is_not_running]
      ,roov.[has_exchange]
	  ,roov.[has_sharepoint]
	  ,ISNULL(roov.[parent_id], '00000000-0000-0000-0000-000000000000') AS parent_id
	  ,ISNULL(oibs.[object_id], '00000000-0000-0000-0000-000000000000') AS parent_obj_id
      ,ISNULL(rss.is_accessible, 1) AS is_accessible
      ,dbo.MaxValue6(back.usn, oib_usn, oib_failover_usn, point_usn, rmaxusn.session_usn, rss.plugin_usn) AS usn
FROM [Backup.Model.Backups] back 
	LEFT JOIN dbo.ReportMaxBackupSessionUsn rmaxusn ON back.id = rmaxusn.backup_id
	LEFT JOIN dbo.ReportObjectOibsView roov ON back.id = roov.backup_id
	LEFT JOIN dbo.BackupRepositories repo ON back.repository_id = repo.id
	LEFT JOIN dbo.ReportSanBackupsState rss ON back.id = rss.backup_id
	LEFT JOIN dbo.[Backup.Model.OIBs] oibs ON oibs.[id] = roov.[parent_id]
GO

--------------------------------------------------------------------------------
-- ReportBackupsDeleteView
PRINT N'Creating [dbo].[ReportBackupsDeleteView]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[ReportBackupsDeleteView]') AND type in (N'P'))
	DROP PROCEDURE [dbo].[ReportBackupsDeleteView]
GO

	CREATE PROCEDURE [dbo].[ReportBackupsDeleteView]
		@row_usn bigint
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT uid, usn FROM TombStones 
		WHERE (table_name = 'Backup.Model.Backups' 
			OR table_name = 'Backup.Model.OIBs'
			) AND usn > @row_usn
			AND uid NOT IN
			(
				SELECT id FROM [Backup.Model.Backups]
				UNION
				SELECT id FROM [Backup.Model.OIBs]
			)
END
GO

--------------------------------------------------------------------------------
-- GetObjectOibsAllForBackup
PRINT N'Creating [dbo].[GetObjectOibsAllForBackup]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetObjectOibsAllForBackup]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetObjectOibsAllForBackup]
GO

	CREATE PROCEDURE [dbo].[GetObjectOibsAllForBackup]
		@backup_id uniqueidentifier
	AS
	BEGIN
		SELECT 
			reportView.*
		FROM 
			[dbo].[ReportBackupsView] reportView
		WHERE
			reportView.[backup_id] = @backup_id
	END

GO

--------------------------------------------------------------------------------
-- AddVmWareSnapshot
PRINT N'Creating [dbo].[AddVmWareSnapshot]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[AddVmWareSnapshot]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[AddVmWareSnapshot]
GO

	CREATE PROCEDURE [dbo].[AddVmWareSnapshot]
			   @job_id uniqueidentifier,
			   @session_id uniqueidentifier,	
			   @host_name nvarchar(1024),
			   @snapshot_ref nvarchar(1024),
			   @vm_ref nvarchar(1024),
			   @snapshot_name nvarchar(1024),
			   @description nvarchar(1024),
			   @viproxy_id uniqueidentifier,	
			   @proxymode nvarchar(1024)	 
			     
	AS
	BEGIN
		SET NOCOUNT ON;
		
		INSERT INTO [dbo].[VmWareSnapshots]
			   ([job_id],[session_id],[host_name],[snapshot_ref],[vm_ref],[snapshot_name],[description],[viproxy_id],[proxymode])
		VALUES
			   (@job_id,@session_id,@host_name,@snapshot_ref,@vm_ref,@snapshot_name,@description,@viproxy_id,@proxymode)          
	END	

GO

--------------------------------------------------------------------------------
-- DeleteVmWareSnapshot
PRINT N'Creating [dbo].[DeleteVmWareSnapshot]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DeleteVmWareSnapshot]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[DeleteVmWareSnapshot]
GO

	CREATE PROCEDURE [dbo].[DeleteVmWareSnapshot]
			   @snapshot_ref nvarchar(1024)		   	  
	AS
	BEGIN
		SET NOCOUNT ON;
		
		DELETE FROM
				[dbo].[VmWareSnapshots]
		WHERE
				[snapshot_ref] = @snapshot_ref
				
	END	

GO

--------------------------------------------------------------------------------
-- GetVmWareSnapshotsBySessionId
PRINT N'Creating [dbo].[GetVmWareSnapshotsBySessionId]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetVmWareSnapshotsBySessionId]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetVmWareSnapshotsBySessionId]
GO

	CREATE PROCEDURE [dbo].[GetVmWareSnapshotsBySessionId]
			   @session_id nvarchar(1024)			   	  
	AS
	BEGIN
		SET NOCOUNT ON;
		
		SELECT * FROM
				[dbo].[VmWareSnapshots]
		WHERE
				[session_id] = @session_id			
	END	

GO

--------------------------------------------------------------------------
-- [GetVmWareSnapshotsByJobId]
PRINT N'Creating [dbo].[GetVmWareSnapshotsByJobId]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetVmWareSnapshotsByJobId]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetVmWareSnapshotsByJobId]
GO

	CREATE PROCEDURE [dbo].[GetVmWareSnapshotsByJobId]
			   @job_id nvarchar(1024)			   	  
	AS
	BEGIN
		SET NOCOUNT ON;
		
		SELECT * FROM
				[dbo].[VmWareSnapshots]
		WHERE
				@job_id = @job_id			
	END	

GO

--------------------------------------------------------------------------------
-- AddBaseSessionRow
PRINT N'Creating [dbo].[AddBaseSessionRow]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[AddBaseSessionRow]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[AddBaseSessionRow]
GO

	CREATE PROCEDURE [dbo].[AddBaseSessionRow]
			   @row_id uniqueidentifier,
			   @row_job_id uniqueidentifier,
			   @row_job_name nvarchar(255),
			   @row_job_type int,
			   @row_result int,
			   @row_description text,
			   @row_operation nvarchar(400),
			   @row_progress int,
			   @row_state int,
			   @row_creation_time datetime,
			   @row_end_time datetime,
			   @row_lease_id uniqueidentifier,
			   @orig_session_id uniqueidentifier,
			   @aux_data xml,
			   @job_spec xml
	AS
	BEGIN
		SET NOCOUNT ON;

		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		INSERT INTO [dbo].[Backup.Model.JobSessions]
			   ([id]
			  ,[job_id]
			  ,[job_name]
			  ,[job_type]
			  ,[result]
			  ,[description]
			  ,[operation]
			  ,[progress]
			  ,[state]
			  ,[creation_time]
			  ,[end_time]
			  ,[lease_id]
			  ,[orig_session_id]
			  ,[aux_data]
			  ,[job_spec]
			  ,[usn])
		 VALUES
			   (@row_id,
				@row_job_id,
				@row_job_name,
				@row_job_type,
				@row_result,
				@row_description,
				@row_operation,
				@row_progress,
				@row_state,
				@row_creation_time,
				@row_end_time,
				@row_lease_id,
				@orig_session_id,			
				@aux_data,
				@job_spec,
				@usn)			
	END	

GO

--------------------------------------------------------------------------------
-- UpdateBaseSessionRow
PRINT N'Creating [dbo].[UpdateBaseSessionRow]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateBaseSessionRow]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateBaseSessionRow]
GO

	CREATE PROCEDURE [dbo].[UpdateBaseSessionRow]
			   @row_id uniqueidentifier,
			   @row_job_id uniqueidentifier,
			   @row_job_name nvarchar(255),
			   @row_job_type int,
			   @row_result int,
			   @row_description text,
			   @row_operation nvarchar(400),
			   @row_progress int,
			   @row_state int,
			   @row_creation_time datetime,
			   @row_end_time datetime,
			   @row_lease_id uniqueidentifier,
			   @orig_session_id uniqueidentifier,
			   @aux_data xml,
			   @job_spec xml
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @usn bigint	
		exec [dbo].[IncrementUsn] @usn OUTPUT
		
		UPDATE [dbo].[Backup.Model.JobSessions] SET
			   [job_id]		  	    =@row_job_id,
			   [job_name]			=@row_job_name,
			   [job_type] 		    =@row_job_type,
			   [result]			    =@row_result,
			   [description]		=@row_description,
			   [operation]			=@row_operation,
			   [progress]			=@row_progress,
			   [state]			    =@row_state,
			   [creation_time]		=@row_creation_time,
			   [end_time]			=@row_end_time,
			   [lease_id]			=@row_lease_id,
			   [orig_session_id]	=@orig_session_id,
			   [aux_data]			=@aux_data,
			   [job_spec]			=@job_spec,
			   [usn]                =@usn
			   WHERE [id] = @row_id   
	END	

GO

--------------------------------------------------------------------------------
-- GetBSessionsRunning
PRINT N'Creating [dbo].[GetBSessionsRunning]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetBSessionsRunning]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetBSessionsRunning]
GO

	CREATE PROCEDURE [dbo].[GetBSessionsRunning]
		@stop_state int
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * 
		
		FROM [dbo].[Backup.Model.JobSessions] INNER JOIN [dbo].[Backup.Model.BackupJobSessions] 
			ON [dbo].[Backup.Model.JobSessions].[id] = [dbo].[Backup.Model.BackupJobSessions].[id]
		
		WHERE [state] != @stop_state
	END

GO

--------------------------------------------------------------------------------
-- ReportVmssStatisticView
PRINT N'Creating [dbo].[ReportVmssStatisticView]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[ReportVmssStatisticView]') AND type in (N'V'))
	DROP VIEW [dbo].[ReportVmssStatisticView]
GO

	CREATE VIEW [dbo].[ReportVmssStatisticView]
	AS
		SELECT cast('7B441333-6A99-499d-8FCB-9936255805E8' as uniqueidentifier) as id, 
			COUNT(*) as mounted_vm_count,
			[dbo].[MaxValue]
			(
				(SELECT MAX(usn) FROM [dbo].[TombStones] WHERE table_name = 'VmssVms'),
				(SELECT MAX(usn) FROM [dbo].[VmssVms])
			) as usn
		FROM  [dbo].[VmssSessionsView]
	
GO

--------------------------------------------------------------------------------
-- FindBackupProxyById
PRINT N'Creating [dbo].[FindBackupProxyById]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[FindBackupProxyById]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[FindBackupProxyById]
GO

	CREATE PROCEDURE [dbo].[FindBackupProxyById]
		@id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[BackupProxies] where [dbo].[BackupProxies].[id] = @id
	END
	
GO

--------------------------------------------------------------------------------
-- UpdateBackupProxyState
PRINT N'Creating [dbo].[UpdateBackupProxyState]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateBackupProxyState]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateBackupProxyState]
GO

	CREATE PROCEDURE [dbo].[UpdateBackupProxyState]
		@id uniqueidentifier,
		@disabled bit
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		UPDATE [dbo].[BackupProxies] SET
				[disabled] = @disabled,
				[usn] = @usn
		WHERE [id] = @id
			
	END	

GO

--------------------------------------------------------------------------------
-- GetHostByParentAndRef
PRINT N'Creating [dbo].[GetHostByParentAndRef]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetHostByParentAndRef]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetHostByParentAndRef]
GO

	CREATE PROCEDURE [dbo].[GetHostByParentAndRef]
		@parent_id uniqueidentifier,
		@reference nvarchar(1024)
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * 
		from
			[dbo].[Hosts] h
		where
			h.[parent_id] = @parent_id and 
			h.[reference] = @reference
			
	END

GO

--------------------------------------------------------------------------------
-- GetHostByParentAndName
PRINT N'Creating [dbo].[GetHostByParentAndName]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetHostByParentAndName]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetHostByParentAndName]
GO

	CREATE PROCEDURE [dbo].[GetHostByParentAndName]
		@parent_id uniqueidentifier,
		@name nvarchar(1024)
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * 
		from
			[dbo].[Hosts] h
		where
			h.[parent_id] = @parent_id and 
			h.[name] = @name
			
	END

GO

--------------------------------------------------------------------------------
-- GetBaseSessionState
PRINT N'Creating [dbo].[GetJobSessionState]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetJobSessionState]') AND type in (N'P'))
	DROP PROCEDURE [dbo].[GetJobSessionState]
GO			

	CREATE PROCEDURE [dbo].[GetJobSessionState]
		@id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		
		SELECT [state]
		FROM    [dbo].[Backup.Model.JobSessions]
		WHERE  [id] = @id
					
	END

GO

--------------------------------------------------------------------------------
-- GetBaseSessionResult
PRINT N'Creating [dbo].[GetJobSessionResult]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetJobSessionResult]') AND type in (N'P'))
	DROP PROCEDURE [dbo].[GetJobSessionResult]
GO			

	CREATE PROCEDURE [dbo].[GetJobSessionResult]
		@id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		
		SELECT [result]
		FROM    [dbo].[Backup.Model.JobSessions]
		WHERE  [id] = @id
					
	END

GO

--------------------------------------------------------------------------------
-- UpdatePhysicalHostChassisType
PRINT N'Creating [dbo].[UpdatePhysicalHostChassisType]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdatePhysicalHostChassisType]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdatePhysicalHostChassisType]
GO

	CREATE PROCEDURE [dbo].[UpdatePhysicalHostChassisType]
		@id uniqueidentifier,
		@chassis_type int
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		UPDATE [dbo].[PhysicalHosts]
		SET
			   [chassis_type] = @chassis_type,
			   [usn] = @usn
		WHERE [id] = @id
	END	

GO

--------------------------------------------------------------------------------
-- UpdatePhysicalHostBiosUuid
PRINT N'Creating [dbo].[UpdatePhysicalHostBiosUuid]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdatePhysicalHostBiosUuid]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdatePhysicalHostBiosUuid]
GO

	CREATE PROCEDURE [dbo].[UpdatePhysicalHostBiosUuid]
		@id uniqueidentifier,
		@bios_uuid nvarchar(255)
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		UPDATE [dbo].[PhysicalHosts]
		SET
			   [bios_uuid] = @bios_uuid,
			   [usn] = @usn
		WHERE [id] = @id
	END	

GO

--------------------------------------------------------------------------------
-- GetJobProxiesByProxy
PRINT N'Creating [dbo].[GetJobProxiesByProxy]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetJobProxiesByProxy]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetJobProxiesByProxy]
GO

	CREATE PROCEDURE [dbo].[GetJobProxiesByProxy]
		@proxy_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[Backup.Model.JobProxies] WHERE [proxy_id] = @proxy_id
	END

GO

--------------------------------------------------------------------------------
-- UpdateHostInfo
PRINT N'Creating [dbo].[UpdateHostInfo]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateHostInfo]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateHostInfo]
GO

	CREATE PROCEDURE [dbo].[UpdateHostInfo]
		@id uniqueidentifier,
		@info nvarchar(255)
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		UPDATE [dbo].[Hosts] SET
				[info] = @info,
				[usn] = @usn
		WHERE [id] = @id
			
	END	

GO

--------------------------------------------------------------------------------
-- UpdatePhysHostDiskIsAutoDetect
PRINT N'Creating [dbo].[UpdatePhysHostDiskIsAutoDetected]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdatePhysHostDiskIsAutoDetected]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdatePhysHostDiskIsAutoDetected]
GO

	CREATE PROCEDURE [dbo].[UpdatePhysHostDiskIsAutoDetected]
			   @id uniqueidentifier,
			   @is_auto_detected bit
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		UPDATE [dbo].[PhysHost_Disk] SET
			   [is_auto_detected] = @is_auto_detected,
			   [usn] = @usn
		WHERE [id] = @id
	END

GO

--------------------------------------------------------------------------------
-- UpdatePhysHostDiskIsIsManualAdded
PRINT N'Creating [dbo].[UpdatePhysHostDiskIsManualAdded]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdatePhysHostDiskIsManualAdded]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdatePhysHostDiskIsManualAdded]
GO

	CREATE PROCEDURE [dbo].[UpdatePhysHostDiskIsManualAdded]
			   @id uniqueidentifier,
			   @is_manual_added bit
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		UPDATE [dbo].[PhysHost_Disk] SET
			   [is_manual_added] = @is_manual_added,
			   [usn] = @usn
		WHERE [id] = @id
	END

GO

--------------------------------------------------------------------------------
-- GetManualAddedPhysHostDisksByPhysHost
PRINT N'Creating [dbo].[GetPhysHostDisksByPhysHost]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetManualAddedPhysHostDisksByPhysHost]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetManualAddedPhysHostDisksByPhysHost]
GO

	CREATE PROCEDURE [dbo].[GetManualAddedPhysHostDisksByPhysHost]
		@physhost_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT 
			* 
		FROM 
			[dbo].[PhysHost_Disk] 
		WHERE 
			[dbo].[PhysHost_Disk].[physhost_id] = @physhost_id AND
			[dbo].[PhysHost_Disk].[is_manual_added] = 1
	END

GO

--------------------------------------------------------------------------------
-- GetAutodetectedPhysHostDisksByPhysHost
PRINT N'Creating [dbo].[GetAutodetectedPhysHostDisksByPhysHost]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetAutodetectedPhysHostDisksByPhysHost]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetAutodetectedPhysHostDisksByPhysHost]
GO

	CREATE PROCEDURE [dbo].[GetAutodetectedPhysHostDisksByPhysHost]
		@physhost_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT 
			* 
		FROM 
			[dbo].[PhysHost_Disk] 
		WHERE 
			[dbo].[PhysHost_Disk].[physhost_id] = @physhost_id AND
			[dbo].[PhysHost_Disk].[is_auto_detected] = 1
	END

GO

--------------------------------------------------------------------------------
-- UpdatePhysHostDiskVmsCount
PRINT N'Creating [dbo].[UpdatePhysHostDiskConnection]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdatePhysHostDiskConnection]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdatePhysHostDiskConnection]
GO

	CREATE PROCEDURE [dbo].[UpdatePhysHostDiskConnection]
			   @id uniqueidentifier,
			   @port int,
			   @path_id int,
			   @target_id int,
			   @lun int
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		UPDATE [dbo].[PhysHost_Disk] SET
			   [port] = @port,
			   [path_id] = @path_id,
			   [target_id] = @target_id,
			   [lun] = @lun,
			   [usn] = @usn
		WHERE [id] = @id
	END

GO

--------------------------------------------------------------------------------
-- GetDiskByNameAndInquiryAndControllerInquiry
PRINT N'Creating [dbo].[GetDiskByNameAndInquiryAndControllerInquiry]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetDiskByNameAndInquiryAndControllerInquiry]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetDiskByNameAndInquiryAndControllerInquiry]
GO

	CREATE PROCEDURE [dbo].[GetDiskByNameAndInquiryAndControllerInquiry]
		@name nvarchar(255),
		@controllerInquiry nvarchar(1000),
		@diskInquiry nvarchar(1000)
		
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT 
			* 
		FROM 
			[dbo].[Disks] 
		WHERE 
			[dbo].[Disks].[Name] = @name AND
			[dbo].[Disks].[controllerInquiry] = @controllerInquiry AND
			[dbo].[Disks].[diskInquiry] = @diskInquiry
			
	END

GO

--------------------------------------------------------------------------------
-- ReportServersView
PRINT N'Creating [dbo].[ReportServersView]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[ReportServersView]') AND type in (N'V'))
	DROP VIEW [dbo].[ReportServersView]
GO

CREATE VIEW [dbo].[ReportServersView]
AS
SELECT 
		[dbo].[Hosts].[id],
		[dbo].[Hosts].[name],
		[dbo].[Hosts].[description],
		[dbo].[Hosts].[type],
		[dbo].[Hosts].[parent_id],
		[dbo].[Hosts].[is_unavailable],
		[dbo].[fn.IsHostUpgradeRequired]([dbo].[Hosts].[id]) as [is_upgrade_required],
		[dbo].[fn.IsImportedHost]([dbo].[Hosts].[id]) as [is_imported],
		[dbo].[fn.GetMaxHostUsn]([dbo].[Hosts].[id]) as [usn],
		plugins.plugin_id
	FROM 
		[dbo].[Hosts] LEFT JOIN [Backup.Model.SanHostsPlugins] plugins ON [dbo].[Hosts].id = plugins.host_id
GO

--------------------------------------------------------------------------------
-- ReportServersDeleteView
PRINT N'Creating [dbo].[ReportServersDeleteView]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[ReportServersDeleteView]') AND type in (N'P'))
	DROP PROCEDURE [dbo].[ReportServersDeleteView]
GO

	CREATE PROCEDURE [dbo].[ReportServersDeleteView]
		@row_usn bigint
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT uid, usn FROM TombStones WHERE table_name= 'Hosts' AND usn > @row_usn
	END

GO

--------------------------------------------------------------------------------
-- [Backup.Model.GetMruList]
PRINT N'Creating [dbo].[Backup.Model.GetMruList]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetMruList]') AND type in (N'P'))
	DROP PROCEDURE [dbo].[Backup.Model.GetMruList]
GO

CREATE PROCEDURE [dbo].[Backup.Model.GetMruList]
	@user_name nvarchar(256)
AS
BEGIN
	SET NOCOUNT ON;
	SELECT ml.* 
		FROM [dbo].[Backup.Model.MruList] AS ml INNER JOIN [dbo].[Backup.Model.MruUsers] AS mu ON ml.[user_id] = mu.id
		WHERE mu.name = @user_name ORDER BY ml.changed_time DESC
END	
GO

--------------------------------------------------------------------------------
-- [dbo].[Backup.Model.CreateMruList]
PRINT N'Creating [dbo].[Backup.Model.CreateMruList]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.CreateMruList]') AND type in (N'P'))
	DROP PROCEDURE [dbo].[Backup.Model.CreateMruList]
GO

CREATE PROCEDURE [dbo].[Backup.Model.CreateMruList]
	@id [uniqueidentifier],
	@url	nvarchar(MAX),
	@credential_id [uniqueidentifier],
	@user_id [uniqueidentifier],
	@changed_time datetime
AS
BEGIN
	SET NOCOUNT ON;
	INSERT INTO [dbo].[Backup.Model.MruList] (id, url, credential_id, [user_id], changed_time) VALUES (@id, @url, @credential_id, @user_id, @changed_time)
END
GO

--------------------------------------------------------------------------------
-- [Backup.Model.UpdateMruList]
PRINT N'Creating [dbo].[Backup.Model.UpdateMruList]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.UpdateMruList]') AND type in (N'P'))
	DROP PROCEDURE [dbo].[Backup.Model.UpdateMruList]
GO

CREATE PROCEDURE [dbo].[Backup.Model.UpdateMruList]
	@id [uniqueidentifier],
	@credential_id [uniqueidentifier],
	@changed_time datetime
AS
BEGIN
	SET NOCOUNT ON;
	UPDATE [dbo].[Backup.Model.MruList] SET credential_id = @credential_id, changed_time = @changed_time WHERE id = @id
END
GO

--------------------------------------------------------------------------------
-- [Backup.Model.FindAllMruList]
PRINT N'Creating [dbo].[Backup.Model.FindAllMruList]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.FindAllMruList]') AND type in (N'P'))
	DROP PROCEDURE [dbo].[Backup.Model.FindAllMruList]
GO

CREATE PROCEDURE [dbo].[Backup.Model.FindAllMruList]
	@user_name nvarchar(256),
	@url  nvarchar(MAX)
AS
BEGIN
	SET NOCOUNT ON;
	
	SELECT ml.* 
		FROM [dbo].[Backup.Model.MruList] AS ml INNER JOIN [dbo].[Backup.Model.MruUsers] AS mu ON ml.[user_id] = mu.id
		WHERE mu.name = @user_name AND ml.url LIKE '%' + @url + '%'
		ORDER BY ml.changed_time DESC
END	
GO


--------------------------------------------------------------------------------
-- [Backup.Model.FindMruList]
PRINT N'Creating [dbo].[Backup.Model.FindMruList]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.FindMruList]') AND type in (N'P'))
	DROP PROCEDURE [dbo].[Backup.Model.FindMruList]
GO

CREATE PROCEDURE [dbo].[Backup.Model.FindMruList]
	@user_name nvarchar(256),
	@url  nvarchar(MAX)
AS
BEGIN
	SET NOCOUNT ON;
		
	SELECT ml.* 
		FROM [dbo].[Backup.Model.MruList] AS ml INNER JOIN [dbo].[Backup.Model.MruUsers] AS mu ON ml.[user_id] = mu.id
		WHERE mu.name = @user_name AND ml.url = @url
END	
GO


--------------------------------------------------------------------------------
-- [Backup.Model.ResolveMruUser]
PRINT N'Creating [dbo].[Backup.Model.ResolveMruUser]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.ResolveMruUser]') AND type in (N'P'))
	DROP PROCEDURE [dbo].[Backup.Model.ResolveMruUser]
GO

CREATE PROCEDURE [dbo].[Backup.Model.ResolveMruUser]
	@user_name nvarchar(256)
AS
BEGIN
	SET NOCOUNT ON;
	DECLARE @user_id [uniqueidentifier]

	SELECT @user_id = id FROM [dbo].[Backup.Model.MruUsers] WHERE name = @user_name
	IF (@user_id IS NULL) BEGIN
		SET @user_id = NEWID()
		INSERT INTO [dbo].[Backup.Model.MruUsers] (id, name) VALUES (@user_id, @user_name)
	END	
	SELECT @user_id 
END

GO

--------------------------------------------------------------------------------
-- [Backup.Model.FindLastMruList]
PRINT N'Creating [dbo].[Backup.Model.FindLastMruList]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.FindLastMruList]') AND type in (N'P'))
	DROP PROCEDURE [dbo].[Backup.Model.FindLastMruList]
GO

CREATE PROCEDURE [dbo].[Backup.Model.FindLastMruList]
	@user_name nvarchar(256)
AS
BEGIN
	SET NOCOUNT ON;
	SELECT TOP 1 ml.[id]
		,[url]
		,[credential_id]
		,[user_id]
		,[changed_time]
	FROM [dbo].[Backup.Model.MruList] ml INNER JOIN [dbo].[Backup.Model.MruUsers] mu ON ml.[user_id] = mu.id	
		WHERE [name] = @user_name
	ORDER BY [changed_time] DESC
END	
GO

--------------------------------------------------------------------------------
-- UpdateHostRuntimeInfo
PRINT N'Creating [dbo].[UpdateHostRuntimeInfo]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateHostRuntimeInfo]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateHostRuntimeInfo]
GO

	CREATE PROCEDURE [dbo].[UpdateHostRuntimeInfo]
		@row_id uniqueidentifier,
		@row_runtime_info xml
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		UPDATE [dbo].[Hosts] SET
				[runtime_info] = @row_runtime_info,
				[usn] = @usn
		WHERE [id] = @row_id
			
	END	

GO

--------------------------------------------------------------------------------
-- SetIrContentRestoreState
PRINT N'Creating [dbo].[SetIrContentRestoreState]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[SetIrContentRestoreState]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[SetIrContentRestoreState]
GO

	CREATE PROCEDURE [dbo].[SetIrContentRestoreState]	
			   @row_id uniqueidentifier,	
			   @content_restore_state int,	   
			   @content_restore_percent int
	AS
	BEGIN
		SET NOCOUNT ON;
		
		UPDATE [dbo].[VmssVms]
		SET [dbo].[VmssVms].[content_restore_state] = @content_restore_state,
			[dbo].[VmssVms].[content_restore_percent] = @content_restore_percent
		WHERE [dbo].[VmssVms].[id] = @row_id

	END   
	 
GO

--------------------------------------------------------------------------------
-- GetJobsByTypeAndPlatform
PRINT N'Creating [dbo].[GetJobsByTypeAndPlatform]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetJobsByTypeAndPlatform]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetJobsByTypeAndPlatform]
GO

	CREATE PROCEDURE [dbo].[GetJobsByTypeAndPlatform]
		@type int,
		@platform int
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[BJobs] WHERE [type] = @type AND [platform] = @platform
	END

GO

--------------------------------------------------------------------------------
-- GetChildOibs
PRINT N'Creating [dbo].[Backup.Model.GetChildOibs]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetChildOibs]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetChildOibs]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetChildOibs]
		@parent_oib_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		
		SELECT *
		FROM [dbo].[Backup.Model.OIBs]
		WHERE [dbo].[Backup.Model.OIBs].[parent_id] = @parent_oib_id
	END	

GO

--------------------------------------------------------------------------------
-- GetLeftoveredTemporaryBackups
PRINT N'Creating [dbo].[GetLeftoveredTemporaryBackups]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetLeftoveredTemporaryBackups]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetLeftoveredTemporaryBackups]
GO

	CREATE PROCEDURE [dbo].[GetLeftoveredTemporaryBackups]
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT
			DISTINCT
			[backup_id], [temporary_storage]
		FROM
			[dbo].[Backup.TrackedActions.TemporaryBackups]
		WHERE
			[backup_id] NOT IN
		(	
			SELECT 
				DISTINCT
				[dbo].[Backup.TrackedActions.TemporaryBackups].[backup_id]
			FROM
				[dbo].[Backup.TrackedActions.TemporaryBackups]
			INNER JOIN 
				[dbo].[Backup.Model.JobSessions]
			ON
				[dbo].[Backup.TrackedActions.TemporaryBackups].[session_id] = [dbo].[Backup.Model.JobSessions].[id]
			WHERE
				[dbo].[Backup.Model.JobSessions].[state] != -1
		)
	END
GO

--------------------------------------------------------------------------------
-- RegisterTemporaryBackup
PRINT N'Creating [dbo].[RegisterTemporaryBackup]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[RegisterTemporaryBackup]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[RegisterTemporaryBackup]
GO

	CREATE PROCEDURE [dbo].[RegisterTemporaryBackup]
		@session_id uniqueidentifier,
		@backup_id uniqueidentifier,
		@temporary_storage bit
	AS
	BEGIN
		SET NOCOUNT ON;
		DECLARE @existing_backup_id [uniqueidentifier]	

		SELECT @existing_backup_id = backup_id FROM [dbo].[Backup.TrackedActions.TemporaryBackups] WHERE backup_id = @backup_id AND session_id = @session_id 
		IF (@existing_backup_id IS NULL) 
		BEGIN
			INSERT INTO [dbo].[Backup.TrackedActions.TemporaryBackups] (session_id, backup_id, temporary_storage) VALUES (@session_id, @backup_id, @temporary_storage)
		END		
	END
GO

--------------------------------------------------------------------------------
-- UnregisterTemporaryBackup
PRINT N'Creating [dbo].[UnregisterTemporaryBackup]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UnregisterTemporaryBackup]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UnregisterTemporaryBackup]
GO

	CREATE PROCEDURE [dbo].[UnregisterTemporaryBackup]
		@session_id uniqueidentifier,
		@backup_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		DELETE FROM [dbo].[Backup.TrackedActions.TemporaryBackups] WHERE (backup_id = @backup_id AND session_id = @session_id)
	END
GO

--------------------------------------------------------------------------------
-- UnregisterTemporaryBackupForAllSessions
PRINT N'Creating [dbo].[UnregisterTemporaryBackupForAllSessions]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UnregisterTemporaryBackupForAllSessions]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UnregisterTemporaryBackupForAllSessions]
GO

	CREATE PROCEDURE [dbo].[UnregisterTemporaryBackupForAllSessions]
		@backup_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		DELETE FROM [dbo].[Backup.TrackedActions.TemporaryBackups] WHERE (backup_id = @backup_id)
	END
GO
--------------------------------------------------------------------------------
-- IsHostHaveObjects
PRINT N'Creating [dbo].[IsHostHaveObjects]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[IsHostHaveObjects]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[IsHostHaveObjects]
GO

	CREATE PROCEDURE [dbo].[IsHostHaveObjects] 
		@host_id uniqueidentifier
	AS
	BEGIN
		DECLARE @objsCount int
		SELECT 
			@objsCount = COUNT(*)
		FROM
			[dbo].[BObjects]
		WHERE
			[host_id] = @host_id 

		IF (@objsCount > 0)
			SELECT 1 retValue

		SELECT 0 retValue
	END

GO

--------------------------------------------------------------------------------
-- UnregisterTemporaryBackupForAllSessions
PRINT N'Creating [dbo].[GetCountActiveReplica]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetCountActiveReplica]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetCountActiveReplica]
GO
	CREATE PROCEDURE [dbo].[GetCountActiveReplica]
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT COUNT(*) FROM [dbo].[Backup.Model.OIBsFailoverInfo]
	END	
GO

--------------------------------------------------------------------------------
-- FindChildHost
PRINT N'Creating [dbo].[FindChildHost]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[FindChildHost]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[FindChildHost]
GO

	CREATE PROCEDURE [dbo].[FindChildHost] 
		@parent_id uniqueidentifier,
		@type int,
		@name nvarchar(255)
	AS
	BEGIN
		SELECT * FROM [Hosts] WHERE [parent_id] = @parent_id AND [type] = @type AND [name] = @name
	END

GO

--------------------------------------------------------------------------------
-- GetEnabledProxiesCountByType
PRINT N'Creating [dbo].[GetEnabledProxiesCountByType]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetEnabledProxiesCountByType]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetEnabledProxiesCountByType]
GO
	CREATE PROCEDURE [dbo].[GetEnabledProxiesCountByType]
		@type int
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT 
			COUNT(*) retValue 
		FROM 
			[dbo].[BackupProxies] 
		WHERE 
			[type] = @type AND
			[disabled] = 0

	END	
GO

--------------------------------------------------------------------------------
-- GetJobsByRepositoryId
PRINT N'Creating [dbo].[GetJobsByRepositoryId]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetJobsByRepositoryId]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetJobsByRepositoryId]
GO
	CREATE PROCEDURE [dbo].[GetJobsByRepositoryId]
		@repositoryId uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * FROM [dbo].[BJobs] WHERE [repository_id] = @repositoryId OR [initialsync_repository_id] = @repositoryId 
	END	
GO

--------------------------------------------------------------------------------
-- GetRepositoriesCount
PRINT N'Creating [dbo].[GetRepositoriesCount]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetRepositoriesCount]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetRepositoriesCount]
GO
	CREATE PROCEDURE [dbo].[GetRepositoriesCount]
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT COUNT(*) retValue FROM [dbo].[BackupRepositories]
	END	
GO

--------------------------------------------------------------------------------
-- CheckPlatforms
PRINT N'Creating [dbo].[CheckPlatforms]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[CheckPlatforms]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[CheckPlatforms]
GO

	CREATE PROCEDURE [dbo].[CheckPlatforms]
	AS
	BEGIN
		DECLARE @ViHostsAddedCount int
		SELECT @ViHostsAddedCount = COUNT(*) FROM [Hosts] WHERE ([type] = 0 OR [type] = 1 OR [type] = 6) AND [dbo].[fn.IsImportedHost]([id]) = 'False'

		DECLARE @HvHostsAddedCount int
		SELECT @HvHostsAddedCount = COUNT(*) FROM [Hosts] WHERE ([type] = 7 OR [type] = 8 OR [type] = 9) AND ([parent_id] = '00000000-0000-0000-0000-000000000000') AND [dbo].[fn.IsImportedHost]([id]) = 'False'

		DECLARE @VcdHostsAddedCount int
		SELECT @VcdHostsAddedCount = COUNT(*) FROM [Hosts] WHERE ([type] = 14) AND [dbo].[fn.IsImportedHost]([id]) = 'False'

		DECLARE	@ViBackupsCount int
		SELECT @ViBackupsCount = COUNT(*) FROM [Backup.Model.Backups] WHERE [platform] = 0

		DECLARE @HvBackupsCount int
		SELECT @HvBackupsCount = COUNT(*) FROM [Backup.Model.Backups] WHERE [platform] = 1

		DECLARE @VcdBackupsCount int
		SELECT @VcdBackupsCount = COUNT(*) FROM [Backup.Model.Backups] WHERE [platform] = 3

		DECLARE @isVMwareEnabled bit
		IF @ViHostsAddedCount > 0 OR @ViBackupsCount > 0
			SET @isVMwareEnabled = 1
		ELSE
			SET @isVMwareEnabled = 0

		DECLARE @isHyperVEnabled bit
		IF @HvHostsAddedCount > 0 OR @HvBackupsCount > 0
			SET @isHyperVEnabled = 1
		ELSE
			SET @isHyperVEnabled = 0
	
		DECLARE @isVcdEnabled bit
		IF @VcdHostsAddedCount > 0 OR @VcdBackupsCount > 0
			SET @isVcdEnabled = 1
		ELSE
			SET @isVcdEnabled = 0
	
		DECLARE @isTapeEnabled bit
		IF EXISTS(SELECT * FROM [dbo].[Tape.devices])
			SET @isTapeEnabled = 1
		ELSE	
			SET @isTapeEnabled = 0

		SELECT @isVMwareEnabled isVMwareEnabled, @isHyperVEnabled isHyperVEnabled, @isVcdEnabled isVcdEnabled, @isTapeEnabled isTapeEnabled
	END
GO

--------------------------------------------------------------------------------
-- GetSyncRepositories
PRINT N'Creating [dbo].[GetSyncRepositories]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetSyncRepositories]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetSyncRepositories]
GO

	CREATE PROCEDURE [dbo].[GetSyncRepositories]
	AS
	BEGIN

	SELECT * FROM [dbo].[BackupRepositories] WHERE [id] IN 
	(
		SELECT DISTINCT [initialsync_repository_id] FROM [dbo].[BJobs] WHERE initialsync_repository_id != '00000000-0000-0000-0000-000000000000'
	)
	
	END	

GO

--------------------------------------------------------------------------------
-- GetHostSyncRepositories
PRINT N'Creating [dbo].[GetHostSyncRepositories]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetHostSyncRepositories]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetHostSyncRepositories]
GO

	CREATE PROCEDURE [dbo].[GetHostSyncRepositories]
			@hostId uniqueidentifier
	AS
	BEGIN

	SELECT * FROM [dbo].[BackupRepositories] WHERE [id] IN 
	(
		SELECT DISTINCT [initialsync_repository_id] FROM [dbo].[BJobs] WHERE initialsync_repository_id != '00000000-0000-0000-0000-000000000000'
	)
	AND ISNULL([host_id], '6745a759-2205-4cd2-b172-8ec8f7e60ef8') = @hostId
	
	END	

GO

--------------------------------------------------------------------------------
-- SbJobTR TRIGGER
GO
IF OBJECT_ID ('SbJobTR', 'TR') IS NOT NULL
   DROP TRIGGER SbJobTR;
GO
CREATE TRIGGER SbJobTR
ON [dbo].[BJobs] 
FOR UPDATE AS 
if exists(select * from [BJobs], inserted, deleted where (([BJobs].id=inserted.id) AND (inserted.type = 3) AND (deleted.type <> 3)))
begin
   raiserror ('MUTATED TO SB JOB!', 16, 1) 
   rollback
end
GO

--------------------------------------------------------------------------------
-- GetVisibleHostByNameAndType
PRINT N'Creating [dbo].[GetVisibleHostByNameAndType]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetVisibleHostByNameAndType]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetVisibleHostByNameAndType]
GO

	CREATE PROCEDURE [dbo].[GetVisibleHostByNameAndType]
		@name nvarchar(max),
		@type int
	AS
	BEGIN
		SET NOCOUNT ON;

	SELECT 
		*
	FROM
		[dbo].[Hosts]
	WHERE
		[dbo].[Hosts].[name] = @name AND
		[dbo].[Hosts].[type] = @type AND
		[dbo].[fn.IsImportedHost]([dbo].[Hosts].[id]) = 'False'

	END

GO

--------------------------------------------------------------------------------
-- SetHostImported
PRINT N'Creating [dbo].[SetHostImported]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[SetHostImported]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[SetHostImported]
GO

	CREATE PROCEDURE [dbo].[SetHostImported]
		@hostId uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		DECLARE @usn BIGINT
		EXEC [dbo].[IncrementUsn] @usn OUTPUT

		DELETE FROM [dbo].[Folder_Host] WHERE [host_id] = @hostId

		UPDATE 
			[dbo].[Hosts] 
		SET 
			[parent_id] = '00000000-0000-0000-0000-000000000000',
			[physical_host_id] = '00000000-0000-0000-0000-000000000000',
			[usn] = @usn
		WHERE [id] = @hostId
	END
GO

--------------------------------------------------------------------------------
-- GetVisibleHostsByType
PRINT N'Creating [dbo].[GetVisibleHostsByType]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetVisibleHostsByType]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetVisibleHostsByType]
GO

	CREATE PROCEDURE [dbo].[GetVisibleHostsByType]
		@type int
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * FROM [dbo].[Hosts] WHERE [dbo].[Hosts].[type] = @type AND [dbo].[fn.IsImportedHost]([dbo].[Hosts].[id]) = 'False'
	END

GO

--------------------------------------------------------------------------------
-- GetVisibleUnavailableHosts
PRINT N'Creating [dbo].[GetVisibleUnavailableHosts]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetVisibleUnavailableHosts]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetVisibleUnavailableHosts]
GO

	CREATE PROCEDURE [dbo].[GetVisibleUnavailableHosts]
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * FROM [dbo].[Hosts] WHERE [dbo].[Hosts].[is_unavailable] = 'True' AND [dbo].[fn.IsImportedHost]([dbo].[Hosts].[id]) = 'False'
	END

GO

--------------------------------------------------------------------------------
-- IsHostUnavailable
PRINT N'Creating [dbo].[IsHostUnavailable]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[IsHostUnavailable]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[IsHostUnavailable]
GO

	CREATE PROCEDURE [dbo].[IsHostUnavailable] 
		@host_id uniqueidentifier
	AS
	BEGIN
		DECLARE @res BIT
	
		SET @res = 'False'

		SELECT 
			  TOP (1) @res = [dbo].[Hosts].[is_unavailable]
		FROM
			[dbo].[Hosts]	

		SELECT @res retValue
	END
GO

--------------------------------------------------------------------------------
-- GetVisibleUpgradeRequiredHostsByType
PRINT N'Creating [dbo].[GetVisibleUpgradeRequiredHostsByType]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetVisibleUpgradeRequiredHostsByType]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetVisibleUpgradeRequiredHostsByType]
GO

	CREATE PROCEDURE [dbo].[GetVisibleUpgradeRequiredHostsByType]
		@type int
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * FROM [dbo].[Hosts] WHERE [dbo].[Hosts].[type] = @type AND [dbo].[fn.IsImportedHost]([dbo].[Hosts].[id]) = 'False' AND [dbo].[fn.IsHostUpgradeRequired]([dbo].[Hosts].[id]) = 'True'
	END

GO

--------------------------------------------------------------------------------
-- FindImportedHost
PRINT N'Creating [dbo].[FindImportedHost]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[FindImportedHost]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[FindImportedHost]
GO

	CREATE PROCEDURE [dbo].[FindImportedHost] 
		@type int,
		@name nvarchar(255)
	AS
	BEGIN
		SELECT * FROM [Hosts] WHERE [type] = @type AND [name] = @name AND [dbo].[fn.IsImportedHost]([id]) = 'True'
	END

GO

--------------------------------------------------------------------------------
-- GetUpgradeRequiredHostsUsedByVisibleProxies
PRINT N'Creating [dbo].[GetUpgradeRequiredHostsUsedByVisibleProxies]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetUpgradeRequiredHostsUsedByVisibleProxies]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetUpgradeRequiredHostsUsedByVisibleProxies]
GO

	CREATE PROCEDURE [dbo].[GetUpgradeRequiredHostsUsedByVisibleProxies]
	AS
	BEGIN
		SET NOCOUNT ON;

		DECLARE @viProxyType int
		DECLARE @hvOffhostProxyType int

		DECLARE @rows_count int
		
		SET @viProxyType = 0
		SET @hvOffhostProxyType = 2

		SELECT 
			* 
		FROM 
			[dbo].[Hosts] 
		WHERE 
			[id] IN 
				(SELECT 
					DISTINCT (hosts.[id]) 
				FROM 
					[dbo].[Hosts] hosts INNER JOIN [dbo].[BackupProxies] proxies ON hosts.[id] = proxies.[host_id] 
				WHERE 
					proxies.[type] = @viProxyType OR proxies.[type] = @hvOffhostProxyType)
					
			AND [dbo].[fn.IsHostUpgradeRequired]([dbo].[Hosts].[id]) = 'True'
	END

GO

--------------------------------------------------------------------------------
-- GetUpgradeRequiredHostsUsedByRepositories
PRINT N'Creating [dbo].[GetUpgradeRequiredHostsUsedByRepositories]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetUpgradeRequiredHostsUsedByRepositories]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetUpgradeRequiredHostsUsedByRepositories]
GO

	CREATE PROCEDURE [dbo].[GetUpgradeRequiredHostsUsedByRepositories]
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT 
			* 
		FROM 
			[dbo].[Hosts] 
		WHERE 
			[id] IN 
				(SELECT 
					DISTINCT (hosts.[id]) 
				FROM 
					[dbo].[Hosts] hosts JOIN [dbo].[BackupRepositories] repositories ON hosts.[id] = repositories.[host_id] OR hosts.[id] = repositories.[mount_host_id]
				)
			AND [dbo].[fn.IsHostUpgradeRequired]([dbo].[Hosts].[id]) = 'True' 
	END
GO

--------------------------------------------------------------------------------
-- IsUpgradeRequiredRepositoryExists
PRINT N'Creating [dbo].[IsUpgradeRequiredRepositoryExists]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[IsUpgradeRequiredRepositoryExists]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[IsUpgradeRequiredRepositoryExists]
GO

	CREATE PROCEDURE [dbo].[IsUpgradeRequiredRepositoryExists]
	AS
	BEGIN
		DECLARE @rows_count int
		SELECT @rows_count = COUNT(*) FROM [dbo].[BackupRepositories] WHERE [dbo].[fn.IsHostUpgradeRequired]([dbo].[BackupRepositories].[host_id]) = 'True' OR [dbo].[fn.IsHostUpgradeRequired]([dbo].[BackupRepositories].[mount_host_id]) = 'True'
		IF @rows_count = 0
			SELECT 0 retValue
		ELSE
			SELECT 1 retValue
	END

GO

--------------------------------------------------------------------------------
-- IsUpgradeRequiredVisibleProxyExists
PRINT N'Creating [dbo].[IsUpgradeRequiredVisibleProxyExists]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[IsUpgradeRequiredVisibleProxyExists]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[IsUpgradeRequiredVisibleProxyExists]
GO

	CREATE PROCEDURE [dbo].[IsUpgradeRequiredVisibleProxyExists]
	AS
	BEGIN
		DECLARE @viProxyType int
		DECLARE @hvOffhostProxyType int

		DECLARE @rows_count int
		
		SET @viProxyType = 0
		SET @hvOffhostProxyType = 2
		
		SELECT 
			@rows_count = COUNT(*) 
		FROM 
			[dbo].[BackupProxies] proxies
		WHERE 
			(proxies.[type] = @viProxyType OR proxies.[type] = @hvOffhostProxyType) AND
			[dbo].[fn.IsHostUpgradeRequired](proxies.[host_id]) = 'True'

		IF @rows_count = 0
			SELECT 0 retValue
		ELSE
			SELECT 1 retValue
	END

GO

--------------------------------------------------------------------------------
-- GetLastUncorruptedObjOibs4ObjByTargetType
PRINT N'Creating [dbo].[GetLastUncorruptedObjectOibs4ObjByTargetType]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetLastUncorruptedObjOibs4ObjByTargetType]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetLastUncorruptedObjOibs4ObjByTargetType]
GO

	CREATE PROCEDURE [dbo].[GetLastUncorruptedObjOibs4ObjByTargetType]
		@hostId uniqueidentifier,
		@objId nvarchar(2000),
		@targetType int
	AS
	BEGIN
		DECLARE @vcdPlatform int
		DECLARE @vcdVAppObjType int
		SET @vcdPlatform = 4
		SET @vcdVAppObjType = 3
		
		SELECT 
			TOP (1) reportView.*
		FROM 
			[dbo].[ReportBackupsView] reportView INNER JOIN [dbo].[BObjects] objs ON reportView.[object_id] = objs.[id]
		WHERE 
			objs.[host_id] = @hostId 
			AND objs.[object_id] = @objId 
			AND reportView.[target_type] = @targetType 
			AND reportView.[is_corrupted] = 0
			AND (reportView.[platform] != @vcdPlatform OR reportView.[obj_type] != @vcdVAppObjType OR reportView.[is_consistent] = 1)  
		ORDER BY 
			reportView.[last_oib_creation_time] DESC
	END
GO

--------------------------------------------------------------------------------
-- IsTemporaryBackup
PRINT N'Creating [dbo].[IsTemporaryBackup]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[IsTemporaryBackup]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[IsTemporaryBackup]
GO

	CREATE PROCEDURE [dbo].[IsTemporaryBackup]
		@backup_id uniqueidentifier
	AS
	BEGIN
		DECLARE @rows_count int
		SELECT @rows_count = COUNT(*) FROM [dbo].[Backup.TrackedActions.TemporaryBackups] WHERE [backup_id] = @backup_id
		IF @rows_count = 0
			SELECT 0 retValue
		ELSE
			SELECT 1 retValue
	END
GO

--------------------------------------------------------------------------------
-- FindOrphanedVolumes
PRINT N'Creating [dbo].[FindOrphanedVolumes]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[FindOrphanedVolumes]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[FindOrphanedVolumes]
GO
	CREATE PROCEDURE [dbo].[FindOrphanedVolumes] 
	AS
	BEGIN
		SELECT * FROM [dbo].[Volumes]
		WHERE NOT [id] IN
		(
			SELECT DISTINCT 
				v.id
			FROM 
				([dbo].[Volumes] as v RIGHT JOIN [dbo].[PhysHost_Volume] as phv ON v.id = phv.volume_id)
		)
	END
GO


--------------------------------------------------------------------------------
-- Backup.Model.GetOibsFromBackup
PRINT N'Creating [dbo].[Backup.Model.GetOibsFromBackup]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetOibsFromBackup]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetOibsFromBackup]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetOibsFromBackup]
		@row_backup_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;	
		SELECT oibs.* FROM 
			[dbo].[Backup.Model.OIBs] oibs,
			[dbo].[Backup.Model.Points] p
		WHERE 
			oibs.point_id  = p.id and
			p.backup_id  = @row_backup_id
		ORDER BY p.num		
	END
GO

-- checking for the existence of a server
PRINT N'Creating [dbo].[ExistsHost]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[ExistsHost]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[ExistsHost]
GO

	CREATE PROCEDURE [dbo].[ExistsHost]
		@host_type as int
	AS
	BEGIN
		SET NOCOUNT ON;
		declare @res as bit;
		set @res = 0;
		if @host_type = 0
			if exists(select 1 from [dbo].[Hosts] h where h.[type] in (0, 1, 6))
				set @res = 1
		if @host_type = 1
			if exists(select 1 from [dbo].[Hosts] h where h.[type] in (7, 8, 9))
				set @res = 1				 
		select @res
	END
GO

--------------------------------------------------------------------------------
-- GetRootVisibleViHosts
PRINT N'Creating [dbo].[GetRootVisibleViHosts]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetRootVisibleViHosts]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetRootVisibleViHosts]
GO

	CREATE PROCEDURE [dbo].[GetRootVisibleViHosts]
	AS
	BEGIN
		SET NOCOUNT ON;

		DECLARE @vcType int
		SET @vcType = 1

		DECLARE @esxType int
		SET @esxType = 0

		DECLARE @esxiType int
		SET @esxiType = 6

		SELECT 
			* 
		FROM 
			[dbo].[Hosts]
		WHERE 
			[type] in (@esxType, @esxiType, @vcType) AND
			[dbo].[fn.IsRootVisibleHost]([id]) = 'True'

	END
GO

--------------------------------------------------------------------------------
-- GetRootVisibleHvHosts
PRINT N'Creating [dbo].[GetRootVisibleHvHosts]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetRootVisibleHvHosts]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetRootVisibleHvHosts]
GO

	CREATE PROCEDURE [dbo].[GetRootVisibleHvHosts]
	AS
	BEGIN
		SET NOCOUNT ON;

		DECLARE @hostType int
		SET @hostType = 7

		DECLARE @clusterType int
		SET @clusterType = 8

		DECLARE @scvmmType int
		SET @scvmmType = 9

		SELECT 
			* 
		FROM 
			[dbo].[Hosts]
		WHERE 
			[type] in (@hostType, @clusterType, @scvmmType) AND
			[dbo].[fn.IsRootVisibleHost]([id]) = 'True'

	END
GO

--------------------------------------------------------------------------------
-- Helpers

--------------------------------------------------------------------------------
-- HrIsProcExists

PRINT N'Creating [dbo].[HrIsProcExists]'

IF EXISTS(
	SELECT *
	FROM sys.objects
	WHERE object_id = OBJECT_ID(N'[dbo].[HrIsProcExists]') AND
	TYPE IN (N'P', N'PC')
	)
	DROP PROCEDURE [dbo].[HrIsProcExists]
GO

CREATE PROCEDURE [dbo].[HrIsProcExists]
	@proc NVARCHAR(256)
	AS
	BEGIN
		IF EXISTS(
			SELECT *
			FROM sys.objects
			WHERE object_id = OBJECT_ID(@proc) AND
			TYPE IN (N'P', N'PC')
			)
			RETURN 1;
		ELSE
			RETURN 0;
	END
GO

--------------------------------------------------------------------------------
-- HrDropProcIfExists

PRINT N'Creating [dbo].[HrDropProcIfExists]'

DECLARE @result INT
EXEC @result = HrIsProcExists @proc = N'[dbo].[HrDropProcIfExists]'
IF @result = 1
	DROP PROCEDURE [dbo].[HrDropProcIfExists]
GO

CREATE PROCEDURE [dbo].[HrDropProcIfExists]
	@proc NVARCHAR(256)
	AS
	BEGIN
		DECLARE @result INT
		EXEC @result = HrIsProcExists @proc
		IF @result = 1
			BEGIN
				EXEC('DROP PROCEDURE' + @proc)
			END
	END
GO

--------------------------------------------------------------------------------
-- HrPreCreateProc

PRINT N'Creating [dbo].[HrPreCreateProc]'

EXEC HrDropProcIfExists @proc = N'[dbo].[HrPreCreateProc]'
GO

CREATE PROCEDURE [dbo].[HrPreCreateProc]
	@proc NVARCHAR(256)
	AS
	BEGIN
		PRINT N'Creating ' + @proc
		EXEC HrDropProcIfExists @proc
	END
GO

--------------------------------------------------------------------------------
-- DataSources Management

--------------------------------------------------------------------------------
-- CreateDataSource

EXEC HrPreCreateProc @proc = N'[dbo].[CreateDataSource]'
GO

CREATE PROCEDURE [dbo].[CreateDataSource]
	@id UNIQUEIDENTIFIER,
	@name NVARCHAR(256),
	@description NVARCHAR(MAX),
	@database_name NVARCHAR(256),
	@host_name NVARCHAR(256),
	@options XML
	AS
	BEGIN
		SET NOCOUNT ON
		INSERT INTO [dbo].[DataSources] (
			[id],
			[name],
			[description],
			[database_name],
			[host_name],
			[options]
		)
		VALUES (
			@id,
			@name,
			@description,
			@database_name,
			@host_name,
			@options
		)
	END
GO

--------------------------------------------------------------------------------
-- UpdateDataSource

EXEC HrPreCreateProc @proc = N'[dbo].[UpdateDataSource]'
GO

CREATE PROCEDURE [dbo].[UpdateDataSource]
	@id UNIQUEIDENTIFIER,
	@name NVARCHAR(256),
	@description NVARCHAR(MAX),
	@database_name NVARCHAR(256),
	@host_name NVARCHAR(256),
	@options XML
	AS
	BEGIN
		SET NOCOUNT ON
		UPDATE [dbo].[DataSources] SET
			[name] = @name,
			[description] = @description,
			[database_name] = @database_name,
			[host_name] = @host_name,
			[options] = @options
		WHERE [id] = @id
	END
GO

--------------------------------------------------------------------------------
-- DeleteDataSource

EXEC HrPreCreateProc @proc = N'[dbo].[DeleteDataSource]'
GO

CREATE PROCEDURE [dbo].[DeleteDataSource]
	@id UNIQUEIDENTIFIER
	AS
	BEGIN
		SET NOCOUNT ON
		DELETE
		FROM [dbo].[DataSources]
		WHERE [id] = @id
	END
GO

--------------------------------------------------------------------------------
-- FindDataSourceById

EXEC HrPreCreateProc @proc = N'[dbo].[FindDataSourceById]'
GO

CREATE PROCEDURE [dbo].[FindDataSourceById]
	@id UNIQUEIDENTIFIER
	AS
	BEGIN
		SET NOCOUNT ON
		SELECT *
		FROM [dbo].[DataSources]
		WHERE [id] = @id
	END
GO

--------------------------------------------------------------------------------
-- FindDataSourceByName

EXEC HrPreCreateProc @proc = N'[dbo].[FindDataSourceByName]'
GO

CREATE PROCEDURE [dbo].[FindDataSourceByName]
	@name NVARCHAR(256)
	AS
	BEGIN
		SET NOCOUNT ON
		SELECT *
		FROM [dbo].[DataSources]
		WHERE [name] = @name
	END
GO

--------------------------------------------------------------------------------
-- EnumAllDataSources

EXEC HrPreCreateProc @proc = N'[dbo].[EnumAllDataSources]'
GO

CREATE PROCEDURE [dbo].[EnumAllDataSources]
	AS
	BEGIN
		SET NOCOUNT ON
		SELECT *
		FROM [dbo].[DataSources]
	END
GO

--------------------------------------------------------------------------------
-- EnumDataSourcesByHostName

EXEC HrPreCreateProc @proc = N'[dbo].[EnumDataSourcesByHostName]'
GO

CREATE PROCEDURE [dbo].[EnumDataSourcesByHostName]
	@host_name NVARCHAR(256)
	AS
	BEGIN
		SET NOCOUNT ON
		SELECT *
		FROM [dbo].[DataSources]
		WHERE [host_name] = @host_name
	END
GO

--------------------------------------------------------------------------------
-- IsExistsBackups
PRINT N'Creating [dbo].[IsExistsBackups]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[IsExistsBackups]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[IsExistsBackups]
GO

CREATE PROC IsExistsBackups
AS
BEGIN
	SET NOCOUNT ON;
	IF EXISTS(SELECT TOP(1) id FROM [dbo].[Backup.Model.Backups] WHERE target_type IN (0, 4)) -- Backups & Tapes
		SELECT 1
	ELSE
	BEGIN
		IF EXISTS(SELECT TOP(1) back.id FROM [Backup.Model.Backups] back -- SAN (exclude backups without points and oibs)
				INNER JOIN [Backup.Model.Points] pnt ON pnt.backup_id = back.id
				INNER JOIN [Backup.Model.OIBs] oibs ON oibs.point_id = pnt.id
				WHERE target_type = 3)
			SELECT 1
		ELSE
			SELECT 0
	END
		
END		
GO

-- IsExistsDiskBackups
PRINT N'Creating [dbo].[IsExistsDiskBackups]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[IsExistsDiskBackups]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[IsExistsDiskBackups]
GO

CREATE PROC IsExistsDiskBackups
AS
BEGIN
	SET NOCOUNT ON;
	IF EXISTS (SELECT TOP(1) id FROM [dbo].[Backup.Model.Backups] WHERE target_type = 0 
			AND repository_id IS NOT NULL
			AND repository_id <> '00000000-0000-0000-0000-000000000000'	
			AND job_id IS NOT NULL
			AND job_id <> '00000000-0000-0000-0000-000000000000')
		SELECT 1
	ELSE
		SELECT 0	
END		
GO	

-- IsExistsImportBackups
PRINT N'Creating [dbo].[IsExistsImportBackups]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[IsExistsImportBackups]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[IsExistsImportBackups]
GO

CREATE PROC IsExistsImportBackups
AS 
BEGIN
	SET NOCOUNT ON;
	IF EXISTS (SELECT TOP(1) id FROM [dbo].[Backup.Model.Backups] WHERE 
			target_type = 0 AND 
			(job_id IS NULL OR job_id = '00000000-0000-0000-0000-000000000000'))
		SELECT 1
	ELSE
		SELECT 0	
END
GO


-- IsExistsReplicas
PRINT N'Creating [dbo].[IsExistsReplicas]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[IsExistsReplicas]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[IsExistsReplicas]
GO

CREATE PROC IsExistsReplicas
AS
BEGIN
	SET NOCOUNT ON;
	IF EXISTS(SELECT TOP(1) back.id FROM [Backup.Model.Backups] back
				INNER JOIN [Backup.Model.Points] pnt ON pnt.backup_id = back.id
				INNER JOIN [Backup.Model.OIBs] oibs ON oibs.point_id = pnt.id
				WHERE target_type IN (2, 5))
		SELECT 1
	ELSE
		SELECT 0
END		
GO

-- IsExistsBackups
PRINT N'Creating [dbo].[IsExistsReadyReplicas]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[IsExistsReadyReplicas]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[IsExistsReadyReplicas]
GO

CREATE PROC IsExistsReadyReplicas
AS
BEGIN
	SET NOCOUNT ON;
	IF EXISTS (SELECT TOP (1) oibs.id FROM 
			[dbo].[Backup.Model.OIBs] oibs 
				INNER JOIN [dbo].[Backup.Model.Points] points ON oibs.point_id = points.id	
				INNER JOIN [dbo].[Backup.Model.Backups] back ON back.id = points.backup_id
				LEFT JOIN dbo.[Backup.Model.JobSessions] sess ON sess.[job_id] = back.[job_id] AND sess.[state] <> -1
			WHERE target_type IN (2, 5) 
				AND sess.id IS NULL 
				AND oibs.id NOT IN (SELECT oib_id FROM [dbo].[Backup.Model.OIBsFailoverInfo]))
		SELECT 1
	ELSE	
		SELECT 0
END		
GO	

-- IsTapeBackupsExist
PRINT N'Creating [dbo].[IsTapeBackupsExist]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[IsTapeBackupsExist]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[IsTapeBackupsExist]
GO

CREATE PROC IsTapeBackupsExist
AS
BEGIN
	SET NOCOUNT ON;
	IF EXISTS(SELECT TOP(1) id FROM [dbo].[Backup.Model.Backups] WHERE target_type = 4)
		SELECT 1
	ELSE
		SELECT 0
		
END		
GO

-- IsExistsSanBackups
PRINT N'Creating [dbo].[IsExistsSanBackups]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[IsExistsSanBackups]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[IsExistsSanBackups]
GO

CREATE PROC [dbo].[IsExistsSanBackups]
AS 
BEGIN
	SET NOCOUNT ON;
	IF EXISTS (
		SELECT 
			TOP(1) backup_id
		FROM 
			[dbo].[Backup.Model.Backups] backups 
			join [dbo].[Backup.Model.Points] points on backups.id = points.backup_id
			join [dbo].[Backup.Model.OIBs] oibs on points.id = oibs.point_id 
		WHERE target_type = 3
		)
		SELECT 1
	ELSE
		SELECT 0		
END
GO

--------------------------------------------------------------------------------
PRINT N'Creating [dbo].[GetHostsWithoutInstanceId]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetHostsWithoutInstanceId]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetHostsWithoutInstanceId]
GO
	CREATE PROCEDURE [dbo].[GetHostsWithoutInstanceId]
	AS
	BEGIN
		SELECT 
			* 
		FROM 
			[dbo].[Hosts]
		WHERE 
			[dbo].[Hosts].[host_instance_id] = null
	END
GO

--------------------------------------------------------------------------------
PRINT N'Creating [dbo].[UpdateHostsHostInstanceId]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateHostsHostInstanceId]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateHostsHostInstanceId]
GO
	CREATE PROCEDURE [dbo].[UpdateHostsHostInstanceId]
		@host_id uniqueidentifier,
		@host_instance_id nvarchar(255)
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		UPDATE 
			[dbo].[Hosts] 
		SET 
			[host_instance_id] = @host_instance_id,
			[usn] = @usn
		where [id] = @host_id
	END
GO

---------------------------------------------------------------------------------
PRINT N'Creating [dbo].[FindHostsByHostInstanceId]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[FindHostsByHostInstanceId]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[FindHostsByHostInstanceId]
GO
CREATE PROCEDURE [dbo].[FindHostsByHostInstanceId]
	@host_instance_id varchar(255)
AS
BEGIN
	SET NOCOUNT ON;
	SELECT * 
	FROM [dbo].[Hosts]
	WHERE [host_instance_id] = @host_instance_id
END
GO
-----------------------------------------------------
PRINT N'Creating [dbo].[usp.Hierarchy.SyncVmsRecursiveInclusion]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[usp.Hierarchy.SyncVmsRecursiveInclusion]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[usp.Hierarchy.SyncVmsRecursiveInclusion]
GO
CREATE PROCEDURE [dbo].[usp.Hierarchy.SyncVmsRecursiveInclusion]
	@objId varbinary(16),
	@changesDoc xml
AS
BEGIN
	SET NOCOUNT ON;

    CREATE TABLE #syncVmsRecInclusion (
		[id] as [container_key_hash] + [vm_key_hash] PERSISTED NOT NULL,		
		[container_key_hash] varbinary(16),
        [vm_key_hash] varbinary(16),
		[vm_real_name] nvarchar(256)
        CONSTRAINT [PK_Hierarchy.VmsRecursiveInclusion] PRIMARY KEY CLUSTERED 
		(
			[id] ASC
		)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
		) ON [PRIMARY]
    
    DECLARE @idoc int
    EXEC sp_xml_preparedocument @idoc OUTPUT, @changesDoc
    
    INSERT INTO #syncVmsRecInclusion([container_key_hash],[vm_key_hash],[vm_real_name])	
    SELECT @objId, [dbo].[fn.Common.FromBase64](vm_key_hash), vm_real_name
    FROM OPENXML( @idoc, '/Root/row', 2)
    WITH
    (        
        [vm_key_hash] nvarchar(max) 'vm_key_hash',
		[vm_real_name] nvarchar(256) 'vm_real_name'
    )
    EXEC sp_xml_removedocument @idoc
    
    --select  * from #syncVmsRecInclusion
	
	UPDATE [dbo].[Hierarchy.VmsRecursiveInclusion]
	SET 
        [vm_key_hash]  = src.[vm_key_hash],
		[vm_real_name] = src.[vm_real_name]
    FROM [dbo].[Hierarchy.VmsRecursiveInclusion] tgt INNER JOIN #syncVmsRecInclusion src ON tgt.[id] = src.[id]
    WHERE tgt.[container_key_hash] = @objId

	INSERT INTO [dbo].[Hierarchy.VmsRecursiveInclusion] ([container_key_hash], [vm_key_hash], [vm_real_name])
	SELECT 
		@objId,
		src.[vm_key_hash],
		src.[vm_real_name]
	FROM #syncVmsRecInclusion src LEFT OUTER JOIN [dbo].[Hierarchy.VmsRecursiveInclusion] tgt ON src.[id] = tgt.[id]
	WHERE tgt.id IS NULL

	DELETE [dbo].[Hierarchy.VmsRecursiveInclusion]
	FROM [dbo].[Hierarchy.VmsRecursiveInclusion] tgt LEFT OUTER JOIN #syncVmsRecInclusion src ON tgt.[id] = src.[id]
	WHERE tgt.[container_key_hash] = @objId AND src.[id] IS NULL
	
	DROP TABLE #syncVmsRecInclusion

END
GO



PRINT N'Creating [dbo].[HierarchyScan.GetVmsInContainer]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[HierarchyScan.GetVmsInContainer]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[HierarchyScan.GetVmsInContainer]
GO

CREATE PROCEDURE [dbo].[HierarchyScan.GetVmsInContainer]
	@container_key varbinary(16)
AS
BEGIN
	SET NOCOUNT ON;
	SELECT vm_key_hash, vm_real_name FROM [dbo].[Hierarchy.VmsRecursiveInclusion] WHERE container_key_hash = @container_key;
END
GO

	--------------------------------------------------------------------------------
-- [AddSanVolume]
PRINT N'Creating [dbo].[AddSanVolume]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[AddSanVolume]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[AddSanVolume]
GO
	CREATE PROCEDURE [dbo].[AddSanVolume]
		@row_id uniqueidentifier,
		@row_name nvarchar(255),
		@row_parent_id uniqueidentifier,
		@row_iqn_or_wwn nvarchar(512),		
		@row_size bigint,
		@row_thin_provision bit,
		@row_consumed_space bigint,
		@row_saved_space bigint,
		@row_host_id uniqueidentifier,
		@row_aux_data xml,
		@row_san_type int,
		@row_internal_id nvarchar(255)
	AS
	BEGIN
		declare @update_usn bigint
		exec [dbo].[IncrementUsn] @update_usn OUTPUT
		INSERT INTO [dbo].[Backup.Model.SanVolumes]
			   ([id]
			   ,[name]
			   ,[parent_id]
			   ,[iqn_or_wwn]			   
			   ,[usn]
			   ,[size]
			   ,[is_thin_provision]
			   ,[consumed_space]
			   ,[saved_space]
			   ,[host_id]
			   ,[aux_data]
			   ,[san_type]
			   ,[internal_id])
		 VALUES
			   (@row_id,
				@row_name,
				@row_parent_id,
				@row_iqn_or_wwn,				
				@update_usn,
				@row_size,
				@row_thin_provision,
				@row_consumed_space,
				@row_saved_space,
				@row_host_id,
				@row_aux_data,
				@row_san_type,
				@row_internal_id)
	END	

GO
--------------------------------------------------------------------------------
-- [UpdateSanVolume]
PRINT N'Creating [dbo].[UpdateSanVolume]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateSanVolume]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateSanVolume]
GO
	CREATE PROCEDURE [dbo].[UpdateSanVolume]
		@row_id uniqueidentifier,
		@row_name nvarchar(255),
		@row_parent_id uniqueidentifier,
		@row_iqn_or_wwn nvarchar(512),		
		@row_size bigint,
		@row_thin_provision bit,
		@row_consumed_space bigint,
		@row_saved_space bigint,
		@row_host_id uniqueidentifier,
		@row_aux_data xml,
		@row_san_type int,
		@row_internal_id nvarchar(255)
	AS
	BEGIN
		declare @update_usn bigint
		exec [dbo].[IncrementUsn] @update_usn OUTPUT
		UPDATE [dbo].[Backup.Model.SanVolumes] SET
			   [name] = @row_name,
			   [parent_id] = @row_parent_id,
			   [iqn_or_wwn] = @row_iqn_or_wwn,			   
			   [usn] = @update_usn,
			   [size] = @row_size,
			   [is_thin_provision] = @row_thin_provision,
			   [consumed_space] =	@row_consumed_space,
			   [saved_space] =	@row_saved_space,
			   [host_id] = @row_host_id,
			   [aux_data] = @row_aux_data,
			   [san_type] = @row_san_type,
			   [internal_id] = @row_internal_id
			   WHERE [id] = @row_id
	END	

GO
--------------------------------------------------------------------------------
-- [GetSanVolume]
PRINT N'Creating [dbo].[GetSanVolume]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetSanVolume]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetSanVolume]
GO
	CREATE PROCEDURE [dbo].[GetSanVolume]
		@row_id uniqueidentifier
	AS
	BEGIN
		SELECT * FROM [dbo].[Backup.Model.SanVolumes]
			   WHERE [id] = @row_id
	END	
GO	
--------------------------------------------------------------------------------
-- [GetAllSanVolumes]
PRINT N'Creating [dbo].[GetAllSanVolumes]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetAllSanVolumes]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetAllSanVolumes]
GO
	CREATE PROCEDURE [dbo].[GetAllSanVolumes]
	AS
	BEGIN
		SELECT * FROM [dbo].[Backup.Model.SanVolumes]
	END	

GO

--------------------------------------------------------------------------------
-- [GetSanVolumesInParent]
PRINT N'Creating [dbo].[GetSanVolumesInParent]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetSanVolumesInParent]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetSanVolumesInParent]
GO
	CREATE PROCEDURE [dbo].[GetSanVolumesInParent]
		@row_parent_id uniqueidentifier
	AS
	BEGIN
		SELECT * FROM [dbo].[Backup.Model.SanVolumes]
		WHERE parent_id = @row_parent_id
	END	

GO

--------------------------------------------------------------------------------
-- [GetSanVolumeByNameInParent]
PRINT N'Creating [dbo].[GetSanVolumeByNameInParent]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetSanVolumeByNameInParent]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].GetSanVolumeByNameInParent
GO

	CREATE PROCEDURE [dbo].GetSanVolumeByNameInParent
		@row_name nvarchar(255),
		@row_parent_id uniqueidentifier
	AS
	BEGIN
		SELECT * FROM [dbo].[Backup.Model.SanVolumes]
		WHERE [name] = @row_name AND [parent_id] = @row_parent_id
	END	
GO	

--------------------------------------------------------------------------------
-- [AddSanSnapshot]
PRINT N'Creating [dbo].[AddSanSnapshot]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[AddSanSnapshot]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[AddSanSnapshot]
GO
	CREATE PROCEDURE [dbo].[AddSanSnapshot]
		@row_id uniqueidentifier,
		@row_name nvarchar(255),
		@creation_time datetime,
		@row_volume_id uniqueidentifier,
		@iqn_or_wwn nvarchar(255),
		@indexed int,
		@consumed_space bigint,
		@vmfs_version int,
		@app_managed bit,
		@parent_snapshot_id uniqueidentifier,
		@aux_data xml,
		@internal_id nvarchar(255)
	AS
	BEGIN
		declare @update_usn bigint
		exec [dbo].[IncrementUsn] @update_usn OUTPUT
		INSERT INTO [dbo].[Backup.Model.SanSnapshots]
			   ([id]
			   ,[name]
			   ,[creation_time]
			   ,[volume_id]
			   ,[iqn_or_wwn]
			   ,[usn]
			   ,[indexed]
			   ,[consumed_space]
			   ,[vmfs_version]
			   ,[app_managed]
			   ,[parent_snapshot_id]
			   ,[aux_data]
			   ,[internal_id]
			   )
		 VALUES
			   (@row_id,
				@row_name,
				@creation_time,
				@row_volume_id,
				@iqn_or_wwn,
				@update_usn,
				@indexed,
				@consumed_space,
				@vmfs_version,
				@app_managed,
				@parent_snapshot_id,
				@aux_data,
				@internal_id)
	END	

GO
--------------------------------------------------------------------------------
-- [UpdateSanSnapshot]
PRINT N'Creating [dbo].[UpdateSanSnapshot]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateSanSnapshot]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateSanSnapshot]
GO
	CREATE PROCEDURE [dbo].[UpdateSanSnapshot]
		@row_id uniqueidentifier,
		@row_name nvarchar(255),
		@creation_time datetime,
		@row_volume_id uniqueidentifier,
		@iqn_or_wwn nvarchar(255),
		@indexed int,
		@consumed_space bigint,
		@vmfs_version int,
		@app_managed bit,
		@parent_snapshot_id uniqueidentifier,
		@aux_data xml,
		@internal_id nvarchar(255)
	AS
	BEGIN
		declare @update_usn bigint
		exec [dbo].[IncrementUsn] @update_usn OUTPUT
		UPDATE [dbo].[Backup.Model.SanSnapshots] SET
			   [name] = @row_name,
			   [creation_time] = @creation_time,
			   [volume_id] = @row_volume_id,
			   [iqn_or_wwn] = @iqn_or_wwn,
			   [usn] = @update_usn,
			   [indexed] = @indexed,
			   [consumed_space] = @consumed_space,
			   [vmfs_version] = @vmfs_version,
			   [app_managed] = @app_managed,
			   [parent_snapshot_id] = @parent_snapshot_id,
			   [aux_data] = @aux_data,
			   [internal_id] = @internal_id
			   WHERE [id] = @row_id
	END	

GO
--------------------------------------------------------------------------------
-- [GetSanSnapshot]
PRINT N'Creating [dbo].[GetSanSnapshot]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetSanSnapshot]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetSanSnapshot]
GO
	CREATE PROCEDURE [dbo].[GetSanSnapshot]
		@row_id uniqueidentifier
	AS
	BEGIN
		SELECT * FROM [dbo].[Backup.Model.SanSnapshots]
			   WHERE [id] = @row_id
	END	
GO	
--------------------------------------------------------------------------------
-- [GetAllSanSnapshots]
PRINT N'Creating [dbo].[GetAllSanSnapshots]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetAllSanSnapshots]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetAllSanSnapshots]
GO
	CREATE PROCEDURE [dbo].[GetAllSanSnapshots]
	AS
	BEGIN
		SELECT * FROM [dbo].[Backup.Model.SanSnapshots]
	END	

GO

--------------------------------------------------------------------------------
-- [GetSanSnapshotsInVolume]
PRINT N'Creating [dbo].[GetSanSnapshotsInVolume]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetSanSnapshotsInVolume]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetSanSnapshotsInVolume]
GO
	CREATE PROCEDURE [dbo].[GetSanSnapshotsInVolume]
		@row_volume_id uniqueidentifier
	AS
	BEGIN
		SELECT * FROM [dbo].[Backup.Model.SanSnapshots]
		WHERE volume_id = @row_volume_id
	END	

GO

--------------------------------------------------------------------------------
-- [GetSanSnapshotByNameInVolume]
PRINT N'Creating [dbo].[GetSanSnapshotByNameInVolume]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetSanSnapshotByNameInVolume]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].GetSanSnapshotByNameInVolume
GO

	CREATE PROCEDURE [dbo].GetSanSnapshotByNameInVolume
		@row_name nvarchar(255),
		@row_volume_id uniqueidentifier
	AS
	BEGIN
		SELECT * FROM [dbo].[Backup.Model.SanSnapshots]
		WHERE [name] = @row_name AND [volume_id] = @row_volume_id
	END	
GO	

--------------------------------------------------------------------------------
PRINT N'Creating [dbo].[ReportSanSnapshotView]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[ReportSanSnapshotView]') AND type in (N'V'))
	DROP VIEW [dbo].[ReportSanSnapshotView]
GO
CREATE VIEW [dbo].[ReportSanSnapshotView]
AS
	SELECT 
		sn.id, 
		sn.name, 
		sn.creation_time, 
		sn.volume_id, 
		vl.name as volume_name, 
		vl.size as reported_size,
		sn.consumed_space,
		sn.app_managed,
		sn.aux_data,
		sn.parent_snapshot_id,
		[dbo].[fn.GetSnapshotVmsCount](sn.id) as vms_count,
		[dbo].[fn.GetSnapshotMaxUsn](sn.id) as usn
	FROM 
		[dbo].[Backup.Model.SanSnapshots] sn
		inner join [dbo].[Backup.Model.SanVolumes] vl ON vl.id = sn.volume_id
GO

--------------------------------------------------------------------------------
PRINT N'Creating [dbo].[ReportSanVolumeDeleteView]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[ReportSanVolumeDeleteView]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[ReportSanVolumeDeleteView]
GO
	CREATE PROCEDURE [dbo].[ReportSanVolumeDeleteView]
		@row_usn bigint
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT uid, usn FROM TombStones WHERE table_name= 'Backup.Model.SanVolumes' AND usn > @row_usn
	END

GO

--------------------------------------------------------------------------------
PRINT N'Creating [dbo].[ReportSanSnapshotDeleteView]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[ReportSanSnapshotDeleteView]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[ReportSanSnapshotDeleteView]
GO
	CREATE PROCEDURE [dbo].[ReportSanSnapshotDeleteView]
		@row_usn bigint
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT uid, usn FROM TombStones WHERE table_name= 'Backup.Model.SanSnapshots' AND usn > @row_usn
	END

GO

--------------------------------------------------------------------------------
-- [AddSmbFileShare]
PRINT N'Creating [dbo].[AddSmbFileShare]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[AddSmbFileShare]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[AddSmbFileShare]
GO
	CREATE PROCEDURE [dbo].[AddSmbFileShare]
		@row_id uniqueidentifier,
		@server_name nvarchar(255),
		@folder_name nvarchar(255),
		@host_id uniqueidentifier,
		@credentials_id uniqueidentifier,
		@type int,
		@max_snapshots_count int
	AS
	BEGIN
		declare @update_usn bigint
		exec [dbo].[IncrementUsn] @update_usn OUTPUT
		INSERT INTO [dbo].[SmbFileShares]
			   ([id]
			   ,[server_name]
			   ,[folder_name]
			   ,[host_id]
			   ,[credentials_id]
			   ,[type]
			   ,[max_snapshots_count])
		 VALUES
			   (@row_id,
				@server_name,
				@folder_name,
				@host_id,
				@credentials_id,
				@type,
				@max_snapshots_count)
	END	
GO

--------------------------------------------------------------------------------
-- [UpdateSmbFileShare]
PRINT N'Creating [dbo].[UpdateSmbFileShare]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateSmbFileShare]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateSmbFileShare]
GO
	CREATE PROCEDURE [dbo].[UpdateSmbFileShare]
		@row_id uniqueidentifier,
		@server_name nvarchar(255),
		@folder_name nvarchar(255),
		@host_id uniqueidentifier,
		@credentials_id uniqueidentifier,
		@type int,
		@max_snapshots_count int
	AS
	BEGIN
		SET NOCOUNT ON;
		UPDATE [dbo].[SmbFileShares] SET
			   [server_name]		=@server_name,
			   [folder_name]		=@folder_name,
			   [host_id]			=@host_id,
			   [credentials_id]		=@credentials_id,
			   [type]				=@type,
			   [max_snapshots_count] = @max_snapshots_count		   
			where [id] = @row_id
	END	
GO


--------------------------------------------------------------------------------
-- DeleteSmbFileShare
PRINT N'Creating [dbo].[DeleteSmbFileShare]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DeleteSmbFileShare]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[DeleteSmbFileShare]
GO

	CREATE PROCEDURE [dbo].[DeleteSmbFileShare]
		@row_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		DELETE FROM [dbo].[SmbFileShares] WHERE [id] = @row_id
	END

GO


--------------------------------------------------------------------------------
-- FindSmbFileSharesByServerAndFolderNames
PRINT N'Creating [dbo].[FindSmbFileSharesByServerAndFolderNames]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[FindSmbFileSharesByServerAndFolderNames]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[FindSmbFileSharesByServerAndFolderNames]
GO

	CREATE PROCEDURE [dbo].[FindSmbFileSharesByServerAndFolderNames]
		@server_name nvarchar(255),
		@folder_name nvarchar(255)		
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[SmbFileShares] where [server_name] = @server_name and [folder_name] = @folder_name
	END

GO

--------------------------------------------------------------------------------
-- FindSmbFileSharesById
PRINT N'Creating [dbo].[FindSmbFileSharesById]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[FindSmbFileSharesById]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[FindSmbFileSharesById]
GO

	CREATE PROCEDURE [dbo].[FindSmbFileSharesById]
		@row_id uniqueidentifier	
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[SmbFileShares] where [id] = @row_id
	END

GO

--------------------------------------------------------------------------------
-- FindSmbFileSharesByHostId
PRINT N'Creating [dbo].[FindSmbFileSharesByHostId]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[FindSmbFileSharesByHostId]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[FindSmbFileSharesByHostId]
GO

	CREATE PROCEDURE [dbo].[FindSmbFileSharesByHostId]
		@host_id uniqueidentifier	
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[SmbFileShares] where [host_id] = @host_id
	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.GetBackupForSanVolume
PRINT N'Creating [dbo].[Backup.Model.GetBackupForSanVolume]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetBackupForSanVolume]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetBackupForSanVolume]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetBackupForSanVolume]
		@volumeId uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;	
		SELECT [b].*, [vb].[volume_id] 
		from 
			[dbo].[Backup.Model.Backups] AS [b] 
		LEFT JOIN 
			[dbo].[Backup.Model.SanVolumeBackups] AS [vb] ON [b].[id]=[vb].[backup_id]  			
		where
			[vb].[volume_id] = @volumeId	
	END

GO
--------------------------------------------------------------------------------
-- Backup.Model.GetStorageForSanSnapshot
PRINT N'Creating [dbo].[Backup.Model.GetStorageForSanSnapshot]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetStorageForSanSnapshot]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetStorageForSanSnapshot]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetStorageForSanSnapshot]
		@snapshotId uniqueidentifier		
	AS
	BEGIN
		SET NOCOUNT ON;	
		SELECT [s].*, [ss].[snapshot_id] 
		from 
			[dbo].[Backup.Model.Storages] AS [s] 
		LEFT JOIN 
			[dbo].[Backup.Model.SanSnapshotStorages] AS [ss] ON [s].[id]=[ss].[storage_id] 			
		where
			[ss].[snapshot_id] = @snapshotId				
	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.DeleteSanSnapshot
PRINT N'Creating [dbo].[Backup.Model.DeleteSanSnapshot]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.DeleteSanSnapshot]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.DeleteSanSnapshot]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.DeleteSanSnapshot]
		@id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;						
			
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT									

		DELETE [dbo].[Backup.Model.SanSnapshots] WHERE id = @id								
		DELETE [dbo].[Backup.Model.SanSnapshotStorages] WHERE snapshot_id = @id

		exec [dbo].[InsertTombStone] 'Backup.Model.SanSnapshots', @id, @usn

	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.DeleteSanVolume
PRINT N'Creating [dbo].[Backup.Model.DeleteSanVolume]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.DeleteSanVolume]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.DeleteSanVolume]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.DeleteSanVolume]
		@id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;						
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT				

		DELETE [dbo].[Backup.Model.SanVolumes] WHERE id = @id							
		DELETE [dbo].[Backup.Model.SanVolumeBackups] WHERE volume_id = @id	
		
		exec [dbo].[InsertTombStone] 'Backup.Model.SanVolumes', @id, @usn					
	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.GetSanVolumeForBackup
PRINT N'Creating [dbo].[Backup.Model.GetSanVolumeForBackup]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetSanVolumeForBackup]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetSanVolumeForBackup]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetSanVolumeForBackup]
		@backupId uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;	
		SELECT [v].*
		from 
			[dbo].[Backup.Model.SanVolumes] AS [v] 
		LEFT JOIN 
			[dbo].[Backup.Model.SanVolumeBackups] AS [vb] ON [v].[id]=[vb].[volume_id]  			
		where
			[vb].[backup_id] = @backupId	
	END

GO
--------------------------------------------------------------------------------
-- Backup.Model.GetSanSnapshotForStorage
PRINT N'Creating [dbo].[Backup.Model.GetSanSnapshotForStorage]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetSanSnapshotForStorage]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetSanSnapshotForStorage]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetSanSnapshotForStorage]
		@storageId uniqueidentifier		
	AS
	BEGIN
		SET NOCOUNT ON;	
		SELECT [s].*
		from 
			[dbo].[Backup.Model.SanSnapshots] AS [s] 
		LEFT JOIN 
			[dbo].[Backup.Model.SanSnapshotStorages] AS [ss] ON [s].[id]=[ss].[snapshot_id] 			
		where
			[ss].[storage_id] = @storageId				
	END

GO

--------------------------------------------------------------------------------
-- [AddSanSnapshotStorageLink]
PRINT N'Creating [dbo].[AddSanSnapshotStorageLink]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[AddSanSnapshotStorageLink]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[AddSanSnapshotStorageLink]
GO
	CREATE PROCEDURE [dbo].[AddSanSnapshotStorageLink]
		@snapshot_id uniqueidentifier,
		@storage_id uniqueidentifier
	AS
	BEGIN
		declare @update_usn bigint
		exec [dbo].[IncrementUsn] @update_usn OUTPUT
		
		INSERT INTO [dbo].[Backup.Model.SanSnapshotStorages]([storage_id], [snapshot_id]) VALUES (@storage_id, @snapshot_id)				
	END	

GO

--------------------------------------------------------------------------------
-- [AddSanVolumeBackupLink]
PRINT N'Creating [dbo].[AddSanVolumeBackupLink]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[AddSanVolumeBackupLink]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[AddSanVolumeBackupLink]
GO
	CREATE PROCEDURE [dbo].[AddSanVolumeBackupLink]
		@volume_id uniqueidentifier,
		@backup_id uniqueidentifier
	AS
	BEGIN
		declare @update_usn bigint
		exec [dbo].[IncrementUsn] @update_usn OUTPUT
		
		INSERT INTO [dbo].[Backup.Model.SanVolumeBackups]([backup_id], [volume_id]) VALUES (@backup_id, @volume_id)		
	END	

GO




-- [AddTaskResource]
PRINT N'Creating [dbo].[AddTaskResource]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[AddTaskResource]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[AddTaskResource]
GO
	CREATE PROCEDURE [dbo].[AddTaskResource]
		@task_id uniqueidentifier,
		@res_id uniqueidentifier,
		@res_type int
	AS
	BEGIN
		declare @update_usn bigint
		exec [dbo].[IncrementUsn] @update_usn OUTPUT
		
		INSERT INTO [dbo].[Backup.Model.ResourceUsages]([task_id], [resource_id], [resource_type]) 
		VALUES (@task_id, @res_id, @res_type)		
	END	

GO

-- [RemoveTaskResource]
PRINT N'Creating [dbo].[RemoveTaskResource]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[RemoveTaskResource]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[RemoveTaskResource]
GO
	CREATE PROCEDURE [dbo].[RemoveTaskResource]
		@task_id uniqueidentifier,
		@res_id uniqueidentifier
	AS
	BEGIN		
		DELETE FROM [dbo].[Backup.Model.ResourceUsages]
		WHERE [task_id] = @task_id AND [resource_id] = @res_id
	END	

GO

-- [CleanupRuntimeData]
PRINT N'Creating [dbo].[CleanupRuntimeData]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[CleanupRuntimeData]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[CleanupRuntimeData]
GO
	CREATE PROCEDURE [dbo].[CleanupRuntimeData]	
	AS
	BEGIN		
		DELETE FROM [dbo].[Backup.Model.ResourceUsages]
	END	
GO


--------------------------------------------------------------------------------
-- GetRootVisibleHvHosts
PRINT N'Creating [dbo].[GetRootVisibleSmbV3Hosts]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetRootVisibleSmbV3Hosts]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetRootVisibleSmbV3Hosts]
GO

	CREATE PROCEDURE [dbo].[GetRootVisibleSmbV3Hosts]
	AS
	BEGIN
		SET NOCOUNT ON;

		DECLARE @hostType int
		SET @hostType = 12

		DECLARE @clusterType int
		SET @clusterType = 13

		SELECT 
			* 
		FROM 
			[dbo].[Hosts]
		WHERE 
			[type] in (@hostType, @clusterType) AND
			[dbo].[fn.IsRootVisibleHost]([id]) = 'True'

	END
GO


--------------------------------------------------------------------------------
-- UpdateBackupRepository
PRINT N'Creating [dbo].[UpdateBackupRepositorySpaceInfo]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateBackupRepositorySpaceInfo]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateBackupRepositorySpaceInfo]
GO

	CREATE PROCEDURE [dbo].[UpdateBackupRepositorySpaceInfo]
			@id uniqueidentifier,
			@total_space bigint,
			@free_space bigint
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		UPDATE [dbo].[BackupRepositories] 
		SET
			   [total_space] = @total_space,
			   [free_space] = @free_space
		WHERE [id] = @id
	END
	
GO

--------------------------------------------------------------------------------
-- ReportSnapshotVmStatisticsView
PRINT N'Creating [dbo].[ReportSnapshotVmStatisticsView]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[ReportSnapshotVmStatisticsView]') AND type in (N'V'))
	DROP VIEW [dbo].[ReportSnapshotVmStatisticsView]
GO

CREATE VIEW ReportSnapshotVmStatisticsView
AS
SELECT 
		backup_id
		, oibs.object_id AS object_id
		, SUM(CASE WHEN oibs.is_corrupted = 0 THEN 1 ELSE 0 END) AS valid_oibs_count
		, SUM(CASE WHEN oibs.is_corrupted = 0 AND oibs.is_consistent = 1 THEN 1 ELSE 0 END) AS consistent_oibs_count
		, CAST(MAX(CASE WHEN oibs.has_exchange = 0 THEN 0 ELSE 1 END) AS BIT) AS has_exchange_in_any_point
		, MAX(oibs.creation_time) AS last_oib_creation_time
FROM  
		[dbo].[Backup.Model.OIBs] oibs 
			INNER JOIN [dbo].[Backup.Model.Points] points ON oibs.point_id = points.id
			
GROUP BY 
	backup_id, oibs.object_id
GO

--------------------------------------------------------------------------------
-- ReportSnapshotVmsView
PRINT N'Creating [dbo].[ReportSnapshotVmsView]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[ReportSnapshotVmsView]') AND type in (N'V'))
	DROP VIEW [dbo].[ReportSnapshotVmsView]
GO

CREATE VIEW [dbo].[ReportSnapshotVmsView]
AS

SELECT 
	objs.[object_name] vm_name,
	objs.[platform] platform,
	oibs.[approx_size] vm_size,
	oibs.[id] oib_id,
	oibs.[aux_data] aux_data,
	oibs.[creation_time] creation_time,
	oibs.[has_exchange] has_exchange,
	oibs.[object_id] obj_id,
	oibs.[point_id] point_id,
	oibs.[storage_id] storage_id,
	snapshotStorage.[snapshot_id] snapshot_id,
	snapshotVmStatistics.[backup_id],
	snapshotVmStatistics.[valid_oibs_count],
	snapshotVmStatistics.[consistent_oibs_count],
	snapshotVmStatistics.[last_oib_creation_time],
	snapshotVmStatistics.[has_exchange_in_any_point],
	[dbo].[MaxValue](objs.[usn], oibs.[usn]) usn
FROM
	[dbo].[Backup.Model.OIBs] oibs 
	join [dbo].[BObjects] objs on oibs.[object_id] = objs.[id] 
	join [dbo].[Backup.Model.Points] points on points.[id] = oibs.[point_id]
	join [dbo].[Backup.Model.SanSnapshotStorages] snapshotStorage on snapshotStorage.[storage_id] = oibs.[storage_id]
	join [dbo].[ReportSnapshotVmStatisticsView] snapshotVmStatistics on snapshotVmStatistics.[backup_id] = points.[backup_id] AND snapshotVmStatistics.[object_id] = oibs.[object_id]
WHERE
	oibs.[type] = 4
GO

--------------------------------------------------------------------------------
PRINT N'Creating [dbo].[ReportSnapshotVmsDeleteView]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[ReportSnapshotVmsDeleteView]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[ReportSnapshotVmsDeleteView]
GO
	CREATE PROCEDURE [dbo].[ReportSnapshotVmsDeleteView]
		@row_usn bigint
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT uid, usn FROM TombStones WHERE table_name= 'Backup.Model.OIBs' AND usn > @row_usn
	END

GO

--------------------------------------------------------------------------------
PRINT N'Creating [dbo].[DatabaseVersion]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DatabaseVersion]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[DatabaseVersion]
GO
	CREATE PROCEDURE [dbo].[DatabaseVersion]
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT TOP 1 [current_version] FROM [dbo].[Version]
	END
GO

----------------------------------------------------------------------
PRINT N'Creating [dbo].[UpdateHostDnsName]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateHostDnsName]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateHostDnsName]
GO
	CREATE PROCEDURE [dbo].[UpdateHostDnsName]
		@host_id uniqueidentifier,
		@dns_name nvarchar(255)
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		UPDATE 
			[dbo].[Hosts] 
		SET 
			[dns_name] = @dns_name,
			[usn] = @usn
		where [id] = @host_id
	END
GO

--------------------------------------------------------------------------------
-- GetVisibleHosts
PRINT N'Creating [dbo].[GetVisibleHosts]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetVisibleHosts]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetVisibleHosts]
GO

	CREATE PROCEDURE [dbo].[GetVisibleHosts]
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT 
			* 
		FROM 
			[dbo].[Hosts] hosts
		WHERE
			[dbo].[fn.IsImportedHost](hosts.[id]) = 'False'
	END

GO

--------------------------------------------------------------------------------
-- IsSanHostStoragesLocked
PRINT N'Creating [dbo].[IsSanHostStoragesLocked]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[IsSanHostStoragesLocked]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[IsSanHostStoragesLocked]
GO

	CREATE PROCEDURE [dbo].[IsSanHostStoragesLocked]
		@san_host_id uniqueidentifier
	AS
	BEGIN

	DECLARE @result bit
	DECLARE @locks_count int

	SELECT 
		@locks_count = COUNT(*)
	FROM		
		[dbo].[Backup.Model.SanVolumes] volumes,
		[dbo].[Backup.Model.SanSnapshots] snapshots,
		[dbo].[Backup.Model.SanSnapshotStorages] snapshotStorages,
		[dbo].[Backup.TrackedActions.LockItems] lockItems,
		[dbo].[Backup.TrackedActions.Locks] locks
	WHERE		
		volumes.[host_id] = @san_host_id
		AND snapshots.[volume_id] = volumes.[id]
		AND snapshotStorages.[snapshot_id] = snapshots.[id]
		AND lockItems.[lock_item_id] = snapshotStorages.[storage_id]
		AND locks.[id] = lockItems.[lock_id]

	IF @locks_count = 0
		SET @result = 'False'
	ELSE
		SET @result = 'True'
		
	SELECT @result result
			
	END	

GO

--------------------------------------------------------------------------------
-- [GetSanSnapshotsByInternalId]
PRINT N'Creating [dbo].[GetSanSnapshotsByInternalId]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetSanSnapshotsByInternalId]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetSanSnapshotsByInternalId]
GO
	CREATE PROCEDURE [dbo].[GetSanSnapshotsByInternalId]
		@row_internal_id nvarchar(255)
	AS
	BEGIN
		SELECT * FROM [dbo].[Backup.Model.SanSnapshots]
		WHERE internal_id = @row_internal_id
	END	
GO

--------------------------------------------------------------------------------
-- [Backup.Model.GetSanSnapshotChilds]
PRINT N'Creating [dbo].[Backup.Model.GetSanSnapshotChilds]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetSanSnapshotChilds]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetSanSnapshotChilds]
GO
	CREATE PROCEDURE [dbo].[Backup.Model.GetSanSnapshotChilds]
		@row_snapshot_id nvarchar(255)
	AS
	BEGIN
		SELECT * FROM [dbo].[Backup.Model.SanSnapshots]
		WHERE parent_snapshot_id = @row_snapshot_id
	END	
GO

--------------------------------------------------------------------------------
-- GetLinkedScheduleJobs
PRINT N'Creating [dbo].[GetLinkedScheduleJobs]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetLinkedScheduleJobs]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetLinkedScheduleJobs]
GO

	CREATE PROCEDURE [dbo].[GetLinkedScheduleJobs]
		@id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;											
		select * from dbo.BJobs j where j.parent_schedule_id = @id										
	END

GO

--------------------------------------------------------------------------------
-- TryUpdateEMInfo
PRINT N'Creating [dbo].[TryUpdateEMInfo]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[TryUpdateEMInfo]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[TryUpdateEMInfo]
GO

	CREATE PROCEDURE [dbo].[TryUpdateEMInfo]
		@newEMName nvarchar(255),
		@newEMVersion nvarchar(255),
		@force bit,
		@oldEMName nvarchar(255) output,
		@oldEMVersion nvarchar(255) output,
		@ok bit output
	AS
	BEGIN
		SET NOCOUNT ON;

		SET @oldEMName = (SELECT em_name FROM [dbo].[ReplicationInfo])
		SET @oldEMVersion = (SELECT em_version FROM [dbo].[ReplicationInfo])

		IF (@oldEMName IS NULL AND @oldEMVersion IS NULL) OR @force = 1 BEGIN
			UPDATE [dbo].[ReplicationInfo] SET em_name = @newEMName, em_version = @newEMVersion
			SET @ok = 1
		END ELSE BEGIN
			SET @ok = 0
		END
	END
GO

--------------------------------------------------------------------------------
-- [ResetSanSnapshotsIndexedType]
PRINT N'Creating [dbo].[ResetSanSnapshotsIndexedType]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[ResetSanSnapshotsIndexedType]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[ResetSanSnapshotsIndexedType]
GO
	CREATE PROCEDURE [dbo].[ResetSanSnapshotsIndexedType]
	AS
	BEGIN
		declare @update_usn bigint
		exec [dbo].[IncrementUsn] @update_usn OUTPUT
		UPDATE [dbo].[Backup.Model.SanSnapshots] SET
			   [indexed] = 0,
			   [usn] = @update_usn
	END	

GO

--------------------------------------------------------------------------------
-- GetEMInfo
PRINT N'Creating [dbo].[GetEMInfo]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetEMInfo]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetEMInfo]
GO

	CREATE PROCEDURE [dbo].[GetEMInfo]
		@emName nvarchar(255) output,
		@emVersion nvarchar(255) output
	AS
	BEGIN
		SET NOCOUNT ON;

		SET @emName = (SELECT em_name FROM [dbo].[ReplicationInfo])
		SET @emVersion = (SELECT em_version FROM [dbo].[ReplicationInfo])
	END
GO

--------------------------------------------------------------------------------
-- GetVirtualLabsByPlatform
PRINT N'Creating [dbo].[GetVirtualLabsByPlatform]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetVirtualLabsByPlatform]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetVirtualLabsByPlatform]
GO

	CREATE PROCEDURE [dbo].[GetVirtualLabsByPlatform]
		@row_platform int
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT 
			* 
		FROM 
			[dbo].[VirtualLabs] virtualLabs
		WHERE
			virtualLabs.[platform] = @row_platform
	END	

GO

--------------------------------------------------------------------------------
-- GetSubFolderByNameAndPlatform
PRINT N'Creating [dbo].[GetSubFolderByNameAndPlatform]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetSubFolderByNameAndPlatform]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetSubFolderByNameAndPlatform]
GO

	CREATE PROCEDURE [dbo].[GetSubFolderByNameAndPlatform]
				@name nvarchar(255),
				@parent_id uniqueidentifier,
				@platform int
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT 
			* 
		FROM 
			[dbo].[Folders]
		WHERE 
			[name] = @name AND
			[parent_id] = @parent_id AND
			[platform] = @platform
	END	

GO

--------------------------------------------------------------------------------
-- GetSubFoldersCount
PRINT N'Creating [dbo].[GetSubFoldersCount]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetSubFoldersCount]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetSubFoldersCount]
GO

	CREATE PROCEDURE [dbo].[GetSubFoldersCount]
		@parent_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT 
			COUNT(*) sub_folders_count 
		FROM 
			[dbo].[Folders]
		WHERE
			[parent_id] = @parent_id
	END	

GO

--------------------------------------------------------------------------------
-- AddWanAccelerator
PRINT N'Creating [dbo].[AddWanAccelerator]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[AddWanAccelerator]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[AddWanAccelerator]
GO

	CREATE PROCEDURE [dbo].[AddWanAccelerator]
		@id uniqueidentifier,
		@name nvarchar(max),
		@description nvarchar(max),
		@host_id uniqueidentifier,
		@options xml
	AS
	BEGIN
		SET NOCOUNT ON;

		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		INSERT INTO [dbo].[WanAccelerators]
			   ([id]
			   ,[name]
			   ,[description]
			   ,[host_id]
			   ,[options]
			   ,[usn])
		 VALUES
			   (@id,
				@name,
				@description,
				@host_id,
				@options,
				@usn)
	END

GO

--------------------------------------------------------------------------------
-- UpdateWanAccelerator
PRINT N'Creating [dbo].[UpdateWanAccelerator]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateWanAccelerator]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateWanAccelerator]
GO

	CREATE PROCEDURE [dbo].[UpdateWanAccelerator]
			@id uniqueidentifier,
			@name nvarchar(max),
			@description nvarchar(max),
			@host_id uniqueidentifier,
			@options xml
	AS
	BEGIN
		SET NOCOUNT ON;
		
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		UPDATE [dbo].[WanAccelerators] 
		SET
			   [name] = @name,
			   [description] = @description,
			   [host_id] = @host_id,
			   [options] = @options,
			   [usn] = @usn
		WHERE [id] = @id
	END

GO

--------------------------------------------------------------------------------
-- FindWanAcceleratorByIdAndType
PRINT N'Creating [dbo].[FindWanAcceleratorById]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[FindWanAcceleratorById]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[FindWanAcceleratorById]
GO

	CREATE PROCEDURE [dbo].[FindWanAcceleratorById]
		@id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[WanAccelerators] where [dbo].[WanAccelerators].[id] = @id
	END
	
GO

--------------------------------------------------------------------------------
-- GetAllWanAccelerators
PRINT N'Creating [dbo].[GetAllWanAccelerators]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetAllWanAccelerators]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetAllWanAccelerators]
GO

	CREATE PROCEDURE [dbo].[GetAllWanAccelerators]	
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * from [dbo].[WanAccelerators] 
		
	END

GO

--------------------------------------------------------------------------------
-- DeleteWanAccelerator
PRINT N'Creating [dbo].[DeleteWanAccelerator]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DeleteWanAccelerator]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[DeleteWanAccelerator]
GO

	CREATE PROCEDURE [dbo].[DeleteWanAccelerator]
		@id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		DELETE FROM [dbo].[WanAccelerators] WHERE [id] = @id
	END

GO

--------------------------------------------------------------------------------
-- IsUpgradeRequiredWanAcceleratorExists
PRINT N'Creating [dbo].[IsUpgradeRequiredWanAcceleratorExists]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[IsUpgradeRequiredWanAcceleratorExists]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[IsUpgradeRequiredWanAcceleratorExists]
GO

	CREATE PROCEDURE [dbo].[IsUpgradeRequiredWanAcceleratorExists]
	AS
	BEGIN
		DECLARE @rows_count int
		SELECT @rows_count = COUNT(*) FROM [dbo].[WanAccelerators] WHERE [dbo].[fn.IsHostUpgradeRequired]([dbo].[WanAccelerators].[host_id]) = 'True'
		IF @rows_count = 0
			SELECT 0 retValue
		ELSE
			SELECT 1 retValue
	END

GO

--------------------------------------------------------------------------------
-- FindWanAcceleratorByHost
PRINT N'Creating [dbo].[FindWanAcceleratorByHost]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[FindWanAcceleratorByHost]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[FindWanAcceleratorByHost]
GO

	CREATE PROCEDURE [dbo].[FindWanAcceleratorByHost]
		@host_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT 
			* 
		FROM 
			[dbo].[WanAccelerators] 
		WHERE 
			[dbo].[WanAccelerators].[host_id] = @host_id
	END

GO

--------------------------------------------------------------------------------
-- UpdateWanAcceleratorOptions
PRINT N'Creating [dbo].[UpdateWanAcceleratorOptions]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateWanAcceleratorOptions]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateWanAcceleratorOptions]
GO

	CREATE PROCEDURE [dbo].[UpdateWanAcceleratorOptions]
		@id uniqueidentifier,
		@options xml
	AS
	BEGIN
		SET NOCOUNT ON;
		
		UPDATE [dbo].[WanAccelerators] SET
				[options] = @options
		WHERE [id] = @id
			
	END	

GO

--------------------------------------------------------------------------------
-- UpdateWanAcceleratorDescription
PRINT N'Creating [dbo].[UpdateWanAcceleratorDescription]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateWanAcceleratorDescription]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateWanAcceleratorDescription]
GO

	CREATE PROCEDURE [dbo].[UpdateWanAcceleratorDescription]
		@id uniqueidentifier,
		@description nvarchar(max)
	AS
	BEGIN
		SET NOCOUNT ON;
		
		UPDATE [dbo].[WanAccelerators] SET
				[description] = @description
		WHERE [id] = @id
			
	END	

GO

--------------------------------------------------------------------------------
-- GetUpgradeRequiredHostsUsedByWanAccelerators
PRINT N'Creating [dbo].[GetUpgradeRequiredHostsUsedByWanAccelerators]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetUpgradeRequiredHostsUsedByWanAccelerators]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetUpgradeRequiredHostsUsedByWanAccelerators]
GO

	CREATE PROCEDURE [dbo].[GetUpgradeRequiredHostsUsedByWanAccelerators]
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT
			hosts.*
		FROM
			[dbo].[Hosts] hosts JOIN [dbo].[WanAccelerators] wanAccelerators ON hosts.[id] = wanAccelerators.[host_id] 
		WHERE
			[dbo].[fn.IsHostUpgradeRequired](hosts.[id]) = 'True'
			
	END
GO

--------------------------------------------------------------------------------
-- ReportWanAcceleratorsView
PRINT N'Creating [dbo].[ReportWanAcceleratorsView]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[ReportWanAcceleratorsView]') AND type in (N'V'))
	DROP VIEW [dbo].[ReportWanAcceleratorsView]
GO

	CREATE VIEW [dbo].[ReportWanAcceleratorsView]
	AS
		SELECT     
			wanAccelerators.[id],
			wanAccelerators.[name], 
			wanAccelerators.[description],
			wanAccelerators.[host_id],
			wanAccelerators.[options],
			[dbo].[MaxValue](hosts.[usn], wanAccelerators.[usn]) as [usn],
			hosts.[name] as [host_name],
			[dbo].[fn.IsHostUpgradeRequired] (wanAccelerators.[host_id]) as [is_upgrade_required],
			wanAccelerators.[is_busy],
			wanAccelerators.[is_unavailable]
		FROM 
			[dbo].[WanAccelerators] wanAccelerators LEFT JOIN [dbo].[Hosts] hosts ON wanAccelerators.[host_id] = hosts.[id]
GO

--------------------------------------------------------------------------------
-- ReportWanAcceleratorsDeleteView
PRINT N'Creating [dbo].[ReportWanAcceleratorsDeleteView]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[ReportWanAcceleratorsDeleteView]') AND type in (N'P'))
	DROP PROCEDURE [dbo].[ReportWanAcceleratorsDeleteView]
GO

	CREATE PROCEDURE [dbo].[ReportWanAcceleratorsDeleteView]
		@row_usn bigint
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT uid, usn FROM TombStones WHERE table_name= 'WanAccelerators' AND usn > @row_usn
	END
	
GO

--------------------------------------------------------------------------------
-- Backup.Model.GetPluginForSanHost
PRINT N'Creating [dbo].[Backup.Model.GetPluginForSanHost]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetPluginForSanHost]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetPluginForSanHost]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetPluginForSanHost]
		@hostId uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;	
		SELECT [plugin_id]
		from 			
			[dbo].[Backup.Model.SanHostsPlugins]
		where
			[host_id] = @hostId	
	END
GO

--------------------------------------------------------------------------------
-- Backup.Model.GetSanHostsForPlugin
PRINT N'Creating [dbo].[Backup.Model.GetSanHostsForPlugin]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetSanHostsForPlugin]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetSanHostsForPlugin]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetSanHostsForPlugin]
		@pluginId uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;	
		SELECT h.* FROM 
			[dbo].[Hosts] h INNER JOIN [dbo].[Backup.Model.SanHostsPlugins] shp
			ON h.id = shp.host_id
		WHERE
			[plugin_id] = @pluginId	
	END
GO

--------------------------------------------------------------------------------
-- [Backup.Model.AddSanHostToPluginLink]
PRINT N'Creating [dbo].[Backup.Model.AddSanHostToPluginLink]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.AddSanHostToPluginLink]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.AddSanHostToPluginLink]
GO
	CREATE PROCEDURE [dbo].[Backup.Model.AddSanHostToPluginLink]
		@host_id uniqueidentifier,
		@plugin_id uniqueidentifier
	AS
	BEGIN
		declare @update_usn bigint
		exec [dbo].[IncrementUsn] @update_usn OUTPUT
		
		INSERT INTO [dbo].[Backup.Model.SanHostsPlugins]([host_id], [plugin_id]) VALUES (@host_id, @plugin_id)		
	END	

GO

--------------------------------------------------------------------------------
-- [Backup.Model.RemoveSanHostToPluginLink]
PRINT N'Creating [dbo].[Backup.Model.RemoveSanHostToPluginLink]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.RemoveSanHostToPluginLink]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.RemoveSanHostToPluginLink]
GO
	CREATE PROCEDURE [dbo].[Backup.Model.RemoveSanHostToPluginLink]
		@host_id uniqueidentifier
	AS
	BEGIN						
		DELETE [dbo].[Backup.Model.SanHostsPlugins] WHERE host_id = @host_id	
	END	

GO

--------------------------------------------------------------------------------
-- [Backup.Model.GetSanVolumesInSanHost]
PRINT N'Creating [dbo].[Backup.Model.GetSanVolumesInSanHost]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetSanVolumesInSanHost]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetSanVolumesInSanHost]
GO
	CREATE PROCEDURE [dbo].[Backup.Model.GetSanVolumesInSanHost]
		@row_host_id uniqueidentifier
	AS
	BEGIN
		SELECT * FROM [dbo].[Backup.Model.SanVolumes]
		WHERE host_id = @row_host_id
	END	

GO

--------------------------------------------------------------------------------
-- GetSbJobsByVLabId
PRINT N'Creating [dbo].[GetSbJobsByVLabId]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetSbJobsByVLabId]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetSbJobsByVLabId]
GO

	CREATE PROCEDURE [dbo].[GetSbJobsByVLabId]
		@vlab_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		DECLARE @sbJobType int
		SET @sbJobType = 3

		SELECT 
			* 
		FROM 
			[dbo].[BJobs] 
		WHERE 
			[type] = @sbJobType AND
			[target_host_id] = @vlab_id
		
	END

GO

--------------------------------------------------------------------------------
-- [Backup.Model.AddSanInitiatorByProxy]
PRINT N'Creating [dbo].[Backup.Model.AddSanInitiatorByProxy]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.AddSanInitiatorByProxy]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.AddSanInitiatorByProxy]
GO
	CREATE PROCEDURE [dbo].[Backup.Model.AddSanInitiatorByProxy]
		@row_id uniqueidentifier,		
		@row_proxy_id uniqueidentifier,
		@row_iqn_or_wwn nvarchar(255),		
		@row_type int		
	AS
	BEGIN
		declare @update_usn bigint		
		INSERT INTO [dbo].[Backup.Model.SanInitiatorsByProxy]
			   ([id]
			   ,[proxy_id]			   
			   ,[iqn_or_wwn]
			   ,[type]			   
			   )
		 VALUES
			   (@row_id,
				@row_proxy_id,
				@row_iqn_or_wwn,
				@row_type)
	END	

GO

--------------------------------------------------------------------------------
-- [Backup.Model.GetSanInitiator]
PRINT N'Creating [dbo].[Backup.Model.GetSanInitiator]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetSanInitiator]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetSanInitiator]
GO
	CREATE PROCEDURE [dbo].[Backup.Model.GetSanInitiator]
		@row_id uniqueidentifier
	AS
	BEGIN
		SELECT * FROM [dbo].[Backup.Model.SanInitiatorsByProxy]
			   WHERE [id] = @row_id
	END	
GO	
--------------------------------------------------------------------------------
-- [Backup.Model.GetAllSanInitiators]
PRINT N'Creating [dbo].[Backup.Model.GetAllSanInitiators]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetAllSanInitiators]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetAllSanInitiators]
GO
	CREATE PROCEDURE [dbo].[Backup.Model.GetAllSanInitiators]
	AS
	BEGIN
		SELECT * FROM [dbo].[Backup.Model.SanInitiatorsByProxy]
	END	

GO

--------------------------------------------------------------------------------
-- [Backup.Model.GetSanInitiatorsByProxy]
PRINT N'Creating [dbo].[Backup.Model.GetSanInitiatorsByProxy]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetSanInitiatorsByProxy]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetSanInitiatorsByProxy]
GO
	CREATE PROCEDURE [dbo].[Backup.Model.GetSanInitiatorsByProxy]
		@row_proxy_id uniqueidentifier
	AS
	BEGIN
		SELECT * FROM [dbo].[Backup.Model.SanInitiatorsByProxy]
		WHERE proxy_id = @row_proxy_id
	END	

GO

--------------------------------------------------------------------------------
-- Backup.Model.DeleteSanInitiator
PRINT N'Creating [dbo].[Backup.Model.DeleteSanInitiator]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.DeleteSanInitiator]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.DeleteSanInitiator]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.DeleteSanInitiator]
		@id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;						
					
		DELETE [dbo].[Backup.Model.SanInitiatorsByProxy] WHERE id = @id										

	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.DeleteSanInitiatorsByProxy
PRINT N'Creating [dbo].[Backup.Model.DeleteSanInitiatorsByProxy]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.DeleteSanInitiatorsByProxy]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.DeleteSanInitiatorsByProxy]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.DeleteSanInitiatorsByProxy]
		@proxy_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;						
					
		DELETE [dbo].[Backup.Model.SanInitiatorsByProxy] WHERE proxy_id = @proxy_id										

	END

GO

--------------------------------------------------------------------------------
-- HasObjValidChildOibsInBackup
PRINT N'Creating [dbo].[HasObjValidChildOibsInBackup]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[HasObjValidChildOibsInBackup]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[HasObjValidChildOibsInBackup]
GO

	CREATE PROCEDURE [dbo].[HasObjValidChildOibsInBackup]
		@obj_id uniqueidentifier,
		@backup_id uniqueidentifier
	AS
	BEGIN
		SELECT top(1) 1 cnt
		FROM	
			[dbo].[Backup.Model.OIBs] childOibs
		join 
		 (
				SELECT	oibs.[id] 
				FROM 	[dbo].[Backup.Model.OIBs] oibs 
				JOIN    [dbo].[Backup.Model.Points] points 
				ON      oibs.[point_id]  = points.id 
				WHERE 	oibs.[object_id] = @obj_id AND  points.[backup_id]  = @backup_id
		 ) parentOibs on childOibs.parent_id = parentOibs.id
		WHERE childOibs.[is_corrupted] != 1 
	END
GO

--------------------------------------------------------------------------------
-- [Backup.Model.AddSanVolumeProxyInitiatorLink]
PRINT N'Creating [dbo].[Backup.Model.AddSanVolumeProxyInitiatorLink]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.AddSanVolumeProxyInitiatorLink]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.AddSanVolumeProxyInitiatorLink]
GO
	CREATE PROCEDURE [dbo].[Backup.Model.AddSanVolumeProxyInitiatorLink]
		@volume_id uniqueidentifier,
		@proxy_initiator_id uniqueidentifier
	AS
	BEGIN				
		INSERT INTO [dbo].[Backup.Model.SanVolumeByProxyInitiators]([volume_id], [proxy_initiator_id]) VALUES (@volume_id, @proxy_initiator_id)		
	END	

GO

--------------------------------------------------------------------------------
-- [Backup.Model.GetProxyInitiatorsForSanVolume]
PRINT N'Creating [dbo].[Backup.Model.GetProxyInitiatorsForSanVolume]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetProxyInitiatorsForSanVolume]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetProxyInitiatorsForSanVolume]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetProxyInitiatorsForSanVolume]
		@volume_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;	
		SELECT [pr].*
		FROM
			[dbo].[Backup.Model.SanInitiatorsByProxy] AS [pr] 
		LEFT JOIN 
			[dbo].[Backup.Model.SanVolumeByProxyInitiators] AS [vpr] ON [pr].[id]=[vpr].[proxy_initiator_id]  			
		WHERE
			[vpr].[volume_id] = @volume_id	
	END
GO

--------------------------------------------------------------------------------
-- [Backup.Model.RemoveSanVolumeProxyInitiatorLink]
PRINT N'Creating [dbo].[Backup.Model.RemoveSanVolumeProxyInitiatorLink]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.RemoveSanVolumeProxyInitiatorLink]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.RemoveSanVolumeProxyInitiatorLink]
GO
	CREATE PROCEDURE [dbo].[Backup.Model.RemoveSanVolumeProxyInitiatorLink]
		@id uniqueidentifier		
	AS
	BEGIN				
		DELETE FROM [dbo].[Backup.Model.SanVolumeByProxyInitiators] WHERE [id] = @id
	END	
GO

--------------------------------------------------------------------------------
-- [Backup.Model.GetAllSanVolumeByProxyInitiators]
PRINT N'Creating [dbo].[Backup.Model.GetAllSanVolumeByProxyInitiators]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetAllSanVolumeByProxyInitiators]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetAllSanVolumeByProxyInitiators]
GO
	CREATE PROCEDURE [dbo].[Backup.Model.GetAllSanVolumeByProxyInitiators]		
	AS
	BEGIN				
		SELECT * FROM [dbo].[Backup.Model.SanVolumeByProxyInitiators]
	END	

GO

--------------------------------------------------------------------------------
-- [Backup.Model.GetSanVolumeByProxyInitiator]
PRINT N'Creating [dbo].[Backup.Model.GetSanVolumeByProxyInitiator]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetSanVolumeByProxyInitiator]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetSanVolumeByProxyInitiator]
GO
	CREATE PROCEDURE [dbo].[Backup.Model.GetSanVolumeByProxyInitiator]
		@row_id uniqueidentifier
	AS
	BEGIN
		SELECT * FROM [dbo].[Backup.Model.SanVolumeByProxyInitiators]
			   WHERE [id] = @row_id
	END	
GO	

--------------------------------------------------------------------------------
-- Backup.Model.GetSanVolumesOnHostForSanProxyInitiator
PRINT N'Creating [dbo].[Backup.Model.GetSanVolumesOnHostForSanProxyInitiator]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetSanVolumesOnHostForSanProxyInitiator]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetSanVolumesOnHostForSanProxyInitiator]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetSanVolumesOnHostForSanProxyInitiator]
		@initiator_id uniqueidentifier,
		@host_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;	
			
		SELECT * FROM [dbo].[Backup.Model.SanVolumeByProxyInitiators] AS [vpi]
		LEFT JOIN
			[dbo].[Backup.Model.SanVolumes] AS [v] ON [vpi].volume_id = [v].id
		WHERE
			[v].host_id = @host_id AND
			[proxy_initiator_id] = @initiator_id	
	END
GO

--------------------------------------------------------------------------------
-- [Backup.Model.GetSanVolumesForProxy]
PRINT N'Creating [dbo].[Backup.Model.GetSanVolumesForProxy]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetSanVolumesForProxy]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetSanVolumesForProxy]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetSanVolumesForProxy]
		@proxy_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;	
		SELECT [vol].*
		FROM
			[dbo].[Backup.Model.SanVolumeByProxyInitiators] AS [vol] 
		LEFT JOIN 
			[dbo].[Backup.Model.SanInitiatorsByProxy] AS [pr] ON [vol].[proxy_initiator_id]=[pr].[id]
		WHERE
			[pr].[proxy_id] = @proxy_id	
	END
GO

--------------------------------------------------------------------------------
-- [Report3PARVolumeView]
PRINT N'Creating [dbo].[Report3PARVolumeView]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Report3PARVolumeView]') AND type in (N'V'))
	DROP VIEW [dbo].[Report3PARVolumeView]
GO
CREATE VIEW [dbo].[Report3PARVolumeView]
AS
SELECT 
		vl.id, 
		vl.name, 
		vl.parent_id as cluster_id, 
		vl.iqn_or_wwn, 
		(select count(sn.id) from [dbo].[Backup.Model.SanSnapshots] sn where sn.volume_id = vl.id) as snapshots_count,
		vl.size as reported_size,
		vl.consumed_space,
		vl.is_thin_provision,
		vl.saved_space,
		vl.aux_data,
		vl.host_id,
		(select top(1) sn.creation_time from [dbo].[Backup.Model.SanSnapshots] sn where sn.volume_id = vl.id order by sn.creation_time desc) as last_snapshot_creation_time,
		vl.usn
	FROM 
		[dbo].[Backup.Model.SanVolumes] vl

GO

--------------------------------------------------------------------------------
-- [dbo].[Backup.Model.AddPlugin]
PRINT N'Creating [dbo].[Backup.Model.AddPlugin]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.AddPlugin]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.AddPlugin]
GO

CREATE PROC [dbo].[Backup.Model.AddPlugin]
	@plugin_id	uniqueidentifier,
	@name	nvarchar(255),
	@kind	nvarchar(255),
	@module_path	nvarchar(MAX),
	@enabled	bit,
	@software_version	nvarchar(50),
	@db_version	bigint,
	@compatible bit,
	@ps_module_path	nvarchar(MAX)
AS
BEGIN
	SET NOCOUNT ON
	INSERT INTO [dbo].[Backup.Model.Plugins] 
		(id, [name], [kind], module_path, [enabled], software_version, db_version, compatible, ps_module_path)
	VALUES 
		(@plugin_id, @name, @kind, @module_path, @enabled, @software_version, @db_version, @compatible, @ps_module_path)
END
GO

--------------------------------------------------------------------------------
-- [dbo].[Backup.Model.UpdatePlugin]
PRINT N'Creating [dbo].[Backup.Model.UpdatePlugin]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.UpdatePlugin]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.UpdatePlugin]
GO

CREATE PROC [dbo].[Backup.Model.UpdatePlugin]
	@plugin_id	uniqueidentifier,
	@name	nvarchar(255),
	@kind	nvarchar(255),
	@module_path	nvarchar(MAX),
	@enabled	bit,	
	@software_version	nvarchar(50),
	@db_version	bigint,
	@compatible bit,
	@ps_module_path	nvarchar(MAX)
AS
BEGIN
	SET NOCOUNT ON
	UPDATE [dbo].[Backup.Model.Plugins] SET
		[name] = @name
		, kind = @kind
		, module_path = @module_path
		, [enabled] = @enabled		
		, software_version = @software_version
		, db_version = @db_version
		, compatible = @compatible
		, ps_module_path = @ps_module_path
	WHERE id = @plugin_id
END
GO

--------------------------------------------------------------------------------
-- [dbo].[Backup.Model.UpdatePluginState]
PRINT N'Creating [dbo].[Backup.Model.UpdatePluginState]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.UpdatePluginState]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.UpdatePluginState]
GO

CREATE PROC [dbo].[Backup.Model.UpdatePluginState]
	@plugin_id	uniqueidentifier,
	@enabled	bit,	
	@compatible bit
AS
BEGIN
	SET NOCOUNT ON
	UPDATE [dbo].[Backup.Model.Plugins] SET
		 [enabled] = @enabled		
		, compatible = @compatible
	WHERE id = @plugin_id
END
GO

--------------------------------------------------------------------------------
-- [dbo].[Backup.Model.DeletePlugin]
PRINT N'Creating [dbo].[Backup.Model.DeletePlugin]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.DeletePlugin]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.DeletePlugin]
GO

CREATE PROC [dbo].[Backup.Model.DeletePlugin]
	@plugin_id	uniqueidentifier
AS
BEGIN
	SET NOCOUNT ON
	DELETE FROM [dbo].[Backup.Model.Plugins] WHERE id = @plugin_id 
END
GO

--------------------------------------------------------------------------------
-- [dbo].[Backup.Model.GetPlugin]
PRINT N'Creating [dbo].[Backup.Model.GetPlugin]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetPlugin]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetPlugin]
GO

CREATE PROC [dbo].[Backup.Model.GetPlugin]
	@plugin_id	uniqueidentifier
AS
BEGIN
	SET NOCOUNT ON
	SELECT * FROM [dbo].[Backup.Model.Plugins] WHERE id = @plugin_id 
END
GO

--------------------------------------------------------------------------------
-- [Backup.Model.GetPlugins]
PRINT N'Creating [Backup.Model.GetPlugins]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetPlugins]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetPlugins]
GO

CREATE PROC [dbo].[Backup.Model.GetPlugins]
AS
BEGIN
	SET NOCOUNT ON
	SELECT * FROM [dbo].[Backup.Model.Plugins]
END
GO

--------------------------------------------------------------------------------
-- [Backup.Model.EnumerateMruList]
PRINT N'[Creating Backup.Model.EnumerateMruList]'
IF  EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.EnumerateMruList]') AND type in (N'P', N'PC'))
DROP PROCEDURE [dbo].[Backup.Model.EnumerateMruList]
GO

CREATE PROCEDURE [dbo].[Backup.Model.EnumerateMruList]
AS
BEGIN
	SET NOCOUNT ON;
	SELECT * FROM [dbo].[Backup.Model.MruList]
END	

GO

--------------------------------------------------------------------------------
-- ItemRestoreAudit Management

--------------------------------------------------------------------------------
-- CreateItemRestoreAudit

EXEC HrPreCreateProc @proc = N'[dbo].[CreateItemRestoreAudit]'
GO

CREATE PROCEDURE [dbo].[CreateItemRestoreAudit]
	@id UNIQUEIDENTIFIER,
	@restore_session_id UNIQUEIDENTIFIER,
	@restore_state INT,
	@item_type NVARCHAR(256),
	@item_name NVARCHAR(256),
	@item_size BIGINT,
	@dest_type int,
	@destination NVARCHAR(256),
	@destHost NVARCHAR(256),
	@start_time DATETIME,
	@finish_time DATETIME,
	@message NVARCHAR(1024),
	@aux_data XML,
	@source nvarchar(256)
	AS
	BEGIN
		SET NOCOUNT ON

		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		INSERT INTO [dbo].[ItemRestoreAudits] (
			[id],
			[restore_session_id],
			[restore_state],
			[item_type],
			[item_name],
			[item_size],
			[dest_type],
			[destination],
			[dest_host],
			[start_time],
			[finish_time],
			[message],
			[aux_data],
			[source],
			[usn]
		)
		VALUES (
			@id,
			@restore_session_id,
			@restore_state,
			@item_type,
			@item_name,
			@item_size,
			@dest_type,
			@destination,
			@destHost,
			@start_time,
			@finish_time,
			@message,
			@aux_data,
			@source,
			@usn
		)
	END
GO

--------------------------------------------------------------------------------
-- UpdateItemRestoreAudit

EXEC HrPreCreateProc @proc = N'[dbo].[UpdateItemRestoreAudit]'
GO

CREATE PROCEDURE [dbo].[UpdateItemRestoreAudit]
	@id UNIQUEIDENTIFIER,
	@restore_session_id UNIQUEIDENTIFIER,
	@restore_state INT,
	@item_type NVARCHAR(256),
	@item_name NVARCHAR(256),
	@item_size BIGINT,
	@dest_type int,
	@destination NVARCHAR(256),
	@destHost NVARCHAR(256),
	@start_time DATETIME,
	@finish_time DATETIME,
	@message NVARCHAR(1024),
	@source nvarchar(256),
	@aux_data XML
	AS
	BEGIN
		SET NOCOUNT ON

		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		UPDATE [dbo].[ItemRestoreAudits] SET
			[restore_session_id] = @restore_session_id,
			[restore_state] = @restore_state,
			[item_type] = @item_type,
			[item_name] = @item_name,
			[item_size] = @item_size,
			[dest_type] = @dest_type,
			[destination] = @destination,
			[dest_host] = @destHost,
			[start_time] = @start_time,
			[finish_time] = @finish_time,
			[message] = @message,
			[aux_data] = @aux_data,
			[source] = @source,
			[usn] = @usn
		WHERE [id] = @id
	END
GO

--------------------------------------------------------------------------------
-- DeleteItemRestoreAudit

EXEC HrPreCreateProc @proc = N'[dbo].[DeleteItemRestoreAudit]'
GO

CREATE PROCEDURE [dbo].[DeleteItemRestoreAudit]
	@id UNIQUEIDENTIFIER
	AS
	BEGIN
		SET NOCOUNT ON
		DELETE
		FROM [dbo].[ItemRestoreAudits]
		WHERE [id] = @id
	END
GO

--------------------------------------------------------------------------------
-- FindItemRestoreAuditById

EXEC HrPreCreateProc @proc = N'[dbo].[FindItemRestoreAuditById]'
GO

CREATE PROCEDURE [dbo].[FindItemRestoreAuditById]
	@id UNIQUEIDENTIFIER
	AS
	BEGIN
		SET NOCOUNT ON
		SELECT *
		FROM [dbo].[ItemRestoreAudits]
		WHERE [id] = @id
	END
GO

--------------------------------------------------------------------------------
-- EnumItemRestoreAuditsBySessionId

EXEC HrPreCreateProc @proc = N'[dbo].[EnumItemRestoreAuditsBySessionId]'
GO

CREATE PROCEDURE [dbo].[EnumItemRestoreAuditsBySessionId]
	@id UNIQUEIDENTIFIER
	AS
	BEGIN
		SET NOCOUNT ON
		SELECT *
		FROM [dbo].[ItemRestoreAudits]
		WHERE [restore_session_id] = @id
	END
GO

--------------------------------------------------------------------------------
-- EnumAllItemRestoreAudits

EXEC HrPreCreateProc @proc = N'[dbo].[EnumAllItemRestoreAudits]'
GO

CREATE PROCEDURE [dbo].[EnumAllItemRestoreAudits]
	AS
	BEGIN
		SET NOCOUNT ON
		SELECT *
		FROM [dbo].[ItemRestoreAudits]
	END
GO

--------------------------------------------------------------------------------

-- AddJobWanAccelerator
EXEC HrPreCreateProc @proc = N'[dbo].[AddJobWanAccelerator]'
GO

CREATE PROCEDURE [dbo].[AddJobWanAccelerator]
			   @id uniqueidentifier,
			   @job_id uniqueidentifier,
			   @wan_accelerator_id uniqueidentifier,
			   @type int
	AS
	BEGIN
		SET NOCOUNT ON;
		INSERT INTO [dbo].[Backup.Model.JobWanAccelerators] ([id], [job_id], [accelerator_id], [type])
		VALUES (@id, @job_id, @wan_accelerator_id, @type)
	END
GO
----------------------------------------------------------------------------------


-- GetJobWanAcceleratorsByJobAndType
EXEC HrPreCreateProc @proc = N'[dbo].[GetJobWanAcceleratorsByJobAndType]'
GO

CREATE PROCEDURE [dbo].[GetJobWanAcceleratorsByJobAndType]
		@job_id uniqueidentifier,
		@type int
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT * from [dbo].[Backup.Model.JobWanAccelerators] WHERE job_id = @job_id AND type = @type
	END
GO

-----------------------------------------------------------------------------------

-- GetJobWanAcceleratorByJob

EXEC HrPreCreateProc @proc = N'[dbo].[GetJobWanAcceleratorByJob]'
GO

CREATE PROCEDURE [dbo].[GetJobWanAcceleratorByJob]
		@job_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT * from [dbo].[Backup.Model.JobWanAccelerators] WHERE job_id = @job_id
	END
GO

-----------------------------------------------------------------------------------

-- GetJobWanAcceleratorsByAcceleratorId

EXEC HrPreCreateProc @proc = N'[dbo].[GetJobWanAcceleratorsByAcceleratorId]'
GO

CREATE PROCEDURE [dbo].[GetJobWanAcceleratorsByAcceleratorId]
		@accelerator_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT * from [dbo].[Backup.Model.JobWanAccelerators] WHERE accelerator_id = @accelerator_id
	END
GO

-----------------------------------------------------------------------------------

-- GetAllJobWanAccelerators

EXEC HrPreCreateProc @proc = N'[dbo].[GetAllJobWanAccelerators]'
GO

CREATE PROCEDURE [dbo].[GetAllJobWanAccelerators]
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT * from [dbo].[Backup.Model.JobWanAccelerators] 
	END
GO

------------------------------------------------------------------------------------

-- DeleteJobWanAccelerator


EXEC HrPreCreateProc @proc = N'[dbo].[DeleteJobWanAccelerator]'
GO

CREATE PROCEDURE [dbo].[DeleteJobWanAccelerator]
		@id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		DELETE FROM [dbo].[Backup.Model.JobWanAccelerators] WHERE id = @id
	END
GO

------------------------------------------------------------------------------------

-- CreateJobObjectState


EXEC HrPreCreateProc @proc = N'[dbo].[CreateJobObjectState]'
GO

CREATE PROCEDURE [dbo].[CreateJobObjectState]
		@id uniqueidentifier,
		@job_id uniqueidentifier,
		@obj_id uniqueidentifier,
		@creation_time datetime,
		@data xml
	AS
	BEGIN
		SET NOCOUNT ON

		INSERT INTO [dbo].[JobObjectsState]
			   ([id], [job_id], [obj_id], [creation_time], [data])
		VALUES
			   (@id, @job_id, @obj_id, @creation_time, @data)
	END	

GO

------------------------------------------------------------------------------------

-- GetAllJobObjectsStates


EXEC HrPreCreateProc @proc = N'[dbo].[GetAllJobObjectsStates]'
GO

CREATE PROCEDURE [dbo].GetAllJobObjectsStates
	AS
	BEGIN
		SET NOCOUNT ON
		SELECT * from [dbo].[JobObjectsState]
	END
GO

------------------------------------------------------------------------------------

-- DeleteJobObjectState


EXEC HrPreCreateProc @proc = N'[dbo].[DeleteJobObjectState]'
GO

CREATE PROCEDURE [dbo].DeleteJobObjectState
		@id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON
		DELETE FROM [dbo].[JobObjectsState] WHERE id = @id
	END
GO

------------------------------------------------------------------------------------

-- UpdateJobObjectState


EXEC HrPreCreateProc @proc = N'[dbo].[UpdateJobObjectState]'
GO

CREATE PROCEDURE [dbo].UpdateJobObjectState
		@id uniqueidentifier,
		@job_id uniqueidentifier,
		@obj_id uniqueidentifier,
		@creation_time datetime,
		@data xml
	AS
	BEGIN
		SET NOCOUNT ON

		UPDATE [dbo].[JobObjectsState] SET
			[job_id] = @job_id,
			[obj_id] = @obj_id,
			[creation_time] = @creation_time,
			[data] = @data
		WHERE [id] = @id
	END
GO

------------------------------------------------------------------------------------

-- FindJobObjectStateByJobAndObj


EXEC HrPreCreateProc @proc = N'[dbo].[FindJobObjectStateByJobAndObj]'
GO

CREATE PROCEDURE [dbo].FindJobObjectStateByJobAndObj
		@job_id uniqueidentifier,
		@obj_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON

		SELECT
			*
		FROM
			[dbo].[JobObjectsState]
		WHERE
			[job_id] = @job_id AND
			[obj_id] = @obj_id
	END
GO

------------------------------------------------------------------------------------

-- FindJobObjectState


EXEC HrPreCreateProc @proc = N'[dbo].[FindJobObjectState]'
GO

CREATE PROCEDURE [dbo].FindJobObjectState
		@id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON

		SELECT
			*
		FROM
			[dbo].[JobObjectsState]
		WHERE
			[id] = @id
	END
GO

---------------------------------------------------------------------------------------

-- GetDependentJobs

EXEC HrPreCreateProc @proc = N'[dbo].[GetDependentJobs]'
GO

CREATE PROCEDURE [dbo].[GetDependentJobs]
	@id uniqueidentifier
AS
BEGIN
	SET NOCOUNT ON;
	SELECT j.* FROM  [BJobs] j 
    JOIN (SELECT job_id FROM LinkedJobs WHERE [linked_job_id] = @id) 
    l ON j.id = l.job_id 
END
GO

--------------------------------------------------------------------------------
-- UpdateJobCredentials
PRINT N'Creating [dbo].[UpdateJobCredentials]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateJobCredentials]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateJobCredentials]
GO

	CREATE PROCEDURE [dbo].[UpdateJobCredentials]
		@row_id uniqueidentifier,
		@row_cred_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
			
		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT
		UPDATE dbo.JobVssCredentials
		SET [credentials_id] = @row_cred_id,[usn] = @usn
		WHERE id=@row_id
	END	
	
GO

------------------------------------------------------------------------------------

-- FindOibForObjectInStorage


EXEC HrPreCreateProc @proc = N'[dbo].[FindOibForObjectInStorage]'
GO

CREATE PROCEDURE [dbo].FindOibForObjectInStorage
		@storage_id uniqueidentifier,
		@obj_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON

		SELECT
			*
		FROM
			[dbo].[Backup.Model.OIBs]
		WHERE
			[object_id] = @obj_id AND
			[storage_id] = @storage_id
	END
GO

--------------------------------------------------------------------------------
-- Backup.Model.GetOibsForObjectInBackup
PRINT N'Creating [dbo].[GetOibsForObjectInBackup]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetOibsForObjectInBackup]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetOibsForObjectInBackup]
GO

	CREATE PROCEDURE [dbo].[GetOibsForObjectInBackup]
		@row_backup_id uniqueidentifier,
		@row_object_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;	
		SELECT oibs.* FROM 
			[dbo].[Backup.Model.OIBs] oibs,
			[dbo].[Backup.Model.Storages] storages
		WHERE 
			oibs.storage_id  = storages.id and
			oibs.object_id = @row_object_id AND 
			storages.backup_id  = @row_backup_id
		ORDER BY storages.creation_time		
	END

GO

--------------------------------------------------------------------------------
-- Backup.Model.[AddTaskTransferProgress]
PRINT N'Creating [dbo].[AddTaskTransferProgress]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[AddTaskTransferProgress]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[AddTaskTransferProgress]
GO

	CREATE PROCEDURE [dbo].[AddTaskTransferProgress]
			   @row_session_id uniqueidentifier,
			   @row_transfered bigint,
			   @row_processed bigint,
			   @row_date datetime
	AS
	BEGIN

		INSERT INTO [dbo].[Backup.Model.BackupTaskSessionsProgress]
			   ([session_id]
			   ,[transfered]
			   ,[processed]
			   ,[date]
			   )
		 VALUES
			   (@row_session_id,
			   @row_transfered,
			   @row_processed,
			   @row_date
			   )
	END	

GO

--------------------------------------------------------------------------------
-- [Backup.Model.FindJobs]
PRINT N'Creating [dbo].[Backup.Model.FindJobs]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.FindJobs]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.FindJobs]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.FindJobs]
				@row_ids xml
	AS
	BEGIN
		SELECT * FROM [dbo].[BJobs] WHERE [id] in (SELECT id FROM ParseIdList(@row_ids))
	END	

GO

--------------------------------------------------------------------------------
-- AddLinkedBackupRepository
PRINT N'Creating [dbo].[AddLinkedBackupRepository]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[AddLinkedBackupRepository]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[AddLinkedBackupRepository]
GO
	CREATE PROCEDURE [dbo].[AddLinkedBackupRepository]
		@id uniqueidentifier
		,@job_id uniqueidentifier
		,@linked_backup_repository_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		INSERT INTO [dbo].[LinkedBackupRepositories] (
			id
			,job_id
			,linked_backup_repository_id) 
		VALUES (
			@id
			,@job_id
			,@linked_backup_repository_id)
	END	
GO

--------------------------------------------------------------------------------
-- GetLinkedBackupRepositoriesByJobId
PRINT N'Creating [dbo].[GetLinkedBackupRepositoriesByJobId]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetLinkedBackupRepositoriesByJobId]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetLinkedBackupRepositoriesByJobId]
GO
	CREATE PROCEDURE [dbo].[GetLinkedBackupRepositoriesByJobId]
		@job_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * FROM [dbo].[LinkedBackupRepositories] WHERE job_id = @job_id
	END	
GO

--------------------------------------------------------------------------------
-- [GetLinkedBackupRepositoriesByRepId]
PRINT N'Creating [dbo].[GetLinkedBackupRepositoriesByRepId]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetLinkedBackupRepositoriesByRepId]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetLinkedBackupRepositoriesByRepId]
GO
	CREATE PROCEDURE [dbo].[GetLinkedBackupRepositoriesByRepId]
		@rep_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT * FROM [dbo].[LinkedBackupRepositories] WHERE linked_backup_repository_id = @rep_id
	END	

GO

--------------------------------------------------------------------------------
-- DeleteLinkedBackupRepositoriesByJobId
PRINT N'Creating [dbo].[DeleteLinkedBackupRepositoriesByJobId]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DeleteLinkedBackupRepositoriesByJobId]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[DeleteLinkedBackupRepositoriesByJobId]
GO
	CREATE PROCEDURE [dbo].[DeleteLinkedBackupRepositoriesByJobId]
		@job_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		DELETE FROM [dbo].[LinkedBackupRepositories] WHERE job_id = @job_id
	END	
GO

--------------------------------------------------------------------------------
-- GetLastUncorruptedOib4ObjByTargetType
PRINT N'Creating [dbo].[GetLastUncorruptedOib4ObjByTargetType]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetLastUncorruptedOib4ObjByTargetType]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetLastUncorruptedOib4ObjByTargetType]
GO

	CREATE PROCEDURE [dbo].[GetLastUncorruptedOib4ObjByTargetType]
		@obj_id uniqueidentifier,
		@target_type int
	AS
	BEGIN
		SET NOCOUNT ON;	
		select top 1 oib.* from 
			[dbo].[Backup.Model.OIBs] oib,
			[dbo].[Backup.Model.Points] pnt,
			[dbo].[Backup.Model.Backups] _backup,
			[dbo].[BObjects] obj	
		where 
			oib.point_id = pnt.id and
			pnt.backup_id = _backup.id and
			_backup.target_type = @target_type and
			oib.object_id = obj.id and	
			oib.is_corrupted = 0 and
			obj.id = @obj_id
		order by oib.creation_time desc
	END

GO

--------------------------------------------------------------------------------
-- GetOibClosestToTime4ObjByTargetType
PRINT N'Creating [dbo].[Backup.Model.GetOibClosestToTime]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetOibClosestToTime4ObjByTargetType]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetOibClosestToTime4ObjByTargetType]
GO

	CREATE PROCEDURE [dbo].[GetOibClosestToTime4ObjByTargetType]
		@obj_id uniqueidentifier,
		@target_type int,
		@restore_point_time datetime
	AS
	BEGIN
		SET NOCOUNT ON;	
		select top 1 oib.* from 
			[dbo].[Backup.Model.OIBs] oib,
			[dbo].[Backup.Model.Points] pnt,
			[dbo].[Backup.Model.Backups] _backup,
			[dbo].[BObjects] obj
		where 
			oib.point_id = pnt.id
			and pnt.backup_id = _backup.id
			and _backup.[job_target_type] in (0, 1)
			and _backup.target_type = @target_type
			and oib.object_id = obj.id
			and obj.id = @obj_id
		order by abs(datediff(second, @restore_point_time, pnt.creation_time)) asc
	END
	
GO

--------------------------------------------------------------------------------
-- GetLastOib4ObjByTargetType
PRINT N'Creating [dbo].[GetLastOib4ObjByTargetType]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetLastOib4ObjByTargetType]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetLastOib4ObjByTargetType]
GO

	CREATE PROCEDURE [dbo].[GetLastOib4ObjByTargetType]
		@obj_id uniqueidentifier,
		@target_type int
	AS
	BEGIN
		SET NOCOUNT ON;	
		select top 1 oib.* from 
			[dbo].[Backup.Model.OIBs] oib,
			[dbo].[Backup.Model.Points] pnt,
			[dbo].[Backup.Model.Backups] _backup,
			[dbo].[BObjects] obj	
		where 
			oib.point_id = pnt.id and
			pnt.backup_id = _backup.id and
			_backup.[job_target_type] in (0, 1) and
			_backup.target_type = @target_type and
			oib.object_id = @obj_id
		order by oib.creation_time desc
	END
	
GO

--------------------------------------------------------------------------------
-- GetBackupsByTargetTypeAndPlatform
PRINT N'Creating [dbo].[GetBackupsByTargetTypeAndPlatform]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetBackupsByTargetTypeAndPlatform]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetBackupsByTargetTypeAndPlatform]
GO

	CREATE PROCEDURE [dbo].[GetBackupsByTargetTypeAndPlatform]
		@target_type int,
		@platform int
	AS
	BEGIN
		SET NOCOUNT ON;	
		SELECT 
			*
		FROM 
			[dbo].[Backup.Model.Backups]
		WHERE 
			[target_type] = @target_type AND
			[platform] = @platform
	END

GO

--------------------------------------------------------------------------------
-- GetBackupsByTargetTypeAndPlatform
PRINT N'Creating [dbo].[GetBackupsByTargetTypeAndPlatformAndNotInRepository]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetBackupsByTargetTypeAndPlatformAndNotInRepository]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetBackupsByTargetTypeAndPlatformAndNotInRepository]
GO

	CREATE PROCEDURE [dbo].[GetBackupsByTargetTypeAndPlatformAndNotInRepository]
		@target_type int,
		@platform int,
		@repository_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;	
		SELECT 
			*
		FROM 
			[dbo].[Backup.Model.Backups]
		WHERE 
			[target_type] = @target_type AND
			[platform] = @platform AND
			[repository_id] <> @repository_id

	END

GO

--------------------------------------------------------------------------------
-- GetBackupsByJobTypeAndPlatform
PRINT N'Creating [dbo].[GetBackupsByJobTypeAndPlatform]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetBackupsByJobTypeAndPlatform]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetBackupsByJobTypeAndPlatform]
GO

	CREATE PROCEDURE [dbo].[GetBackupsByJobTypeAndPlatform]
		@job_type int,
		@platform int
	AS
	BEGIN
		SET NOCOUNT ON;	
		SELECT 
			*
		FROM 
			[dbo].[Backup.Model.Backups]
		WHERE 
			[job_target_type] = @job_type AND
			[platform] = @platform
	END

GO

--------------------------------------------------------------------------------
-- SetVmssVmRef
PRINT N'Creating [dbo].[SetVmssVmRef]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[SetVmssVmRef]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[SetVmssVmRef]
GO

	CREATE PROCEDURE [dbo].[SetVmssVmRef]	
			   @id uniqueidentifier,		   
			   @vm_ref nvarchar(400)
	AS
	BEGIN
		SET NOCOUNT ON;
		
		UPDATE [dbo].[VmssVms]
			SET [dbo].[VmssVms].[vm_ref] = @vm_ref
			WHERE [dbo].[VmssVms].[id] = @id

	END   
	 
GO

--------------------------------------------------------------------------------
-- GetVisibleHostByName
PRINT N'Creating [dbo].[GetVisibleHostByName]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetVisibleHostByName]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetVisibleHostByName]
GO

	CREATE PROCEDURE [dbo].[GetVisibleHostByName]
		@name nvarchar(max)
	AS
	BEGIN
		SET NOCOUNT ON;

	SELECT 
		*
	FROM
		[dbo].[Hosts]
	WHERE
		[dbo].[Hosts].[name] = @name AND
		[dbo].[fn.IsImportedHost]([dbo].[Hosts].[id]) = 'False'

	END

GO

--------------------------------------------------------------------------------
-- [ReportBackupTaskSessionsProgress]
PRINT N'Creating [dbo].[ReportBackupTaskSessionsProgress]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[ReportBackupTaskSessionsProgress]') AND type in (N'V'))
	DROP VIEW [dbo].[ReportBackupTaskSessionsProgress]
GO

	CREATE VIEW [dbo].[ReportBackupTaskSessionsProgress]
	AS
	SELECT 
		[session_id],
		[date],
		[transfered],
		[processed]
	FROM [dbo].[Backup.Model.BackupTaskSessionsProgress]
GO

-- [dbo].[ReportSessionProgress]
PRINT N'Creating [dbo].[ReportSessionProgress]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[ReportSessionProgress]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[ReportSessionProgress]
GO
CREATE PROCEDURE ReportSessionProgress
			   @row_session_id UNIQUEIDENTIFIER,
			   @isLastFive BIT,
			   @isWAN BIT
AS
BEGIN
	DECLARE @requiredPeriod INT, @countSeconds INT
	SET @requiredPeriod = 10
	IF @isWAN = 1
		SET @requiredPeriod = 20
	DECLARE @min AS DATETIME, @max AS DATETIME
	SELECT @max=MAX([date]) FROM ReportBackupTaskSessionsProgress WHERE [session_id] = @row_session_id
	SELECT @min=MIN([date]) FROM ReportBackupTaskSessionsProgress WHERE [session_id] = @row_session_id
	IF @isLastFive = 1 AND DATEDIFF(SECOND,@min, @max) > 6*60
		SELECT @min = DATEADD(SECOND, @requiredPeriod *  ROUND( DATEDIFF(SECOND,@min, DATEADD(SECOND, -6*60, @max)) / @requiredPeriod, 0), @min)
	SELECT @countSeconds = DATEDIFF(SECOND,@min, @max)
	IF @countSeconds / @requiredPeriod > 300
		SET @requiredPeriod = @countSeconds / 300
	SELECT 		MAX(rbtsp.[date]) AS [date],
				SUM(rbtsp.[transfered]) AS [transfered],
				SUM(rbtsp.[processed]) AS [processed],
				@requiredPeriod AS [period],
				pointInPeriod.point
		FROM ReportBackupTaskSessionsProgress AS rbtsp
	CROSS APPLY (SELECT point=DATEDIFF(SECOND,@min, rbtsp.[date])/@requiredPeriod) pointInPeriod	
	WHERE rbtsp.[session_id] = @row_session_id and rbtsp.[date] > @min
	GROUP BY pointInPeriod.point
	ORDER BY [date]
END
GO


--------------------------------------------------------------------------------

-- AddJobSourceRepository
EXEC HrPreCreateProc @proc = N'[dbo].[AddJobSourceRepository]'
GO
CREATE PROCEDURE [dbo].[AddJobSourceRepository]
			   @id uniqueidentifier,
			   @job_id uniqueidentifier,
			   @rep_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		INSERT INTO [dbo].[JobSourceRepositories] ([id], [job_id], [repository_id])
		VALUES (@id, @job_id, @rep_id)
	END
GO

-- GetJobSourceRepositoryByJob
EXEC HrPreCreateProc @proc = N'[dbo].[GetJobSourceRepositoryByJob]'

GO
CREATE PROCEDURE [dbo].[GetJobSourceRepositoryByJob]
		@job_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT * from [dbo].[JobSourceRepositories] WHERE job_id = @job_id
	END

GO

-- DeleteJobSourceRepository
EXEC HrPreCreateProc @proc = N'[dbo].[DeleteJobSourceRepository]'

GO

CREATE PROCEDURE [dbo].[DeleteJobSourceRepository]
		@id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		DELETE FROM [dbo].[JobSourceRepositories] WHERE id = @id
	END
GO

-- GetChainOibsFromIncrementalToFull
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetChainOibsFromIncrementalToFull]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetChainOibsFromIncrementalToFull]
GO
	CREATE PROCEDURE [dbo].[GetChainOibsFromIncrementalToFull]
			   @oib_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		with cteOibs (id, link_id, cnt) 
		as
		(
			select id, link_id, 0 from [Backup.Model.OIBs] where  id = @oib_id
			union all
			select o.id, o.link_id, c.cnt + 1 from [Backup.Model.OIBs] o
			join cteOibs c on o.id = c.link_id 
		)
		select 
		o.* 
		from cteOibs c join [Backup.Model.OIBs] o on c.id = o.id
		order by c.cnt desc 
		OPTION (MAXRECURSION 0) --//<dev-a1056>
	END	

Go

--------------------------------------------------------------------------------
-- GetRootVisibleHostByName
PRINT N'Creating [dbo].[GetRootVisibleHostByName]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetRootVisibleHostByName]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetRootVisibleHostByName]
GO

	CREATE PROCEDURE [dbo].[GetRootVisibleHostByName]
		@name nvarchar(max)
	AS
	BEGIN
		SET NOCOUNT ON;

	SELECT 
		*
	FROM
		[dbo].[Hosts]
	WHERE
		[dbo].[Hosts].[name] = @name AND
		[dbo].[fn.IsRootVisibleHost]([dbo].[Hosts].[id]) = 'True'

	END

GO

--------------------------------------------------------------------------------
-- GetRootVisibleHostByNameAndType
PRINT N'Creating [dbo].[GetRootVisibleHostByNameAndType]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetRootVisibleHostByNameAndType]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetRootVisibleHostByNameAndType]
GO

	CREATE PROCEDURE [dbo].[GetRootVisibleHostByNameAndType]
		@name nvarchar(max),
		@type int
	AS
	BEGIN
		SET NOCOUNT ON;

	SELECT 
		*
	FROM
		[dbo].[Hosts]
	WHERE
		[dbo].[Hosts].[name] = @name AND
		[dbo].[Hosts].[type] = @type AND
		[dbo].[fn.IsRootVisibleHost]([dbo].[Hosts].[id]) = 'True'

	END

GO

PRINT N'Creating [dbo].[GetBSessionsByOrigSessionId]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetBSessionsByOrigSessionId]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetBSessionsByOrigSessionId]
GO

	CREATE PROCEDURE [dbo].[GetBSessionsByOrigSessionId]
		@orig_session_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT * 	
		FROM [dbo].[Backup.Model.JobSessions] INNER JOIN [dbo].[Backup.Model.BackupJobSessions] 
			ON [dbo].[Backup.Model.JobSessions].[id] = [dbo].[Backup.Model.BackupJobSessions].[id]
			
		WHERE [orig_session_id] = @orig_session_id
	END

GO

--------------------------------------------------------------------------------
-- ReportSessionsView
PRINT N'Creating [Backup.Model.CredentialsObjectsView]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[Backup.Model.CredentialsObjectsView]') AND type in (N'V'))
	DROP VIEW [Backup.Model.CredentialsObjectsView]
GO

CREATE VIEW [Backup.Model.CredentialsObjectsView]
AS
	SELECT cr.id AS credential_id
		, h.id AS [object_id]
		, h.name AS [name]
		, 0 AS [assigned_type]
		, h.[type] 
		, NULL AS [platform]
	FROM [Credentials] cr
			INNER JOIN Hosts h ON cr.id = h.credentials_id
	UNION
	SELECT cr.id, h.id, h.name, 0, h.[type], NULL
		FROM [Credentials] cr
			INNER JOIN Soap_creds soap_cr ON cr.id = soap_cr.creds		
			INNER JOIN Hosts h ON soap_cr.host_id = h.id
	UNION
	SELECT cr.id, h.id, h.name, 0, h.[type], NULL
		FROM [Credentials] cr
			INNER JOIN Ssh_creds ssl_cr ON cr.id = ssl_cr.creds		
			INNER JOIN Hosts h ON ssl_cr.host_id = h.id
	UNION
	SELECT cr.id, mru.id, mru.url, 1, NULL, NULL
		FROM [Credentials] cr
			INNER JOIN [Backup.Model.MruList] mru ON cr.id = mru.credential_id
	UNION
	SELECT cr.id, repo.id, repo.name, 2, NULL, NULL
		FROM [Credentials] cr
			INNER JOIN BackupRepositories repo ON cr.id = repo.share_creds_id	
	UNION		
	SELECT cr.id, job.id, job.name, 3, job.[type], job.[platform]
		FROM [Credentials] cr
			INNER JOIN JobVssCredentials job_vss ON cr.id = job_vss.credentials_id
			INNER JOIN BJobs job ON job_vss.job_id = job.id
	WHERE job_vss.[oij_id] IS NULL
	UNION
	SELECT cr.id, oij.id, obj.[object_name] + ' ('  + job.name + ')', 4, job.[type], obj.[platform]
		FROM [Credentials] cr
			INNER JOIN JobVssCredentials job_vss ON cr.id = job_vss.credentials_id
			INNER JOIN ObjectsInJobs oij ON job_vss.[oij_id] = oij.id
			INNER JOIN BJobs job ON oij.job_id = job.id
			INNER JOIN BObjects obj ON oij.[object_id] = obj.id
GO

PRINT N'Creating [Backup.Model.GetCredentialsObjects]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[Backup.Model.GetCredentialsObjects]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [Backup.Model.GetCredentialsObjects]
GO

CREATE PROC [dbo].[Backup.Model.GetCredentialsObjects]
	@row_ids xml = NULL
AS 
BEGIN	
	IF @row_ids IS NULL
		SELECT * FROM [Backup.Model.CredentialsObjectsView]
	ELSE	
		SELECT * FROM [Backup.Model.CredentialsObjectsView] WHERE credential_id IN (SELECT id FROM ParseIdList(@row_ids))
END

GO

--------------------------------------------------------------------------------
-- ClearProgressForOtherSessionsInJob
--------------------------------------------------------------------------------
print N'Creating [dbo].[ClearProgressForOtherSessionsInJob]'
if exists (select * from sys.objects where object_id = OBJECT_ID(N'[dbo].[ClearProgressForOtherSessionsInJob]') and type in (N'P', N'PC'))
	drop procedure [dbo].[ClearProgressForOtherSessionsInJob]
go
	create procedure [dbo].[ClearProgressForOtherSessionsInJob]
		@row_id uniqueidentifier
	as
	begin
		set nocount on;

		declare @currentJobId uniqueidentifier
		select @currentJobId = [job_id] from [dbo].[Backup.Model.JobSessions] where [id] = @row_id

		delete oldProgress from [dbo].[Backup.Model.BackupTaskSessionsProgress] as oldProgress
		inner join [dbo].[Backup.Model.JobSessions] as js 
             on js.id != @row_id and js.job_id = @currentJobId and js.id = oldProgress.session_id
	end
go

--------------------------------------------------------------------------------
-- AnyIncrementStorage
--------------------------------------------------------------------------------
print N'Creating [dbo].[AnyIncrementStorage]'
if exists (select * from sys.objects where object_id = OBJECT_ID(N'[dbo].[AnyIncrementStorage]') and type in (N'P', N'PC'))
	drop procedure [dbo].[AnyIncrementStorage]
go
create procedure [dbo].[AnyIncrementStorage]
		@backup_id uniqueidentifier
	as
	begin
		SET NOCOUNT ON;	
		declare @retval bit
		if(exists(select distinct 1 from [Backup.Model.Storages] s where backup_id = @backup_id AND lower(right(rtrim(s.file_path), 4)) = '.vib'))
			set @retval = 1
		else
			set @retval = 0
		select @retval 
	END
go

------------------------------------------------------------------------------
-- FindTopUncorruptedOibs
------------------------------------------------------------------------------

print N'Creating [dbo].[FindTopUncorruptedOibs]'
if exists (select * from sys.objects where object_id = OBJECT_ID(N'[dbo].[FindTopUncorruptedOibs]') and type in (N'P', N'PC'))
	drop procedure [dbo].[FindTopUncorruptedOibs]
go
create procedure [dbo].[FindTopUncorruptedOibs]
		@count int,
		@obj_type_flags int,
		@target_type int,
		@obj_name_criteria nvarchar(2000)
	as
	begin
		set nocount on;
		declare @vm int, @vapp int
		declare @isVapp bit
		select @vm = case when (@obj_type_flags & 1) = 1 then 1 else -1 end, 
			   @vapp = case when (@obj_type_flags & 2) = 2 then 3 else -1 end,
			   @isVapp = case when (@obj_type_flags & 2) = 2 then 1 else 0 end				
		
		select oib.*
		from
		(
			select 
				 oib.id
				,row_number()  over(partition by obj.id order by oib.creation_time desc) row_num
			from 
				[dbo].[Backup.Model.OIBs] oib
				join
				(
					select distinct top (@count) obj.id
					from 
						[dbo].[BObjects] obj
						join [dbo].[Backup.Model.OIBs] oib on obj.id = oib.[object_id]
						join [dbo].[Backup.Model.Points] pnt on oib.point_id = pnt.id
						join [dbo].[Backup.Model.Backups] _backup on pnt.backup_id = _backup.id
					where   
						oib.is_corrupted = 0 and (@isVapp = 0 or oib.is_consistent = 1) 
						and (obj.[type] in (@vm, @vapp)) 
						and _backup.target_type = @target_type  
						and oib.display_name like '%' + @obj_name_criteria + '%'
				) obj on oib.object_id = obj.id
				join [dbo].[Backup.Model.Points] pnt on oib.point_id = pnt.id
				join [dbo].[Backup.Model.Backups] _backup on pnt.backup_id = _backup.id
			where oib.is_corrupted = 0 and (@isVapp = 0 or oib.is_consistent = 1) and _backup.target_type = @target_type
		) lastOib 
			join [dbo].[Backup.Model.OIBs] oib on lastOib.id = oib.id
		where lastOib.row_num = 1 
	end
go

------------------------------------------------------------------------------
-- GetNotImportedBackupsByJobTypeAndPlatform
------------------------------------------------------------------------------

print N'Creating [dbo].[GetNotImportedBackupsByJobTypeAndPlatform]'
if exists (select * from sys.objects where object_id = OBJECT_ID(N'[dbo].[GetNotImportedBackupsByJobTypeAndPlatform]') and type in (N'P', N'PC'))
	drop procedure [dbo].[GetNotImportedBackupsByJobTypeAndPlatform]
go
	create procedure [dbo].[GetNotImportedBackupsByJobTypeAndPlatform]
		@job_type int,
		@platform int
	as
	begin
		set nocount on;	
		select b.* 
		from [dbo].[Backup.Model.Backups] b
		join [dbo].[BJobs] j 
		on  b.job_id = j.id 
		and b.[job_target_type] = @job_type 
		and b.[platform] = @platform
	end
GO

PRINT N'Creating [dbo].[GetProtectedVmCount]'
IF EXISTS (select * from sys.objects where object_id = OBJECT_ID(N'[dbo].[GetProtectedVmCount]') and type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetProtectedVmCount]
GO

CREATE PROC [dbo].[GetProtectedVmCount]
	@days int
AS
BEGIN
SET NOCOUNT ON	
SELECT COUNT(*) [vm_count]
FROM 
(SELECT DISTINCT objs.id
FROM 
	BObjects objs 
		INNER JOIN [Backup.Model.OIBs] oibs ON oibs.[object_id] = objs.id
		INNER JOIN [Backup.Model.Points] points ON oibs.point_id = points.id
		INNER JOIN [Backup.Model.Backups] back ON points.backup_id = back.id
WHERE is_corrupted = 0 AND back.job_id <> '00000000-0000-0000-0000-000000000000'
	AND back.target_type <> 3
	AND DATEDIFF(DAY, oibs.creation_time, GETDATE()) <= @days) as t1
END
GO

--------------------------------------------------------------------------------
-- Update Pid
PRINT N'Creating [dbo].[SetJobSessionPId]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[SetJobSessionPId]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[SetJobSessionPId]
GO

	CREATE PROCEDURE [dbo].[SetJobSessionPId]
		@row_id uniqueidentifier,
		@pid int
	AS
	BEGIN
		SET NOCOUNT ON;
		UPDATE [dbo].[Backup.Model.JobSessions] SET [pid] = @pid where [id] = @row_id 
	END

GO

--------------------------------------------------------------------------------
-- GetJobsByWanAccelerator
EXEC HrPreCreateProc @proc = N'[dbo].[GetJobsByWanAccelerator]'
GO

CREATE PROCEDURE [dbo].[GetJobsByWanAccelerator]
	@wan_accelerator_id uniqueidentifier
AS
BEGIN
	SET NOCOUNT ON;
	SELECT 
		* 
	FROM 
		[BJobs] 
	WHERE 
		[id] IN
			(SELECT 
				DISTINCT(jobs.[id])
			FROM
				[dbo].[BJobs] jobs LEFT JOIN [dbo].[Backup.Model.JobWanAccelerators] jobWanAccelerators 
					ON jobs.[id] = jobWanAccelerators.[job_id]
			WHERE
				jobWanAccelerators.[accelerator_id] = @wan_accelerator_id
			)
END
GO

------------------------------------------------------------------------------------
-- DeleteJobWanAcceleratorsByWanAccelerator

EXEC HrPreCreateProc @proc = N'[dbo].[DeleteJobWanAcceleratorsByWanAccelerator]'
GO

CREATE PROCEDURE [dbo].[DeleteJobWanAcceleratorsByWanAccelerator]
		@accelerator_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		DELETE FROM [dbo].[Backup.Model.JobWanAccelerators] WHERE accelerator_id = @accelerator_id
	END
GO

PRINT N'Creating [dbo].[IsExistsFailoverPlans]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[IsExistsFailoverPlans]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[IsExistsFailoverPlans]
GO
CREATE PROC [dbo].[IsExistsFailoverPlans]
AS
BEGIN
	SET NOCOUNT ON;
	IF EXISTS(SELECT TOP(1) id FROM [dbo].[BJobs] WHERE [type]=202) -- FailoverPlans
		SELECT 1
	ELSE
		SELECT 0
END
GO

------------------------------------------------------------------------------------

-- FindJobObjectStateByJob


EXEC HrPreCreateProc @proc = N'[dbo].[FindJobObjectStateByJob]'
GO

CREATE PROCEDURE [dbo].FindJobObjectStateByJob
		@job_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON

		SELECT
			*
		FROM
			[dbo].[JobObjectsState]
		WHERE
			[job_id] = @job_id 
	END
GO

exec  HrPreCreateProc @proc = N'[dbo].[GetBackupsByFlagsTargetTypeAndPlatform]'
go

create proc [dbo].[GetBackupsByFlagsTargetTypeAndPlatform]
	@target_type_flags int,
	@platform_flags int
as
begin

set nocount on;	

declare @other as int, @snapReplica as int, @sanSnapshot as int, @tape as int, @legacyReplica as int, @files as int;
declare @vi as int, @hv as int, @vcd as int;
--ETargetType
select @other = case when (@target_type_flags & 1) = 1 then 0 else -1 end, 
       @snapReplica = case when (@target_type_flags & 2) = 2 then 2 else -1 end,
	   @sanSnapshot = case when (@target_type_flags & 4) = 4 then 3 else -1 end,
	   @tape = case when (@target_type_flags & 8) = 8 then 4 else -1 end,
	   @legacyReplica = case when (@target_type_flags & 16) = 16 then 5 else -1 end,
	   @files = case when (@target_type_flags & 32) = 32 then 6 else -1 end

--EPlatform
select @vi = case when (@platform_flags & 1) = 1 then 0 else -1 end,
       @hv = case when (@platform_flags & 2) = 2 then 1 else -1 end,
	   @vcd = case when (@platform_flags & 4) = 4 then 4 else -1 end

select * from  [dbo].[Backup.Model.Backups]
where  [target_type] in (@other, @snapReplica, @tape, @legacyReplica, @sanSnapshot, @files) 
	    and
	   [platform] in (@vi, @hv, @vcd)
order by [platform], [target_type]

end
go



--------------------------------------------------------------------------------
PRINT N'Creating [dbo].[UpdateSessionAlgInSession]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[UpdateSessionAlgInSession]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[UpdateSessionAlgInSession]
GO
CREATE PROCEDURE [dbo].[UpdateSessionAlgInSession]
		@row_session_id uniqueidentifier,
		@alg int
	AS
	BEGIN
		SET NOCOUNT ON;

		declare @usn bigint
		exec [dbo].[IncrementUsn] @usn OUTPUT

		UPDATE bjs
			SET [session_algorithm] = @alg,
				[usn] = @usn
		FROM 
			[dbo].[Backup.Model.BackupJobSessions] bjs
			INNER JOIN [dbo].[Backup.Model.JobSessions] js ON bjs.id = js.id			
		WHERE bjs.[id] = @row_session_id		
	END
GO


--------------------------------------------------------------------------------
PRINT N'Creating [dbo].[Backup.Model.GetApplicationOibs]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetApplicationOibs]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetApplicationOibs]
GO
CREATE PROCEDURE [dbo].[Backup.Model.GetApplicationOibs]
AS
	BEGIN
	SELECT * 
	FROM [dbo].[Backup.Model.OIBs]
	Where has_exchange='True' or has_sql ='True' or has_sharepoint ='True'
	END
GO

--------------------------------------------------------------------------------
PRINT N'Creating [dbo].[Backup.Model.CanDisablePlugin]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.CanDisablePlugin]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.CanDisablePlugin]
GO

CREATE PROC [dbo].[Backup.Model.CanDisablePlugin]
	@plugin_id	uniqueidentifier
AS
BEGIN
	SET NOCOUNT ON

	IF EXISTS (SELECT * FROM [Backup.Model.SanHostsPlugins] pl INNER JOIN Hosts ON pl.[host_id] = Hosts.id  WHERE pl.plugin_id = @plugin_id)
		SELECT 0
	ELSE
		SELECT 1
END		
GO

PRINT N'Creating [dbo].[IsFullOnlyBackup]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[IsFullOnlyBackup]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[IsFullOnlyBackup]
GO
create procedure [dbo].[IsFullOnlyBackup]
		@backup_id uniqueidentifier
	as
	begin
		set nocount on;	
		declare @retval bit
		if(exists(select distinct 1 from [Backup.Model.Storages] s where backup_id = @backup_id and lower(right(rtrim(s.file_path), 4)) != '.vbk'))
			set @retval = 0
		else
			set @retval = 1
		select @retval 
	end
go

--------------------------------------------------------------------------------
-- [Backup.Model.AddSanVolumeExportInfo]
PRINT N'Creating [dbo].[Backup.Model.AddSanVolumeExportInfo]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.AddSanVolumeExportInfo]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.AddSanVolumeExportInfo]
GO
	CREATE PROCEDURE [dbo].[Backup.Model.AddSanVolumeExportInfo]
		@id uniqueidentifier,
		@volume_id uniqueidentifier,
		@protocol int,
		@source_server_iqn_or_wwn [nvarchar](512),
		@server_iqn_or_wwn [nvarchar](512),
		@lun_id int
	AS
	BEGIN				
		INSERT INTO [dbo].[Backup.Model.SanVolumeExportInfos]		
			([id],
			[volume_id],
			[protocol],
			[source_server_iqn_or_wwn],
			[server_iqn_or_wwn],
			[lun_id]) 
		VALUES 
			(@id,
			@volume_id, 
			@protocol,
			@source_server_iqn_or_wwn,		
			@server_iqn_or_wwn,
			@lun_id)		
	END	

GO

--------------------------------------------------------------------------------
-- [Backup.Model.RemoveSanVolumeExportInfo]
PRINT N'Creating [dbo].[Backup.Model.RemoveSanVolumeExportInfo]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.RemoveSanVolumeExportInfo]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.RemoveSanVolumeExportInfo]
GO
	CREATE PROCEDURE [dbo].[Backup.Model.RemoveSanVolumeExportInfo]
		@id uniqueidentifier		
	AS
	BEGIN				
		DELETE FROM [dbo].[Backup.Model.SanVolumeExportInfos] WHERE [id] = @id
	END	
GO

--------------------------------------------------------------------------------
-- [Backup.Model.GetExportInfoForSanVolume]
PRINT N'Creating [dbo].[Backup.Model.GetExportInfoForSanVolume]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetExportInfoForSanVolume]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetExportInfoForSanVolume]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetExportInfoForSanVolume]
		@volume_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;	
		SELECT *
		FROM
			[dbo].[Backup.Model.SanVolumeExportInfos]
		WHERE
			[volume_id] = @volume_id	
	END
GO

--------------------------------------------------------------------------------
-- DeleteLicensedHostByUuid
PRINT N'Creating [dbo].[DeleteLicensedHostByUuid]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DeleteLicensedHostByUuid]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[DeleteLicensedHostByUuid]
GO

	CREATE PROCEDURE [dbo].[DeleteLicensedHostByUuid]
		@uuid nvarchar(255)
	AS
	BEGIN
		SET NOCOUNT ON;

		DELETE FROM [dbo].[LicensedHosts] WHERE [uuid] = @uuid
	END

GO

--------------------------------------------------------------------------------
-- DeleteHostByJobsByHostId
PRINT N'Creating [dbo].[DeleteHostsByJobsByHostId]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DeleteHostsByJobsByHostId]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[DeleteHostsByJobsByHostId]
GO

	CREATE PROCEDURE [dbo].[DeleteHostsByJobsByHostId]
		@host_id uniqueidentifier
	AS
	BEGIN
		DELETE FROM [dbo].[HostsByJobs]	where [host_id] = @host_id
	END	

GO

--------------------------------------------------------------------------------
-- DeleteOijsByJobId
PRINT N'Creating [dbo].[DeleteOijsByJobId]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DeleteOijsByJobId]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[DeleteOijsByJobId]
GO

	CREATE PROCEDURE [dbo].[DeleteOijsByJobId]
		@job_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;

		DELETE FROM [dbo].[ObjectsInJobs] WHERE [job_id] = @job_id
	END

GO

exec HrPreCreateProc @proc = N'[dbo].[GetSecondDestinationJobs]'
go
create proc [dbo].[GetSecondDestinationJobs]
				@job_id as uniqueidentifier
	as
	begin
	   set nocount on;
	   
	   declare @backup_copy_type as int,@tape_job_type as int
		SET @backup_copy_type = 51
		SET @tape_job_type = 28
		
		select j.*
		from BJobs j join  LinkedJobs lj on j.id = lj.job_id   
		where lj.linked_job_id = @job_id and (j.[type] in (@backup_copy_type, @tape_job_type)) 
	end	
go

exec HrPreCreateProc @proc = N'[dbo].[SecondaryDestinationJobsExists]'
go
	create proc [dbo].[SecondaryDestinationJobsExists]
				@platform as int
	as
	begin
	   set nocount on;
		declare @backup_copy_type as int
		       ,@tape_job_type as int
		select @backup_copy_type = 51,  @tape_job_type = 28
		select distinct 1 from BJobs where [type] =  @tape_job_type or ([type] = @backup_copy_type and [platform] = @platform) 
	end	
go

--------------------------------------------------------------------------------
-- GetObjectInJobByJobAndFolderAndType
PRINT N'Creating [dbo].[GetObjectInJobByJobAndFolderAndType]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetObjectInJobByJobAndFolderAndType]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetObjectInJobByJobAndFolderAndType]
GO

	CREATE PROCEDURE [dbo].[GetObjectInJobByJobAndFolderAndType]
		@job_id uniqueidentifier,
		@folder_id uniqueidentifier,
		@oij_type int
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT * from [dbo].[ObjectsInJobs]  oijs 
		LEFT JOIN [dbo].[JobVssCredentials] jobVssCreds ON oijs.[id] = jobVssCreds.[oij_id]
		LEFT JOIN [dbo].[Credentials] creds ON creds.[id] = jobVssCreds.[credentials_id]
		WHERE oijs.[job_id] = @job_id AND oijs.[object_id] = @folder_id AND oijs.[type] = @oij_type order by oijs.[order_no] asc
	END

GO

--------------------------------------------------------------------------------

go
exec HrPreCreateProc @proc = N'[dbo].[GetUncorruptedOibsForObjectInBackup]'
go
	create proc [dbo].[GetUncorruptedOibsForObjectInBackup]
				 @backup_id as uniqueidentifier --= '13AFFA07-6B44-48AB-AD6E-6EE8757378EA'
				,@obj_id as uniqueidentifier --= 'BF091A50-DDDB-4AA0-94DB-F9F8720E9C9C'
	as
	begin
	   set nocount on;
		declare @vcdPlatform int
		declare @vcdVAppObjType int
		select @vcdPlatform = 4, @vcdVAppObjType = 3

		select 
			o.*
		from
			[Backup.Model.OIBs] o
		join
			[BObjects] obj
		on
			o.[object_id] = obj.id 
		join
			[Backup.Model.Points] p
		join
			[Backup.Model.Backups] b
		on
			p.backup_id = b.id
		on
			p.id = o.point_id
		join
			[Backup.Model.Storages] s
		on
			o.storage_id = s.id
		where
			b.id = @backup_id and o.[object_id] = @obj_id 
			and 
			o.is_corrupted = 0
			and (b.[platform] != @vcdPlatform or obj.[type] != @vcdVAppObjType or o.[is_consistent] = 1)
			--and (b.job_target_type != 28 or [dbo].[IsValidChainOibs] (o.id) = 1)
		order by s.creation_time desc	   
	end	
go

---
EXEC HrPreCreateProc @proc = N'[dbo].[Backup.Model.GetApplicationsObjectOibsByPlatformAndType]'
GO
CREATE PROC [dbo].[Backup.Model.GetApplicationsObjectOibsByPlatformAndType]
	@platform as int
	,@target_type as int 
AS
BEGIN
	SET NOCOUNT ON;

	SELECT DISTINCT bk.id AS backup_id
		, oib.[object_id] AS [object_id]  
	FROM [dbo].[Backup.Model.OIBs] oib
		LEFT JOIN dbo.[Backup.Model.Storages] st ON oib.storage_id = st.id
		LEFT JOIN dbo.[Backup.Model.Points] ptn ON oib.point_id = ptn.id
		LEFT JOIN dbo.[Backup.Model.Backups] bk ON ptn.backup_id = bk.[id]
	WHERE
		 bk.target_type = @target_type AND bk.[platform] = @platform AND st.[state] = 0 AND
		 oib.is_corrupted = 0 AND (oib.has_sql = 1 OR oib.has_exchange = 1 OR oib.has_sharepoint = 1)
END
GO

---
EXEC HrPreCreateProc @proc = N'[dbo].[Backup.Model.UpdateJobRestoreSessionSubType]'
GO
CREATE PROC [dbo].[Backup.Model.UpdateJobRestoreSessionSubType]
				 @session_id as uniqueidentifier
				,@sub_type as int 
	AS
	BEGIN
	   SET NOCOUNT ON;

	UPDATE [dbo].[Backup.Model.RestoreJobSessions] 
		SET [dbo].[Backup.Model.RestoreJobSessions].[sub_type] = @sub_type
	WHERE [dbo].[Backup.Model.RestoreJobSessions].id = @session_id

END
GO


---
EXEC HrPreCreateProc @proc = N'[dbo].[Events.CreateTaskSessionEvent]'
GO
CREATE PROC [dbo].[Events.CreateTaskSessionEvent]
	@event_id uniqueidentifier,
	@event_type int,
	@job_session_id uniqueidentifier,
	@task_session_id uniqueidentifier,
	@param0 nvarchar(255) = NULL,
	@param1 nvarchar(255) = NULL,
	@param2 nvarchar(255) = NULL,
	@param3 nvarchar(255) = NULL,
	@param4 nvarchar(255) = NULL,
	@param5 nvarchar(255) = NULL
	AS
	BEGIN
	   SET NOCOUNT ON;

	INSERT INTO [dbo].[Events.TaskSessionEvents] (id, event_type, job_session_id, task_session_id,param0, param1, param2, param3, param4, param5)
	VALUES ( @event_id, @event_type, @job_session_id, @task_session_id,	@param0, @param1, @param2, @param3, @param4, @param5)
		

END
GO



---
EXEC HrPreCreateProc @proc = N'[dbo].[Events.CreateJobSessionEvent]'
GO
CREATE PROC [dbo].[Events.CreateJobSessionEvent]
	@event_id uniqueidentifier,
	@event_type int,
	@job_session_id uniqueidentifier,
	@param0 nvarchar(255) = NULL,
	@param1 nvarchar(255) = NULL,
	@param2 nvarchar(255) = NULL,
	@param3 nvarchar(255) = NULL,
	@param4 nvarchar(255) = NULL,
	@param5 nvarchar(255) = NULL
	AS
	BEGIN
	   SET NOCOUNT ON;

	INSERT INTO [dbo].[Events.JobSessionEvents] (id, event_type, job_session_id, param0, param1, param2, param3, param4, param5)
	VALUES ( @event_id, @event_type, @job_session_id, @param0, @param1, @param2, @param3, @param4, @param5)
		
END
GO

--------------------------------------------------------------------------------
-- [Backup.Model.GetExportInfo]
PRINT N'Creating [dbo].[Backup.Model.GetExportInfo]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.GetExportInfo]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.GetExportInfo]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.GetExportInfo]
		@protocol int,
		@source_iqn_or_wwn nvarchar(512),
		@lun_id int,
		@server_iqn_or_wwn nvarchar(512)
	AS
	BEGIN
		
		SET NOCOUNT ON;	
		SELECT *
		FROM			
			[dbo].[Backup.Model.SanVolumeExportInfos]  			
		WHERE
			[protocol] = @protocol AND
			[source_server_iqn_or_wwn] = @source_iqn_or_wwn AND
			[server_iqn_or_wwn] = @server_iqn_or_wwn AND 
			[lun_id] = @lun_id
	END	
GO

--------------------------------------------------------------------------------
-- GetJobVmDisksStateByJobId
PRINT N'Creating [dbo].[GetJobVmDisksStateByJobId]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetJobVmDisksStateByJobId]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetJobVmDisksStateByJobId]
GO

	CREATE PROCEDURE [dbo].[GetJobVmDisksStateByJobId]
		@job_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		SELECT jvds.* from 
			[dbo].[JobObjectsState] jos,
			[dbo].[JobVmDisksState] jvds 
		WHERE 
			jos.[job_id] = @job_id AND 
			jos.[id] = jvds.[job_object_state_id]
	END

GO

--------------------------------------------------------------------------------
-- CreateJobVmDiskState
PRINT N'Creating [dbo].[CreateJobVmDiskState]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[CreateJobVmDiskState]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[CreateJobVmDiskState]
GO

	CREATE PROCEDURE [dbo].[CreateJobVmDiskState]
		@id uniqueidentifier,
		@job_object_state_id uniqueidentifier,
		@disk_key [nvarchar](512),
		@data xml
	AS
	BEGIN				
		INSERT INTO [dbo].[JobVmDisksState]
			([id],
			[job_object_state_id],
			[disk_key],
			[aux_data]) 
		VALUES 
			(@id,
			@job_object_state_id,
			@disk_key,
			@data)		
	END	

GO
--------------------------------------------------------------------------------
-- FindJobVmDiskStateByJOIdAndDiskKey
PRINT N'Creating [dbo].[FindJobVmDiskStateByJOIdAndDiskKey]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[FindJobVmDiskStateByJOIdAndDiskKey]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[FindJobVmDiskStateByJOIdAndDiskKey]
GO

	CREATE PROCEDURE [dbo].[FindJobVmDiskStateByJOIdAndDiskKey]
		@job_object_state_id uniqueidentifier,
		@disk_key [nvarchar](512)		
	AS
	BEGIN				
		SELECT * from 
			[dbo].[JobVmDisksState]
		WHERE 
			[job_object_state_id] = @job_object_state_id AND 
			[disk_key] = @disk_key
	END	

GO
 
 --------------------------------------------------------------------------------
--  FindAllJobVmDiskStatesByJOId
PRINT N'Creating [dbo].[FindAllJobVmDiskStatesByJOId]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[FindAllJobVmDiskStatesByJOId]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[FindAllJobVmDiskStatesByJOId]
GO

	CREATE PROCEDURE [dbo].[FindAllJobVmDiskStatesByJOId]
		@job_object_state_id uniqueidentifier
	AS
	BEGIN				
		SELECT * from 
			[dbo].[JobVmDisksState]
		WHERE 
			[job_object_state_id] = @job_object_state_id
	END	

GO


--------------------------------------------------------------------------------
-- DeleteJobVmDiskStateByJOIdAndDiskKey
PRINT N'Creating [dbo].[DeleteJobVmDiskStateByJOIdAndDiskKey]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DeleteJobVmDiskStateByJOIdAndDiskKey]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[DeleteJobVmDiskStateByJOIdAndDiskKey]
GO

	CREATE PROCEDURE [dbo].[DeleteJobVmDiskStateByJOIdAndDiskKey]
		@job_object_state_id uniqueidentifier,
		@disk_key [nvarchar](512)		
	AS
	BEGIN				
		DELETE FROM [dbo].[JobVmDisksState]
		WHERE 
			[job_object_state_id] = @job_object_state_id AND 
			[disk_key] = @disk_key
	END	

GO

--------------------------------------------------------------------------------
-- DeleteJobVmDiskStateById
PRINT N'Creating [dbo].[DeleteJobVmDiskStateById]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DeleteJobVmDiskStateById]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[DeleteJobVmDiskStateById]
GO

	CREATE PROCEDURE [dbo].[DeleteJobVmDiskStateById]
		@id uniqueidentifier		
	AS
	BEGIN				
		DELETE FROM [dbo].[JobVmDisksState]
		WHERE [id] = @id
	END	

GO

--------------------------------------------------------------------------------
-- [Backup.Model.AddSanVolumeExportToProxyLunId]
PRINT N'Creating [dbo].[Backup.Model.AddSanVolumeExportToProxyLunId]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.AddSanVolumeExportToProxyLunId]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.AddSanVolumeExportToProxyLunId]
GO
	CREATE PROCEDURE [dbo].[Backup.Model.AddSanVolumeExportToProxyLunId]
		@id uniqueidentifier,
		@san_initiator_id uniqueidentifier,
		@san_host_id uniqueidentifier,
		@lun_id int,
		@init_time datetime,
		@ttl_min int
	AS
	BEGIN				
		INSERT INTO [dbo].[Backup.Model.SanVolumeExportToProxyLunId]		
			(
			[id],
			[san_initiator_id],
			[san_host_id],
			[lun_id] ,
			[init_time] ,
			[ttl_min]) 
		VALUES 
			(
			@id,
			@san_initiator_id, 
			@san_host_id,
			@lun_id,
			@init_time,		
			@ttl_min )		
	END	

GO

--------------------------------------------------------------------------------
-- [Backup.Model.RemoveSanVolumeExportToProxyLunId]
PRINT N'Creating [dbo].[Backup.Model.RemoveSanVolumeExportToProxyLunId]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.RemoveSanVolumeExportToProxyLunId]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.RemoveSanVolumeExportToProxyLunId]
GO
	CREATE PROCEDURE [dbo].[Backup.Model.RemoveSanVolumeExportToProxyLunId]
		@san_initiator_id uniqueidentifier,
		@san_host_id uniqueidentifier,
		@lun_id	int,
		@current_time datetime
	AS
	BEGIN	
		
		DELETE FROM [dbo].[Backup.Model.SanVolumeExportToProxyLunId] 
        WHERE [lun_id] = @lun_id AND [san_host_id] = @san_host_id  AND [san_initiator_id] = @san_initiator_id        						

		--Remove all expired for another lunIDs on the same SAN host and SAN Initiator
		DELETE FROM [dbo].[Backup.Model.SanVolumeExportToProxyLunId] 
        WHERE [san_host_id] = @san_host_id  AND [san_initiator_id] = @san_initiator_id AND
        DATEDIFF(minute, [init_time], @current_time) > [ttl_min]	
	END	
GO

--------------------------------------------------------------------------------
-- [Backup.Model.IsSanVolumeExportToProxyLunIdOccupied]
PRINT N'Creating [dbo].[Backup.Model.IsSanVolumeExportToProxyLunIdOccupied]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Backup.Model.IsSanVolumeExportToProxyLunIdOccupied]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[Backup.Model.IsSanVolumeExportToProxyLunIdOccupied]
GO

	CREATE PROCEDURE [dbo].[Backup.Model.IsSanVolumeExportToProxyLunIdOccupied]
		@san_initiator_id uniqueidentifier,
		@san_host_id uniqueidentifier,
		@lun_id	int,
		@current_time datetime
	AS
	BEGIN
		SET NOCOUNT ON;	
		
		--Remove expired previous lock for this LUN ID
		DELETE FROM [dbo].[Backup.Model.SanVolumeExportToProxyLunId] 
        WHERE [lun_id] = @lun_id AND [san_host_id] = @san_host_id  AND [san_initiator_id] = @san_initiator_id AND
        DATEDIFF(minute, [init_time], @current_time) > [ttl_min]							
        
		SELECT * FROM [dbo].[Backup.Model.SanVolumeExportToProxyLunId] 
        WHERE [lun_id] = @lun_id AND [san_host_id] = @san_host_id  AND [san_initiator_id] = @san_initiator_id
	END
GO

--------------------------------------------------------------------------------
-- [AddCorruptedGlobalCacheDiskRole]
PRINT N'Creating [dbo].[AddCorruptedGlobalCacheDiskRole]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[AddCorruptedGlobalCacheDiskRole]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[AddCorruptedGlobalCacheDiskRole]
GO

CREATE PROCEDURE [dbo].[AddCorruptedGlobalCacheDiskRole]
		@src_wan_id varchar(255),
		@tgt_wan_id varchar(255),
		@role	varchar(255)
	AS
	BEGIN
		SET NOCOUNT ON;	
		IF NOT EXISTS(SELECT * FROM [dbo].[WanGlobalCacheCorruptedDiskRoles] WHERE src_wan_id = @src_wan_id and tgt_wan_id = @tgt_wan_id and disk_role = @role)
			INSERT INTO [dbo].[WanGlobalCacheCorruptedDiskRoles](src_wan_id,tgt_wan_id,disk_role) VALUES(@src_wan_id,@tgt_wan_id,@role);
	END
GO

--------------------------------------------------------------------------------
-- [RemoveCorruptedGlobalCacheDiskRole]
PRINT N'Creating [dbo].[RemoveCorruptedGlobalCacheDiskRole]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[RemoveCorruptedGlobalCacheDiskRole]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[RemoveCorruptedGlobalCacheDiskRole]
GO

CREATE PROCEDURE [dbo].[RemoveCorruptedGlobalCacheDiskRole]
		@src_wan_id varchar(255),
		@tgt_wan_id varchar(255),
		@role	varchar(255)
	AS
	BEGIN
		SET NOCOUNT ON;	

		DELETE FROM [dbo].[WanGlobalCacheCorruptedDiskRoles] WHERE src_wan_id = @src_wan_id and tgt_wan_id = @tgt_wan_id and disk_role = @role;
	END
GO

--------------------------------------------------------------------------------
-- [RemoveCorruptedGlobalCacheDiskRole]
PRINT N'Creating [dbo].[GetCorruptedGlobalCacheDiskRole]'
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[GetCorruptedGlobalCacheDiskRole]') AND type in (N'P', N'PC'))
	DROP PROCEDURE [dbo].[GetCorruptedGlobalCacheDiskRole]
GO

CREATE PROCEDURE [dbo].[GetCorruptedGlobalCacheDiskRole]
		@src_wan_id varchar(255),
		@tgt_wan_id varchar(255)
	AS
	BEGIN
		SET NOCOUNT ON;	

		SELECT disk_role FROM [dbo].[WanGlobalCacheCorruptedDiskRoles] WHERE src_wan_id = @src_wan_id and tgt_wan_id = @tgt_wan_id
	END

go
exec HrPreCreateProc @proc = N'[dbo].[GetJobs4Schedule]'
go
	create proc [dbo].[GetJobs4Schedule]
	as
	begin
		set nocount on;
		select
		* 
		from 
			[dbo].[BJobs] j
		where 
			j.[type] not in (100, 3, 51) --ConfBackup, DRV, BackupSync  
		order by  
			j.[type], j.name		
	end
go

-- Tape.BackupSetInfoView
print N'Creating [dbo].[Tape.BackupSetInfoView]'
if exists (select * from sys.objects where object_id = OBJECT_ID(N'[dbo].[Tape.BackupSetInfoView]') and type in (N'V'))
	drop view [dbo].[Tape.BackupSetInfoView]
go
	create view [dbo].[Tape.BackupSetInfoView]
	as
	select distinct 
		 bs.id [backupset_id]
		,bs.write_time [backupset_creation_time]
		,bs.name [backupset_name]
		,mf.name [media_set_name]
		,ts.tape_storage_id
		,mf.id [media_set_id]
	from 
		[Tape.storages] ts
	join
		[Tape.backup_sets] bs
	on
		ts.backup_set_id = bs.id and ts.media_family_id = bs.media_family_id 
	join
		[Tape.media_families] mf
	on
		bs.media_family_id = mf.id

go
exec HrPreCreateProc @proc = N'[dbo].[GetUncorruptedTapeOibsForObjectInBackup]'
go
create proc [dbo].[GetUncorruptedTapeOibsForObjectInBackup]
				 @backup_id as uniqueidentifier --= '13AFFA07-6B44-48AB-AD6E-6EE8757378EA'
				,@obj_id as uniqueidentifier --= 'BF091A50-DDDB-4AA0-94DB-F9F8720E9C9C'
	as
	begin
	    set nocount on;
		declare @vcdPlatform int
		declare @vcdVAppObjType int
		select @vcdPlatform = 4, @vcdVAppObjType = 3
		select 
			 o.*
			,t.[backupset_creation_time]
			,t.[media_set_name]
			,t.[backupset_id]
			,t.[backupset_name]
			,t.[media_set_id]
			,t.[library_id]
		from
			[Backup.Model.OIBs] o
		join
			[BObjects] obj
		on
			o.[object_id] = obj.id 
		join
			[Backup.Model.Points] p
		join
			[Backup.Model.Backups] b
		on
			p.backup_id = b.id
		on
			p.id = o.point_id
		join
			[Backup.Model.Storages] s
		on
			o.storage_id = s.id
		join
			(
			select distinct 
				 bs.id [backupset_id]
				,bs.write_time [backupset_creation_time]
				,bs.name [backupset_name]
				,mf.name [media_set_name]
				,ts.tape_storage_id
				,mf.id [media_set_id]
				,p.library_id 
			from 
				[Tape.storages] ts
			join
				[Tape.backup_sets] bs
			on
				ts.backup_set_id = bs.id and ts.media_family_id = bs.media_family_id 
			join
				[Tape.media_families] mf
			on
				bs.media_family_id = mf.id
			join 
				[Tape.media_pools] p
			join
				[Tape.tape_mediums] m
			on
				p.id = m.media_pool_id
			on
				m.media_family_id = mf.id
			) t
		on 
			o.storage_id = t.[tape_storage_id]
		where
			b.job_target_type = 28  and --tapeVm
			b.id = @backup_id and o.[object_id] = @obj_id 
			and 
			o.is_corrupted = 0
			and (b.[platform] != @vcdPlatform or obj.[type] != @vcdVAppObjType or o.[is_consistent] = 1)
		order by t.backupset_creation_time desc, o.creation_time desc	 	   
	end	
go


exec HrPreCreateProc @proc = N'[dbo].[GetTapeJobsByHostName]'
go
create proc [dbo].[GetTapeJobsByHostName]
				 @hostName as nvarchar(max)
	as
begin
	set nocount on;
	declare @id as varchar(100)
	select @id = lower(id) from [Tape.hosts] where name = @hostName;  
	select * from [Tape.jobs] 
	where [options].exist('/TapeJobOptionsBase/Selection/BackupSelectionBase/HostId[. = sql:variable("@id")]') = 1
end
go

--------------------------------------------------------------------------------
-- GetVisibleHostsByType
exec HrPreCreateProc @proc = N'[dbo].[CountVisibleHostsByType]'
go
CREATE PROC [dbo].CountVisibleHostsByType
				 @type int

	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT COUNT(*) res FROM [dbo].[Hosts] WHERE [dbo].[Hosts].[type] = @type AND [dbo].[fn.IsImportedHost]([dbo].[Hosts].[id]) = 'False'
	END

GO


--------------------------------------------------------------------------------
-- [GetSessionLogForSessionDetailsCtrl]
exec HrPreCreateProc @proc = N'[dbo].[GetSessionLogForSessionDetailsCtrl]'
go
	CREATE PROCEDURE [dbo].[GetSessionLogForSessionDetailsCtrl]	
				@row_session_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		select [log_xml] from [dbo].[Backup.Model.JobSessions] where [id] = @row_session_id
	END  

GO

--------------------------------------------------------------------------------
-- [GetTaskSessionLogForSessionDetailsCtrl]
exec HrPreCreateProc @proc = N'[dbo].[GetTaskSessionLogForSessionDetailsCtrl]'
go
	CREATE PROCEDURE [dbo].[GetTaskSessionLogForSessionDetailsCtrl]	
				@row_task_session_id uniqueidentifier
	AS
	BEGIN
		SET NOCOUNT ON;
		select [log_xml] from [dbo].[Backup.Model.BackupTaskSessions] where [id] = @row_task_session_id
	END  

GO

--------------------------------------------------------------------------------
-- GetPhysicalHostsByHostType
EXEC HrPreCreateProc @proc = N'[dbo].[GetPhysicalHostsByHostType]'
GO

	CREATE PROCEDURE [dbo].[GetPhysicalHostsByHostType]
		@host_type int
	AS
	BEGIN
		SET NOCOUNT ON;

		SELECT
			physHosts.*
		FROM
			[dbo].[PhysicalHosts] physHosts join [dbo].[Hosts] hosts on physHosts.[id] = hosts.[physical_host_id]
		WHERE
			hosts.[type] = @host_type
	END
GO

