Sean Long's questions

Às vezes, nossos desenvolvedores escrevem uma consulta que usa cursores, mas não os fecha explicitamente. Estou tentando gerar uma lista de objetos ativos no meu banco de dados de produção que usam cursores, mas não os fecham/desalocam explicitamente. Para fazer isso, escrevi uma instrução simples que faz o trabalho, mas é extremamente lenta:

select distinct name, 
            definition
from   SYS.SQL_MODULES 
   inner join SYS.OBJECTS O 
           on SQL_MODULES.OBJECT_ID = O.OBJECT_ID 
where  SQL_MODULES.DEFINITION like '%open%'
   and SQL_MODULES.DEFINITION like '%declare % cursor%'
   and ( SQL_MODULES.DEFINITION not like '%close%' 
          or SQL_MODULES.DEFINITION not like '%deallocate%' )

Atualmente, isso leva algo como 3 minutos para ser executado. Existe uma maneira melhor de obter as informações que estou procurando?

Tenho 2 instâncias do SQL Server instaladas em um servidor: SQL002.

Uma instância é uma instância padrão, SQL2008 R2, e o serviço SQL geralmente não está em execução, exceto para testes específicos.

A outra instância é uma instância nomeada, SQL 2014 (portanto, SQL002/SQL2014). Isso geralmente é executado o tempo todo.

Hoje, um desenvolvedor acabou de me dizer que, quando eles se conectarem ao SQL002 no SQL Server Management Studio, ele se conectará com sucesso. Eu repliquei isso da minha máquina e também vejo uma conexão bem-sucedida, no entanto, quando olho para as propriedades da conexão, ela informa que ela se conectou à instância nomeada.

O que está acontecendo aqui? Existe um redirecionamento que não conheço?

Estou tentando inserir a seguinte string, conforme escrita, em uma tabela:

'affinity mask', 0

No entanto, não consigo descobrir exatamente como preciso escapar das aspas. Ele sempre deseja tratar o , 0como uma coluna separada.

Como posso escapar da vírgula corretamente?

Não tenho certeza da alteração que causou isso (os logs não mostram nada específico), mas desde a tarde de segunda-feira, vejo o seguinte erro repetido:

Login failed for user 'sa'. Reason: An attempt to login using SQL authentication failed. Server is configured for Windows authentication only. [CLIENT: 10.10.220.32]

O IP informado é o SQL Server. Como isso está em andamento, existe uma maneira de descobrir o que está tentando passar nessa credencial? Se eu pudesse obter um nome de aplicativo ou qualquer coisa, provavelmente poderia resolver o problema.

Estou tentando rastrear o que está causando o aumento de alguns tempos de resposta quando os dados são compactados pela compactação de página, quando o sistema não está vinculado à CPU e 95% das respostas apresentam uma diminuição no tempo de resposta.

Então, o que fiz foi rastreá-lo para um único processo acontecendo no sistema e criei o perfil desse processo para determinar quais SPs e UFNs são disparados durante o processo. Meu pensamento original era que eu poderia executar cada SP e UFN isoladamente e dar uma olhada nos planos de consulta para ver onde as varreduras completas estão acontecendo, isso pode exigir que os dados sejam descompactados da compactação e pode causar uma espera para disparar.

Então o que tenho agora é:

• Uma lista de SPs com os parâmetros usados
• O banco de dados no qual os SPs são executados
• Acesso de administrador irrestrito ao sistema para reproduzir o problema
• Um rastreamento de perfil do processo em questão

Como há algo como 35 SPs/UFNs que eu teria que classificar, estou me perguntando qual é a maneira mais eficiente de restringir a causa. Posso inferir que alguns SPs são culpados mais prováveis ​​do que outros pela minha experiência com o sistema, mas gostaria de tentar reduzi-lo de uma forma mais científica. Existem ferramentas ou metodologias que possam me ajudar a descobrir os infratores mais prováveis?

Se eu puder determinar os objetos que são mais lentos quando compactados do que quando não, isso ajudará a informar nossa estratégia em relação à compactação de página.

