Perguntas[sql-server-2012](dba)

Atualmente, temos um banco de dados SQL 2016 replicando para um banco de dados SQL 2012 e estamos atualizando nossa instância SQL 2016 para SQL 2019. De acordo com a documentação de compatibilidade, a replicação entre as versões não seria mais possível: https://learn.microsoft.com/en-us/sql/relational-databases/replication/replication-backward-compatibility

Não conseguimos atualizar a instância do SQL 2012, então fiquei pensando se uma abordagem de "vários saltos" funcionaria, ou seja, replicação do SQL 2012 para um novo SQL 2016 e depois replicação da nova instância do SQL 2016 para a instância do SQL 2019.

Estou configurando a replicação transacional no meu servidor 2008R2 para o servidor de distribuição 2012 para o servidor Subscriber 2012. Todos os três servidores estão no modo de recuperação FULL. O backup de log é feito a cada 15 minutos e o backup completo é feito diariamente, todos os dias, em todos os três bancos de dados de servidor usados ​​na replicação. Queremos usar o subscriber como um servidor de relatórios. O Publisher é nosso principal banco de dados OLTP.

Mas o SSMS do assinante é o SSMS 2012 e o SSMS do publicador é o 2008r2, então a replicação está gerando o erro: "O assinante selecionado não atende ao nível mínimo de compatibilidade de versão do publicador selecionado"

Então, estou pensando em usar minha máquina Distributor (servidor 2012 com SSMS 2012) para acessar remotamente meu publicador (servidor 2008R2) e então configurar a replicação do publicador de lá. Deve funcionar bem? Ou causará algum problema.

Ou seria melhor instalar o SSMS 2012 no meu servidor publicador e depois configurar a replicação a partir dele?

Por favor ajude

Eu tinha instalado o 2012SSMS no editor do servidor de teste e estava funcionando muito bem. Mas não quero entrar no licenciamento para 2 SSMSs

Eu seria capaz de reverter (remover/excluir) a replicação facilmente caso houvesse um problema se eu usasse um servidor diferente (não o servidor do publicador real) para configurar a replicação?

Estou tentando fazer uma consulta em loop para o agente Sql que verifica os dados dos usuários e se os critérios forem atendidos a recompensa é enviada, após isso excluiria os registros da tabela reiniciando o loop. O problema é que não consigo fazer o loop funcionar.

Minha mesa fica assim:

ID | login_id | price     |    date    |
1      user1      -100       01/01/1999   

O que eu tentei:

DECLARE @retVal int
SELECT  @retVal = COUNT(*)
select x.login_id, x.price
FROM Table as x inner join Table as b on x.login_id=b.login_id 
where x.price='-100'
order by x.login_id

IF (@retVal >= 3)
BEGIN

DELETE TOP (3) x 
FROM point_log_pitty as x 
inner join point_log_pitty as b on x.login_id=b.login_id 
where b.login_id=x.login_id and @retVal = 3 and x.price='-100';
End

O primeiro problema é que ele conta todos os registros para condições definidas (vários usuários), não por usuário. Exemplo do que tenho (não se limita a apenas 1 usuário):

ID | login_id | price     |    date    |
1      user1      -100       01/01/1999   
2      user2      -100       01/01/1999   
3      user3      -100       01/01/1999   

Eu tentei este também:

SELECT login_id, COUNT(login_id) AS username_count
FROM point_log_pitty
where price='-100'
GROUP BY login_id

O que conta corretamente os registros, mas não posso usar os resultados de username_count para excluir a consulta.

Objetivo: seria mais ou menos assim: Quando seu usuário x atingir 3'-100' de correspondência de preços, a consulta será executada e selecionará os registros do histórico do usuário que correspondem aos critérios e excluirá esses registros, reiniciando o loop.

Esses dados estão sendo buscados e excluídos.

ID | login_id | price     |    date    |
1      user1      -100       01/01/1999   
2      user1      -100       01/01/1999   
3      user1      -100       01/01/1999   

É possível adaptar isso na consulta de atualização que deve buscar uma sequência livre de 3 bytes ou (0x000000) e substituí-la por uma nova sequência se os dados forem divididos assim a cada 3 bytes? O problema é que converter/substituir não funcionará com dados indefinidos que são 0x00. Os dados varbinary são divididos a cada 3bytes -> data(3bytes long)data(3bytes long).

DECLARE @YourTable table
(
Id INT PRIMARY KEY,
Val VARBINARY(50)
)

INSERT @YourTable
VALUES (1, 0x0329000414000B14000C14000D0F00177800224600467800473C00550F00000000000000000000000000),
       (2, 0x0329002637000B14000C14000D0F00177800224600467800473C00550F00000000000000000000000000);


