All perguntas(dba)

Em um servidor com SQL Server 2019 Standard Edition instalado, nenhum de nossos bancos de dados tem a Recuperação Acelerada de Banco de Dados habilitada ainda quando executo o DMV - sys.dm_db_index_physical_stats, a coluna version_record_countmostra um valor diferente de zero.

A pergunta é: se esse recurso estiver desabilitado, por que o DMV está me informando que as versões de linha estão sendo retidas para tabelas em cada banco de dados?

Os bancos de dados em questão estão usando Snapshot Isolation, mas eu teria pensado que as versões seriam armazenadas em tempdb.

Estou executando a consulta abaixo para encontrar tabelas CDC com dados além da profundidade de retenção configurada:

SELECT DB_ID() AS database_id, ct.capture_instance, object_id, source_object_id
, rcounts.source_table_rows
, rcounts.ct_table_rows
, ct_pstats.used_page_count
, source_pstats.used_page_count
, sys.fn_cdc_map_lsn_to_time(sys.fn_cdc_get_min_lsn(ct.capture_instance))
from cdc.change_tables AS ct
outer apply
(
select source_table_rows = (SELECT SUM(rows) FROM sys.partitions AS p WHERE p.object_id = ct.source_object_id AND p.index_id <= 1)
, ct_table_rows = (SELECT SUM(rows) FROM sys.partitions AS p WHERE p.object_id = ct.object_id AND p.index_id <= 1)
) as rcounts
outer apply
(
select used_page_count = SUM(used_page_count)
from sys.dm_db_partition_stats AS ps
where ps.object_id = ct.object_id
) AS ct_pstats
outer apply
(
select used_page_count = SUM(used_page_count)
from sys.dm_db_partition_stats AS ps
where ps.object_id = ct.source_object_id
) AS source_pstats
outer apply
(
select *
from msdb.dbo.cdc_jobs
where job_type = 'cleanup'
and database_id = DB_ID()
) as cleanup
WHERE DATEADD(minute, 60*25, sys.fn_cdc_map_lsn_to_time(sys.fn_cdc_get_min_lsn(ct.capture_instance))) < DATEADD(minute, -cleanup.retention, GETDATE())

Isso retorna muitos resultados em que a diferença entre o tempo mínimo de lsn e a retenção de CDC configurada é superior a 25 horas.

O tempo de retenção configurado é de 5.000 minutos e o tempo mínimo de lsn é superior a 5.800 minutos no momento da redação deste artigo.

Para tentar resolver isso, executei o cdc.cleanuptrabalho manualmente. Foi concluído com sucesso, mas não fez nenhuma alteração.

Em seguida, executei manualmente o procedimento sp_cdc_cleanup_change_tablepara cada uma das instâncias de captura e elas foram concluídas com êxito, mas, novamente, não fiz alterações.

EXEC sys.sp_cdc_cleanup_change_table @capture_instance = '...', @low_water_mark = NULL, @threshold = 5000;

Suspeitamos que esse problema esteja relacionado a um failover que ocorreu na mesma época, mas desde então já fizemos o failover para a réplica primária original.

Alguém pode aconselhar como resolver essa latência na limpeza sem precisar desabilitar e reativar o CDC?

Obrigado

Detalhes do ambiente:

• SQL Server 2014 Enterprise Edition, versão 12.0.6024
• Grupo de disponibilidade AlwaysOn com 3 nós - 2 síncronos com failover automático e um assíncrono.

Meu procedimento é o seguinte:

    
set [tb1].[SLD_VAR] =               case when [CalendarDate] = [tb1].[FileDate] and ([tb2].[SLD] - [tb2].[LAG_SLD])/([tb2].[SLD]+1) >= 0.15     then 1 else 0 end, 
    [tb1].[StartingDate_VAR] =      case when [CalendarDate] = [tb1].[FileDate] and [tb2].[StartingDate] <> [tb2].[LAG_StartingDate]            then 1 else 0 end,
    [tb1].[ClosingDate_VAR] =       case when [CalendarDate] = [tb1].[FileDate] and [tb2].[ClosingDate] <> [tb2].[LAG_ClosingDate]              then 1 else 0 end,
    [tb1].[CurrentStatus_VAR] =     case when [CalendarDate] = [tb1].[FileDate] and [tb2].[CurrentStatus] <> [tb2].[LAG_CurrentStatus]          then 1 else 0 end,
    [tb1].[Rate_VAR] =              case when [CalendarDate] = [tb1].[FileDate] and [tb2].[Rate] <> [tb2].[LAG_Rate]                            then 1 else 0 end,
    [tb1].[COF_VAR] =               case when [CalendarDate] = [tb1].[FileDate] and [tb2].[COF] <> [tb2].[LAG_COF]                              then 1 else 0 end,
    [tb1].[Term_VAR] =              case when [CalendarDate] = [tb1].[FileDate] and [tb2].[Term] <> [tb2].[LAG_Term]                            then 1 else 0 end,
    [tb1].[Term_GT_VAR] =           case when [CalendarDate] = [tb1].[FileDate] and [tb2].[Term_GT] <> [tb2].[LAG_Term_GT]                      then 1 else 0 end

