jcolebrand's questions

Cenário:

Nós escrevemos software de banco on-line e, por enquanto (devido a decisões de design herdadas), estamos usando o Quartz 2.2 agora como um sistema de filas para executar algumas operações de longo prazo. [Vamos deixar de lado a discussão sobre se é a ferramenta certa, funcionou bem por muitos anos até atualizarmos para 2.2]

Parte desse quartz.net possui as seguintes tabelas (relacionadas) para esquema: https://gist.github.com/jcolebrand/8695603

Portanto, o processo é inserir registros nesta tabela, digamos, 80 mil registros. (Tenho três replicações do quartz.net atendendo a três configurações diferentes, uma com 80k de registros, outra com 50k, outra com 280k, então varia). Nós os inserimos de alguma outra tabela que é a tabela de registro, então reconstruir esta tabela não é uma perda terrível. O problema é descrito abaixo.

Eu tenho uma ferramenta que pode agendar essas tarefas em massa (a maioria das quais é única e acontecerá de duas semanas a vinte anos no futuro, novamente, trata-se do banco de dados e não das opções de arquitetura) e posso depurar a etapa completamente, veja as linhas serem inseridas na tabela sem preocupação. Posso monitorar a tabela e ver se eles são inseridos. Eu então volto 30 minutos depois (bem, esta parte varia. Não é determinístico quando eles desaparecem) e verifico se os registros estão faltando.

De 80k em uma instância, estou perdendo aproximadamente 2.700 registros. E quando executo minha ferramenta, vejo todos eles sincronizados e, depois de algum tempo, eles evaporaram novamente.

Aqui estão as coisas que eu tentei:

• verificando o relatório de todas as transações no SSMS
• verificando o relatório de todas as transações de bloqueio no SSMS
• deixar meu aplicativo de agendamento aberto por muito tempo (caso, por alguma mágica, houvesse uma transação aberta e não confirmada)
• reiniciando o aplicativo de serviço do Windows Quartz.net mantendo o banco de dados
• inserindo registros com o serviço windows quartz.net desabilitado

Coisas que não experimentei:

• reiniciando o servidor SQL
• minhas consultas não usam "with(nolock)" [ouvi dizer que isso é ruim para o dia-a-dia]

Coisas que acho que devo fazer e não sei como:

• execute o SQL Profiler na instância e monitore as instruções "excluir"
• mágica para determinar se há uma transação não confirmada
• sacrificar unicórnios
• telefone para um amigo
• duplo diário

@@versão:

Microsoft SQL Server 2008 R2 (SP2) - 10.50.4000.0 (X64)
28 de junho de 2012 08:36:30
Copyright (c) Microsoft Corporation
Standard Edition (64 bits) no Windows NT 6.1 (Build 7601: Service Pack 1) (Hypervisor )

EDITAR 2014-01-30

É imperativo, por razões internas, que eu possa demonstrar precisamente por que os registros estão desaparecendo, incluindo, entre outros:

• exclusão por um usuário
• transação não confirmada
• deleção pelo próprio Quartz
• alguns outros fenômenos inexplicáveis
• efeito Borboleta
• efeito de gatilho
• unicórnios

Sempre que possível, preciso da instrução específica envolvida na exclusão.

TL;DR

Então, basicamente, o TL;DR é: os registros são inseridos. Por algum período de tempo de até pelo menos 30 minutos, o registro é definitivamente exibido em consultas na tabela. Depois de algum tempo, os registros não são mais exibidos em consultas na tabela.

O que da? O que estou deixando passar? Como você perfilaria isso EM PRODUÇÃO para ver o que está acontecendo aqui?

Eu tenho meu tipo de código segregado como "blocos coerentes" que posso inserir em um "script de configuração" mais longo repetidamente, e um dos padrões que estou usando é este:

CREATE TABLE #WidgetSetting 
(
    WidgetID bigint not null,
    Name nvarchar(100) not null,
    Value nvarchar(max) not null,
    CreateDate datetime not null
)

INSERT VALUES

MERGE TABLES

DROP TABLE #WidgetSetting

Mas agora o SSMS está reclamando que o objeto já existe na próxima vez que o CREATE TABLEdisparo. O que da?

Acho óbvio que vou ter que declarar a tabela uma vez no início do script, truncar em vez de descartar, mas é frustrante, naturalmente, não poder simplesmente descartar a tabela e usar o mesmo nome novamente.

Contexto: Algumas de nossas restrições de coluna padrão foram geradas sem nomes explícitos, portanto, obtemos nomes divertidos que variam de servidor para servidor, como:DF__User__TimeZoneIn__5C4D869D

