youcantryreachingme's questions

Primeiro, esta NÃO é uma duplicata desta pergunta . Nessa questão, a pessoa estava sobrescrevendo o arquivo todas as vezes e a solução é usar INIT ou NOINIT.

No meu caso, estamos gerando um nome de arquivo exclusivo com cada backup - um registro de data e hora é anexado ao nome do arquivo.

Temos um trabalho de agente que executa backups completos todas as noites para cerca de 20 bancos de dados. Por cerca de uma semana, 1 banco de dados parece estar aumentando de tamanho significativamente a cada noite.

Executamos um segundo trabalho de agente que executa backups de log a cada 15 minutos, mas para de ser executado entre 23h e 5h. Normalmente, logo pela manhã, os backups de log são grandes e, em seguida, seu tamanho é pequeno até que as pessoas comecem a trabalhar e, em seguida, eles têm vários tamanhos.

Tudo isso está funcionando sem problemas há anos.

Apenas um banco de dados dos 20 está mostrando esse problema - o backup completo de cada noite é significativamente maior do que na noite anterior.

Os backups do arquivo de log estão funcionando para este banco de dados e todos os outros.

Temos um grupo de disponibilidade com três réplicas. Duas são configuradas para failover uma para a outra e a terceira réplica é somente leitura para consultas pesadas, extrações de dados e relatórios. O console AG mostra marcas de seleção verdes em toda a página para todos os servidores.

O banco de dados em questão é o maior dos 20. O backup completo normal tem cerca de 25 GB. Ele aumentou lentamente da seguinte forma: 33, 35, 36, 41, 47, 54, 64, 73 GB.

Por outro lado, para todos os 14 backups anteriores a esse problema, o tamanho do arquivo era bastante estável em torno de 25 GB.

Acabei de pausar todos os backups de log para todos os bancos de dados e emitir um backup completo para o banco de dados afetado e esse último backup completo é de 76 GB.

Eu tenho um procedimento armazenado que começa declarando algumas variáveis ​​e depois contém begin tran;Depois disso, ele executa algumas validações nos argumentos fornecidos (e incrementa uma contagem de erros cada vez que um argumento fornecido falha na validação). Se não houver contagem de erros, procede-se a realizar 7 inserções. Na sequência disso, temcommit tran;

Recentemente eu adicionei uma 8ª inserção à lista. Uma conversão de tipo implícita significava que alguns dados inseridos seriam truncados se inseridos. Isso gerou um erro na tela do SSMS, mas descobri que as primeiras 7 inserções foram confirmadas enquanto a 8ª obviamente não foi concluída.

Eu aprecio que eu poderia incluir um try ... catchbloco para lidar com erros, mas se um explícito begin tran;não tornar todo o bloco de trabalho autônomo até o commit, então qual é o objetivo? O que eu perdi?

Entendo que talvez eu pudesse ter envolvido minha chamada de procedimento em uma transação nesse nível - mas alguém pode explicar o que está acontecendo e por que begin tranparece desrespeitado quando incluído no corpo do procedimento? Se chamar o procedimento inicia uma transação implícita, então uma etapa com falha no proc não deveria reverter todas as alterações efetuadas pelo proc - mesmo sem incluir explicitamente begin tranno corpo do proc?

Eu sei que outras respostas aqui (e aqui ) dizem para pedir por newid(). No entanto, se eu estiver selecionando top 1em uma subconsulta - para gerar uma seleção aleatória por linha na consulta externa - usando newid()produz o mesmo resultado todas as vezes.

Aquilo é:

select *,
    (select top 1 [value] from lookupTable where [code] = 'TEST' order by newid())
from myTable

... produz o mesmo lookupTable.valuevalor em cada linha retornada de myTable.

Estou tentando escolher um valor aleatório de lookupTable. Essa tabela tem apenas algumas linhas. No mundo real, eu quero update myTable set someColumn = ... um valor aleatório de lookupTable.valuemodo que cada linha myTableseja definida com um valor aleatório e não de forma que um único valor aleatório seja gerado e atribuído a todas as linhas.