from [DataTable]     as [tb1]

left join (
    
    select       [Filedate]
                ,cast([Deal] as inT) as [Deal]
                ,[SLD]
                ,[CurrentStatus]
                ,[StartingDate]
                ,[ClosingDate]
                ,[Rate]
                ,[COF]
                ,[Term],
                DATEDIFF(dd,[ApplicationDate],[ClosingDate])                                                       as [Term_GT],
                LAG([StartingDate],1)                               over (partition BY [Deal] order by [FileDate]) as [LAG_StartingDate],
                LAG([ClosingDate],1)                                over (partition BY [Deal] order by [FileDate]) as [LAG_ClosingDate],
                LAG([CurrentStatus],1)                              over (partition BY [Deal] order by [FileDate]) as [LAG_CurrentStatus],
                LAG([Rate],1)                                       over (partition BY [Deal] order by [FileDate]) as [LAG_Rate],
                LAG([COF],1)                                        over (partition BY [Deal] order by [FileDate]) as [LAG_COF],
                LAG([SLD],1)                                        over (partition BY [Deal] order by [FileDate]) as [LAG_SLD],
                LAG([Term],1)                                       over (partition BY [Deal] order by [FileDate]) as [LAG_Term],
                LAG(DATEDIFF(dd,[ApplicationDate],[ClosingDate]),1) over (partition BY [Deal] order by [FileDate]) as [LAG_Term_GT]

    from        [DataTable]
                    
    where       [FileDate] >= DATEADD( day, -14, @Date)
    
    )  as [tb2]

on          [tb1].[Filedate]        = [tb2].[Filedate] 
and         [tb1].[Deal]            = [tb2].[Deal]

where       [tb1].[CalendarDate]    >= @DateProd

end 

Tendo CalendarDatee Dealjuntos como PrimaryKey, criei alguns índices mas ainda demorou bastante para executar e preciso executar esse procedimento semanalmente. Por favor me ajude com alguma estratégia para otimizar isso.

Eu tenho um trabalho do SQL Server Agent projetado para se reconfigurar em resposta às condições existentes quando o trabalho é iniciado.

Então, em essência, a primeira etapa atualiza a segunda etapa. Isso acontece corretamente, mas parece que o processo do SQL Server Agent não sabe que a segunda etapa foi atualizada e executa a cópia antiga em cache do comando da etapa 2. Tentei adicionar sp_update_joba primeira etapa na tentativa de fazer com que o processo do Agente atualizasse seu cache, mas não foi uma alegria.

Aqui está um mcve para seu prazer:

BEGIN TRANSACTION
DECLARE @ReturnCode INT
SELECT @ReturnCode = 0
IF NOT EXISTS (SELECT name FROM msdb.dbo.syscategories WHERE name=N'[Uncategorized (Local)]' AND category_class=1)
BEGIN
EXEC @ReturnCode = msdb.dbo.sp_add_category @class=N'JOB', @type=N'LOCAL', @name=N'[Uncategorized (Local)]'
IF (@@ERROR <> 0 OR @ReturnCode <> 0) GOTO QuitWithRollback

END

DECLARE @jobId BINARY(16)
EXEC @ReturnCode =  msdb.dbo.sp_add_job @job_name=N'Test self-updating job', 
        @enabled=1, 
        @notify_level_eventlog=0, 
        @notify_level_email=0, 
        @notify_level_netsend=0, 
        @notify_level_page=0, 
        @delete_level=0, 
        @description=N'No description available.', 
        @category_name=N'[Uncategorized (Local)]', 
        @owner_login_name=N'sa', @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'step 1 - update step 2', 
        @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'USE [msdb];
GO
DECLARE @job_name sysname = N''Test self-updating job'';

DECLARE @command nvarchar(max);
IF EXISTS
(
    SELECT 1
    FROM [msdb].[dbo].[sysjobsteps] [sjs]
        INNER JOIN [msdb].[dbo].[sysjobs] [sj] ON [sjs].[job_id] = [sj].[job_id]
    WHERE [sj].[name] = N''Test self-updating job''
        AND [sjs].[step_id] = 2
        AND [sjs].[command] = N''PRINT N''''A'''';''
)
BEGIN
    SET @command = N''PRINT N''''B'''';''; 
