Как настроить мониторинг SQL Server за 30 минут: базовые метрики, которые должен отслеживать каждый администратор

Привет, друзья! Максим на связи.

Помните ситуацию, когда директор звонит и говорит: "У нас ничего не работает, база данных тормозит"? А вы даже не знаете, с чего начать диагностику? Или, что еще хуже, узнаете о проблеме от пользователей, когда она уже критическая?

За 10+ лет администрирования SQL Server я понял одну важную вещь: хороший мониторинг — это как система раннего предупреждения. Он позволяет увидеть проблемы до того, как они станут катастрофой, и часто даже предсказать их появление.

Сегодня я расскажу, как быстро настроить базовый мониторинг SQL Server, который будет отслеживать самые важные метрики и предупреждать вас о потенциальных проблемах. И всё это можно сделать за 30 минут, даже если у вас нет бюджета на дорогие инструменты мониторинга.

Почему мониторинг SQL Server так важен?

Прежде чем мы начнем, давайте поговорим о том, почему мониторинг SQL Server критически важен:

1. Раннее обнаружение проблем — вы узнаете о проблемах до того, как о них сообщат пользователи
2. Предотвращение простоев — многие проблемы можно предотвратить, если заметить тревожные тенденции заранее
3. Планирование ресурсов — мониторинг помогает понять, когда пора обновлять оборудование
4. Оптимизация производительности — данные мониторинга показывают, где искать узкие места
5. Доказательная база — когда руководство спрашивает "почему нам нужен еще один сервер?", у вас есть графики и цифры

Какие метрики нужно отслеживать в первую очередь?

Существуют сотни метрик, которые можно мониторить в SQL Server. Но если вы только начинаете, вот 10 ключевых метрик, которые дадут вам 80% информации о состоянии вашего сервера:

1. Использование CPU — насколько загружен процессор
2. Использование памяти — сколько памяти потребляет SQL Server
3. Активность дисковой подсистемы — скорость чтения/записи и очереди ввода-вывода
4. Блокировки и взаимоблокировки — кто кого блокирует и как долго
5. Длительные запросы — запросы, выполняющиеся дольше определенного порога
6. Размер и рост баз данных — как быстро растут ваши базы
7. Статус резервного копирования — когда последний раз выполнялся бэкап и был ли он успешным
8. Ошибки в журнале — критические ошибки в журнале SQL Server
9. Состояние индексов — уровень фрагментации индексов
10. Статистика запросов — какие запросы выполняются чаще всего и потребляют больше всего ресурсов

Теперь давайте посмотрим, как настроить мониторинг этих метрик за 30 минут.

Шаг 1: Настройка базовых оповещений SQL Server (5 минут)

SQL Server имеет встроенную систему оповещений, которая может отправлять уведомления при возникновении определенных событий. Настроим самые важные:

1. Откройте SQL Server Management Studio (SSMS)
2. Подключитесь к вашему серверу
3. В Object Explorer перейдите к SQL Server Agent > Alerts
4. Создайте следующие оповещения:

Оповещение о высокой загрузке CPU

-- Создаем оповещение о высокой загрузке CPU
USE [msdb]
GO

EXEC msdb.dbo.sp_add_alert
@name = N'High CPU Usage Alert',
@message_id = 0,
@severity = 0,
@enabled = 1,
@delay_between_responses = 300, -- 5 минут между оповещениями
@include_event_description_in = 1,
@performance_condition = N'SQLServer:Resource Pool Stats|CPU usage %|default|>|90',
@job_id = N'00000000-0000-0000-0000-000000000000'
GO

Оповещение о нехватке памяти

-- Создаем оповещение о низком значении Page Life Expectancy
USE [msdb]
GO

EXEC msdb.dbo.sp_add_alert
@name = N'Low Page Life Expectancy',
@message_id = 0,
@severity = 0,
@enabled = 1,
@delay_between_responses = 300,
@include_event_description_in = 1,
@performance_condition = N'SQLServer:Buffer Manager|Page life expectancy||<|300',
@job_id = N'00000000-0000-0000-0000-000000000000'
GO

Оповещение о критических ошибках

-- Создаем оповещение о критических ошибках (severity 19-25)
USE [msdb]
GO

EXEC msdb.dbo.sp_add_alert
@name = N'Severity 19 Errors',
@message_id = 0,
@severity = 19,
@enabled = 1,
@delay_between_responses = 60,
@include_event_description_in = 1,
@job_id = N'00000000-0000-0000-0000-000000000000'
GO

-- Повторите для severity 20-25

Настройка получателя оповещений

Чтобы получать оповещения по электронной почте, настройте Database Mail и оператора:

-- Настройка оператора для получения оповещений
USE [msdb]
GO

EXEC msdb.dbo.sp_add_operator
@name = N'DBA Team',
@enabled = 1,
@email_address = N'dba@yourcompany.com',
@pager_address = N'',
@weekday_pager_start_time = 080000,
@weekday_pager_end_time = 180000,
@saturday_pager_start_time = 080000,
@saturday_pager_end_time = 180000,
@sunday_pager_start_time = 080000,
@sunday_pager_end_time = 180000,
@pager_days = 0,
@netsend_address = N'',
@category_name = N'[Uncategorized]'
GO

-- Назначаем оператора для всех оповещений
EXEC msdb.dbo.sp_update_alert
@name = N'High CPU Usage Alert',
@notification_message = N'CPU usage has exceeded 90% for more than 5 minutes',
@operator_name = N'DBA Team',
@operator_email = 1
GO

-- Повторите для других оповещений

Шаг 2: Создание скрипта для сбора ключевых метрик (10 минут)

Теперь создадим скрипт, который будет собирать ключевые метрики производительности и сохранять их в базе данных для последующего анализа:

-- Создаем базу данных для хранения метрик мониторинга
IF NOT EXISTS (SELECT name FROM sys.databases WHERE name = 'DBAMonitoring')
BEGIN
CREATE DATABASE DBAMonitoring;
END
GO

USE DBAMonitoring;
GO