Tenha paciência comigo - o código de exemplo está acontecendo e farei o meu melhor para explicá-lo abaixo.

with ENTITIES as (
select [name] as entityName from (values ('A'), ('B'), ('C')) X([name])
),
PROPERTIES as (
select [propName] as entityName, [propValue] as propertyValue from (values ('A','1'),('A','2'),('B','3'),('UNIVERSAL','999')) Y([propName], [propValue])
),
SUBPROPERTIES as (
select [propValue] as propertyValue, [subPropValue] as subPropertyValue from (values ('1','x'),('1','y'),('2','z'),('999','xyz')) Y([propValue], [subPropValue])
)
--select * from ENTITIES
--select * from PROPERTIES

select (

    select entityName as 'entityName',
    (
        select * from 
            (
                select propertyValue as 'propertyValue',
                (
                    select subPropertyValue from SUBPROPERTIES where SUBPROPERTIES.propertyValue = PROPERTIES.propertyValue
                    FOR JSON PATH, INCLUDE_NULL_VALUES
                ) Y
                from PROPERTIES where PROPERTIES.entityName = ENTITIES.entityName 

-- For testing, comment out from here -------------------------------------------------------------------------------------
                UNION
    
                select propertyValue as 'propertyValue',
                (
                    select subPropertyValue from SUBPROPERTIES where SUBPROPERTIES.propertyValue = PROPERTIES.propertyValue
                    FOR JSON PATH, INCLUDE_NULL_VALUES
                ) Y
                from PROPERTIES where PROPERTIES.entityName = 'UNIVERSAL' 
-- For testing, stop commenting out here ----------------------------------------------------------------------------------

            ) X
        FOR JSON PATH, INCLUDE_NULL_VALUES
    ) as entityProperties
    
    from ENTITIES
    FOR JSON PATH, INCLUDE_NULL_VALUES

) jsondata

Configurei 3 CTEs - representando 3 tabelas que se conectam. Um registro de ENTIDADES (como 'A') pode ter várias PROPRIEDADES (como '1' e '2') e cada registro de PROPRIEDADES pode ter várias SUBPROPRIEDADES (como '1' tem subpropriedades 'x' e 'y').

Agora, a consulta principal está simplesmente tentando construir um objeto JSON que retornará todas as ENTITIES juntamente com todas as suas PROPRIEDADES vinculadas e as SUBPROPRIEDADES vinculadas.

Portanto, a primeira coluna de seleção fornece apenas o entityName - uma consulta de nível superior.

A próxima coluna é uma subconsulta para obter todos os valores PROPERTIES relacionados ao registro ENTITIES fornecido. Você verá que retorna algo com o alias 'propertyValue' - é claro que isso será um conjunto de valores - um valor para cada registro PROPERTIES vinculado ao registro ENTITIES atual.

A subconsulta possui uma segunda coluna que é outra subconsulta - para a tabela SUBPROPERTIES - semelhante à anterior.

Agora aqui está o problema - neste nível médio (relatando PROPRIEDADES), eu realmente quero obter os dados de uma UNIÃO.

(Neste exemplo, a segunda consulta na união está consultando a mesma tabela de origem - para evitar uma união alterando a cláusula WHERE para ter or PROPERTIES.entityName = 'UNIVERSAL'- mas no mundo real estou obtendo dados de duas tabelas diferentes, então quero agregado com uma UNIÃO).

Eu entendo que, ao usar FOR XML PATHcom um UNION, você precisa envolver todos os SELECTs de UNION-ed entre parênteses e fornecer um alias (X, neste exemplo) e, em seguida, SELECT a partir disso - o que eu fiz com select * from. (Ignore isso select *é uma má prática - esse não é o ponto).

Essa abordagem para UNIONs funciona bem - desde que as consultas que foram UNION-ed não contenham subconsultas - mas como você pode ver aqui, eu tenho subconsultas.