Eu tenho a necessidade de reiniciar o grupo de serviços do Microsoft SQL Server em um determinado computador, remotamente, por meio de algum tipo de método programático que eu possa inserir em um fluxo de trabalho. Estou procurando a melhor maneira de fazer isso, já vi algumas maneiras diferentes e gostaria de saber se está faltando alguma coisa:

• Use Net Stopand Net Start- Isso funcionaria se eu precisasse apenas reiniciar o SQL Service e não houvesse dependências, não é realmente uma opção se o SQL Server Agent estiver em execução.
• Use SC //<computernameIsso me permitiria algum acesso para servicecontrollerque eu pudesse consultar se há ou não um serviço dependente em execução.
• Use o método .NET Servicecontroller, que me permite criar uma matriz de serviços em execução no computador de destino e, em seguida, iterá-los para interromper o que preciso interromper.

Estou perdendo alguma maneira?

Atualmente eu executo DBCC FREEPROCCACHEquando quero limpar informações do buffer pool entre a execução de consultas SQL. No entanto, eu estava revisando este artigo do Technet que faz referência ao DBCC FREESYSTEMCACHE. Quais caches limpam e não FREESYSTEMCACHElimpam FREEPROCCACHE?

Estou familiarizado com o conceito de fragmentação de índice e como corrigi-lo, mas não tenho certeza de um item específico.

Quando você observa a fragmentação do índice, ela sempre é relatada em termos de Percentage .

• De quanto é essa porcentagem?

Tenho um grupo de cerca de 30 tabelas e quero saber o tamanho físico em disco de todas essas tabelas (mais índices).

Existe uma maneira mais fácil de fazer isso do que por meio da GUI no SQL Server 2008 R2?

Estou executando o SQL Server 2008 R2 SP1, em uma caixa do Windows Server 2008. Eu tenho um script .NET em execução no Visual Studio 2010 que faz o seguinte:

• Entra no banco de dados
• Faz uma mudança
• Itera

O número total de vezes que iterará é 150, no entanto, está parando em 100 conexões e não consigo descobrir o porquê. Eu poderia ajustar meu script para usar apenas um único thread, mas prefiro saber onde estou perdendo uma configuração de conexão máxima, pois isso será mais útil para referência futura.

Aqui está onde eu verifiquei até agora:

• Cadeia de conexão SQL no Visual Studio 2010 (é definido como 1000)
• Propriedades de conexão da instância do banco de dados SSMS (é definido como 0 [infinito] conexões de usuário)
• Pesquisei no Google algumas informações sobre o Server 2008, parece que ele pode lidar com mais de 100 conexões
• Percorreu meu código ao lado SP_WHO2que fornece mais informações sobre conexões lógicas, visto que o número de conexões começa em 52 e os erros de script com o erro "Max Pooled Connections reach" em 152 conexões lógicas.
• Alterada a string de conexão a ser usadaData Source=PerfSQL02;Initial Catalog=Masked;Integrated Security=True;Max Pool Size=1000

Não tenho certeza de onde verificar, sei que tenho muitas partes móveis aqui, mas tenho a sensação de que estou perdendo uma configuração máxima de piscina em algum lugar.

O que exatamente o argumento de restauração "With Replace" faz? Estou procurando restaurar um banco de dados de volta a um ponto inicial regularmente e tenho tentado descobrir se há alguma desvantagem em usar Restaurar com substituição em vez de descartar/excluir o banco de dados inteiramente e restaurá-lo.

"Com substituir" limpará os arquivos de log e redefinirá quaisquer bits que possam ter restado nos bancos de dados do sistema também? Parece que seria muito mais rápido, pois não preciso esperar que o banco de dados termine de cair (o banco de dados em questão tem cerca de 2 TB). Já verifiquei o artigo do TechNet sobre os argumentos de restauração, ele não aborda essa questão específica.

Eu tenho um arquivo .bak criado hoje por outra pessoa, criado manualmente através do SSMS 2008 R2. Estou tentando restaurar manualmente o banco de dados, infelizmente o arquivo não está aparecendo quando vou procurá-lo.

Posso fazer o script do processo de restauração, mas já vi esse problema antes e não tenho certeza do que poderia fazer com que o .bak não aparecesse.