Eu preferiria que todos eles fossem gerenciáveis ​​com uma nomenclatura consistente DF_Users_TimeZoneInfo, para que possamos garantir que as restrições apropriadas existam em futuras tabelas de destino (como na comparação do RedGate ou mesmo apenas visualmente)

Eu tenho um script que funciona principalmente para o que eu quero:

select 'sp_rename N''[' + s.name + '].[' + d.name + ']'', 
   N''[DF_' + t.name + '_' + c.name + ']'', ''OBJECT'';'
from sys.tables t
    join
    sys.default_constraints d
        on d.parent_object_id = t.object_id
    join
    sys.columns c
        on c.object_id = t.object_id
        and c.column_id = d.parent_column_id
    join sys.schemas s
        on t.schema_id = s.schema_id
WHERE d.NAME like 'DF[_][_]%'

Mas isso apenas me dá um conjunto de resultados, e não algo que eu possa realmente passar para um executivo ou algo assim.

Como posso fazer isso para executar esses sp_renamescripts sem ter que recorrer a copiar todos os elementos retornados e colá-los em uma nova janela de consulta e executá-los novamente? Tentando salvar o máximo possível de pressionamentos de tecla para que eu possa corrigir isso em muitos ambientes.

Método:

Abra SSMS. Encontrar mesa. Restrições abertas. Encontre o nome da restrição. Clique com o botão direito, renomeie. Dê um novo nome.

EXPLODIR. (bem, apenas falha, pelo menos)

Portanto, podemos fazer login do Windows ou modo misto, mas podemos configurar o SQL Server para usar apenas logins internos e bloquear todos os logins do Windows?

A única solução é adicionar todos os possíveis logins do Windows e defini-los com privilégios restritos como um procedimento preventivo (ou reativo)?

Temos uma instância de banco de dados simples com dados suficientes nos bancos de dados para mantê-la útil e podemos usá-la para fins de demonstração, e quero colocar uma cópia dela no meu laptop para poder usá-la no trabalho de desenvolvimento quando Não estou no escritório. (As instâncias regulares do banco de dados de desenvolvimento têm cerca de 150 GB, esta instância tem 3 GB)

Qual é o método mais repetível/programável para recriar a instância no meu laptop? Tenho certeza de que terei que executar o instalador novamente para SqlServer2008 e configurar uma instância, mas depois disso ... estou pensando em poder descartar meus bancos de dados antigos a cada mês ou mais e copie todas as coisas novas para o meu laptop, pois minha instância não será alterada nem no sistema de demonstração nem no laptop. Mas os próprios bancos de dados serão atualizados, com atualizações nos sprocs e similares.

Eu considerei fazer o script de todos os "arquivos de banco de dados; adicionar arquivos de banco de dados {caminho}" e mantê-los em um arquivo de lote executável de algum tipo, e então posso "eliminar, excluir, copiar, adicionar", mas me perguntei se havia era uma maneira melhor do que apenas xcopy e batch?

Estou tentando fazer isso de forma barata (nem sempre tentamos fazer as coisas de forma barata), então não estou particularmente interessado em produtos RedGate ou similares. Eu quero algo que eu possa manter facilmente em um editor de texto para mim.

Sou um desenvolvedor que herdou uma caixa quase funcional, fazendo a maior parte do que preciso. Exceto que o nome da máquina ainda é o do antigo dev (nós o chamamos de "{username}-dt" ou "{username}-lt" para facilitar o id na rede) e quero renomeá-lo de old-username para meu-nome de usuário.

Naturalmente, isso também afetará o SQL, então pensei em pedir conselhos mais experientes sobre o que preciso fazer antes de renomear minha máquina. Sei que existem alguns sprocs "sp_" a serem executados, mas quando os executo? Preciso reiniciar minha caixa antes ou depois e preciso de um certo nível de privilégio? Isso destruirá qualquer autenticação baseada em Windows existente na caixa (essas contas são todas contas AD de qualquer maneira)?

Para começar: meu título é péssimo, então me ajude a descobrir um novo?

Não posso postar todo o SQL aqui (mais de 30 mil caracteres), então colei no pastebin.com

O problema:

Recebo um arquivo XML do qual extraí alguns registros e preciso extrair alguns dados dos registros e criar outra tabela a partir dele. Os registros são para um evento acontecendo e acontecendo, e incluí dados de amostra no pastebin para recriação. Sem ver os dados é meio difícil de explicar. Forneci todos os dados que tenho da minha amostra de importação, que devem ser suficientes para criar o aplicativo, mas não estou obtendo mais informações do que as mostradas nos dados.

Vou dar a você um momento para olhar os dados para que isso faça sentido.

