carlo.borreo's questions

Eu preciso excluir muitas linhas de uma tabela pessoas, que é referenciada por muitas outras tabelas como FK.

Se eu tivesse DELETE CASCADE, poderia simplesmente deletar os registros das pessoas, e deletar automaticamente das outras tabelas, mas não gosto da ideia.

Eu gostaria de um script que recebesse como entrada uma instrução DELETE e gerasse todas as instruções DELETE necessárias. Idealmente, ele me diria quantos registros seriam excluídos.

Exemplo:

Entrada:

DELETE FROM persons WHERE person_id < 1000000

Resultado:

-- This would delete 124,345 records
DELETE FROM persons_addresses WHERE person_id < 1000000
-- This would delete 82,954 records
DELETE FROM persons_phone numbers WHERE person_id < 1000000
...
-- This would delete 999,999 records
DELETE FROM persons WHERE person_id < 1000000

Eu tenho um aplicativo escrito em PHP com Laravel que prepara e executa regularmente instruções como esta:

   -- All parameters are varchar(10)
   SELECT c1, c2, c3, c4
      from MyBigTable
     where is_active = 1
       and c1 in (@P1, @P2, @P3, @P4 ... @P250)
       AND c2 is not NULL

Os usuários têm uma grade de big data e podem selecionar muitas linhas (há até um botão para selecionar 'ALL'). Se eles selecionarem 250 linhas, essa instrução é o que acontece. Mas leva mais de um minuto para ser executado, o que é inaceitável.

Tabela MyBigTable tem cerca de 10 milhões de linhas. O plano de execução estimado mostra que 100% do tempo é gasto em uma "busca de índice, não clusterizada". A partir disso, deduzo que a situação não pode ser melhorada usando índices, e que o único problema está no uso de declarações preparadas. (Se você acha que estou errado, é só me avisar). Além disso, entendo que essas declarações preparadas são preparadas, usadas uma vez e descartadas, então não acho que sejam realmente benéficas.

Que recomendação devo dar aos desenvolvedores?

Devo apenas dizer a eles para parar de usar instruções preparadas e codificar os 250 valores na consulta?

Ou devo dar a eles alguma solução alternativa, como o uso de tabelas temporárias (crie uma tabela temporária, insira 250 valores e faça uma consulta em MyBigTable JOINed com temp)?

Ou alguma outra ideia?

EDIT: plano de execução https://www.brentozar.com/pastetheplan/?id=rJ-b2XalH

Eu uso eventos estendidos para identificar consultas lentas, definidas como consultas que levam mais de 2 segundos para serem concluídas, assim:

CREATE EVENT SESSION SlowQueries ON SERVER 
ADD EVENT sqlserver.sql_statement_completed
    (
    ACTION
        (
        sqlserver.client_hostname,
        sqlserver.sql_text,
        sqlserver.database_id,
        sqlserver.tsql_stack,
        sqlserver.username
        )
    WHERE 
        (
        duration > 2000000
        )
    ) 
ADD TARGET package0.asynchronous_file_target
    (
    SET filename='D:\SlowQueries.xel'
    )
WITH 
    (
    MAX_MEMORY=256 KB,
    EVENT_RETENTION_MODE=ALLOW_SINGLE_EVENT_LOSS,
    MAX_DISPATCH_LATENCY=30 SECONDS,
    MAX_EVENT_SIZE=0 KB,
    MEMORY_PARTITION_MODE=NONE,
    TRACK_CAUSALITY=OFF,
    STARTUP_STATE=ON
    );

No entanto, notei nos perfis do SQL Server que um aplicativo PHP/Laravel não está enviando instruções diretamente, mas usando RPC:Completed: elas parecem instruções preparadas, recebendo o argumento em tempo de execução. Como faço para expandir minhas SlowQueries para incluir instruções executadas via RPC:Completed? Tenho 100% de certeza de que as consultas lentas estão acontecendo, mas não relatadas pelo meu evento.

Em um banco de dados em que estou trabalhando, há uma tabela chamada personscom cerca de um milhão de linhas e 60 restrições FK (FK) de outras tabelas (algumas com muitos milhões de linhas) apontando para ela.