-- Создаем таблицу для хранения метрик производительности
IF NOT EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[PerformanceMetrics]') AND type in (N'U'))
BEGIN
CREATE TABLE [dbo].[PerformanceMetrics](
[MetricID] [int] IDENTITY(1,1) PRIMARY KEY,
[CollectionDate] [datetime] NOT NULL,
[CPU_Usage_Pct] [decimal](5, 2) NULL,
[Memory_Usage_GB] [decimal](10, 2) NULL,
[PLE] [int] NULL,
[Disk_Read_Latency_ms] [decimal](10, 2) NULL,
[Disk_Write_Latency_ms] [decimal](10, 2) NULL,
[Batch_Requests_Sec] [int] NULL,
[Active_Connections] [int] NULL,
[Blocked_Processes] [int] NULL,
[Lock_Waits_Sec] [decimal](10, 2) NULL,
[Full_Scans_Sec] [decimal](10, 2) NULL
)

CREATE NONCLUSTERED INDEX [IX_PerformanceMetrics_CollectionDate] ON [dbo].[PerformanceMetrics]
(
[CollectionDate] ASC
)
END
GO

-- Создаем процедуру для сбора метрик
CREATE OR ALTER PROCEDURE [dbo].[CollectPerformanceMetrics]
AS
BEGIN
SET NOCOUNT ON;

-- Получаем загрузку CPU
DECLARE @CPU_Usage_Pct DECIMAL(5,2)
SELECT @CPU_Usage_Pct = ProcessUtilization
FROM (
SELECT
record.value('(./Record/@id)[1]', 'int') AS record_id,
record.value('(./Record/SchedulerMonitorEvent/SystemHealth/ProcessUtilization)[1]', 'int') AS ProcessUtilization
FROM (
SELECT TOP 1 CONVERT(xml, record) AS [record]
FROM sys.dm_os_ring_buffers
WHERE ring_buffer_type = N'RING_BUFFER_SCHEDULER_MONITOR'
AND record LIKE '%<SystemHealth>%'
ORDER BY timestamp DESC
) AS x
) AS y

-- Получаем использование памяти
DECLARE @Memory_Usage_GB DECIMAL(10,2)
SELECT @Memory_Usage_GB = physical_memory_in_use_kb / 1024.0 / 1024.0
FROM sys.dm_os_process_memory

-- Получаем Page Life Expectancy
DECLARE @PLE INT
SELECT @PLE = cntr_value
FROM sys.dm_os_performance_counters
WHERE counter_name = 'Page life expectancy'
AND object_name LIKE '%Buffer Manager%'

-- Получаем задержки дисковой подсистемы
DECLARE @Disk_Read_Latency_ms DECIMAL(10,2), @Disk_Write_Latency_ms DECIMAL(10,2)
SELECT
@Disk_Read_Latency_ms = CASE WHEN num_of_reads = 0 THEN 0 ELSE (io_stall_read_ms / num_of_reads) END,
@Disk_Write_Latency_ms = CASE WHEN num_of_writes = 0 THEN 0 ELSE (io_stall_write_ms / num_of_writes) END
FROM (
SELECT
SUM(num_of_reads) AS num_of_reads,
SUM(io_stall_read_ms) AS io_stall_read_ms,
SUM(num_of_writes) AS num_of_writes,
SUM(io_stall_write_ms) AS io_stall_write_ms
FROM sys.dm_io_virtual_file_stats(NULL, NULL)
) AS IOStats

-- Получаем количество запросов в секунду
DECLARE @Batch_Requests_Sec INT
SELECT @Batch_Requests_Sec = cntr_value
FROM sys.dm_os_performance_counters
WHERE counter_name = 'Batch Requests/sec'
AND object_name LIKE '%SQL Statistics%'

-- Получаем количество активных соединений
DECLARE @Active_Connections INT
SELECT @Active_Connections = COUNT(*)
FROM sys.dm_exec_connections

-- Получаем количество заблокированных процессов
DECLARE @Blocked_Processes INT
SELECT @Blocked_Processes = COUNT(*)
FROM sys.dm_exec_requests
WHERE blocking_session_id <> 0

-- Получаем время ожидания блокировок
DECLARE @Lock_Waits_Sec DECIMAL(10,2)
SELECT @Lock_Waits_Sec = SUM(wait_time_ms) / 1000.0
FROM sys.dm_os_wait_stats
WHERE wait_type LIKE 'LCK%'

-- Получаем количество полных сканирований в секунду
DECLARE @Full_Scans_Sec DECIMAL(10,2)
SELECT @Full_Scans_Sec = cntr_value
FROM sys.dm_os_performance_counters
WHERE counter_name = 'Full Scans/sec'
AND object_name LIKE '%Access Methods%'

-- Сохраняем метрики в таблицу
INSERT INTO [dbo].[PerformanceMetrics]
(
[CollectionDate],
[CPU_Usage_Pct],
[Memory_Usage_GB],
[PLE],
[Disk_Read_Latency_ms],
[Disk_Write_Latency_ms],
[Batch_Requests_Sec],
[Active_Connections],
[Blocked_Processes],
[Lock_Waits_Sec],
[Full_Scans_Sec]
)
VALUES
(
GETDATE(),
@CPU_Usage_Pct,
@Memory_Usage_GB,
@PLE,
@Disk_Read_Latency_ms,
@Disk_Write_Latency_ms,
@Batch_Requests_Sec,
@Active_Connections,
@Blocked_Processes,
@Lock_Waits_Sec,
@Full_Scans_Sec
)
END
GO

Шаг 3: Создание задания для регулярного сбора метрик (5 минут)

Теперь создадим задание SQL Server Agent, которое будет регулярно вызывать нашу процедуру сбора метрик:

-- Создаем задание для сбора метрик каждые 5 минут
USE [msdb]
GO

BEGIN TRANSACTION
DECLARE @ReturnCode INT
SELECT @ReturnCode = 0

-- Создаем категорию заданий, если она не существует
IF NOT EXISTS (SELECT name FROM msdb.dbo.syscategories WHERE name=N'Monitoring' AND category_class=1)
BEGIN
EXEC @ReturnCode = msdb.dbo.sp_add_category @class=N'JOB', @type=N'LOCAL', @name=N'Monitoring'
IF (@@ERROR <> 0 OR @ReturnCode <> 0) GOTO QuitWithRollback
END