Então - para ver o que estou tentando ilustrar, se você comentar o UNION (e o segundo select), você obterá um JSON bem estruturado conforme a ilustração a seguir . Eu destaquei onde as SUBPROPRIEDADES são mostradas - corretamente - em JSON estruturado.

No entanto, quando adiciono UNION, essas subconsultas retornam strings, em vez de JSON , conforme ilustração abaixo. Eu destaquei onde estão as cordas.

Eu tentei várias abordagens para adicionar uma função JSON_QUERY (que é recomendada em alguns casos para analisar uma string como JSON), mas a) não conseguiu resolver o problema e b) não há necessidade real para exatamente os mesmos dados quando há não é UNIÃO.

Também tentei várias abordagens para select * fromas subconsultas de nível mais baixo - sem sucesso.

Desde já, obrigado.

Eu li os documentos do MS sobre roteamento somente leitura , mas não estou falando sobre isso.

Atualmente, se eu executar um UPDATEem um banco de dados que está em uma réplica secundária e faz parte do grupo de disponibilidade, recebo uma mensagem:

Msg 3906, Level 16, State 2, Line 6
Failed to update database "dbName" because the database is read-only.

Minha dúvida é se essa configuração é estabelecida por padrão (e inevitável) em virtude do banco de dados fazer parte do AG e estar em um Secundário no momento?

Alguns extras interessantes:

O SQL a seguir, executado nesse Secundário, mostra que tenho UPDATEe ALTERmuito mais permissões nesse banco de dados:

SELECT * 
FROM fn_my_permissions(null, 'DATABASE')   
ORDER BY subentity_name, permission_name;

O SQL a seguir mostra explicitamente que tenho permissão para UPDATEuma tabela nesse banco de dados:

SELECT * 
FROM fn_my_permissions('dbName.dbo.tblName', 'OBJECT')   
ORDER BY subentity_name, permission_name ;

Apesar disso, estou realmente impedido de atualizar essa tabela. Isso implica:

• A saída de fn_my_permissionsnão está estritamente correta
• A configuração "somente leitura" do banco de dados substitui permissões individuais

Eu entendo que a configuração em jogo é configurada por meio de:

ALTER DATABASE dbName SET READ_ONLY

e

ALTER DATABASE dbName SET READ_WRITE WITH NO_WAIT

A principal razão para a pergunta é entender se a configuração "somente leitura" é responsabilidade de um DBA/designer durante o projeto e implantação do AG, ou um recurso esperado (e garantido?) pelo simples uso de um AG.

Com o exemplo abaixo, como faço para escapar os caracteres de aspas duplas que estão na variável @data?

declare @data nvarchar(max) = N'"TEST"';
declare @jsonFragment nvarchar(max);
declare @id int = 999;

set @jsonFragment = ',"' + cast(@id as nvarchar(16)) + '":"' + @data + '"';

select @jsonFragment;

O resultado é:

 ,"999":""TEST""

Eu preciso que seja:

 ,"999":"\"TEST\""

Pelo que entendi, selecionar for json pathrequer que eu defina um nome de chave estático - mas, como pode ser visto, tenho um cenário em que os nomes de chave estão sendo definidos dinamicamente.

No meu caso de uso do mundo real, essa construção de string está ocorrendo dentro de uma stuffinstrução, ela própria parte de uma definição de coluna maior selectque utiliza CTEs - o que significa que seria muito difícil criar uma instrução sql dinâmica para ser executada usando sp_executeSQL.

Parece que json_queryfalha ao remover caracteres de escape para o caractere de aspas duplas ("") se a função estiver sendo aplicada em uma caseinstrução.

Código de exemplo abaixo.

declare @data nvarchar(max);
declare @debug int = 0;

set @data = '{"id":10}';

set @debug = 0;
select
    isjson(@data) as 'validateData',
    @data as 'unprocessedSourceData',
    json_query(@data) as 'processedSourceData',
    case when @debug = 1 then json_query(@data) else null end as 'conditionallyProcessedSourceData'
    for json path, without_array_wrapper ;

