Jeremy Boyd's questions

Eu tenho um índice de texto completo em uma tabela para as articlescolunas contentetitlekeywords

Ao fazer a busca em cada uma das colunas, assim select count(1) from articles where match(content,title,keywords) against ('cats' in boolean mode), os resultados demoram entre 12 e 15 segundos.

Mas fazer as colunas individualmente ( select count(1) from articles where match(content) against ('cats' in boolean mode)) normalmente leva menos de 50 ms.

Por que pesquisar as 3 colunas leva mais de 100 vezes mais do que todas elas separadamente?

Esta não é uma questão de como torná-lo mais rápido, mas sim de perguntar "por que é tão lento?"

Tabela/Índices

id           int(30)       PK       auto_increment
url          varchar(1024)
title        varchar(255)  FULLTEXT
content      text          FULLTEXT
keywords     varchar(1024) FULLTEXT
comments     text
created_date int(11)
posted_date  int(11)

explica

Este primeiro é a consulta de várias colunas:

Esta segunda é a nova consulta muito mais rápida que executa as 3 colunas separadamente e depois as une (o cache da consulta foi limpo).

Ordem das Colunas de Texto Completo

Usar/Forçar Índice com Explicar

O título resume bem. Estamos ficando sem espaço em nossos discos de backup e precisamos remover os backups antigos do conjunto. Não consigo encontrar nenhuma informação sobre isso.

Trabalhando no ajuste de nosso banco de dados e consultas para um de nossos produtos, decidi abrir o Profiler no ambiente de controle de qualidade e ver o que ele mostra.

Eu vi para cada inserção que chamei, uma chamada foi feita para sp_executesql com o texto da instrução de inserção.

Este parece ser um grande sucesso, existe uma maneira de desligar isso?

Meio Ambiente:

• SQL Server 2008 R2 Padrão
• Windows Server 2008 R2 Enterprise
• RAM de 32 GB
• 2x4 Xeon

Executamos um site que tem 250 milhões de linhas em uma tabela e em outra tabela à qual o associamos para a maioria das consultas tem pouco menos de 15 milhões de linhas.

Estruturas de amostra:

MasterTable (Id, UserId, Created, Updated...) -- 15MM Rows
DetailsTable (Id, MasterId, SomeColumn...) -- 250MM Rows
UserTable (Id, Role, Created, UserName...) -- 12K Rows

Regularmente temos que fazer algumas consultas em todas essas tabelas. Uma é obter estatísticas para usuários gratuitos (~ 10 mil usuários gratuitos).

Select Count(1) from DetailsTable dt 
join MasterTable mt on mt.Id = dt.MasterId 
join UserTable ut on ut.Id = mt.UserId 
where ut.Role is null and mt.created between @date1 and @date2

O problema é que essa consulta algumas vezes será executada por muito tempo devido ao fato de as junções acontecerem muito antes do where.

Nesse caso, seria mais sensato usar wheres em vez de joins ou possivelmente where column in(...)?

Não tenho certeza se esse é o termo correto "Instrução de inserção compacta". É exatamente o que sempre ouvi referir. É o seguinte:

INSERT INTO [tblUsers]
       ([username], [password]) 
VALUES ('user1', 'pass1'), 
       ('user2', 'pass2')

De qualquer forma, temos uma tabela com pouco mais de 5 milhões de linhas e estamos prestes a importar alguns dados, MAS a probabilidade é alta de que cerca de 75% dos dados sejam duplicados (compramos dados de várias fontes, mas eles compartilham cerca de 30-40% com cada uma de nossas fontes :/).

Se eu fizer uma restrição exclusiva na coluna, toda a inserção falhará desse ponto em diante (a menos que seja envolvido em uma transação, é claro).

Não sei como fazer isso com eficiência e com código que pode ser reutilizado daqui para frente.

Tenho uma lista de 3.000 strings e as estou passando (vinte por vez) para uma cláusula IN parametrizada. Definitivamente não está obtendo os resultados que eu gostaria de ver ~ 500ms por execução.

A coluna é um índice. Você conhece uma maneira melhor do que esta:

SELECT * FROM [ohb].[dbo].[MasterUrls] WITH (NOLOCK) WHERE Hash 
IN(@p0,@p1,@p2,@p3,@p4,@p5,@p6,@p7,@p8,@p9,@p10,@p11,@p12,@p13,@p14,@p15,@p16,@p17,@p18,@p19)

Uma lista de 3000 leva entre 3 e 5 minutos. Eu realmente preciso disso para cerca de 30 segundos. Isso é possível?

Estou usando o MSSQL 2008 R2 em um servidor com 24 GB de RAM e NUMA Xeons duplos de 8 núcleos a 2,4 Ghz rodando em um RAID 10 ISCSI de 6 HDD (@15k/rpm).

A tabela tem 1,4 milhão de linhas e o índice é um índice não clusterizado.

O plano de execução mostra a varredura de índice como 90% da execução total.