Paul's questions

Como você retorna o nome da conexão via TSQL? Isso é visível no SSMS por meio da janela de propriedades. Por exemplo, se você tiver um alias DNS "ProductionServer" para uma máquina chamada "SRVR0001" e ainda tiver um registro de servidor local para isso chamado "Live Production" e, em seguida,

1) Abra uma nova consulta fornecendo um nome de servidor de "ProductionServer" então o nome da conexão será "ProductionServer" 2) Clique com o botão direito do mouse no registro local e selecione nova consulta, o nome da conexão será "Live Production"

E, claro, em ambas as instâncias select @@SERVERNAMEretornará SRVR0001.

Isso é semelhante, mas diferente, a estas perguntas:
https://stackoverflow.com/questions/16088151/how-to-find-server-name-of-sql-server-management-studio
https://stackoverflow.com/ questions/129861/how-can-i-query-the-name-of-the-current-sql-server-database-instance

Prevejo que a resposta pode ser que esta é uma propriedade local mantida pelo SSMS e, portanto, não pode ser retornada pelo TSQL executado no SQL Server.

Recentemente, tive meu primeiro gosto do erro " Consultas heterogêneas exigem que as opções ANSI_NULLS e ANSI_WARNINGS sejam definidas para a conexão ". Quase todos os recursos que encontrei neste site e em outros lugares lidavam com isso ocorrendo em um procedimento armazenado.

Meu cenário específico é um aplicativo e banco de dados fornecidos pelo fornecedor, posso alterar o banco de dados, mas não o aplicativo. Eu criei uma visão no banco de dados para outro servidor (através de um servidor vinculado), mas quando tentei usar isso no aplicativo, recebi o erro mencionado acima. Eu usei o SQL Profiler para provar que o aplicativo abre suas conexões com ANSI NULLs e WARNINGS OFF. Eu usei o SSMS para provar que o link funciona com os valores padrão. Mas ao contrário de um SP eu não posso definir ANSI WARNINGS em uma view.

Eu configurei ANSI WARNINGS no banco de dados como um teste, o aplicativo agora funcionou, mas não pude pagar um teste de regressão completo do aplicativo, portanto, esta solução não funciona. Eu também tentei muitas maneiras diferentes de implementar o servidor vinculado, incluindo criar uma conexão ODBC no servidor e usá-la. Mas é como se o aplicativo estivesse definindo explicitamente ANSI WARNINGS para off.

Não tenho certeza se importa, mas o servidor de origem é SQL2000 e o servidor remoto era SQL2008R2.

Um de nossos desenvolvedores criou uma visão em que uma das colunas selecionadas foi encapsulada em uma função RTRIM. Essa mesma coluna na tabela subjacente tem um índice não clusterizado.

Agora, as consultas usando essa exibição e uma instrução where nesta coluna estão falhando ao usar o índice devido ao RTRIM. Eu preciso que a saída da visualização seja consistente, pois infelizmente esse desenvolvedor não está mais conosco e não consigo ler seu código.

Quais são algumas opções de otimização? Eu tenho um, mas espero que seja melhor.

Estou tentando escrever um CTE recursivo para explorar um sistema de fluxo de trabalho. Infelizmente, estou recebendo erros máximos de recursão devido a loops:

with cteActs as
 (
  select a.id as [id], aa.TASKNEXTID as [childid]
  from TASK a
  inner join TASKNEXT aa on a.id = aa.TASKPARENTID
  where a.id != aa.TASKNEXTID
  ),
 cteNext as
(
    select a.*
    from cteActs as a
    where a.id=42
    union all
    select a.*
    from cteActs as a
    inner join cteNext as n on a.id = n.childid
    )
select * 
from cteNext

A tabela TASKé uma lista de tarefas em que 42 é "Iniciar trabalho", por exemplo. TASKNEXTvincula 42 a possíveis subtarefas na TASKtabela. por exemplo, pode ligar 42 a 43 que pode ser "Encontrar materiais", por exemplo

