Jonathan Fite's questions

Eu preciso encontrar, para um determinado segundo atual e limite superior e inferior, encontrar todos os segundos que cairiam dentro disso, envolvendo a marca de 59 segundos.

Com essa palavra salada fora do caminho, aqui estão alguns exemplos de entradas e saídas.

• Se a entrada for 58 segundos e o intervalo for +/- 5 segundos, então eu quero retornar 58, 59, 0, 1, 2, 3 AND 57, 56, 55, 54, 53
• Se a entrada for 22 e o mesmo intervalo, quero retornar 22, 23, 24, 25, 26, 27 E 21, 20, 19, 18, 17
• Se o Input for 5 e o mesmo intervalo, então quero retornar 0, 1, 2, 3, 4, 5 AND 5, 7, 8, 9, 10.

Eu tenho brincado com o tipo de dados TIME para tentar usar o datemath embutido para lidar com a quebra da marca de 59 segundos, mas tive sucesso limitado. Incluído aqui está minha versão completa que não funciona.

Minhas desculpas pelo estado do código, estou trabalhando nele há um tempo e estou optando por deixar todos os meus bits e bobs para ilustrar completamente o que tentei. Se eu não conseguir encontrar uma solução mais elegante, terei que construir uma tabela de contagem com a resposta "correta" para nosso valor de intervalo inicial, mas gostaria de ter mais flexibilidade do que isso, se possível.

DECLARE @CurrentSecond SMALLINT = 22 -- DATEPART(SECOND, SYSUTCDATETIME()) 
DECLARE @LowerBoundary INT  = -5
DECLARE @UpperBoundary INT = 5

;WITH CTE_Parts AS
        (
        SELECT P.ID 
            , LowerBound = DATEPART(SECOND, DATEADD(SECOND, @LowerBoundary, CONVERT(TIME, '00:00:' + CONVERT(NVARCHAR(20), P.ID))))
            --, lowerBoundTime = DATEADD(SECOND, @LowerBoundary, CONVERT(TIME, '00:00:' + CONVERT(NVARCHAR(20), P.ID)))
            , UpperBound = DATEPART(SECOND, DATEADD(SECOND, @UpperBoundary , CONVERT(TIME, '00:00:' + CONVERT(NVARCHAR(20), P.ID)))) 
            --, UpperBoundTime = DATEADD(SECOND, @UpperBoundary , CONVERT(TIME, '00:00:' + CONVERT(NVARCHAR(20), P.ID)))
            , C.LowerBoundary_Current
            --, C.LowerBoundTime_Current
            , C.UpperBoundary_Current
            --, C.UpperBoundTime_Current
        FROM (VALUES (0), (1), (2), (3), (4), (5), (6), (7), (8), (9)
                    , (10), (11), (12), (13), (14), (15), (16), (17), (18), (19)
                    , (20), (21), (22), (23), (24), (25), (26), (27), (28), (29)
                    , (30), (31), (32), (33), (34), (35), (36), (37), (38), (39)
                    , (40), (41), (42), (43), (44), (45), (46), (47), (48), (49)
                    , (50), (51), (52), (53), (54), (55), (56), (57), (58), (59)
                    ) AS P (ID)
            OUTER APPLY (SELECT DATEPART(SECOND, DATEADD(SECOND, @LowerBoundary, CONVERT(TIME, '00:00:' + CONVERT(NVARCHAR(20), @CurrentSecond)))) AS LowerBoundary_Current
                                , LowerBoundTime_Current = DATEADD(SECOND, @LowerBoundary, CONVERT(TIME, '00:00:' + CONVERT(NVARCHAR(20), @CurrentSecond)))
                                , DATEPART(SECOND, DATEADD(SECOND, @UpperBoundary, CONVERT(TIME, '00:00:' + CONVERT(NVARCHAR(20), @CurrentSecond))))  AS UpperBoundary_Current
                                , UpperBoundTime_Current = DATEADD(SECOND, @UpperBoundary, CONVERT(TIME, '00:00:' + CONVERT(NVARCHAR(20), @CurrentSecond)))
                            ) AS C
        )