-- Создаем задание
DECLARE @jobId BINARY(16)
EXEC @ReturnCode = msdb.dbo.sp_add_job @job_name=N'Collect Performance Metrics',
@enabled=1,
@notify_level_eventlog=0,
@notify_level_email=2,
@notify_level_netsend=0,
@notify_level_page=0,
@delete_level=0,
@description=N'Collects SQL Server performance metrics every 5 minutes',
@category_name=N'Monitoring',
@owner_login_name=N'sa',
@notify_email_operator_name=N'DBA Team',
@job_id = @jobId OUTPUT
IF (@@ERROR <> 0 OR @ReturnCode <> 0) GOTO QuitWithRollback

-- Создаем шаг задания
EXEC @ReturnCode = msdb.dbo.sp_add_jobstep @job_id=@jobId, @step_name=N'Run Collection Procedure',
@step_id=1,
@cmdexec_success_code=0,
@on_success_action=1,
@on_success_step_id=0,
@on_fail_action=2,
@on_fail_step_id=0,
@retry_attempts=0,
@retry_interval=0,
@os_run_priority=0, @subsystem=N'TSQL',
@command=N'EXEC DBAMonitoring.dbo.CollectPerformanceMetrics',
@database_name=N'master',
@flags=0
IF (@@ERROR <> 0 OR @ReturnCode <> 0) GOTO QuitWithRollback

-- Создаем расписание задания (каждые 5 минут)
EXEC @ReturnCode = msdb.dbo.sp_add_jobschedule @job_id=@jobId, @name=N'Every 5 Minutes',
@enabled=1,
@freq_type=4,
@freq_interval=1,
@freq_subday_type=4,
@freq_subday_interval=5,
@freq_relative_interval=0,
@freq_recurrence_factor=0,
@active_start_date=20230101,
@active_end_date=99991231,
@active_start_time=0,
@active_end_time=235959
IF (@@ERROR <> 0 OR @ReturnCode <> 0) GOTO QuitWithRollback

-- Назначаем задание серверу
EXEC @ReturnCode = msdb.dbo.sp_add_jobserver @job_id = @jobId, @server_name = N'(local)'
IF (@@ERROR <> 0 OR @ReturnCode <> 0) GOTO QuitWithRollback

COMMIT TRANSACTION
GOTO EndSave

QuitWithRollback:
IF (@@TRANCOUNT > 0) ROLLBACK TRANSACTION

EndSave:
GO

Шаг 4: Мониторинг длительных запросов (5 минут)

Одна из самых частых причин проблем с производительностью — длительные запросы. Настроим их отслеживание:

USE DBAMonitoring;
GO

-- Создаем таблицу для хранения информации о длительных запросах
IF NOT EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[LongRunningQueries]') AND type in (N'U'))
BEGIN
CREATE TABLE [dbo].[LongRunningQueries](
[QueryID] [int] IDENTITY(1,1) PRIMARY KEY,
[CaptureTime] [datetime] NOT NULL,
[SessionID] [int] NOT NULL,
[RequestID] [int] NULL,
[DatabaseName] [nvarchar](128) NULL,
[CPUTime_ms] [bigint] NULL,
[TotalElapsedTime_ms] [bigint] NULL,
[Reads] [bigint] NULL,
[Writes] [bigint] NULL,
[LogicalReads] [bigint] NULL,
[Status] [nvarchar](30) NULL,
[WaitType] [nvarchar](60) NULL,
[WaitTime_ms] [bigint] NULL,
[WaitResource] [nvarchar](256) NULL,
[BlockingSessionID] [int] NULL,
[QueryText] [nvarchar](max) NULL,
[QueryPlan] [xml] NULL
)

CREATE NONCLUSTERED INDEX [IX_LongRunningQueries_CaptureTime] ON [dbo].[LongRunningQueries]
(
[CaptureTime] ASC
)
END
GO

-- Создаем процедуру для сбора информации о длительных запросах
CREATE OR ALTER PROCEDURE [dbo].[CollectLongRunningQueries]
@DurationThreshold_Seconds INT = 30 -- Порог длительности запроса в секундах
AS
BEGIN
SET NOCOUNT ON;

INSERT INTO [dbo].[LongRunningQueries]
(
[CaptureTime],
[SessionID],
[RequestID],
[DatabaseName],
[CPUTime_ms],
[TotalElapsedTime_ms],
[Reads],
[Writes],
[LogicalReads],
[Status],
[WaitType],
[WaitTime_ms],
[WaitResource],
[BlockingSessionID],
[QueryText],
[QueryPlan]
)
SELECT
GETDATE() AS CaptureTime,
r.session_id AS SessionID,
r.request_id AS RequestID,
DB_NAME(r.database_id) AS DatabaseName,
r.cpu_time AS CPUTime_ms,
r.total_elapsed_time AS TotalElapsedTime_ms,
r.reads AS Reads,
r.writes AS Writes,
r.logical_reads AS LogicalReads,
r.status AS Status,
r.wait_type AS WaitType,
r.wait_time AS WaitTime_ms,
r.wait_resource AS WaitResource,
r.blocking_session_id AS BlockingSessionID,
SUBSTRING(
st.text,
(r.statement_start_offset/2) + 1,
((CASE r.statement_end_offset WHEN -1 THEN DATALENGTH(st.text) ELSE r.statement_end_offset END - r.statement_start_offset)/2) + 1
) AS QueryText,
qp.query_plan AS QueryPlan
FROM
sys.dm_exec_requests r
CROSS APPLY
sys.dm_exec_sql_text(r.sql_handle) st
OUTER APPLY
sys.dm_exec_query_plan(r.plan_handle) qp
WHERE
r.session_id <> @@SPID -- Исключаем текущую сессию
AND r.total_elapsed_time > @DurationThreshold_Seconds * 1000 -- Конвертируем секунды в миллисекунды
AND r.session_id > 50 -- Исключаем системные сессии
END
GO

-- Создаем задание для сбора информации о длительных запросах
USE [msdb]
GO

BEGIN TRANSACTION
DECLARE @ReturnCode INT
SELECT @ReturnCode = 0

DECLARE @jobId BINARY(16)
EXEC @ReturnCode = msdb.dbo.sp_add_job @job_name=N'Collect Long Running Queries',
@enabled=1,
@notify_level_eventlog=0,
@notify_level_email=2,
@notify_level_netsend=0,
@notify_level_page=0,
@delete_level=0,
@description=N'Collects information about queries running longer than 30 seconds',
@category_name=N'Monitoring',
@owner_login_name=N'sa',
@notify_email_operator_name=N'DBA Team',
@job_id = @jobId OUTPUT
IF (@@ERROR <> 0 OR @ReturnCode <> 0) GOTO QuitWithRollback