ID, name, childID
42, Start job, 43
42, Start job, 44
43, Find materials, 200
44, Report to boss, 201
201, Discuss with boss, 202
202, Receive payment, 44

Acho que a recursão está morrendo porque 44>201>202>44 cria um loop do qual a consulta não escapa. Como posso permitir isso? A maioria dos exemplos/tutoriais que li assumem um relacionamento estrito pai>filho, onde um filho nunca pode ser o pai de algo em sua própria árvore superior.

O que estou tentando obter é uma lista distinta TASKSde fluxos que começam na tarefa 42, ou onde eu escolher.

Esta é a iteração 2 que pode funcionar, mas é tão lenta:

  select a.id as [id], aa.ACTIONACTIVITYID as [childid]
   into #temp
  from TASK a
  inner joinTASKNEXT aa on a.id = aa.TASKPARENTID
  where a.id != aa.TASKNEXTID    
  create clustered index [hello] on #temp (ID ASC)
  create nonclustered index [hello2] on #temp (childid ASC)
  ;
with cteNext as
(
    select a.*, 
    cast(',' + cast(a.ID as varchar(10)) + ',' as varchar(max)) as Path,
    0 as [cyc]
    from #temp as a
    where a.id=42
    union all
    select a.*,
    n.Path + cast(a.ID as varchar(10)) + ',',
         case when n.Path like '%,'+cast(a.ID as varchar(10))+',%' 
           then 1 
           else 0 
         end as [cyc]
    from #temp as a
    inner join cteNext as n on a.id = n.childid
    where n.cyc = 0
    )

select   id, childid
from cteNext
where cyc =0

Plano de execução

Estou executando um aplicativo de produção antigo que possui um banco de dados de back-end hospedado no SQL2008R2 no modo de compatibilidade 80 (SQL2000). Quando executo bits de TSQL para visualizar os planos de execução reais, o SSMS está me fornecendo índices sugeridos que são legais apenas para SQL2005+, por exemplo, aqueles com colunas incluídas. Como posso evitar que isso aconteça? Gostaria de ver os índices sensatos que ele pode sugerir.

NB: O modo de compatibilidade não pode ser alterado. Sim, estamos substituindo o aplicativo, isso eliminará totalmente a necessidade do banco de dados, mas não por algum tempo.

Obs: Já tentei, o SSMS está configurado "Script for server version" como SQL Server 2000.

Esta questão me fez pensar: ROW_NUMBER() OVER (PARTITION BY B,A ORDER BY C) não usa índice em (A,B,C) Nela, o questionador afirma que duas funções fornecem o mesmo conjunto de resultados, mas não t porque eles têm linhas idênticas, mas estão sempre em ordens diferentes (e consistentes).

A ordem de um conjunto de resultados faz parte do conjunto de resultados? Wikipedia implica não (mas não determina fortemente uma resposta, nem fala de uma posição de autoridade):

https://en.wikipedia.org/wiki/Result_set

É

Sector  Name
A   Alpha
B   Beta

o mesmo resultado definido como

Sector  Name
B   Beta
A   Alpha

Eu pessoalmente só trabalho com SQL Server, a resposta muda por plataforma? A resposta é apenas uma questão de opinião? (Em caso afirmativo, dê respostas apenas de fato ou de consenso por órgãos profissionais de qualquer forma - não sua opinião pessoal, por favor)

É possível no SQL Server definir agrupamento em linhas individuais em uma tabela (em oposição a coluna, banco de dados ou servidor)?

Se não, talvez alguém saiba se esse é um recurso planejado para o SQL Server 2016?

O único problema que isso resolve é a curiosidade entre dois colegas.

Normalmente, ao fazer uma restauração de um banco de dados de um servidor de produção para um servidor de não produção, usarei a opção WITH REPLACE, pois quando esqueço, recebo um erro sobre o backup do log final.