SELECT * 
    , Ignore = CASE WHEN @CurrentSecond + @UpperBoundary <= 59 AND @CurrentSecond + @LowerBoundary >= 0 AND ID BETWEEN LowerBoundary_Current AND UpperBoundary_Current THEN 1 
                    WHEN NOT(@CurrentSecond + @UpperBoundary <= 59 AND @CurrentSecond + @LowerBoundary >= 0)
                        AND ID >= LowerBoundary_Current
                        OR ID <= UpperBoundary_Current
                        THEN 1
                    ELSE 0 END
FROM CTE_Parts AS P 
ORDER BY P.ID

Para ser absolutamente claro, o acima NÃO faz o que eu quero (exceto me dar uma lista de valores de ID de 0-06)

Versão curta:

Estou tentando restaurar um backup de uma instância gerenciada do SQL para outra instância gerenciada do SQL. Estes estão em assinaturas diferentes. Usando o Exemplo 3 daqui , posso pelo menos chegar ao ponto em que vejo a restauração começando em sys.dm_operation_status, mas a mensagem de erro é "Assinatura [destino] não contém [MI SQL de origem]".

Perguntas: Como posso migrar o banco de dados de uma Instância Gerenciada de SQL para outra (em uma assinatura diferente)? Minha solução atual é fazer copy_only para um armazenamento de blobs e restaurar dessa maneira.

Assim que habilitarmos o TDE (em andamento), não poderemos fazer backups copy_only para blob. O que então?

Versão longa:

Recentemente, nossa empresa deu o salto para executar nossa carga de trabalho de produção no Azure em instâncias gerenciadas de SQL (e outras PaaS/IaaS) e isso correu muito bem. Tínhamos uma janela grande o suficiente identificada para que pudéssemos fazer o carregamento inicial com um backup completo, embora eu tenha me familiarizado com os Serviços de Migração de Banco de Dados (DMS).

Mas agora estamos expandindo nossos ambientes dev/test/qa e é claro que agora queremos restaurar da produção para esses ambientes. Para fins de isolamento, cada um está recebendo sua própria assinatura.

Esses comandos funcionam, no sentido de que posso pelo menos ver a operação de restauração iniciar em sys.dm_operation_status, mas falha com um erro. O erro é "Assinatura [destino] não contém [fonte SQL MI]" e me leva a acreditar que as restaurações de assinatura cruzada não funcionarão para nós (embora a região cruzada funcione).

O DMS não parece oferecer suporte ao cenário de uso dos Serviços de Migração de Banco de Dados como origem.

Select-AzSubscription -Subscription $SourceSubscriptionID

$GeoBackup = Get-AzSqlInstanceDatabaseGeoBackup -ResourceGroupName $SourceResourceGroupName `
     -InstanceName $SourceSQLMI `
     -Name $SourceDatabaseName

Select-AzSubscription -Subscription $TargetSubscriptionID

Restore-AzSqlInstanceDatabase -FromGeoBackup `
    -GeoBackupObject $GeoBackup `
    -TargetInstanceDatabaseName $TargetDatabaseName `
    -TargetInstanceName $TargetSQLMI `
    -TargetResourceGroupName $TargetResourceGroupName

Alguma dica, ideia? Estou disposto a usar versões prévias dos vários Azure PowerShell, se necessário, embora não tenha encontrado nada que indique que é diferente lá.

POSSÍVEL SOLUÇÃO

Recebi um link de um de nossos contatos da Microsoft que parecia indicar que você pode criar uma instância gerenciada na mesma assinatura, restaurá-la e depois mover a instância gerenciada para outra assinatura. Eu não tentei isso, então eu não sei. O link que eles forneceram estava aqui , embora eu tenha minhas dúvidas sobre sua eficácia.

Então, nossa equipe de dados pediu ajuda para resolver um problema que eles tinham. Acabei rastreando alguns dados realmente fora de alcance (1/1/0001) e uma função DATEDIFF que eles estavam usando. Enquanto eu resolvi o problema deles, aconteceu que eu realmente não sei o que o 0 se transforma quando usado como eles o usavam.