EXEC @ReturnCode = msdb.dbo.sp_add_jobstep @job_id=@jobId, @step_name=N'Run Collection Procedure',
@step_id=1,
@cmdexec_success_code=0,
@on_success_action=1,
@on_success_step_id=0,
@on_fail_action=2,
@on_fail_step_id=0,
@retry_attempts=0,
@retry_interval=0,
@os_run_priority=0, @subsystem=N'TSQL',
@command=N'EXEC DBAMonitoring.dbo.CollectLongRunningQueries @DurationThreshold_Seconds = 30',
@database_name=N'master',
@flags=0
IF (@@ERROR <> 0 OR @ReturnCode <> 0) GOTO QuitWithRollback

EXEC @ReturnCode = msdb.dbo.sp_add_jobschedule @job_id=@jobId, @name=N'Every Minute',
@enabled=1,
@freq_type=4,
@freq_interval=1,
@freq_subday_type=4,
@freq_subday_interval=1,
@freq_relative_interval=0,
@freq_recurrence_factor=0,
@active_start_date=20230101,
@active_end_date=99991231,
@active_start_time=0,
@active_end_time=235959
IF (@@ERROR <> 0 OR @ReturnCode <> 0) GOTO QuitWithRollback

EXEC @ReturnCode = msdb.dbo.sp_add_jobserver @job_id = @jobId, @server_name = N'(local)'
IF (@@ERROR <> 0 OR @ReturnCode <> 0) GOTO QuitWithRollback

COMMIT TRANSACTION
GOTO EndSave

QuitWithRollback:
IF (@@TRANCOUNT > 0) ROLLBACK TRANSACTION

EndSave:
GO

Шаг 5: Мониторинг роста баз данных и состояния резервных копий (5 минут)

Отслеживание роста баз данных и состояния резервных копий поможет избежать проблем с нехваткой места и потерей данных:

USE DBAMonitoring;
GO

-- Создаем таблицу для хранения информации о размере баз данных
IF NOT EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[DatabaseSizes]') AND type in (N'U'))
BEGIN
CREATE TABLE [dbo].[DatabaseSizes](
[SizeID] [int] IDENTITY(1,1) PRIMARY KEY,
[CaptureDate] [datetime] NOT NULL,
[DatabaseName] [nvarchar](128) NOT NULL,
[SizeMB] [decimal](10, 2) NOT NULL,
[SpaceUsedMB] [decimal](10, 2) NOT NULL,
[SpaceFreeMB] [decimal](10, 2) NOT NULL,
[GrowthRate] [decimal](10, 2) NULL -- Скорость роста в МБ/день
)

CREATE NONCLUSTERED INDEX [IX_DatabaseSizes_CaptureDate] ON [dbo].[DatabaseSizes]
(
[CaptureDate] ASC
)

CREATE NONCLUSTERED INDEX [IX_DatabaseSizes_DatabaseName] ON [dbo].[DatabaseSizes]
(
[DatabaseName] ASC
)
END
GO

-- Создаем таблицу для хранения информации о резервных копиях
IF NOT EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[BackupHistory]') AND type in (N'U'))
BEGIN
CREATE TABLE [dbo].[BackupHistory](
[BackupID] [int] IDENTITY(1,1) PRIMARY KEY,
[CaptureDate] [datetime] NOT NULL,
[DatabaseName] [nvarchar](128) NOT NULL,
[LastFullBackupDate] [datetime] NULL,
[LastDiffBackupDate] [datetime] NULL,
[LastLogBackupDate] [datetime] NULL,
[DaysSinceLastFullBackup] [int] NULL,
[HoursSinceLastLogBackup] [int] NULL
)

CREATE NONCLUSTERED INDEX [IX_BackupHistory_CaptureDate] ON [dbo].[BackupHistory]
(
[CaptureDate] ASC
)

CREATE NONCLUSTERED INDEX [IX_BackupHistory_DatabaseName] ON [dbo].[BackupHistory]
(
[DatabaseName] ASC
)
END
GO

-- Создаем процедуру для сбора информации о размере баз данных
CREATE OR ALTER PROCEDURE [dbo].[CollectDatabaseSizes]
AS
BEGIN
SET NOCOUNT ON;

-- Временная таблица для хранения текущих размеров
CREATE TABLE #CurrentSizes (
DatabaseName NVARCHAR(128),
SizeMB DECIMAL(10,2),
SpaceUsedMB DECIMAL(10,2),
SpaceFreeMB DECIMAL(10,2)
)

-- Получаем текущие размеры баз данных

