1. Para otimizar a consulta, você deve tentar evitar a varredura completa da tabela e, primeiro, considerar criar um índice nas colunas envolvidas em onde e ordenação por.
2. Tente evitar julgamento de valor nulo nos campos da cláusula where, caso contrário, isso fará com que o motor abandone o uso de índices e realize uma varredura completa da tabela, como:
selecione id de t onde num é nulo
Você pode definir o valor padrão de 0 no num, garantir que não haja valor nulo na coluna número da tabela e então consultar assim:
selecione id de t onde num=0
3. Tente evitar usar operadores != ou <> na cláusula where, caso contrário o motor abandonará o uso de índices e realizará varredura de tabela completa.
4. Você deve tentar evitar usar OR na cláusula onde para se juntar à condição, caso contrário, isso fará com que o motor abandone o uso de índices e realize uma varredura completa da tabela, como:
selecione id de t, onde num=10 ou num=20
Você pode consultar assim:
selecione id a partir de t, onde num=10
Sindicato de todos
selecione id de t onde num=20
5.in e não em também devem ser usados com cautela, caso contrário isso levará à varredura completa da tabela, como:
selecione id de t onde num em(1,2,3)
Para valores contínuos, não use em se puder usar entre:
selecione id de t onde num está entre 1 e 3
6. A consulta a seguir também resultará em uma varredura completa da tabela:
Selecione ID de T onde o nome seja '%ABC%'
Para melhorar a eficiência, considere a busca por texto completo.
7. Se você usar um parâmetro em uma cláusula where, ele também causará uma varredura completa da tabela. Como o SQL resolve apenas variáveis locais em tempo de execução, mas o otimizador não pode adiar a seleção dos planos de acesso para o tempo de execução; Ele deve ser selecionado na época da compilação. No entanto, se um plano de acesso for estabelecido em tempo de compilação, o valor da variável ainda é desconhecido e, portanto, não pode ser usado como item de entrada para seleção de índice. As seguintes declarações serão digitalizadas na íntegra:
selecione id a partir de t, onde num=@num
Você pode forçar a consulta a usar um índice em vez disso:
selecione id de t com(index(index(index name index)) onde num=@num
8. Tente evitar expressar campos na cláusula where, o que fará com que o motor abandone o uso de índices em favor da varredura completa da tabela. Por exemplo:
selecione id de t onde num/2=100
Devem ser alterados para:
selecione id a partir de t, onde num=100*2
9. Tente evitar realizar operações de função nos campos da cláusula where, o que fará com que o motor abandone o uso de índices em favor da varredura completa da tabela. Por exemplo:
selecione id de t onde substring(name,1,3)='abc' --name id que começa com abc
Selecione ID de T onde datediff(day,createdate,'2005-11-30')=0--'2005-11-30' gerado ID
Devem ser alterados para:
Selecione ID a partir de T onde o nome é 'ABC%'
selecione o ID de T onde criado>='2005-11-30' e criado<'2005-12-1'
10. Não execute funções, operações aritméticas ou outras operações de expressão à esquerda do "=" na cláusula where, caso contrário o sistema pode não conseguir usar o índice corretamente.
11. Ao usar um campo índice como condição, se o índice for um índice composto, então o primeiro campo do índice deve ser usado como condição para garantir que o sistema use o índice, caso contrário o índice não será usado, e a ordem dos campos deve ser consistente com a ordem do índice tanto quanto possível.
12. Não escreva algumas consultas sem sentido, como gerar uma estrutura de tabela vazia:
Selecione col1,col2 para #t a partir de T, onde 1=0
Esse tipo de código não retorna nenhum conjunto de resultados, mas consome recursos do sistema, então deve ser alterado para algo assim:
criar tabela #t(...)
13. Muitas vezes é uma boa escolha substituir em por existe:
selecione num de a onde num em (selecione num de b)
Substitua pela seguinte afirmação:
selecione num de a onde existe (selecione 1 de b onde num=a.num)
14. Nem todos os índices são válidos para consultas, SQL é baseado nos dados da tabela para otimizar a consulta, quando a coluna de índice tem grande duplicação de dados, consultas SQL podem não usar o índice, como uma tabela tem um campo sexo, masculino e feminino são quase metade cada, então mesmo que o índice seja baseado em sexo, isso não terá papel na eficiência da consulta.
15. Quanto mais índices não forem melhor, o índice certamente pode melhorar a eficiência do select correspondente, mas também reduz a eficiência de inserir e atualizar, porque o índice pode ser reconstruído ao inserir ou atualizar, então como construir um índice precisa ser cuidadosamente considerado, dependendo da situação específica. É melhor não ter mais de 6 índices em uma tabela e, se houver muitos índices, considere se é necessário construir índices em algumas colunas pouco usadas.
16. Evite atualizar ao máximo as colunas de dados de índice agrupados, pois a ordem das colunas de dados de índice agrupados é a ordem física de armazenamento dos registros de tabela, e uma vez que o valor da coluna mude, isso levará ao ajuste da ordem de todos os registros de tabela, o que consumirá recursos consideráveis. Se sua aplicação precisar atualizar colunas de índice agrupadas com frequência, você precisa considerar se deve construir o índice como um índice agrupado.
17. Tente usar campos numéricos e tente não projetar campos que contenham apenas informações numéricas como caracteres, o que reduzirá o desempenho de consultas e conexões, além de aumentar a sobrecarga de armazenamento. Isso ocorre porque o motor compara cada caractere da string um por um ao processar consultas e joins, enquanto para tipos numéricos, ele só precisa ser comparado uma vez.
18. Use varchar/nvarchar em vez de char/nchar o máximo possível, porque, primeiro, o espaço de armazenamento de campo maior pode economizar espaço, e segundo, para consultas, a eficiência de busca em um campo relativamente pequeno é obviamente maior.
19. Não use select * de t em lugar nenhum, substitua "*" por uma lista específica de campos e não retorne nenhum campo que não esteja sendo usado.
20. Tente usar variáveis de tabela em vez de tabelas temporárias. Se a variável da tabela contém uma grande quantidade de dados, note que o índice é muito limitado (apenas o índice da chave primária).
21. Evite criar e excluir tabelas temporárias com frequência para reduzir o consumo de recursos das tabelas do sistema.
22. Tabelas temporárias não são inutilizáveis, e usá-las adequadamente pode tornar algumas rotinas mais eficazes, por exemplo, quando você precisa referenciar repetidamente um conjunto de dados em uma tabela grande ou em uma tabela comumente usada. No entanto, para eventos únicos, o melhor é usar uma tabela de exportação.
23. Ao criar uma tabela temporária, se a quantidade de dados inseridos de uma vez for grande, você pode usar select into em vez de criar tabela para evitar causar um grande número de logs para melhorar a velocidade; Se a quantidade de dados não for grande, para facilitar os recursos da tabela do sistema, você deve criar a tabela primeiro e depois inserir.
24. Se uma tabela temporária for usada, certifique-se de excluir explicitamente todas as tabelas temporárias ao final do procedimento armazenado, trunque a tabela primeiro e depois a elimine, para evitar que a tabela do sistema fique travada por muito tempo.
25. Tente evitar usar o cursor, pois a eficiência do cursor é ruim; se os dados operados pelo cursor excederem 10.000 linhas, você deve considerar reescrever.
26. Soluções baseadas em conjuntos devem ser buscadas para resolver problemas antes de usar métodos baseados em cursor ou tabelas temporárias, que geralmente são mais eficazes.
27. Como tabelas temporárias, os cursores não são inutilizáveis. Usar cursores FAST_FORWARD para pequenos conjuntos de dados costuma ser melhor do que outros métodos de processamento linha por linha, especialmente se você precisa consultar várias tabelas para obter os dados necessários. Rotinas que incluem "total" no conjunto de resultados geralmente são mais rápidas do que aquelas executadas com o cursor. Se o tempo de desenvolvimento permitir, métodos baseados em cursor e em conjuntos podem ser tentados para ver qual funciona melhor.
28. Defina SET NOCOUNT ON no início de todos os procedimentos e triggers armazenados, e SET NOCOUNT OFF no final. Não há necessidade de enviar mensagens DONE_IN_PROC ao cliente após executar cada instrução do procedimento armazenado e disparo.
29. Tente evitar grandes operações de transação e melhorar a capacidade de concorrência do sistema.
30. Tente evitar devolver grandes volumes de dados ao cliente; se o volume de dados for muito grande, você deve considerar se a demanda correspondente é razoável. |
Publicado em 27/01/2015 20:09:54
|
|
|