END
ELSE
BEGIN
    SET @command = N''PRINT N''''A'''';''; 
END;
EXEC [msdb].[dbo].[sp_update_jobstep] @job_name = @job_name, @step_id = 2, @command = @command;
EXEC [msdb].[dbo].[sp_update_job] @job_name = @job_name, @automatic_post = 1;
', 
        @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'step 2 - do the work', 
        @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'PRINT N''A'';', 
        @database_name=N'master', 
        @flags=0
IF (@@ERROR <> 0 OR @ReturnCode <> 0) GOTO QuitWithRollback
EXEC @ReturnCode = msdb.dbo.sp_update_job @job_id = @jobId, @start_step_id = 1
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

O trabalho de teste começa com a 2ª etapa alternando entre a impressão Aou Bcada execução. ou seja, na primeira vez que for executado, ele deverá imprimir B, na próxima vez que for executado, deverá imprimir A, na próxima vez que for executado, deverá imprimir Be assim por diante.

Executar o trabalho e verificar o histórico do trabalho mostra que a saída é A, porém a inspeção do comando para a segunda etapa mostra que é PRINT N'B';. Portanto, o comando step está sendo atualizado, mas o Agente está, na verdade, executando o antigo código de etapa pré-atualizado.

Existe uma maneira de fazer com que o SQL Server Agent execute o código atualizado na etapa 2 em vez do código antigo e desatualizado?

No trabalho real, a segunda etapa é o comando cmdExec que é executado usando um proxy, portanto não posso usar SQL dinâmico em uma única etapa.

A replicação está funcionando bem nos outros servidores, porém no DB_B há algum problema; Não é possível receber arquivos.

Alguém pode me ajudar? Se eu perdi algum parâmetro, por favor me avise.

EDIT: Primário é DB_A e DR é DB_B

Configurações no primário

NAME               TYPE   VALUE                                                                                 
------------------ ------ ------------------------------------------------------------------------------------- 
log_archive_dest_5 string service=DB_B ASYNC valid_for=(online_logfile,all_roles) db_unique_name=DB_B 


NAME       TYPE   VALUE                              
---------- ------ ---------------------------------- 
fal_client string DB_A                            
fal_server string DB_C, DB_D, DB_E, DB_B 

NAME               TYPE   VALUE                                               
------------------ ------ --------------------------------------------------- 
log_archive_config string DG_CONFIG=(DB_C,DB_D,DB_E,DB_B,DB_A) 

TNSPing também foi bem-sucedido

Na DR

NAME                                 TYPE        VALUE
------------------------------------ ----------- --------------------------------
fal_client                           string      DB_B
fal_server                           string      DB_C, DB_D, DB_E, DB_A
                                                 
                                                 
                                                 
NAME                                 TYPE        VALUE
------------------------------------ ----------- --------------------------------------------------
log_archive_config                   string      dg_config=(DB_C,DB_A,DB_E,DB_D,DB_B)
                                               

Acabei de pedir à infraestrutura para adicionar memória a uma caixa do SQL Server, a memória total agora é de 16 Gb

Eu configurei a memória máxima no SQL Server para 12 GB.

quando executo a consulta de memória abaixo:

SELECT [ServerName]=@@servername,
       [Setting Name]=name, 
       value, 
       value_in_use, 
       [Value (GB)]=CONVERT(decimal(12,2),CONVERT(decimal(12,2), value_in_use)/1024.00),
       [description] 
FROM master.sys.configurations with(nolock)
WHERE name like '%server memory%'
ORDER BY name OPTION (RECOMPILE);

--Msg 260, Level 16, State 3, Line 12
--Disallowed implicit conversion from data type sql_variant to data type numeric, 
--table 'master.sys.configurations', column 'value_in_use'. 
--Use the CONVERT function to run this query.


SELECT 
    CONVERT(decimal(12,2),physical_memory_in_use_kb/1024.00/1024.00 )                     AS sql_physical_memory_in_use_GB, 
    CONVERT(decimal(12,2),large_page_allocations_kb/1024.00/1024.00)                      AS sql_large_page_allocations_GB, 
    CONVERT(decimal(12,2),locked_page_allocations_kb/1024.00/1024.00)                     AS sql_locked_page_allocations_GB,
    CONVERT(decimal(12,2),virtual_address_space_reserved_kb/1024.00/1024.00)              AS sql_VAS_reserved_GB, 
    CONVERT(decimal(12,2),virtual_address_space_committed_kb/1024.00/1024.00)             AS sql_VAS_committed_GB, 
    CONVERT(decimal(12,2),virtual_address_space_available_kb/1024.00/1024.00)             AS sql_VAS_available_GB,
    REPLACE(CONVERT(VARCHAR(50),CAST(page_fault_count  AS MONEY),1), '.00','')            AS page_fault_count,
    memory_utilization_percentage                                                         AS sql_memory_utilization_percentage, 
    CASE WHEN process_physical_memory_low = 1 THEN 'Yes' ELSE 'No' END                    AS sql_process_physical_memory_low,
    CASE WHEN process_virtual_memory_low = 1  THEN 'Yes' ELSE 'No' END                    AS sql_process_virtual_memory_low