Então, o que preciso fazer é o seguinte: para cada evento "desligado", preciso combiná-lo com o próximo evento "ligado" e preciso ter duas tabelas no final, uma tabela para "eventos históricos" e uma tabela para "eventos atuais". No entanto, se eu conseguir "eventos históricos" construídos corretamente, posso descobrir como obter "eventos atuais" disso.

Regras do negócio:

Se dois ou mais eventos "desligados" forem coletados antes de um evento "ligado", mantenha o evento "desligado" mais antigo. Se dois ou mais eventos "ligados" forem coletados antes de um evento "desligado", mantenha o evento "ligado" mais recente. Se houver um par completo, coloque-os na tabela histórica. Se houver um evento "off" e não um evento "on", coloque-o na tabela atual (portanto, se eu quiser continuar inserindo/excluindo desta tabela, tudo bem também). Se já houver um evento "desligado" na tabela atual, posso pegá-lo e movê-lo para a tabela histórica para que um evento "ligado" seja lido (isso precisará ser implementado posteriormente, mas se eu conseguir que os pares correspondam inicialmente eu poderei ir adiante por enquanto.

Eu acho que é basicamente isso para a lógica. Meus pensamentos são descobrir como fazer isso em SQL ou enviá-lo para um aplicativo escrito em C# e fazê-lo com algumas listas temporárias em C# e construir o que preciso usando para... a próxima lógica. Isso pode ser infinitamente mais fácil em C#, mas tenho a sensação de que o SQL pode fazer esse trabalho tão facilmente quanto o C#, então precisava da ajuda dos gurus do dba.

As consultas que já fiz não funcionam , mas foi aí que comecei antes de ir para casa na sexta-feira, e venho refletindo sobre isso desde então e construindo um exemplo de problema que posso postar online (e toda essa vida coisa também, você sabe). Os dados são dados ao vivo e exatos, exceto os IDs sendo anonimizados e os campos de texto alterados para algo simples de se trabalhar.

Aqui está uma planilha mostrando aproximadamente como quero que os dados apareçam no final e como estão agora. Existem os dados atuais (com uma linha espaçadora entre cada ID para maior clareza), os dados que estariam na tabela histórica (alinhados com o ID dos dados originais para entendimento) e a tabela atual (novamente alinhados). Espero que isso possa ajudar a esclarecer as regras de negócios. https://spreadsheets.google.com/ccc?key=0AuvCdeHuVU5ddHRCNkpuWHBUREpRajlmLU5VX2xsWnc&hl=en&authkey=COq7y50H

Portanto, o SQL completo, incluindo tabledefs e consultas atuais (muito incorretas), está em pastebin http://pastebin.com/k2f2CLnQ

Ok, para começar, eu estraguei tudo quando criei os bancos de dados, usando um script de criação mais ou menos assim: (quebras de linha artificiais e nomes/caminhos para fins de quebra de linha)

CREATE DATABASE [EXAMPLE] ON  PRIMARY 
( NAME = N'EXAMPLE_Data', FILENAME = N'J:\SQLServer2008\MSSQL.INSTANCE\EXAMPLE.mdf', 
    SIZE = 446046KB , MAXSIZE = UNLIMITED, FILEGROWTH = 10%)
 LOG ON 
( NAME = N'EXAMPLE_Log', FILENAME = N'J:\SQLServer2008\MSSQL.INSTANCE\EXAMPLE.ldf', 
    SIZE = 664505KB , MAXSIZE = 2048GB , FILEGROWTH = 10%)
GO

porque criei um script a partir de um banco de dados de desenvolvimento existente e só queria fazer algo funcionar. Eu estraguei tudo quando não mudei meus tamanhos para algo razoável (como 4096KB) e agora não posso reduzir o arquivo de log abaixo de aproximadamente 600 MB.

Eu sei onde errei, mas como faço para corrigir isso facilmente?

No SQL Server (2008 neste caso), como posso reduzir rapidamente todos os arquivos, log e dados, para todos os bancos de dados em uma instância? Eu poderia passar pelo SSMS e clicar com o botão direito em cada um e escolher Tarefas -> Encolher, mas estou procurando algo mais rápido.

Eu criei scripts de alguns scripts "Criar banco de dados" e esqueci que eles tinham tamanhos de balão para padrões e não precisam de muito espaço reservado para esses arquivos neste projeto.

Eu tenho uma instância que realmente não tem nada nela, ela apenas foi instalada (foi destinada a um projeto, mas nunca foi feita neste servidor, o projeto foi feito em duplicata em outro servidor), então, como eu tenho a instância, Eu quero renomeá-lo.

Isso pode ser feito? Como eu faria isso?

Uma investigação mais aprofundada (pesquisando no Google) diz que não é realmente possível. Uma consulta adicional com meus colegas de trabalho diz que é melhor instalar uma instância 2k8 e seguir em frente.