Eu originalmente pensei que estava mais perto de um estouro de número inteiro em vez de um verdadeiro erro de conversão, mas não é isso. Eu tentei em uma caixa SQL 2016 com DATEDIFF_BIG e mesmo erro. Eu tenho uma amostra para vocês abaixo para brincarem com o que funciona e o que não funciona.

/** Setup The Sample */
DECLARE @TestValue DATETIME2(7)
SET @TestValue = '0001-01-01 10:30:00.0000000'

/** Conversion Error 
Msg 242, Level 16, State 3, Line 10
The conversion of a datetime2 data type to a datetime data type resulted in an out-of-range value.
*/
SELECT DATEDIFF(MINUTE, 0, @TestValue)

--Also does not work, same error.
SELECT DATEDIFF_BIG(MINUTE, 0, @TestValue)

/** Works */
SELECT DATEDIFF(MINUTE, '1/1/1900', @TestValue)

/** Works */
SELECT DATEDIFF(MINUTE, CAST(0 AS DATETIME), @TestValue)

/** Doesn't Work, you can't cast 0 to a DATETIME2 */
--SELECT DATEDIFF(MINUTE, CAST(0 AS DATETIME2), @TestValue)

/** Works (or no error, which is fine)*/
SELECT DATEDIFF(MINUTE, 0, TRY_CAST(@TestValue AS DATETIME))

Pergunta bônus, já que 0 não funciona em todos os casos para DATETIME2, qual é a alternativa?

O QUE DECIDIMOS FAZER

Então, comecei a recomendar que minha equipe faça o seguinte, já que você vê 0 em muitos exemplos de datemath (primeiro dia do mês etc.). Portanto, recomendo que você faça uma conversão explícita de 0 para datetime e continue como desejar. Isso evitará o erro enquanto ainda estiver funcionando. Então:

DATEDIFF(MINUTE, CAST(DATETIME, 0), <Date>)

Estamos tentando fazer com que o Service Broker trabalhe em nosso ambiente para resolver um caso de negócios. Não sei se o título da mensagem é bom, mas minha dúvida está abaixo. Mas pode não ser uma boa pergunta, então depois disso é o que estamos fazendo e porque eu acho que é a pergunta certa.

Quantas mensagens devem ser enviadas em uma conversa antes de encerrar a conversa?

Queremos usar o Service Broker para atualizar de forma assíncrona uma tabela de resultados. A tabela de resultados é achatada e rápida. Temos triggers nas tabelas base que enviam uma mensagem com sua tabela e chave primária. Temos três filas:

• Baixa latência - o objetivo é de 15 segundos para processar. Ele lida com itens que mudam em relação a um item específico.
• Fila em massa - o objetivo é de 5 minutos para processar. Ele lida quando algo muda que afeta muitas centenas (ou milhares) de itens. Ele divide a lista de itens que foram afetados e os alimenta na Fila de baixa latência adiada.
• Baixa latência diferida - o objetivo é de 30 minutos para processar. Isso processa itens, mas apenas da fila em massa.

Basicamente, se as informações de um cliente forem atualizadas, isso afetará muitos produtos, então isso será enviado para a fila em massa para um processamento mais lento. No entanto, se um produto for atualizado, ele será enviado para a fila de baixa latência.

Reutilizamos conversas semelhantes ao blog de Remus Rusanu http://rusanu.com/2007/04/25/reusing-conversations/ , com a exceção de que fazemos isso com base no módulo da chave primária. Isso tem o benefício colateral de ajudar na desduplicação de chaves primárias.

Então, estamos reutilizando as conversas e estamos dentro das nossas diretrizes. Com dois threads, consegui gravar 125 mensagens/segundo (queda artificial de vários milhares de mensagens), o que é mais do que capaz de acompanhar a produção (est. 15 mensagens/s).