FROM sys.dm_os_process_memory;


SELECT CONVERT(decimal(12,2),committed_kb/1024.00/1024.00 )        AS [SQL Server Committed Memory in GB],
       CONVERT(decimal(12,2),committed_target_kb/1024.00/1024.00 ) AS [SQL Server Target Committed Memory in GB],
       CONVERT(decimal(12,2),physical_memory_kb/1024.00/1024.00 ) AS [Server Physical Memory in GB],
       sql_memory_model_desc
FROM sys.dm_os_sys_info;

Eu entendi isso:

Pergunta:

Por que a memória do SQL Server não é de 12 GB?

Qual a frase correta para expressar a relação entre o usuário e seu gestor direto:

1. Uma tabela muitos-para-muitos deve ser mantida porque os gerentes têm vários funcionários sob seu comando.
2. Um campo do tipo referência (chave estrangeira) deve ser adicionado à tabela de usuários com referência ao registro do seu gestor direto.
3. Não há necessidade de acrescentar nada porque um gerente também é um funcionário, então usaremos o mecanismo de herança.
4. Nenhuma das respostas está correta.

Acredito que a 2ª opção seja a frase correta pois sugere utilizar um campo do tipo referência (chave estrangeira) na tabela de usuários para estabelecer um relacionamento direto entre um usuário e seu gestor

Peguei um arquivo de backup completo de um sistema ativo, aproximadamente 210 GB. Está na pasta de downloads com a extensão .bak. Estou tentando instalá-lo localmente com o banco de dados de restauração no SQL Server em meu computador desktop, mas ocorre o seguinte erro.

Sim, não tenho mais de 210 GB de espaço livre no disco C, mas ele requer aproximadamente 1,3 TB de espaço livre de mim. Qual é a razão para isso ou existe uma maneira alternativa de evitar isso?

Aqui está a foto;

Espaço de arquivo real em média 210 GB

Tenho backups diferenciais configurados para MS SQL Server 2022 e gostaria de saber quanto cada tabela do banco de dados está contribuindo para o tamanho do backup diferencial.

A página abaixo mostra como obter as informações no nível do banco de dados, mas eu gostaria de ver a porcentagem de extensões alteradas desde o último backup completo em nível de tabela.

https://www.mssqltips.com/sqlservertip/5688/script-to-show-how-much-a-sql-server-database-has-changed-since-last-full-backup/

Existe uma maneira de fazer isso?

Gostaria de saber quais tabelas estão sendo atualizadas e quantos bytes elas estão contribuindo para o backup diferencial. É claro que o número aumentará com o tempo até que um novo backup completo seja feito.

Isso faz parte da pergunta da entrevista sobre o estacionamento, em que o candidato é solicitado a projetar o sistema de estacionamento. Projetar entidades para estacionamentos é um problema bastante discutido. Mas estou preso em uma parte em que temos que atribuir uma vaga de estacionamento a um veículo.

Digamos que estamos implementando o problema do estacionamento com armazenamento de dados externo. E há muitas solicitações simultâneas, solicitando vaga de estacionamento. A implementação básica é,

1. Crie uma linha de banco de dados separada para cada vaga de estacionamento, com disponibilidade de coluna verdadeiro/falso.

2. Sempre que um veículo chegar, encontre um slot disponível (digamos o ID do slot X)

3. Atualize a disponibilidade do banco de dados como falso com bloqueio otimista (ou seja, UPDATE se slotid=X e disponibilidade =false)

A abordagem acima não funcionará bem em cenários de alta simultaneidade, uma vez que o mesmo slot poderia ser alocado para vários veículos e a etapa 3 falharia para todos esses veículos e teríamos que tentar novamente a partir da etapa 2.

Para processar isso de maneira ideal, devo mesclar as etapas 2, 3 e descarregar a atribuição para o próprio banco de dados. E o novo fluxo deve ficar como abaixo

1. Crie uma linha de banco de dados separada para cada vaga de estacionamento, com disponibilidade de coluna verdadeiro/falso.
2. Sempre que um veículo chega, acione uma consulta sql para encontrar uma linha e atualize a disponibilidade para falso. E devolver o slotid ao veículo?

É possível fazer isso em bancos de dados SQL? Existem outras abordagens para alcançar essa funcionalidade.