Se eu deletar uma linha de persons, demora muitos minutos, o que não seria um problema, mas também mantém a tabela bloqueada, bloqueando assim o banco de dados para todos os processos. No passado, isso fazia com que os usuários relatassem que o sistema estava inativo.

É claro que a situação melhoraria muito se eu adicionasse índices de suporte para todos os FKs (atualmente, apenas 20 das 60 tabelas o possuem). Mas muitos desses FKs são para colunas como modified_by, então todos os índices não teriam outra finalidade, e degradariam o desempenho do sistema nas operações diárias, apenas para ganhar uma melhora em um caso excepcional.

Antes de executar o DELETE, já me certifico de que todas as linhas de referência foram excluídas ou atualizadas. Faço isso manualmente, pois sou fortemente contra o uso do CASCADE.

Não estou considerando a exclusão reversível porque, caso contrário, teria que alterar todo o software que lê a personstabela para pular as linhas excluídas.

Pergunta

Existe uma maneira de (possivelmente temporariamente) alterar o mecanismo de bloqueio da personstabela, para que, mesmo que o DELETE demore uma hora, ele não afete os processos simultâneos?

Aqui está o plano de execução anônimo .

Considerações

• Desabilitar FKs pode ser uma possibilidade. O risco é que outra pessoa crie inconsistência enquanto eu excluo a linha, então não consigo reativar os FKs.

• Linhas a serem excluídas: normalmente uma de cada vez. Ou operação manual ou programada.

• Ponto interessante: não verifiquei o plano de execução imediatamente, mas aparentemente, quase todas as operações custam 0%, exceto 7 casos de "Clustered index Scan (Clustered)" no PK das tabelas de referência; um deles custa 57%, o outro de 1% a 16%. Ainda não entendo por que ele deve verificar um índice clusterizado.

Eu uso eventos estendidos para armazenar erros de banco de dados, assim:

CREATE EVENT SESSION [ErrorCapture] 
ON SERVER 
ADD EVENT sqlserver.error_reported
(
    ACTION
    (
        sqlserver.client_hostname,
        sqlserver.database_id,
        sqlserver.sql_text,
        sqlserver.username
    )
    WHERE 
    (
        [severity] >= (11)
    )
) 
ADD TARGET package0.asynchronous_file_target
(
    SET filename='J:\ServerXmlOutput\ErrorCapture.xel'
)
WITH 
(
    MAX_MEMORY=4096 KB,
    EVENT_RETENTION_MODE=ALLOW_SINGLE_EVENT_LOSS,
    MAX_DISPATCH_LATENCY=10 SECONDS,
    MAX_EVENT_SIZE=0 KB,
    MEMORY_PARTITION_MODE=NONE,
    TRACK_CAUSALITY=OFF,
    STARTUP_STATE=ON
);

Isso me ajuda a rastrear facilmente qual aplicativo os está causando. Eu tenho algo semelhante para rastrear consultas lentas e outros casos especiais. No entanto, notei nos perfis do SQL Server que um aplicativo PHP/Laravel não está enviando algumas instruções diretamente, mas usando RPC:Completed: elas parecem instruções preparadas, recebendo o argumento em tempo de execução. Como faço para expandir meu ErrorCapture para incluir erros causados ​​por instruções executadas via RPC:Completed?

Tenho um SQL Server 2016 SP1 com dados que estou pronto para compartilhar com um parceiro (desenvolvedor), exceto algumas colunas, exemplo:

email varchar(64) MASKED WITH (FUNCTION = 'email()') NULL

Eu dou ao parceiro as credenciais para fazer login na cópia de teste do banco de dados como um determinado usuário, sem permissão de desmascarar. Eu entendo que isso é razoavelmente seguro. Agora, estamos pensando em compartilhar o backup do banco de dados com nossos parceiros, para que eles possam recarregar em seu próprio servidor e ambiente.

Eu provavelmente precisaria ter usuários contidos, para que o parceiro não possa criar novos usuários ou conectá-los a logins existentes (não tenho certeza sobre isso).

CREATE USER user_name WITH PASSWORD = 'strong_password';

Existe uma maneira de compartilhar um backup de banco de dados e ainda confiar que as colunas mascaradas são seguras ou preciso excluir fisicamente os dados?