De acordo com o MSDN , eu realmente deveria fazer backup do meu log final antes de restaurar:

Se o banco de dados estiver online e você planeja executar uma operação de restauração no banco de dados, comece fazendo backup do final do log. Para evitar um erro em um banco de dados online, você deve usar a opção … WITH NORECOVERY da instrução BACKUP Transact-SQL.

Quais são alguns perigos ou desvantagens da maneira como estou fazendo isso? Por que fazer backup do registro final é uma vantagem para mim?

Estou usando o SQL Server 2008R2, mas presumo que essa consulta seja relevante para a maioria das versões mais recentes do SQL Server, portanto, não a marquei como tal inicialmente.

O cenário é que os desenvolvedores usaram um objeto de servidor vinculado ServerMpara alcançar ServerST. Este servidor vinculado foi configurado como um tipo "SQL Server" usando um login de domínio que existe como login em ServerST.

Agora, os desenvolvedores exigem que esse objeto de servidor vinculado (chamado ServerST) seja reconfigurado para apontar para ServerAR(mesmo que o objeto confuso ainda seja nomeado ServerST). Isso permite que eles economizem tempo reescrevendo muito código, tempo que eles não têm.

Agora posso criar um novo servidor vinculado ServerMdo tipo "Outra fonte de dados" e fornecer uma string de conexão que funcione. No entanto, uma consulta no servidor vinculado original que levou 5s levou 46s usando o novo servidor vinculado.

Portanto, minha pergunta é como fornecer um servidor vinculado chamado ServerST, que aponta ServerARe opera na mesma velocidade.

Todos os servidores estão no SQL Server 2008 R2 SP2.

O código que uso atualmente para criar o servidor vinculado lento é:

sp_addlinkedserver 'ServerST', ' ', 'MSDASQL', '', '',  
    'Driver={SQL Server};Server=ServerST;Database=theDB;Uid=link_ServerM;Pwd={P@ssw0rd};'

Nesta pergunta: https://stackoverflow.com/questions/18445825/how-to-know-status-of-currently-running-jobs

Esta resposta foi proposta:

SELECT sj.name
   , sja.*
FROM msdb.dbo.sysjobactivity AS sja
INNER JOIN msdb.dbo.sysjobs AS sj ON sja.job_id = sj.job_id
WHERE sja.start_execution_date IS NOT NULL
   AND sja.stop_execution_date IS NULL

No entanto, para um dos meus servidores, há uma entrada que data de 10 meses atrás. Procurar no SQL Agent Job Activity Monitor mostra que não há trabalhos em execução. Olhando em msdb..sysjobs mostra apenas 3 trabalhos. Alguém pode explicar esse fenômeno?

A linha órfã tem NULLs para queued_date, stop_execution_date, job_history_id e next_scheduled_date. Resto dos valores parecem razoáveis.

O chefe pediu uma lista de nomes de banco de dados junto com o tamanho e o nome da última pessoa a usar esse banco de dados. Encontrei recursos para quando um banco de dados foi acessado pela última vez, mas por quem. Como eu resolveria isso?

SQL2008R2 sendo usado e até agora eu tenho isso:

exec sp_MSForEachDB '
use ?
select ''?'', (SUM(df.size)*8)/1024 as ''Size (MB)''
from sys.database_files as df
'

É aceitável que o aspecto da última pessoa da resposta seja impreciso ou vago. ou seja, desde que seja alguém que tenha se aproximado vagamente recentemente, está "OK".

Recentemente eu estava lendo esta postagem no blog: Link

que contém esta seção:

Escolhendo um índice agrupado

Existem algumas estratégias para escolher seus índices clusterizados; um dos mais fáceis e melhores é adicionar outra coluna de tipo de dados datetime e usar essa coluna para seu índice clusterizado. Aqui está o que você precisa fazer:

1. Adicione a coluna como tipo de dados datetime

2. Eu costumo chamá-lo de data