set @debug = 1;
select
    isjson(@data) as 'validateData',
    @data as 'unprocessedSourceData',
    json_query(@data) as 'processedSourceData',
    case when @debug = 1 then json_query(@data) else null end as 'conditionallyProcessedSourceData'
    for json path, without_array_wrapper ;

Resultado da primeira consulta:

{"validateData":1,"unprocessedSourceData":"{\"id\":10}","processedSourceData":{"id":10}}

Resultado da segunda consulta:

{"validateData":1,"unprocessedSourceData":"{\"id\":10}","processedSourceData":{"id":10},"conditionallyProcessedSourceData":"{\"id\":10}"}

Observe os caracteres de escape no final : " {\"id\":10}"

1) Por que seria assim?

2) Como faço para retrabalhar essa consulta para que, se @debug = 1então o conditionallyProcessedSourceDataelemento contiver JSON válido, e se @debug = 0o elemento for null?

• Aqui está um violino para mostrar o que estou procurando .

Dada uma tabela com duas colunas - um ID inteiro e uma string baseada em texto - quero começar com um valor de string que codifique qualquer número de inteiros entre chaves, misturados com quaisquer outros caracteres de texto válidos.

Exemplo:'{1} / {9} ... {12}'

Com uma única SELECTinstrução, quero retornar uma string pela qual todos os inteiros (e suas chaves) foram substituídos por um valor derivado da minha tabela; especificamente, o valor de texto para a linha com um ID que corresponde ao número encontrado na string de origem.... e quaisquer caracteres fora das chaves permanecem intocados.

Aqui está um exemplo que não consegue concluir a tarefa:

select
  replace('{13} {15}','{'+cast(id as varchar)+'}',isNull(display,''))
from testing;

Isso retornaria 1 linha por linha na testingtabela. Para a linha com idvalor = 13, a parte '{13}' da string é substituída com sucesso, mas a parte '{15}' não é (e vice-versa na linha 15).

Imagino que criar uma função que percorra todas as testinglinhas e tente repetidamente substituições resolveria o problema. Seja como for, uma instrução SQL direta seria preferível ao loop.

Dados de exemplo

+----+-------------------+
| id |  display          |
+----+-------------------+
|  1 |  Apple            |
|  2 |  Banana           |
|  3 |  Celery           |
|  4 |  Dragonfruit      |
|  5 |  Eggplant         |
|  6 |  Fenugreek        |
|  7 |  Gourd            |
|  8 |  Honeydew         |
|  9 |  Iceberg Lettuce  |
| 10 |  Jackfruit        |
| 11 |  Kale             |
| 12 |  Lemon            |
| 13 |  Mandarin         |
| 14 |  Nectarine        |
| 15 |  Olive            |
+----+-------------------+

Casos de uso de exemplo

select replace('{1} {3}',null,null) 
-- Returns 'Apple Celery'

select replace('{3},{4},{5}',null,null); 
-- Returns 'Celery,Dragonfruit,Eggplant'

select replace('{1} / {9} ... {12}',null,null); 
-- Returns 'Apple / Iceberg Lettuce ... Lemon'

Claramente, a palavra- replacechave não faz o trabalho.

PS. Se uma solução exigir que o formato da string seja alterado para facilitar isso, essa é uma opção.

Por exemplo: '#1 / #9 ... #12'(para correlacionar com o exemplo anterior)

Nesse formato, talvez pudéssemos dividir a string em um conjunto de linhas, com base em #, pegar os leftcaracteres até encontrarmos um não numérico, joinpara a testingtabela com base nos números obtidos, substituir os #e números pelo valor testingda tabela e displaydepois stufftodos individualmente tokens modificados de volta em uma única string for xml path?

Estou usando o SQL Server 2016, que não oferece suporte ao string_agg. Dito isso, se houver uma solução usando string_agg, ainda estou interessado em analisá-la.

