Daniel James Bryars's questions

Eu tenho uma tabela com uma coluna de identidade e quero reservar um bloco de ids que posso usar para inserção em massa, permitindo que as inserções ainda aconteçam nessa tabela.

Observe que isso faz parte de uma inserção em massa de várias tabelas, onde essas outras tabelas se relacionam a esses ids por meio de um FK. Portanto, eu preciso bloqueá-los para que eu possa preparar os relacionamentos de antemão.

Eu encontrei uma solução que funciona travando a mesa em uma transação e depois faz a nova propagação (que é bem rápida). Mas parece um pouco hacky para mim - existe um padrão geralmente aceito para fazer isso?

create table dbo.test
(
    id bigint not null primary key identity(1,1),
    SomeColumn nvarchar(100) not null
)

Aqui está o código para bloquear (abrir espaço para) alguns ids:

declare @numRowsToMakeRoomFor int = 100

BEGIN TRANSACTION;

        SELECT  MAX(Id) FROM dbo.test WITH (  XLOCK, TABLOCK ) -- will exclusively lock the table whilst this tran is in progress, 
        --another instance of this query will not be able to pass this line until this instance commits

        --get the next id in the block to reserve
        DECLARE @firstId BIGINT = (SELECT IDENT_CURRENT( 'dbo.test' )  +1);

        --calculate the block range
        DECLARE @lastId BIGINT = @firstId + (@numRowsToMakeRoomFor -1);

        --reseed the table
        DBCC CHECKIDENT ('dbo.test',RESEED, @lastId);

COMMIT TRANSACTION;    

select @firstId;

Meu código está processando em lote blocos de dados em pedaços de cerca de 1.000. Tenho cerca de um bilhão de linhas para inserir no total. Tudo está funcionando bem - o banco de dados não é o gargalo, o processamento em lote em si é computacionalmente caro e exige que eu adicione alguns servidores para serem executados em paralelo, então preciso acomodar mais de um processo de "inserção em lote" no mesmo tempo.

Quando crio uma chave mestra de banco de dados para um banco de dados:

CREATE MASTER KEY ENCRYPTION BY PASSWORD = 'Some Long Password'

Esta página da Microsoft recomenda que eu faça backup externo:

http://msdn.microsoft.com/en-us/library/ms174382.aspx

Confirmei por meio de testes que a chave mestra é armazenada quando você faz backup do banco de dados. Já estou fazendo backup do banco de dados, e já estou armazenando a senha com segurança. Então, por que preciso fazer backup da chave mestra também?

(Além disso, já estou fazendo backup da Chave Mestra de Serviço e armazenando fora do local).

Eu tenho um certificado em um banco de dados no Microsoft SQL Server 2008 R2. Desejo obter uma cópia do certificado para gravá-lo em um dispositivo USB e colocá-lo em um cofre. Não quero ter que ir para a própria máquina do servidor sql, quero fazer tudo isso a partir do meu aplicativo cliente que escrevi.

Eu sei como fazer backup de um certificado usando BACKUP CERTIFICATE ( http://msdn.microsoft.com/en-us/library/ms178578.aspx ), mas isso só tem opções para salvar em um ARQUIVO.

Existe outra técnica (talvez usando sys.certificates) que eu possa usar?

Estamos planejando uma atualização para 2014, portanto, se houver uma funcionalidade específica para essa versão, posso usá-la, mas, idealmente, a solução deve funcionar com 2008R2.

Tenho um banco de dados primário em Amsterdã (AMDB) e um secundário em Londres (LNDB). Quero fazer o failover de AMDB para LNDB e vice-versa, sem precisar fazer outro backup completo (porque o banco de dados é muito grande).

De acordo com Alteração de funções entre servidores primários e secundários e Failover para um secundário de envio de logs, tudo isso parece possível. Eu nunca fiz isso antes e vou fazê-lo na produção neste fim de semana. (Farei alguns testes em bancos de dados não prod antes.)

Minha pergunta: devo fazer mais alguma coisa além da documentação da Microsoft para garantir o sucesso? (Gostaria de saber se mais alguém tem alguns truques ou etapas extras que eles executam.) Espero uma resposta tranquilizadora, como "Sim, isso funciona sempre que fazemos isso na produção e é legal", mas também ficarei muito feliz com "Não, não faça isso, certifique-se de fazer x/y/ e z."

Editar: não recomendo que eu use o espelhamento como resposta a esta pergunta - sim, é uma ótima ideia, mas não funciona para nós devido aos custos de licenciamento. Usamos a edição padrão (e isso suporta apenas espelhamento no modo síncrono ). Gostaria de saber se alguém seguiu as etapas da documentação do MS em prod ou se existe uma alternativa melhor que um dba "experiente" usaria.

Ao criar um procedimento armazenado no SQL Server, você pode se referir a tabelas que não existem. Mas, se a tabela existir, qualquer coluna à qual você fizer referência no procedimento deverá existir nessa tabela ( Resolução de Nome Adiada ).

É possível instruir o SQL Server a adiar a resolução de nomes de todas as tabelas referenciadas em um procedimento, independentemente de existirem ou não? Eu quero manter a verificação geral da sintaxe, portanto, mesmo que fosse possível, hackear a definição do procedimento armazenado em uma tabela do sistema não é uma opção.

Espero que minha solicitação para fazer isso possa parecer um pouco estranha , então aqui está um histórico: Eu gero automaticamente definições de tabela e procedimentos armazenados de um aplicativo escrito em C# e é muito difícil para mim alterar o código para ordenar as alterações conforme as necessidades do SQL eles. Meu código "garante" que o esquema é consistente em uma transação, mas atualmente não posso garantir que as colunas da tabela sejam definidas antes de eu definir o procedimento armazenado que as referencia.

Abaixo está um exemplo canônico do SQL criado pelo C# que "ilustra" o problema que estou tentando resolver.

--Say this table already exists.
CREATE TABLE myTable
(
    a NVARCHAR(MAX)
)
GO

--My C# code creates something like this
BEGIN TRAN 
GO

--the stored procedure gets generated first.
CREATE PROCEDURE mySproc
AS
BEGIN
    SELECT a,b FROM myTable
END

--then the table update
ALTER TABLE myTable
    ADD b nvarchar(MAX)

COMMIT TRAN 

É possível corrigir isso no código C #, mas espero um simples ajuste "mágico" que possa fazer no SQL. Isso vai economizar muito tempo para mim.

É bastante simples corrigir um único usuário SQL órfão para um login usando:

EXEC sp_change_users_login 'Auto_Fix', 'usuário'

Eu poderia fazer um script disso, mas existe um procedimento armazenado existente que tenta automaticamente corrigir todos os usuários órfãos em um determinado banco de dados?