SELECT Id, Triplet
FROM @YourTable T
JOIN (VALUES (1),(4),(7),(10),(13),(16),(19),(22),(25),(28),(31),(34),(37),(40),(43),(46),(49)) Nums(Num) ON Num <= DATALENGTH(T.Val)
CROSS APPLY (VALUES (SUBSTRING(T.Val, Num, 3))) V(Triplet)
WHERE Triplet = 0x000000 and DATALENGTH(Triplet) = 3

O que eu tentei:

UPDATE x    
set  x.column =  CAST(REPLACE(x.column, 0x000000, 0xFFFFFF) AS VARBINARY)
from Table as x 

Funciona apenas se a coluna não contiver dados.

UPDATE x    
set  x.attr =  CAST(REPLACE(0x000000, 0x000000, 0xFFFFFF) 
from Table as x 

Este meio funciona substituindo os primeiros 3 bytes dos dados, mas prefiro não perder dados no processo.

O objetivo é substituir a sequência de dados vazios em varbinary(50) pela sequência do meu desejo. Ou selecione um local específico do binário, por exemplo, o último local plausível do trio e importe/substitua os dados ali pela sequência desejada.

Meu colega me disse que qualquer consulta que usa um servidor vinculado primeiro transfere os dados do servidor remoto para o servidor em que a consulta está sendo executada e, em seguida, aplica filtros. Por exemplo, se eu tiver a seguinte consulta:

select id, region
from linked_server.mydb.dbo.product
where id = 1

A consulta trará todos os dados da tabela de produtos do servidor remoto para o servidor local e aplicará ID=1. Não encontrei essa informação no site da Microsoft. Isso é verdade?

Eu tenho uma restrição de verificação em uma coluna que usa uma UDF escalar. Eu tenho um requisito onde preciso fazer alterações no UDF. Com base no que sei, preciso descartar a restrição, fazer alterações na UDF e, em seguida, adicionar novamente a restrição. Durante o período em que a restrição é removida, estou preocupado que dados inválidos possam ser inseridos na tabela. Existe uma maneira de alterar o UDF sem eliminar a restrição? Se não, existe uma maneira de impedir que dados incorretos entrem na tabela?

A maioria das instruções select em nossos procedimentos armazenados usam WITH(NOLOCK)e meus colegas de trabalho me disseram que eles usam para melhorar o desempenho. Agora, eu sei que essa dica ajuda no bloqueio, mas na verdade melhora o desempenho? Li em algum lugar que não devemos usar as NOLOCKdicas nos bancos de dados OLTP, mas vejo o contrário sendo feito no meu local de trabalho. Alguém poderia esclarecer as melhores práticas quando se trata de usar as NOLOCKdicas?

Tenho uma tabela com 150 milhões de registros e 8 índices. Um dos índices está ativado userId. Muitas das consultas atuais são filtradas userIde, portanto, esse índice funciona perfeitamente. Para uma das consultas, tenho que expandir a cláusula where para incluir colunas regionIde . productIdTenho duas opções: posso criar um novo índice com (userId, regionId, productId)ou adicionar essas novas colunas ao índice existente. Qual seria uma opção melhor? Se eu modificar o índice existente, isso afetará as outras consultas que já usam userId?

Meu objetivo:
quero que minha consulta atual que expande a cláusula where seja incluída RegionIde productIdexecutada mais rapidamente, mas não quero que minhas outras consultas que tenham apenas userIda cláusula where sejam afetadas. Se eu adicionar um novo índice, (userid, regional, productid)posso fazer isso, mas não tenho certeza se estou duplicando o índice, pois já tenho um índice existente no userIdqual posso expandir para incluir regionide productId. Mas não tenho certeza sobre as consequências de modificar o índice existente.

Obrigado pelo seu tempo!

Temos um procedimento armazenado que usa SUMuma coluna Int na SELECTinstrução. Temos alguns casos em que, para um dos valores de parâmetro, a SUM (coluna inteira) excede o intervalo Int e, portanto, gera um erro

Erro de estouro aritmético ao converter expressão em tipo de dados int

A solução para isso seria converter a coluna em bigint na função sum, ou seja, Sum(Convert(BigInt, column)). Mas como isso está acontecendo para alguns casos específicos neste momento e não para todos os casos, estou preocupado em acabar penalizando os outros casos em que essa conversão não é necessária. Quanta diferença de desempenho a conversão costuma fazer? Existe alguma outra maneira de lidar com esse problema? Obrigado!

Considere o seguinte cenário:

1. 10.000 usuários tentam criar um perfil em nosso aplicativo simultaneamente ao mesmo tempo e os dados devem ser inseridos na tabela, userProfile.
2. O SP que lida com essa inserção leva meio segundo para ser executado.

Do meu entendimento de bloqueio e transações, esta tabela será bloqueada para cada inserção. Isso significa que, quando o perfil do último usuário for criado, levará um tempo. Como o SQL Server lida com atualizações e bloqueios simultâneos? Eu apreciaria qualquer insight sobre isso. Obrigado!