INSERT INTO #CurrentSizes
EXEC sp_MSforeachdb '
USE [?];
SELECT
DB_NAME() AS DatabaseName,
CAST(SUM(size) * 8 / 1024.0 AS DECIMAL(10,2)) AS SizeMB,
CAST(SUM(FILEPROPERTY(name, ''SpaceUsed'')) * 8 / 1024.0 AS DECIMAL(10,2)) AS SpaceUsedMB,
CAST((SUM(size) - SUM(FILEPROPERTY(name, ''SpaceUsed''))) * 8 / 1024.0 AS DECIMAL(10,2)) AS SpaceFreeMB
FROM sys.database_files
WHERE type_desc = ''ROWS'''

-- Вычисляем скорость роста
INSERT INTO [dbo].[DatabaseSizes]
(
[CaptureDate],
[DatabaseName],
[SizeMB],
[SpaceUsedMB],
[SpaceFreeMB],
[GrowthRate]
)
SELECT
GETDATE() AS CaptureDate,
cs.DatabaseName,
cs.SizeMB,
cs.SpaceUsedMB,
cs.SpaceFreeMB,
CASE
WHEN prev.SizeMB IS NULL THEN NULL
WHEN DATEDIFF(DAY, prev.CaptureDate, GETDATE()) = 0 THEN 0
ELSE (cs.SizeMB - prev.SizeMB) / DATEDIFF(DAY, prev.CaptureDate, GETDATE())
END AS GrowthRate
FROM
#CurrentSizes cs
LEFT JOIN
(
-- Получаем предыдущие размеры
SELECT
DatabaseName,
SizeMB,
CaptureDate
FROM
[dbo].[DatabaseSizes] ds1
WHERE
CaptureDate = (
SELECT MAX(CaptureDate)
FROM [dbo].[DatabaseSizes] ds2
WHERE ds2.DatabaseName = ds1.DatabaseName
)
) prev ON cs.DatabaseName = prev.DatabaseName

DROP TABLE #CurrentSizes
END
GO

-- Создаем процедуру для сбора информации о резервных копиях
CREATE OR ALTER PROCEDURE [dbo].[CollectBackupHistory]
AS
BEGIN
SET NOCOUNT ON;

INSERT INTO [dbo].[BackupHistory]
(
[CaptureDate],
[DatabaseName],
[LastFullBackupDate],
[LastDiffBackupDate],
[LastLogBackupDate],
[DaysSinceLastFullBackup],
[HoursSinceLastLogBackup]
)
SELECT
GETDATE() AS CaptureDate,
d.name AS DatabaseName,
MAX(CASE WHEN b.type = 'D' THEN b.backup_finish_date END) AS LastFullBackupDate,
MAX(CASE WHEN b.type = 'I' THEN b.backup_finish_date END) AS LastDiffBackupDate,
MAX(CASE WHEN b.type = 'L' THEN b.backup_finish_date END) AS LastLogBackupDate,
DATEDIFF(DAY, MAX(CASE WHEN b.type = 'D' THEN b.backup_finish_date END), GETDATE()) AS DaysSinceLastFullBackup,
DATEDIFF(HOUR, MAX(CASE WHEN b.type = 'L' THEN b.backup_finish_date END), GETDATE()) AS HoursSinceLastLogBackup
FROM
sys.databases d
LEFT JOIN
msdb.dbo.backupset b ON d.name = b.database_name
WHERE
d.database_id > 4 -- Исключаем системные базы данных
GROUP BY
d.name
END
GO

-- Создаем задание для сбора информации о размере баз данных и резервных копиях
USE [msdb]
GO

BEGIN TRANSACTION
DECLARE @ReturnCode INT
SELECT @ReturnCode = 0

DECLARE @jobId BINARY(16)
EXEC @ReturnCode = msdb.dbo.sp_add_job @job_name=N'Collect Database Sizes and Backup History',
@enabled=1,
@notify_level_eventlog=0,
@notify_level_email=2,
@notify_level_netsend=0,
@notify_level_page=0,
@delete_level=0,
@description=N'Collects information about database sizes and backup history',
@category_name=N'Monitoring',
@owner_login_name=N'sa',
@notify_email_operator_name=N'DBA Team',
@job_id = @jobId OUTPUT
IF (@@ERROR <> 0 OR @ReturnCode <> 0) GOTO QuitWithRollback

-- Шаг для сбора размеров баз данных
EXEC @ReturnCode = msdb.dbo.sp_add_jobstep @job_id=@jobId, @step_name=N'Collect Database Sizes',
@step_id=1,
@cmdexec_success_code=0,
@on_success_action=3,
@on_success_step_id=0,
@on_fail_action=2,
@on_fail_step_id=0,
@retry_attempts=0,
@retry_interval=0,
@os_run_priority=0, @subsystem=N'TSQL',
@command=N'EXEC DBAMonitoring.dbo.CollectDatabaseSizes',
@database_name=N'master',
@flags=0
IF (@@ERROR <> 0 OR @ReturnCode <> 0) GOTO QuitWithRollback

-- Шаг для сбора истории резервных копий
EXEC @ReturnCode = msdb.dbo.sp_add_jobstep @job_id=@jobId, @step_name=N'Collect Backup History',
@step_id=2,
@cmdexec_success_code=0,
@on_success_action=1,
@on_success_step_id=0,
@on_fail_action=2,
@on_fail_step_id=0,
@retry_attempts=0,
@retry_interval=0,
@os_run_priority=0, @subsystem=N'TSQL',
@command=N'EXEC DBAMonitoring.dbo.CollectBackupHistory',
@database_name=N'master',
@flags=0
IF (@@ERROR <> 0 OR @ReturnCode <> 0) GOTO QuitWithRollback

-- Создаем расписание (раз в день)
EXEC @ReturnCode = msdb.dbo.sp_add_jobschedule @job_id=@jobId, @name=N'Daily at Midnight',
@enabled=1,
@freq_type=4,
@freq_interval=1,
@freq_subday_type=1,
@freq_subday_interval=0,
@freq_relative_interval=0,
@freq_recurrence_factor=0,
@active_start_date=20230101,
@active_end_date=99991231,
@active_start_time=0,
@active_end_time=235959
IF (@@ERROR <> 0 OR @ReturnCode <> 0) GOTO QuitWithRollback

EXEC @ReturnCode = msdb.dbo.sp_add_jobserver @job_id = @jobId, @server_name = N'(local)'
IF (@@ERROR <> 0 OR @ReturnCode <> 0) GOTO QuitWithRollback

COMMIT TRANSACTION
GOTO EndSave

QuitWithRollback:
IF (@@TRANCOUNT > 0) ROLLBACK TRANSACTION

EndSave:
GO

Шаг 6: Создание простой панели мониторинга (5 минут)

Теперь, когда у нас есть все необходимые данные, создадим простую панель мониторинга для их просмотра:

USE DBAMonitoring;
GO

-- Создаем представление для панели мониторинга
CREATE OR ALTER VIEW [dbo].[DashboardCurrentStatus]
AS
SELECT
-- Текущие метрики производительности
(SELECT TOP 1 CPU_Usage_Pct FROM [PerformanceMetrics] ORDER BY CollectionDate DESC) AS CurrentCPU_Pct,
(SELECT TOP 1 Memory_Usage_GB FROM [PerformanceMetrics] ORDER BY CollectionDate DESC) AS CurrentMemory_GB,
(SELECT TOP 1 PLE FROM [PerformanceMetrics] ORDER BY CollectionDate DESC) AS CurrentPLE,
(SELECT TOP 1 Disk_Read_Latency_ms FROM [PerformanceMetrics] ORDER BY CollectionDate DESC) AS CurrentDiskReadLatency_ms,
(SELECT TOP 1 Disk_Write_Latency_ms FROM [PerformanceMetrics] ORDER BY CollectionDate DESC) AS CurrentDiskWriteLatency_ms,
(SELECT TOP 1 Active_Connections FROM [PerformanceMetrics] ORDER BY CollectionDate DESC) AS CurrentConnections,
(SELECT TOP 1 Blocked_Processes FROM [PerformanceMetrics] ORDER BY CollectionDate DESC) AS CurrentBlockedProcesses,

-- Статистика длительных запросов
(SELECT COUNT(*) FROM [LongRunningQueries] WHERE CaptureTime > DATEADD(HOUR, -1, GETDATE())) AS LongQueriesLastHour,

-- Базы данных с наибольшей скоростью роста
(SELECT TOP 1 DatabaseName FROM [DatabaseSizes] WHERE CaptureDate > DATEADD(DAY, -7, GETDATE()) ORDER BY GrowthRate DESC) AS FastestGrowingDB,
(SELECT TOP 1 GrowthRate FROM [DatabaseSizes] WHERE CaptureDate > DATEADD(DAY, -7, GETDATE()) ORDER BY GrowthRate DESC) AS FastestGrowthRate_MBperDay,

-- Базы данных без резервных копий
(SELECT COUNT(*) FROM [BackupHistory] WHERE CaptureDate = (SELECT MAX(CaptureDate) FROM [BackupHistory]) AND (LastFullBackupDate IS NULL OR DaysSinceLastFullBackup > 7)) AS DBsWithoutRecentBackup
GO

-- Создаем процедуру для получения сводки о состоянии сервера
CREATE OR ALTER PROCEDURE [dbo].[GetServerHealthSummary]
AS
BEGIN
SET NOCOUNT ON;

-- Получаем текущее состояние
SELECT * FROM [dbo].[DashboardCurrentStatus];

-- Получаем топ-5 длительных запросов за последний час
SELECT TOP 5
SessionID,
DatabaseName,
TotalElapsedTime_ms / 1000.0 AS DurationSeconds,
CPUTime_ms / 1000.0 AS CPUSeconds,
Reads,
Writes,
LogicalReads,
Status,
WaitType,
BlockingSessionID,
LEFT(QueryText, 200) AS QueryTextSample
FROM
[dbo].[LongRunningQueries]
WHERE
CaptureTime > DATEADD(HOUR, -1, GETDATE())
ORDER BY
TotalElapsedTime_ms DESC;

-- Получаем топ-5 баз данных по размеру
SELECT TOP 5
DatabaseName,
SizeMB,
SpaceUsedMB,
SpaceFreeMB,
GrowthRate AS GrowthRate_MBperDay
FROM
[dbo].[DatabaseSizes]
WHERE
CaptureDate = (SELECT MAX(CaptureDate) FROM [dbo].[DatabaseSizes])
ORDER BY
SizeMB DESC;

-- Получаем базы данных без свежих резервных копий
SELECT
DatabaseName,
LastFullBackupDate,
DaysSinceLastFullBackup,
LastLogBackupDate,
HoursSinceLastLogBackup
FROM
[dbo].[BackupHistory]
WHERE
CaptureDate = (SELECT MAX(CaptureDate) FROM [dbo].[BackupHistory])
AND (LastFullBackupDate IS NULL OR DaysSinceLastFullBackup > 7)
ORDER BY
DaysSinceLastFullBackup DESC;
END
GO

Как использовать созданный мониторинг

Теперь, когда мы настроили базовый мониторинг SQL Server, давайте посмотрим, как его использовать:

1. Ежедневная проверка состояния сервера:

EXEC DBAMonitoring.dbo.GetServerHealthSummary;

Этот запрос покажет текущее состояние сервера, топ-5 длительных запросов, топ-5 баз данных по размеру и базы данных без свежих резервных копий.

2. Анализ тенденций производительности:

-- Средняя загрузка CPU по часам за последнюю неделю
SELECT
CONVERT(DATE, CollectionDate) AS [Date],
DATEPART(HOUR, CollectionDate) AS [Hour],
AVG(CPU_Usage_Pct) AS AvgCPU_Pct
FROM
DBAMonitoring.dbo.PerformanceMetrics
WHERE
CollectionDate > DATEADD(DAY, -7, GETDATE())
GROUP BY
CONVERT(DATE, CollectionDate),
DATEPART(HOUR, CollectionDate)
ORDER BY
[Date], [Hour];

3. Поиск проблемных запросов:

-- Топ-10 запросов по общему времени выполнения
SELECT TOP 10
QueryText,
COUNT(*) AS ExecutionCount,
AVG(TotalElapsedTime_ms) / 1000.0 AS AvgDurationSeconds,
MAX(TotalElapsedTime_ms) / 1000.0 AS MaxDurationSeconds,
SUM(TotalElapsedTime_ms) / 1000.0 AS TotalDurationSeconds,
AVG(LogicalReads) AS AvgLogicalReads
FROM
DBAMonitoring.dbo.LongRunningQueries
WHERE
CaptureTime > DATEADD(DAY, -7, GETDATE())
GROUP BY
QueryText
ORDER BY
TotalDurationSeconds DESC;

4. Прогнозирование роста баз данных:

-- Прогнозирование роста баз данных на следующие 3 месяца
SELECT
DatabaseName,
SizeMB AS CurrentSizeMB,
GrowthRate AS GrowthRateMBperDay,
SizeMB + (GrowthRate * 30) AS EstimatedSizeIn30Days,
SizeMB + (GrowthRate * 60) AS EstimatedSizeIn60Days,
SizeMB + (GrowthRate * 90) AS EstimatedSizeIn90Days
FROM
DBAMonitoring.dbo.DatabaseSizes
WHERE
CaptureDate = (SELECT MAX(CaptureDate) FROM DBAMonitoring.dbo.DatabaseSizes)
AND GrowthRate > 0
ORDER BY
GrowthRate DESC;

Расширение базового мониторинга

Наш базовый мониторинг охватывает самые важные аспекты работы SQL Server, но его можно легко расширить. Вот несколько идей:

1. Мониторинг фрагментации индексов

USE DBAMonitoring;
GO

-- Создаем таблицу для хранения информации о фрагментации индексов
IF NOT EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[IndexFragmentation]') AND type in (N'U'))
BEGIN
CREATE TABLE [dbo].[IndexFragmentation](
[FragmentationID] [int] IDENTITY(1,1) PRIMARY KEY,
[CaptureDate] [datetime] NOT NULL,
[DatabaseName] [nvarchar](128) NOT NULL,
[SchemaName] [nvarchar](128) NOT NULL,
[TableName] [nvarchar](128) NOT NULL,
[IndexName] [nvarchar](128) NOT NULL,
[AvgFragmentationPct] [decimal](5, 2) NOT NULL,
[PageCount] [bigint] NOT NULL,
[IndexSizeMB] [decimal](10, 2) NOT NULL
)

CREATE NONCLUSTERED INDEX [IX_IndexFragmentation_CaptureDate] ON [dbo].[IndexFragmentation]
(
[CaptureDate] ASC
)
END
GO

-- Создаем процедуру для сбора информации о фрагментации индексов
CREATE OR ALTER PROCEDURE [dbo].[CollectIndexFragmentation]
AS
BEGIN
SET NOCOUNT ON;

-- Создаем временную таблицу для хранения списка баз данных
CREATE TABLE #Databases (
DatabaseName NVARCHAR(128)
)

-- Получаем список пользовательских баз данных
INSERT INTO #Databases
SELECT name
FROM sys.databases
WHERE database_id > 4 -- Исключаем системные базы данных
AND state_desc = 'ONLINE'

-- Создаем временную таблицу для хранения информации о фрагментации
CREATE TABLE #FragmentationInfo (
DatabaseName NVARCHAR(128),
SchemaName NVARCHAR(128),
TableName NVARCHAR(128),
IndexName NVARCHAR(128),
AvgFragmentationPct DECIMAL(5,2),
PageCount BIGINT,
IndexSizeMB DECIMAL(10,2)
)

-- Для каждой базы данных собираем информацию о фрагментации индексов
DECLARE @DatabaseName NVARCHAR(128)
DECLARE @SQL NVARCHAR(MAX)

DECLARE db_cursor CURSOR FOR
SELECT DatabaseName FROM #Databases

OPEN db_cursor
FETCH NEXT FROM db_cursor INTO @DatabaseName

WHILE @@FETCH_STATUS = 0
BEGIN
SET @SQL = N'
USE [' + @DatabaseName + N'];

INSERT INTO #FragmentationInfo
SELECT
DB_NAME() AS DatabaseName,
s.name AS SchemaName,
t.name AS TableName,
i.name AS IndexName,
ips.avg_fragmentation_in_percent AS AvgFragmentationPct,
ips.page_count AS PageCount,
(ips.page_count * 8) / 1024.0 AS IndexSizeMB
FROM
sys.dm_db_index_physical_stats(DB_ID(), NULL, NULL, NULL, ''LIMITED'') ips
JOIN
sys.tables t ON ips.object_id = t.object_id
JOIN
sys.schemas s ON t.schema_id = s.schema_id
JOIN
sys.indexes i ON ips.object_id = i.object_id AND ips.index_id = i.index_id
WHERE
ips.index_id > 0 -- Исключаем кучи
AND ips.page_count > 1000 -- Только индексы размером более 8 МБ
AND i.name IS NOT NULL'

EXEC sp_executesql @SQL

FETCH NEXT FROM db_cursor INTO @DatabaseName
END

CLOSE db_cursor
DEALLOCATE db_cursor

-- Сохраняем собранную информацию в таблицу
INSERT INTO [dbo].[IndexFragmentation]
(
[CaptureDate],
[DatabaseName],
[SchemaName],
[TableName],
[IndexName],
[AvgFragmentationPct],
[PageCount],
[IndexSizeMB]
)
SELECT
GETDATE() AS CaptureDate,
DatabaseName,
SchemaName,
TableName,
IndexName,
AvgFragmentationPct,
PageCount,
IndexSizeMB
FROM
#FragmentationInfo

-- Удаляем временные таблицы
DROP TABLE #Databases
DROP TABLE #FragmentationInfo
END
GO

2. Мониторинг ожиданий SQL Server

USE DBAMonitoring;
GO

-- Создаем таблицу для хранения информации о ожиданиях
IF NOT EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[WaitStats]') AND type in (N'U'))
BEGIN
CREATE TABLE [dbo].[WaitStats](
[WaitStatID] [int] IDENTITY(1,1) PRIMARY KEY,
[CaptureDate] [datetime] NOT NULL,
[WaitType] [nvarchar](60) NOT NULL,
[WaitingTasksCount] [bigint] NOT NULL,
[WaitTimeMs] [bigint] NOT NULL,
[MaxWaitTimeMs] [bigint] NOT NULL,
[SignalWaitTimeMs] [bigint] NOT NULL
)

CREATE NONCLUSTERED INDEX [IX_WaitStats_CaptureDate] ON [dbo].[WaitStats]
(
[CaptureDate] ASC
)

CREATE NONCLUSTERED INDEX [IX_WaitStats_WaitType] ON [dbo].[WaitStats]
(
[WaitType] ASC
)
END
GO

-- Создаем процедуру для сбора информации о ожиданиях
CREATE OR ALTER PROCEDURE [dbo].[CollectWaitStats]
AS
BEGIN
SET NOCOUNT ON;

-- Очищаем статистику ожиданий перед сбором (опционально)
-- DBCC SQLPERF('sys.dm_os_wait_stats', CLEAR);

-- Собираем текущую статистику ожиданий
INSERT INTO [dbo].[WaitStats]
(
[CaptureDate],
[WaitType],
[WaitingTasksCount],
[WaitTimeMs],
[MaxWaitTimeMs],
[SignalWaitTimeMs]
)
SELECT
GETDATE() AS CaptureDate,
wait_type AS WaitType,
waiting_tasks_count AS WaitingTasksCount,
wait_time_ms AS WaitTimeMs,
max_wait_time_ms AS MaxWaitTimeMs,
signal_wait_time_ms AS SignalWaitTimeMs
FROM
sys.dm_os_wait_stats
WHERE
wait_type NOT LIKE '%SLEEP%'
AND wait_type NOT LIKE 'LAZYWRITER%'
AND wait_type NOT LIKE 'SQLTRACE%'
AND wait_type NOT LIKE 'XE%'
AND wait_type NOT IN (
'BROKER_TASK_STOP',
'BROKER_TO_FLUSH',
'CHECKPOINT_QUEUE',
'CLR_AUTO_EVENT',
'CLR_MANUAL_EVENT',
'DBMIRROR_DBM_EVENT',
'DBMIRROR_DBM_MUTEX',
'DBMIRROR_EVENTS_QUEUE',
'DBMIRROR_WORKER_QUEUE',
'DBMIRRORING_CMD',
'DIRTY_PAGE_POLL',
'DISPATCHER_QUEUE_SEMAPHORE',
'FT_IFTS_SCHEDULER_IDLE_WAIT',
'FT_IFTSHC_MUTEX',
'HADR_FILESTREAM_IOMGR_IOCOMPLETION',
'HADR_LOGCAPTURE_WAIT',
'HADR_TIMER_TASK',
'HADR_WORK_QUEUE',
'KSOURCE_WAKEUP',
'LOGMGR_QUEUE',
'ONDEMAND_TASK_QUEUE',
'REQUEST_FOR_DEADLOCK_SEARCH',
'RESOURCE_QUEUE',
'SNI_HTTP_ACCEPT',
'SOS_SCHEDULER_YIELD',
'THREADPOOL'
)
END
GO

Автоматизация реагирования на проблемы

Мониторинг — это хорошо, но еще лучше, когда система может автоматически реагировать на некоторые проблемы. Вот пример автоматического реагирования на блокировки:

USE DBAMonitoring;
GO

-- Создаем процедуру для автоматического разрешения длительных блокировок
CREATE OR ALTER PROCEDURE [dbo].[ResolveDeadlocks]
@BlockingThresholdMinutes INT = 10, -- Порог длительности блокировки в минутах
@KillBlockers BIT = 0 -- Флаг, указывающий, нужно ли убивать блокирующие сессии
AS
BEGIN
SET NOCOUNT ON;

-- Создаем временную таблицу для хранения информации о блокировках
CREATE TABLE #BlockingInfo (
BlockingSessionID INT,
BlockedSessionCount INT,
LongestBlockDurationMinutes INT,
BlockingStatement NVARCHAR(MAX),
BlockingLoginName NVARCHAR(128),
BlockingHostName NVARCHAR(128),
BlockingProgramName NVARCHAR(128)
)

-- Собираем информацию о блокировках
INSERT INTO #BlockingInfo
SELECT
r.blocking_session_id AS BlockingSessionID,
COUNT(*) AS BlockedSessionCount,
MAX(DATEDIFF(MINUTE, r.start_time, GETDATE())) AS LongestBlockDurationMinutes,
(SELECT text FROM sys.dm_exec_sql_text(s.sql_handle)) AS BlockingStatement,
s.login_name AS BlockingLoginName,
s.host_name AS BlockingHostName,
s.program_name AS BlockingProgramName
FROM
sys.dm_exec_requests r
JOIN
sys.dm_exec_sessions s ON r.blocking_session_id = s.session_id
WHERE
r.blocking_session_id <> 0
AND r.blocking_session_id <> @@SPID
GROUP BY
r.blocking_session_id,
s.sql_handle,
s.login_name,
s.host_name,
s.program_name
HAVING
MAX(DATEDIFF(MINUTE, r.start_time, GETDATE())) >= @BlockingThresholdMinutes

-- Если есть длительные блокировки и флаг @KillBlockers установлен, убиваем блокирующие сессии
IF @KillBlockers = 1
BEGIN
DECLARE @BlockingSessionID INT
DECLARE @KillCommand NVARCHAR(100)

DECLARE blocker_cursor CURSOR FOR
SELECT BlockingSessionID FROM #BlockingInfo

OPEN blocker_cursor
FETCH NEXT FROM blocker_cursor INTO @BlockingSessionID

WHILE @@FETCH_STATUS = 0
BEGIN
SET @KillCommand = 'KILL ' + CAST(@BlockingSessionID AS NVARCHAR(10))

-- Логируем действие
INSERT INTO [dbo].[LongRunningQueries]
(
[CaptureTime],
[SessionID],
[RequestID],
[DatabaseName],
[CPUTime_ms],
[TotalElapsedTime_ms],
[Status],
[QueryText]
)
SELECT
GETDATE(),
BlockingSessionID,
NULL,
'Unknown',
0,
LongestBlockDurationMinutes * 60 * 1000,
'Killed by ResolveDeadlocks procedure',
'Blocking statement: ' + ISNULL(BlockingStatement, 'Unknown')
FROM
#BlockingInfo
WHERE
BlockingSessionID = @BlockingSessionID

-- Убиваем сессию
EXEC sp_executesql @KillCommand

FETCH NEXT FROM blocker_cursor INTO @BlockingSessionID
END

CLOSE blocker_cursor
DEALLOCATE blocker_cursor
END

-- Возвращаем информацию о блокировках
SELECT * FROM #BlockingInfo

DROP TABLE #BlockingInfo
END
GO

Заключение

Мониторинг SQL Server не должен быть сложным или дорогим. За 30 минут мы настроили базовую систему мониторинга, которая отслеживает ключевые метрики производительности, длительные запросы, рост баз данных и состояние резервных копий.

Эта система мониторинга поможет вам:

• Быстро выявлять проблемы с производительностью
• Предотвращать простои и сбои
• Планировать ресурсы на основе реальных данных
• Оптимизировать запросы и структуру базы данных
• Обеспечивать надежное резервное копирование

Помните, что мониторинг — это не разовое мероприятие, а непрерывный процесс. Со временем вы можете расширить эту базовую систему, добавив:

• Мониторинг репликации и AlwaysOn
• Отслеживание изменений в схеме базы данных
• Мониторинг безопасности и аудит доступа
• Интеграцию с системами оповещения (Slack, Teams, электронная почта)
• Визуализацию данных с помощью Power BI или Grafana

Главное — начать с малого и постепенно улучшать систему мониторинга, основываясь на реальных потребностях вашей организации.

Я надеюсь, что эта статья помогла вам понять, как быстро настроить базовый мониторинг SQL Server. Не откладывайте это на потом — потратьте 30 минут сегодня, и вы сэкономите часы или даже дни на устранение проблем в будущем.

Как говорил Бенджамин Франклин: "Унция профилактики стоит фунта лечения". В мире баз данных это особенно актуально — лучше предотвратить проблему, чем потом героически ее решать.

Начните мониторить свой SQL Server сегодня, и ваша жизнь администратора баз данных станет намного спокойнее и предсказуемее.

Если вам понравилась эта статья, пожалуйста, поставьте лайк и подпишитесь на мой канал, чтобы не пропустить новые материалы о SQL Server, оптимизации производительности и администрировании баз данных. Буду рад вашим комментариям и вопросам!