Eu registrei as consultas mais lentas no meu banco de dados e uma me surpreendeu, aparecendo muitas vezes na lista e demorando muitos segundos para ser executada.

UPDATE books SET last_read='2018-12-31 11:23:45' WHERE book_id='15'

book_id é int identity PK (clustered), last_read é um datetime. A consulta é escrita com o 15 entre aspas simples, exigindo assim uma conversão, mas não posso imaginar que isso seja um grande problema, porque a conversão seria feita apenas uma vez por consulta. Existem 6 índices na tabela, mas a coluna last_read não está envolvida ou incluída em nenhum deles. O PK está no book_id e não tem nada de especial. A tabela é muito central no banco de dados, contém 50 colunas e 400.000 linhas.

O plano de execução estimado me diz:

UPDATE: 0%
Clustered Index Update (on the PK constraint): 100%

A tabela tem um gatilho FOR DELETE, que considero irrelevante aqui, e um gatilho AFTER UPDATE, que diz:

CREATE TRIGGER books_last_update
ON books
AFTER UPDATE
AS
    UPDATE books
    SET last_update = GETDATE()
    WHERE book_id IN (SELECT book_id FROM Inserted)
GO

Isso me mostra que a consulta inicial realmente executa duas consultas, uma após a outra. No entanto, ambas as colunas atualizadas não têm índice definido. Eu gostaria de fazer a consulta inicial executar mais rápido.

Você vê alguma otimização possível?

Receio que, como o gatilho está em UPDATE e, na verdade, atualiza a coluna, ele pode ser acionado várias vezes. É possível? Se sim, como faço para prevenir?

Eu escrevi esta consulta:

UPDATE authors
SET best_seller =
    (
    SELECT TOP 1 book_id
    FROM books
    WHERE books.author_id=authors.author_id
    ORDER BY copies_sold DESC
    )

Eu gostaria SELECTque fosse avaliado uma vez para cada linha em books, para que cada registro de autor contenha seu livro mais vendido. Vamos ignorar:

1. atuação
2. A má ideia de armazenar algo que poderia ser calculado de outras maneiras
3. Caso haja empate entre 2 livros do mesmo autor

Você vê algum outro problema com a consulta ou ela funcionará conforme o esperado em todos os casos?

Recebo resultados que considero inconsistentes com consultas simples.

-- This returns 3 rows
select * from persons
where person_id in (12,13,14)

-- This returns nothing
select *
from documents 
where person_id in (12,13,14)

-- This returns nothing !?!?
select *
  from persons
 where persons.person_id not in ( select documents.person_id from documents )

Há um FK em documents.person_id apontando para people.person_id

Estou esquecendo de algo? Esta é a minha @@versão:

Microsoft SQL Server 2016 (SP1-CU1) (KB3208177) - 13.0.4411.0 (X64) 6 de janeiro de 2017 14:24:37 Direitos autorais (c) Microsoft Corporation Standard Edition (64 bits) no Windows Server 2012 R2 Standard 6.3 (Build 9600) : ) (Hipervisor)

Tenho uma grande aplicação PHP, desenvolvida por uma empresa externa, que está sendo finalizada neste momento; Não posso pedir alterações. Utiliza um banco de dados Microsoft SQL Server 2016, que é acessado por alguns usuários via SSMS, inclusive eu, e por algumas tarefas agendadas em horários específicos do dia. Às vezes encontro conteúdo inesperado em algumas tabelas, e é frustrante porque não sei quando chegou lá. Acabei de descobrir sobre tabelas temporais: saber a data e hora exatas em que um registro muda seria extremamente útil.

É possível adicionar tabelas temporais a 2-3 tabelas-chave no aplicativo, sem alterar o código PHP? Existem riscos de compatibilidade ou desempenhos?

Nos meus logs de erros do banco de dados (produzidos como nesta resposta ), vejo muitas instâncias (centenas por dia) da seguinte consulta:

declare @HkeyLocal nvarchar(18)
declare @ServicesRegPath nvarchar(34)
declare @SqlServiceRegPath sysname
declare @BrowserServiceRegPath sysname
declare @MSSqlServerRegPath nvarchar(31)
declare @InstanceNamesRegPath nvarchar(59)
declare @InstanceRegPath sysname
declare @SetupRegPath sysname
declare @NpRegPath sysname
declare @TcpRegPath sysname
declare @RegPathParams sysname
declare @FilestreamRegPath sysname
selecione @HkeyLocal=N'HKEY_LOCAL_MACHINE'
-- Caminhos baseados em instância
selecione @MSSqlServerRegPath=N'SOFTWARE\Microsoft\MSSQLServer'
selecione @InstanceRegPath=@MSSqlServerRegPath + N'\MSSQLServer'
selecione @FilestreamRegPath=@InstanceRegPath + N'\Filestream'
selecione @SetupRegPath=@MSSqlServerRegPath + N'\Setup'
selecione @RegPathParams=@InstanceRegPath+'\Parameters'
-- Serviços
selecione @ServicesRegPath=N'SYSTEM\CurrentControlSet\Services'
selecione @SqlServiceRegPath=@ServicesRegPath + N'\MSSQLSERVER'
selecione @BrowserServiceRegPath=@ServicesRegPath + N'\SQLBrowser'
-- Configuração de InstanceId
selecione @InstanceNamesRegPath=N'SOFTWARE\Microsoft\Microsoft SQL Server\Instance Names\SQL'
-- Configurações de rede
selecione @NpRegPath=@InstanceRegPath + N'\SuperSocketNetLib\Np'
selecione @TcpRegPath=@InstanceRegPath + N'\SuperSocketNetLib\Tcp'
declare @SmoAuditLevel int
exec master.dbo.xp_instance_regread @HkeyLocal, @InstanceRegPath, N'AuditLevel', @SmoAuditLevel OUTPUT
declare @NumErrorLogs int
exec master.dbo.xp_instance_regread @HkeyLocal, @InstanceRegPath, N'NumErrorLogs', @NumErrorLogs OUTPUT
declare @SmoLoginMode int
exec master.dbo.xp_instance_regread @HkeyLocal, @InstanceRegPath, N'LoginMode', @SmoLoginMode OUTPUT
declare @SmoMailProfile nvarchar(512)
exec master.dbo.xp_instance_regread @HkeyLocal, @InstanceRegPath, N'MailAccountName', @SmoMailProfile OUTPUT
declare @BackupDirectory nvarchar(512)
if 1=isnull(cast(SERVERPROPERTY('IsLocalDB') como bit), 0)
selecione @BackupDirectory=cast(SERVERPROPERTY('instancedefaultdatapath') como nvarchar(512))
senão
exec master.dbo.xp_instance_regread @HkeyLocal, @InstanceRegPath, N'BackupDirectory', @BackupDirectory OUTPUT
declare @SmoPerfMonMode int
exec master.dbo.xp_instance_regread @HkeyLocal, @InstanceRegPath, N'Performance', @SmoPerfMonMode OUTPUT
se @SmoPerfMonMode for nulo
começar
definir @SmoPerfMonMode = 1000
fim
declare @InstallSqlDataDir nvarchar(512)
exec master.dbo.xp_instance_regread @HkeyLocal, @SetupRegPath, N'SQLDataRoot', @InstallSqlDataDir OUTPUT
declare @MasterPath nvarchar(512)
declare @LogPath nvarchar(512)
declare @ErrorLog nvarchar(512)
declare @ErrorLogPath nvarchar(512)
selecione @MasterPath=substring(nome_físico, 1, len(nome_físico) - charindex('\', reverse(nome_físico))) de master.sys.database_files onde nome=N'master'
selecione @LogPath=substring(nome_físico, 1, len(nome_físico) - charindex('\', reverse(nome_físico))) de master.sys.database_files onde nome=N'mastlog'
selecione @ErrorLog=cast(SERVERPROPERTY(N'errorlogfilename') as nvarchar(512))
selecione @ErrorLogPath=substring(@ErrorLog, 1, len(@ErrorLog) - charindex('\', reverse(@ErrorLog)))
declare @SmoRoot nvarchar(512)
exec master.dbo.xp_instance_regread @HkeyLocal, @SetupRegPath, N'SQLPath', @SmoRoot OUTPUT
declare @ServiceStartMode int
EXEC master.sys.xp_instance_regread @HkeyLocal, @SqlServiceRegPath, N'Start', @ServiceStartMode OUTPUT
declare @ServiceAccount nvarchar(512)
EXEC master.sys.xp_instance_regread @HkeyLocal, @SqlServiceRegPath, N'ObjectName', @ServiceAccount OUTPUT
declare @NamedPipesEnabled int
exec master.dbo.xp_instance_regread @HkeyLocal, @NpRegPath, N'Enabled', @NamedPipesEnabled SAÍDA
declare @TcpEnabled int
EXEC master.sys.xp_instance_regread @HkeyLocal, @TcpRegPath, N'Enabled', @TcpEnabled OUTPUT
declare @InstallSharedDirectory nvarchar(512)
EXEC master.sys.xp_instance_regread @HkeyLocal, @SetupRegPath, N'SQLPath', @InstallSharedDirectory OUTPUT
declare @SqlGroup nvarchar(512)
exec master.dbo.xp_instance_regread @HkeyLocal, @SetupRegPath, N'SQLGroup', @SqlGroup OUTPUT
declare @FilestreamLevel int
exec master.dbo.xp_instance_regread @HkeyLocal, @FilestreamRegPath, N'EnableLevel', @FilestreamLevel OUTPUT
declare @FilestreamShareName nvarchar(512)
exec master.dbo.xp_instance_regread @HkeyLocal, @FilestreamRegPath, N'ShareName', @FilestreamShareName OUTPUT
declare @cluster_name nvarchar(128)
declare @quorum_type tinyint
declare @quorum_state tinyint
COMEÇAR A TENTAR
SELECT @cluster_name = cluster_name,
@quorum_type = quorum_type,
@quorum_state = quorum_state
DE sys.dm_hadr_cluster
TERMINAR TENTATIVA
COMEÇAR A PEGAR
--Consultar este DMV usando uma conexão de autenticação contida gera o erro 15562 (o módulo não é confiável)
--por causa da falta de confiabilidade do servidor. Isso é esperado, então deixamos apenas o
--valores como padrão
SE(ERROR_NUMBER() NÃO ESTÁ EM (297.300, 15562))
COMEÇAR
LANÇAR
FIM
TERMINAR ATENDIMENTO
SELECT @SmoAuditLevel AS [AuditLevel], ISNULL(@NumErrorLogs, -1) AS [NumberOfLogFiles], (caso quando @SmoLoginMode 'A' então 1 else 0 final AS bit) AS [IsCaseSensitive], @@MAX_PRECISION AS [MaxPrecision], CAST(FULLTEXTSERVICEPROPERTY('IsFullTextInstalled') AS bit) AS [IsFullTextInstalled], SERVERPROPERTY(N'ProductVersion') AS [VersionString], CAST(SERVERPROPERTY(N'Edition') AS sysname) AS [Edition], CAST(SERVERPROPERTY(N) 'ProductLevel') AS sysname) AS [ProductLevel], CAST(SERVERPROPERTY('IsSingleUser') AS bit) AS [IsSingleUser], CAST(SERVERPROPERTY('EngineEdition') AS int) AS [EngineEdition], convert(sysname, serverproperty( N'collation')) AS [Collation], CAST(SERVERPROPERTY('IsClustered') AS bit) AS [IsClustered], CAST(SERVERPROPERTY(N'MachineName') AS sysname) AS [NetName], @LogPath AS [MasterDBLogPath], @MasterPath AS [MasterDBPath], SERVERPROPERTY('instancedefaultdatapath') AS [DefaultFile], SERVERPROPERTY('instancedefaultlogpath') AS [DefaultLog], SERVERPROPERTY(N'ResourceVersion ') AS [ResourceVersionString], SERVERPROPERTY(N'ResourceLastUpdateDateTime') AS [ResourceLastUpdateDateTime], SERVERPROPERTY(N'CollationID') AS [CollationID], SERVERPROPERTY(N'ComparisonStyle') AS [ComparisonStyle], SERVERPROPERTY(N'SqlCharSet') AS [SqlCharSet], SERVERPROPERTY(N'SqlCharSetName') AS [SqlCharSetName], SERVERPROPERTY(N'SqlSortOrder') AS [SqlSortOrder], SERVERPROPERTY(N'SqlSortOrderName') AS [SqlSortOrderName], SERVERPROPERTY(N'ComputerNamePhysicalNetBIOS') AS [ ComputerNamePhysicalNetBIOS], SERVERPROPERTY(N'BuildClrVersion') AS [BuildClrVersionString], @ServiceStartMode AS [ServiceStartMode], ISNULL(@ServiceAccount,N'') AS [ServiceAccount], CAST(@NamedPipesEnabled AS bit) AS [NamedPipesEnabled], CAST(@TcpEnabled AS bit) AS [ TcpEnabled], ISNULL(@InstallSharedDirectory,N'') AS [InstallSharedDirectory], ISNULL(suser_sname(sid_binary(ISNULL(@SqlGroup,N''))),N'') AS [SqlDomainGroup], caso quando 1=msdb. dbo.fn_syspolicy_is_automation_enabled() e existe (selecione * de msdb.dbo.syspolicy_system_health_state onde target_query_expression_with_id como 'Server%' ) então 1 else 0 end AS [PolicyHealthState], @FilestreamLevel AS [FilestreamLevel], ISNULL(@FilestreamShareName,N'') AS [FilestreamShareName], -1 AS [TapeLoadWaitTime], CAST(SERVERPROPERTY(N'IsHadrEnabled') AS bit) AS [IsHadrEnabled],SERVERPROPERTY(N'HADRManagerStatus') AS [HadrManagerStatus], ISNULL(@cluster_name, '') AS [ClusterName], ISNULL(@quorum_type, 4) AS [ClusterQuorumType], ISNULL(@quorum_state, 3) AS [ClusterQuorumState], SUSER_SID (@ServiceAccount, 0) AS [ServiceAccountSid], CAST(SERVERPROPERTY('IsPolyBaseInstalled') AS bit) AS [IsPolyBaseInstalled], N'Windows' AS [HostPlatform], CAST(
serverproperty(N'Nome do Servidor')
AS sysname) AS [Nome], CAST(
ISNULL(propriedade do servidor(N'nome da instância'),N'')
AS sysname) AS [InstanceName], CAST(0x0001 AS int) AS [Status], N'\' AS [PathSeparator], 0 AS [IsContainedAuthentication], CAST(null AS int) AS [ServerType]
drop table #SVer

Esses comandos vêm do meu computador (DBA) e de um desenvolvedor. Para o desenvolvedor, dá vários erros de permissões:

A permissão VIEW SERVER STATE foi negada no objeto 'servidor', banco de dados 'mestre'. O servidor principal "MYDOMAIN\john.doe" não pode acessar o banco de dados "model" no contexto de segurança atual.
Falha no login do usuário 'MYDOMAIN\john.doe'. Motivo: Falha ao abrir o banco de dados explicitamente especificado 'MODEL'. [CLIENTE: 10.90.90.10]
Falha no login do usuário 'MYDOMAIN\john.doe'.

Para mim, dá este erro:

Não é possível descartar a tabela '#SVer' porque ela não existe ou você não tem permissão.

Não tenho ideia de qual aplicativo está causando essas consultas e, portanto, esses erros irritantes. Olhando para a consulta, você tem alguma idéia? O que eu poderia fazer para investigar?

Eu fiz um script que, uma de cada vez, exclui todas as chaves estrangeiras de um banco de dados, assim:

ALTER TABLE MyTable1 DROP CONSTRAINT FK_MyTable1_col1
ALTER TABLE MyTable2 DROP CONSTRAINT FK_MyTable2_col1
ALTER TABLE MyTable2 DROP CONSTRAINT FK_MyTable2_col2

O que me surpreende é que o script leva muito tempo: em média, 20 segundos para cada DROP FK. Agora, eu entendo que criar um FK pode ser um grande negócio, porque o servidor tem que ir e verificar se a restrição FK não foi infringida desde o início, mas descartando? O que um servidor faz ao descartar FKs que demora tanto? Isso é tanto para minha própria curiosidade quanto para entender se existe uma maneira de tornar as coisas mais rápidas. Ser capaz de remover o FK (não apenas desativá-lo) me permitiria ser muito mais rápido durante uma migração e, portanto, minimizar o tempo de inatividade.

Eu tenho um banco de dados SQL Server 2916 e Solr. O indexador Solr geralmente executa essas consultas:

select book_collection from books group by book_collection having max(updated_on) > '2017-04-04 09:50:05'

A coluna updated_on é atualizada por um gatilho na inserção/atualização; a cada execução do indexador incremental Solr (a cada 10 minutos), muitas consultas como a acima obtêm os registros modificados mais recentes e os reindexam. Esta tabela, por exemplo, tem cerca de um milhão de linhas e a cada vez a consulta retornaria no máximo 10-20 linhas. Essas consultas acabam na lista das consultas mais caras executadas no banco de dados, então gostaria de otimizá-las. Minhas perguntas:

1) Uma coluna de carimbo de data/hora teria um desempenho melhor do que uma coluna de data/hora?

2) Se eu alterasse a consulta assim, seria mais eficiente?

select distinct book_collection from books where updated_on > '2017-04-04 09:50:05'

O primeiro plano de consulta é o original, o segundo é modificado por mim. O fato de o segundo plano solicitar um índice e o primeiro não, realmente sugere que a consulta modificada pode usar um índice, se presente, e, portanto, é melhor.

Eu tenho uma consulta inserindo um caractere especial em uma tabela, por exemplo:

INSERT drinks VALUES( 'Café' )

Eu gostaria de fazer a mesma coisa, da maneira mais portátil possível, usando apenas ASCII na minha consulta, por exemplo:

INSERT drinks VALUES( 'Caf' + <something> )

É possível?

Eu tenho um banco de dados no Microsoft SQL Server 2016, com uma tabela de cerca de um milhão de linhas, vamos chamar de livros. Essa consulta leva mais de um minuto, o que não é aceitável:

selecione * de livros onde publisher_id in (857413, 857317, 857316)

Existe um FK adequado de publisher_id para a tabela de editores. Eu exponho o Plano de Execução Estimado, e ele me diz que 100% do custo está na "Varredura de Índice Clusterizado (clustered)" na chave primária da tabela de livros. E o que me preocupa, não recomenda nenhum índice. Olhando para a consulta, parece óbvio que um índice ajudará. E, de fato, quando crio o índice, a consulta retorna os resultados instantaneamente. Alguma coisa corrompeu no meu banco de dados, talvez estatísticas? Ou você acredita que eu não deveria, em geral, confiar no que li no plano de execução estimado?

Em uma pergunta no StackOverflow, encontrei esta consulta, que exibe a descrição da tabela e da coluna para todas as tabelas no banco de dados atual:

SELECT      u.name + '.' + t.name AS [table],
            td.value AS [table_desc],
            c.name AS [column],
            cd.value AS [column_desc]
FROM        sysobjects t
INNER JOIN  sysusers u
    ON      u.uid = t.uid
LEFT OUTER JOIN sys.extended_properties td
    ON      td.major_id = t.id
    AND     td.minor_id = 0
    AND     td.name = 'MS_Description'
INNER JOIN  syscolumns c
    ON      c.id = t.id
LEFT OUTER JOIN sys.extended_properties cd
    ON      cd.major_id = c.id
    AND     cd.minor_id = c.colid
    AND     cd.name = 'MS_Description'
WHERE t.type = 'u'
ORDER BY    t.name, c.colorder

Isso me ajuda muito porque vejo imediatamente todas as tabelas e colunas que não têm descrição. Agora, seria muito legal poder editar essas descrições diretamente. Existe um software que permite a edição em massa de descrições de tabelas e/ou colunas?

Tenho uma mesa com, digamos, cores preferidas. Para cada pessoa, armazenamos a cor favorita e a data efetiva. Se a pessoa mudar de preferência, armazenamos a nova com uma data efetiva mais recente. Exemplo:

name   color   eff_date
John   Green   2014-03-07
Luis   Red     2014-03-07
Luis   Yellow  2015-05-02
Nina   Blue    2015-07-06

Se quisermos pegar a cor preferida atual de Luis:

SELECT color
  FROM fav_colors
 WHERE name='Luis'
   AND eff_date=( SELECT max(eff_date) FROM fav_colors WHERE name='Luis' )

Agora decidimos que as pessoas podem mudar sua cor favorita a qualquer momento, mas a mudança só será efetivada a partir de 1º de janeiro. Portanto, mesmo que Luis tenha inserido um registro que diga que sua cor favorita é Amarelo, a consulta deve retornar o valor antigo (Vermelho) até 1º de janeiro de 2016.

SELECT color
  FROM fav_colors
 WHERE name='Luis'
   AND eff_date=( SELECT max(eff_date) FROM fav_colors WHERE name='Luis' and eff_date < '1 jan 2015' )

Esta consulta parece ok, mas não retornará nenhum registro para Nina. As regras dizem que um recém-chegado pode escolher a cor favorita imediatamente, sem esperar pelo próximo dia 1º de janeiro. Em outras palavras, "se possível, faça um registro de 1º de janeiro ou antes; se não for possível, qualquer registro; leve o mais recente". Isto é o que eu consegui escrever:

SELECT color
  FROM fav_colors
 WHERE name='Luis'
   AND eff_date= ISNULL(
       ( SELECT max(eff_date) FROM fav_colors WHERE name='Luis' and eff_date < '1 jan 2015' ),
       ( SELECT max(eff_date) FROM fav_colors WHERE name='Luis' )
       )

Existe uma maneira mais elegante ou mais eficiente de obter esse resultado?

Não tenho controle sobre a estrutura das tabelas, elas são da PeopleSoft.

Se Nina fez duas seleções este ano, quero mostrar a mais recente.

A tabela mais importante do meu banco de dados tem cerca de 300.000 registros e está crescendo. Mais de 20 mesas possuem um FK. Sua chave primária é um número, mas por razões históricas é definido como nvarchar(6) que obviamente é ineficiente (e feio). Às vezes, os registros são excluídos do registro; portanto, a chave primária está se aproximando de 999.999 e devo alterá-la. Um campo de identidade seria a escolha óbvia. Uma chave int, ou similar, com o incremento produzido por um gatilho ou pelo software, seria uma alternativa. Isso seria viável porque os registros são sempre inseridos um por vez. Uma chave int forneceria melhores desempenhos com consultas complexas?

Um servidor SERVER_A possui alguns dados.

Um servidor SERVER_B define A como um servidor vinculado e define algumas exibições dos dados. As consultas são assim:

CREATE view myview as
select * from 
openquery ( SERVER_A, select .... )

Um servidor SERVER_C define B como um servidor vinculado.

Tenho acesso total ao SERVER_C, posso solicitar algumas alterações no SERVER_B, mas não no SERVER_A. Todos os meus aplicativos acessarão o servidor SERVER_C e precisarão dos dados do SERVER_A. As visualizações em SERVER_B são bastante complexas e causam timeout antes de retornar qualquer coisa.

Acho que para melhorar a performance nessas queries preciso transformar as views no SERVER_B em "views indexadas". Para indexar uma exibição, devo criar um índice clusterizado.

Perguntas:

1) Onde devo definir o índice clusterizado? Deve estar em SERVER_B ou posso de alguma forma defini-lo em SERVER_C?

2) O uso de uma view indexada no SERVER_B afetará de alguma forma o desempenho do SERVER_A mesmo quando a view não estiver sendo usada?

Tenho um SQL Server 2008R2 e desejo me conectar remotamente a um SQL Server 2012SP1, para o qual recebo:

IP: 12.34.56.78
Login: john
Password: pw1
Database: TESTDB
Table: test_table

O banco de dados remoto está fora da minha LAN, mas o firewall está configurado em ambos os lados, então posso consultá-lo abrindo o SSMS diretamente do meu servidor de banco de dados. Eu executo o seguinte:

EXEC sp_addlinkedserver '12.34.56.78', 'SQL Server';
EXEC master.dbo.sp_addlinkedsrvlogin @rmtsrvname = [12.34.56.78], @locallogin = NULL , @useself = N'False', @rmtuser = 'john', @rmtpassword = 'pw1'

Até agora, nenhum erro e posso ver o servidor vinculado no SSMS, "Test Connection" é bem-sucedido, mas não consigo consultá-lo.

select * from [12.34.56.78].TESTDB.test_table

Retorna este erro:

Msg 208, Level 16, State 1, Line 1
Invalid object name '12.34.56.78.TESTDB.test_table'.

Qual é a maneira correta de definir um servidor vinculado da Internet e, se possível, atribuir um bom nome a ele (em vez de se referir a ele por IP)? Devo usar o SQLNCLI como provedor?