Pelo que entendi, se você selecionar json_valueou json_queryespecificar uma chave ou objeto que não existe em seu documento json, no modo estrito, você receberá um erro. Isso permite, por exemplo, confirmar se a chave foi especificada no documento.

Se um par de valores-chave de exemplo for incluído no documento assim:

"Test":null

... isso, no modo estrito, retornará 'NULL'. Em outras palavras, agora você sabe que a chave está definida no documento e seu valor é nulo.

Agora imagine que seu documento contém:

 "Test":"Some string"

E você consulta:

 select json_modify(@json, '$.Test', null);

Isso retornará uma string json sem a chave "Test".

Como você define corretamente um valor de chave como nulo, em vez de removê-lo do documento json?

(O exemplo acima pode parecer sem sentido, mas posso imaginar definir um valor como null antes de passar o documento json para a próxima consulta ou sistema e exigir que sua chave "Test" exista no documento.)

Observei que os valores de chave-valor podem estar sem aspas quando numéricos em strings TSQL JSON, mas parece que o componente-chave deve sempre ser citado.

select 1, isjson(''), 'empty string' union
select 2, isjson('{}'), 'empty braces' union
select 3, isjson('{1:2}'), 'unquoted both, numerals both' union
select 4, isjson('{1:"2"}'), 'unquoted key, numerals both' union
select 5, isjson('{"1":2}'), 'unquoted value, numerals both' union
select 6, isjson('{"1":"2"}'), 'quoted both, numerals both' union
select 7, isjson('{a:b}'), 'unquoted both, alpha both' union
select 8, isjson('{a:"b"}'), 'unquoted key, alpha both' union
select 9, isjson('{"a":b}'), 'unquoted value, alpha both' union
select 10, isjson('{"a":"b"}'), 'quoted both, alpha both'
order by 1
;

Resultados:

1   0   empty string
2   1   empty braces
3   0   unquoted both, numerals both
4   0   unquoted key, numerals both
5   1   unquoted value, numerals both
6   1   quoted both, numerals both
7   0   unquoted both, alpha both
8   0   unquoted key, alpha both
9   0   unquoted value, alpha both
10  1   quoted both, alpha both

O acima demonstra isso, mas minhas perguntas são:

1. Isso deve ser sempre assim? (Existe uma configuração que pode substituir esse comportamento?)
2. Esse comportamento é especificado por JSON ou SQL Server?
3. Qual é a lógica por trás dessa decisão de design?
4. Haveria um benefício de desempenho se o SQL Server convertesse automaticamente numerais sem aspas como inteiros?

Eu vi uma instrução TSQL concisa que efetivamente divide uma string em seus caracteres constituintes, um por linha, com o objetivo de avaliar o asciivalor de cada caractere.

Se estou lendo a consulta corretamente, efetivamente, 3 CTEs estão sendo usados ​​para preparar uma tabela de 1 coluna contendo 10.000 linhas, cada uma com o valor '0'.

Um quarto CTE é definido da seguinte forma:

cteTally(n) AS(
    SELECT ROW_NUMBER() OVER(ORDER BY (SELECT NULL)) n 
    FROM E4
)

Posteriormente, este CTE é associado a uma tabela contendo uma coluna com as strings de interesse, com o seguinte select:

SELECT n, SUBSTRING(LastName, n, 1), ASCII( SUBSTRING(LastName, n, 1))

Ou seja, o número da linha n, o enésimo caractere em LastName e o valor ascii desse caractere.

Minhas dúvidas se referem à overcláusula do CTE acima.

Essencialmente, o que exatamente ele está fazendo?

Se estamos consultando row_number de 10.000 linhas idênticas, por que precisamos de uma order bycláusula? Por que o put é order bycolocado em uma overcláusula e não como uma order bycláusula para a selectinstrução - especialmente porque a overcláusula nem especifica nenhuma partição? (Presumo que isso significa que a janela sobre a qual row_numberopera são as 10.000 linhas completas?) E o que significa ordenar select null?