3. Defina o valor padrão como GetDate().

4. Torne-o não nulo.

5. Crie seu índice clusterizado nele antes de inserir dados em você.

Minha pergunta é se isso criaria dois valores idênticos para a data? Essa resposta muda se o paralelismo estiver em uso? (Assume valor nunca especificado, sempre vem de GetDate())

Acredito que estou correto ao presumir que não importaria devido à adição do exclusivo de bastidores, certo? Mas estou interessado de qualquer maneira.

Estou perguntando de uma perspectiva do SQL2008R2, mas estaria interessado se a resposta for diferente para qualquer versão do SQL Server de 7.0 para cima.

Gostaria de saber se existem perigos ou precauções relevantes antes de alterar o endereço IP de uma caixa do SQL Server 2008 R2.

Construímos um PC virtual com Windows Server 2008 R2 e SQL Server 2008 R2. O objetivo desta máquina é executar um trabalho que restaura um arquivo de backup (copiado por um servidor diferente), manipula-o, faz backup novamente e depois o copia para outros servidores. Nós o executamos algumas vezes em nossa DMZ de teste/desenvolvimento e agora estamos considerando a implantação.

A opção mais simples seria re-IP. O nome do servidor permaneceria intacto. Meu problema é que um colega sugeriu que isso não é seguro (para re-ip um SQL Server). Minha pergunta é

a) Isso é verdade para o SO e SQL que estou usando? (Win 2008 R2 e SQL 2008 R2?)

b) É verdade para quaisquer outras combinações de SO e/ou SQL?

c) Há algo especial que devemos fazer em preparação?

Minha pesquisa até agora indica que tudo ficará bem, mas confio mais no pessoal do DBA StackExchange do que no pessoal do MSDN social.

http://social.msdn.microsoft.com/Forums/sqlserver/en-US/9844e0c1-b57e-4e0c-88cf-7cb51cc55e07/change-sql-server-ip-address

http://www.sqlservercentral.com/Forums/Topic1164450-391-1.aspx

Existem duas opções diferentes no SQL Server moderno para verificação de página; sendo detecção de página rasgada e soma de verificação . Nenhum também é, obviamente, uma opção.

Acredito que Checksum foi introduzido no SQL Server 2005 e que atualizar ou restaurar um banco de dados de uma versão anterior manteria seu método de verificação de página anterior. ou seja, não houve atualização implícita.

O problema envolvido é que temos um banco de dados de produção que entrou em produção usando o SQL Server 2000 e, desde então, mudou para um servidor SQL Server 2008 R2. A verificação de página está definida como Nenhuma quando eu esperava que fosse Detecção de página rasgada . Voltando a esse período de tempo, parece que o banco de dados foi originalmente desenvolvido no SQL Server 7.0 e depois migrou para o SQL Server 2000 e isso pode explicar o resultado observado.

Eu queria saber quando Torn Page Detection e Checksum se tornaram um recurso do SQL Server e como eles se comportaram quando migrados ou atualizados para versões mais recentes.

Edit: Resumindo algumas das respostas:

Há uma pequena discrepância sobre algumas das datas de quando a Detecção de página rasgada entrou no SQL Server.
Link 1: http://support.microsoft.com/kb/230785
Link 2: http://technet.microsoft.com/en-us/library/aa337525(v=sql.90).aspx

O primeiro link indica SQL 7.0 e o segundo SQL2000. Costumo colocar minha fé na sugestão do SQL7.0 e esse link dois estava confuso por estar desativado por padrão no SQL7.0 e ativado por padrão no SQL2000.

Posso forçar as consultas de um usuário a sempre serem executadas com a dica NOLOCK? por exemplo, eles digitam

select * from customer

Mas o que é executado no servidor é

select * from customer with (nolock)

Esta pergunta não é:
Sobre os vários prós e contras do NOLOCK, respeitosamente. Eu sei o que são, este não é o lugar para discuti-los.