No entanto, o problema que estamos enfrentando é que, após um período de tempo, ~4 horas ou 120 mil mensagens, começamos a ver blocos e alta contenção no sysdesend e na tabela de filas. As fechaduras são LCK_M_U e são fechaduras KEY. Às vezes, o hobt resolve para sysdesend e outras vezes para a tabela de fila específica (queue_).

Temos um processo em vigor que encerrará as conversas após 24 horas ou 30 minutos de inatividade, podemos apenas aumentar o tempo antes de alternar entre as conversas.

Estamos usando o SQL 2016 Enterprise (13.0.4001.0)

1. Disparar Incêndios (enviar para baixa latência ou em massa)
2. Procure ou crie um identificador de conversa.
3. Enviar mensagem
4. Procedimento ativado em fila
5. Atualizar tabela de resultados

O processo de limpeza é executado a cada 10 minutos para ver se há conversas ociosas. ltd os encontra mais de três vezes seguidas, marca-os como inativos e encerra as conversas.

Por favor, deixe-me saber se há quaisquer detalhes adicionais que possam ser benéficos. Não tenho muita experiência com Service Broker, então não sei se nossas mensagens/s são baixas, altas ou indiferentes.

ATUALIZAR

Então, tentamos novamente hoje e encontramos o mesmo problema. Alteramos a vida útil da conversa para 2 horas e isso não teve efeito. Então, implementamos o truque 150, que apresentava o mesmo problema.

Toneladas de espera em SEND CONVERSATION, aguardando sysdesend. Alguém tem mais alguma ideia?

ATUALIZAÇÃO 2

Executamos o teste por mais tempo hoje e, em um dos períodos de amostra de 17 minutos, processamos 41 mil mensagens em 4 identificadores de conversa. Conseguimos acompanhar, exceto no final, quando os bloqueios no sysdesend e na tabela de filas se tornaram demais, e começamos a ficar para trás antes de pará-lo. Parece que não temos problemas para processar mensagens, sem que as coisas entrem na fila: podemos retirá-las e processá-las pelo menos 5x essa velocidade. Nossa velocidade parece ser limitada com base na adição de mensagens.

Em um teste posterior, removemos um dos gatilhos que representavam 80% das mensagens. Mesmo com essa carga muito reduzida, começamos a ver as mesmas esperas.

ATUALIZAÇÃO 3

Obrigado, Remus, pelo seu conselho (e obrigado por postar artigos tão excelentes no blog sobre o assunto, eles foram fundamentais para chegar a este ponto).

Corremos de novo hoje e nos saímos melhor (já que passamos mais tempo antes de ver as esperas e ainda mais antes de nos aleijar). Então, os detalhes.

Nós mudamos:

• Aumentou o número de conversas mantidas por thread de 1:1 para 2:1. Basicamente, tínhamos 8 identificadores de conversa para 4 threads.

• consolidou a fila em massa (porque uma mensagem de entrada pode significar centenas de mensagens de saída) para consolidar em menos mensagens maiores.

Observações sobre esta tentativa:

• desabilitando o procedimento de ativação da fila de destino. nenhuma alteração no bloqueio (esperamos 5 minutos) e as mensagens foram enviadas para sys.transmission_queues.

• monitorando sys.conversation_endpoints. Esse número passou de 0 a 13K muito rapidamente e depois aumentou mais lentamente ao longo do dia, terminando em cerca de 25K após ~ 5 horas. O bloqueio não começou a ocorrer até atingir 16K+/-

• Entrei no DAC e executei os comandos DBREINDEX para as filas, embora a partir de uma consulta, os registros fantasmas nunca tenham ficado acima de 200 ou mais antes da limpeza chegar e reduzir a contagem para 0.

• sysdesend e sysdercv tinham contagens idênticas de 24.932 quando terminei o teste.

• processamos ~310 mil mensagens em 5 horas.

Fomos tão longe antes que as coisas desmoronassem que eu realmente pensei que conseguiríamos desta vez. Amanhã tentaremos forçar as mensagens a passarem pelo fio.