Se eu inserir TSQL no editor de consulta do SSMS, sei que posso "percorrer" as instruções (ou seja, executá-las uma de cada vez) destacando uma instrução e pressionando F5 no teclado.

Parece que, por padrão, essa sessão não tem uma transação aberta. Cada execução é comprometida.

Eu posso escrever meu TSQL para que ele comece BEGIN TRANe termine com um COMMITou ROLLBACK- e isso garante que, conforme eu passo, eu tenha a opção de voltar atrás nas alterações.

No entanto, o problema que tenho é quando declaro variáveis. Considerar:

declare @flag bit = 0;

select case when @flag = 0 then 'off' when @flag = 1 then 'on' end as FlagCheck;

Independentemente de o acima estar envolvido em uma transação, se eu executar a primeira instrução por conta própria, então a próxima instrução por conta própria, a segunda instrução falhará porque a variável não foi declarada.

É possível percorrer um código como este e fazer com que o SSMS entenda que os efeitos da instrução anterior (declarar a variável e atribuir um valor) devem ser transferidos para a próxima etapa? (Mais uma vez, mesmo se envolvido em uma transação, essa persistência de variáveis ​​falha - mesmo que a persistência da atualização de dados seja dependente da resolução da transação - commit ou rollback).

Eu tenho um e-mail falhando com o valor de retorno da função de '101' e @@error valor de '0' (nenhuma linha é adicionada a sysmail_allitems).

Onde posso encontrar documentação sobre códigos de retorno para esta função?

Código de exemplo mostrando como obtenho os valores acima:

exec @result = msdb.dbo.sp_send_dbmail
    @profile_name = 'OBFUSCATED',  
    @recipients = @DL,  
    @subject = 'OBFUSCATED',
    @body = @emailBody,
    @body_format='html',
    @query = @reportQuery,
    @exclude_query_output = 1,
    @attach_query_result_as_file = 1,
    @query_attachment_filename = @filename,
    @query_result_separator = @temp,
    @query_result_header = 1,
    @mailitem_id = @mailitem_id
    ;

    set @temp = @@ERROR;

Imagine a seguinte linha do tempo:

• T0 = ​​backup completo
• T1 = backup de log
• T2 = backup de log
• T3 = backup de log
• T4 = backup completo
• T5 = backup de log

Depois que tudo isso acontecer, se você ainda tiver todos os arquivos de backup, como você restauraria para um ponto no tempo entre T3 e T4?

Meu entendimento é que o backup completo em T4 deve levar o arquivo de log a marcar as transações entre T0 e T4 como inativas, então, em teoria, o log de transações pode não conter mais transações anteriores a T4. Em particular, o backup de log em T5 conterá apenas informações de transação a partir do momento após T4. Isso está correto?

Recentemente, assumi a administração de um sistema com cerca de 25 bancos de dados. Usando o Redgate Monitor para traçar algumas métricas, vejo que a cada dia, um banco de dados mostra valores para fluxos de log/segundo que se parecem com um gráfico "normal" - uma linha em ziguezague ao longo do dia.

Redgate explica a métrica: "Uma liberação de log ocorre quando uma transação é confirmada e os dados são gravados do cache de log para o arquivo de log de transação física".

Tudo muito bem - o trabalho está acontecendo e os dados estão sendo liberados para o disco à medida que são confirmados.

Minha pergunta é - por que todos os outros bancos de dados não registram nada muito acima do eixo x?

Redgate também explica: "As descargas de log por segundo geralmente devem se correlacionar com o número de transações por segundo".

Quando vejo transações por segundo, muitos bancos de dados estão mostrando linhas de gráfico em zigue-zague - então, o que está acontecendo que apenas um deles está mostrando atividade para liberação de logs? Isso significa que todos os outros bancos de dados estão falhando no commit?

Todos os bancos de dados do usuário estão usando o modelo de recuperação completa.