Estou trabalhando com um código antigo que extrai contadores de desempenho e parte do que estou fazendo é garantir que alguns processos sejam executados com eficiência e eficácia.

Agora eu tenho este código que estou olhando:

SELECT REPLACE(RTRIM(OBJECT_NAME), 'SQLServer:', '') AS 'Object',
       RTRIM(counter_name)   AS 'Counter',
       RTRIM(instance_name)  AS 'Instance',
       cntr_value            AS VALUE
FROM   MASTER.dbo.sysperfinfo
WHERE  OBJECT_NAME <> 'SQLServer:User Settable'

Estou propondo substituí-lo por:

SELECT REPLACE(RTRIM(OBJECT_NAME), 'SQLServer:', '') AS 'Object',
       RTRIM(counter_name)   AS 'Counter',
       RTRIM(instance_name)  AS 'Instance',
       cntr_value            AS VALUE
FROM   sys.dm_os_performance_counters
WHERE  OBJECT_NAME <> 'SQLServer:User Settable'

Que é mais rápido e mais compatível com tudo o que é anterior ao SQL 2000. Não há mais ambientes que serão usados ​​nessa execução do SQL 2000, a versão mais antiga que o código acima seria executado é o SQL 2008. Verifiquei se os valores retornados são congruente e funciona no contexto do restante do código.

Minha pergunta é: Quais são as diferenças entre dm_os_performance_counterse master.dbo.sysperfinfo? Preciso extrair dm_os_performance_countersdo contexto Mestre?

Estou trabalhando no SQL Server 2008 R2 e criei uma consulta que reúne e soma o total de arquivos de dados e tamanhos de arquivos de log. No entanto, não consigo descobrir quanto espaço real em disco um único bloco de dados SQL ocupa no disco para que eu possa convertê-lo em algo mais significativo.

Aqui está o roteiro:

DECLARE @DataSize INT
DECLARE @LogSize INT
SELECT @DataSize = SUM(size) from sys.database_files where type_desc = 'Rows'
SELECT @LogSize = SUM(size) from sys.database_files where type_desc = 'Log'
PRINT @DataSize
PRINT @LogSize

Qual é o tamanho de um bloco de espaço? Seria fácil converter essas duas variáveis ​​inteiras em algo mais significativo para um administrador de sistema?

Estou trabalhando na configuração de uma cópia de desenvolvimento de um banco de dados de produção no SQL Server 2008 R2 SP1. Atualmente, o banco de dados ativo está sendo pouco usado por dois desenvolvedores para consultas somente leitura, mas o novo banco de dados também terá atualizações.

Como o banco de dados tem 2,1 TB e levou um total de 3 dias para restaurar e atualizar para a versão mais recente que precisamos para teste, meu plano original era criar um novo conjunto de arquivos de backup e restaurar a partir desses arquivos. Isso me permitiria criar a cópia de desenvolvimento do banco de dados na mesma instância e máquina SQL, sem precisar colocar o banco de dados atual offline.

No entanto, para economizar alguns dias, pensei que seria uma boa ideia copiar os arquivos físicos do banco de dados e anexar a nova cópia do banco de dados. Infelizmente quando tento copiar recebo um erro referente ao bloqueio que o SQL Server coloca nesses arquivos.

Como não posso deixar o banco de dados offline para nada além de transferir os arquivos de log (posso terminar isso antes que as pessoas cheguem pela manhã), existe alguma maneira de copiar os arquivos de banco de dados ativos sem colocar o banco de dados em um estado offline? Ou devo esperar até que as pessoas voltem para casa para fazer isso?

Eu tenho um banco de dados SQL de 2,8 TB (principalmente arquivos de dados, cerca de 400 GB de arquivos de log) que atualmente leva cerca de 9 horas para restaurar. Esse banco de dados é usado para fins de teste e deve ser excluído e restaurado de um backup entre cada execução, para garantir que sempre partamos do mesmo ponto.

Minha pergunta é, o servidor atualmente possui 12 núcleos e 92 GB de RAM, com um subsistema de disco RAID 5 no qual o banco de dados está. Quais áreas geralmente causam gargalos nos processos de restauração do SQL? É o disco, memória ou CPU?