(Também noto que entre as 2h e as 5h há picos enormes nas liberações de log para quase todos os bancos de dados - ainda para investigar a causa disso).

Prever:

use databaseA;
go

exec databaseB.dbo.spProcedure();
go

O procedimento é executado no banco de dadosA - o contexto do qual é chamado, ou banco de dadosB - no contexto em que existe?

Se o procedimento tivesse

insert into myTable(example) values ('example');

... e se ambos os bancos de dados tivessem tabelas idênticas myTable, qual banco de dados receberá o novo registro?

O gráfico abaixo vem de uma ferramenta de monitoramento. A métrica mostrada é "espaço de log usado" para SQL Server 2016 nos últimos 7 dias.

Estou procurando ajuda para entender o que está acontecendo aqui.

O que eu sei é que o departamento de TI está usando uma ferramenta de terceiros (Veeam) para "fazer backup" regularmente. Sou avisado que backups completos são realizados todas as noites e backups de log são executados a cada 15 minutos (mas não tenho certeza se são backups de imagem de disco dos arquivos de banco de dados ou comandos emitidos para SQLServer pela Veeam para realizar um backup). Uma das etapas inclui "logs de processo" para SQL Server e acredito que uma das etapas seja truncar os logs.

Entendo que truncar o log significa marcar como inativas as partes do arquivo de log que podem ser reutilizadas. No momento, entendo (com ou sem razão) que uma parte do arquivo de log pode ser reutilizada se o SQL Server souber que foi gravada em disco - ou seja, via backup.

O que vejo neste gráfico é

1. Um uso anormalmente alto do arquivo de log para um banco de dados na extrema esquerda - ignore isso.
2. Crescimento diário e, em seguida, limpeza diária de cada arquivo de log (3 corcovas).
3. Crescimento ao longo de 3 dias (sex, sáb, dom), depois truncamento.

Minha interpretação aqui é que os backups de log devem estar ocorrendo, caso contrário, o uso não cairia perto de zero.

Suspeito que os backups de log estejam ocorrendo apenas uma vez por dia - embora não ache que este gráfico prove isso. Por exemplo, existe a possibilidade de haver backups de log mais frequentes durante o horário comercial, mas o truncamento não ocorre nesse momento devido a uma transação de longa execução. No entanto, no backup noturno da Veeam, o comando de truncamento é emitido e é bem-sucedido. Apesar dessa possibilidade, ainda acho mais provável que os backups de log estejam sendo realizados apenas uma vez por dia pela Veeam.

Parte do problema aqui é que a Veeam é uma caixa preta para mim - não tenho certeza de como a TI configurou isso. Também não estou claro se ele está tirando imagens instantâneas dos discos rígidos (ou seja, arquivos de banco de dados) ou instruindo o SQLServer a executar um backup.

Meu objetivo é garantir que estamos fazendo backups frequentes de arquivos de log (e trabalhar com uma boa frequência) para oferecer suporte a um modelo de recuperação completo em essencialmente todos esses bancos de dados. Se eu determinar que atualmente não estamos fazendo backups de log com mais frequência do que todas as noites, também preciso garantir que, se eu implementar medidas para backups de log frequentes, não estarei competindo com a Veeam de tal forma que a Veeam e qualquer tarefa agendada dentro O SQLServer não está quebrando as cadeias de log um para o outro - quaisquer sugestões sobre como verificar e planejar essas coisas seriam muito apreciadas.

Gostaria de auditar alterações em uma tabela no SQLServer usando um gatilho e uma tabela de auditoria para fazer isso. Os usuários finais se conectam ao banco de dados por meio de um aplicativo. Se eu usar SYSTEM_USERpara obter o nome de usuário do usuário final, ele retornará o nome do aplicativo que está se conectando ao banco de dados e não o nome de login exclusivo do usuário para esse aplicativo.

Qual seria uma abordagem padrão para capturar o nome de login do aplicativo exclusivo do usuário neste cenário?