1. Pour optimiser la requête, vous devriez essayer d’éviter le balayage complet de tables, et d’abord envisager de créer un index sur les colonnes concernées par où et par ordre.
2. Essayez d’éviter d’utiliser des opérateurs != ou <> dans la clause where, sinon le moteur abandonnera l’utilisation des index et effectuera un balayage complet de table.
3. Essayez d’éviter le jugement de valeur nul sur les champs de la clause where, sinon le moteur abandonnera l’utilisation des index et effectuera un balayage complet des tables, tels que :
Sélectionner l’ID à partir de T où num est nul
Vous pouvez définir la valeur par défaut de 0 sur le num, vous assurer qu’il n’y a pas de valeur nulle dans la colonne numum du tableau, puis interroger comme ceci :
sélectionner l’id à partir de t où num=0
4. Vous devez essayer d’éviter d’utiliser OR dans la clause where pour rejoindre la condition, sinon cela poussera le moteur à abandonner l’utilisation des index et à effectuer un scan complet de la table, par exemple :
Sélectionnez l’ID à partir de t où num=10 ou num=20
Vous pouvez interroger ainsi :
sélectionner l’ID à partir de t où num=10
Syndicalisation générale
sélectionner l’ID à partir de t où num=20
5. La requête suivante entraînera également un balayage complet de la table :
Sélectionnez l’ID à partir de T où le nom est comme ' %ABC %'
Pour améliorer l’efficacité, envisagez la recherche en texte intégral.
6.in et non dans doivent également être utilisés avec prudence, sinon cela entraînera un balayage complet de la table, tel que :
Sélectionnez l’ID à partir de T où num dans (1,2,3)
Pour les valeurs continues, ne pas utiliser dans si vous pouvez utiliser entre :
sélectionner l’ID à partir de t où num entre 1 et 3
7. Si vous utilisez un paramètre dans une clause where, cela provoquera également un balayage complet de la table. Parce que SQL ne résout que les variables locales à l’exécution, mais que l’optimiseur ne peut pas reporter la sélection des plans d’accès à l’exécution ; Il doit être sélectionné au moment de la compilation. Cependant, si un plan d’accès est établi au moment de la compilation, la valeur de la variable reste inconnue et ne peut donc pas être utilisée comme élément d’entrée pour la sélection de l’index. Les déclarations suivantes seront numérisées dans son intégralité :
sélectionner l’ID à partir de t où num=@num
Vous pouvez forcer la requête à utiliser un index à la place :
Sélectionnez l’ID à partir de t avec(index(index(index name)) où num=@num
8. Essayez d’éviter d’exprimer des champs dans la clause where, ce qui pousserait le moteur à abandonner l’utilisation des index au profit d’un balayage complet de tables. Par exemple :
sélectionner l’ID de T où num/2=100
devrait être modifié en :
sélectionner l’ID à partir de t où num=100*2
9. Essayez d’éviter d’effectuer des opérations de fonction sur les champs de la clause where, ce qui pousserait le moteur à abandonner l’utilisation des index au profit d’un balayage complet de table. Par exemple :
Sélectionnez l’ID à partir de t où substring(name,1,3)='abc' --identifiant de nom qui commence par abc
Sélectionnez l’ID à partir de T où DateDiff(Day,Createdate, '2005-11-30')=0--'2005-11-30' Id généré
devrait être modifié en :
Sélectionnez l’ID à partir de T où le nom est comme 'ABC %'
sélectionner l’ID à partir de t où créer>='2005-11-30' et créer<'2005-12-1'
10. Ne pas effectuer les fonctions, opérations arithmétiques ou autres opérations d’expression à gauche de la clause « = » dans la clause where, sinon le système pourrait ne pas être en mesure d’utiliser correctement l’index.
11. Lors de l’utilisation d’un champ d’index comme condition, si l’indice est un indice composite, alors le premier champ de l’index doit être utilisé comme condition pour s’assurer que le système utilise l’index, sinon l’indice ne sera pas utilisé, et l’ordre des champs doit être cohérent autant que possible avec l’ordre de l’index.
12. N’écrivez pas certaines requêtes dénuées de sens, comme la génération d’une structure de table vide :
Sélectionnez col1,col2 dans #t à partir de t où 1=0
Ce type de code ne retourne aucun ensemble de résultats, mais consomme les ressources système, donc il devrait être changé pour quelque chose comme ceci :
créer un tableau #t(...)
13. Souvent, il est judicieux de remplacer par existe :
Sélectionnez num depuis A où Num In(Sélectionnez Num depuis B)
Remplacez par l’affirmation suivante :
Sélectionnez num à partir de A où existe (sélectionnez 1 à partir de B où num=A.num)
14. Tous les index ne sont pas valides pour les requêtes, SQL est basé sur les données du tableau pour optimiser la requête, lorsque la colonne d’index comporte une grande duplication de données, les requêtes SQL peuvent ne pas utiliser l’index, par exemple une table a un champ sexe, mâle, femelle presque la moitié chacune, alors même si l’index est construit sur le sexe, cela ne jouera pas de rôle dans l’efficacité des requêtes.
15. Plus il y a d’indices, mieux c’est, l’index peut certainement améliorer l’efficacité du select correspondant, mais il réduit aussi l’efficacité de l’insertion et de la mise à jour, car l’index peut être reconstruit lors de l’insertion ou de la mise à jour, donc la manière de construire un index doit être soigneusement réfléchie, selon la situation spécifique. Il est préférable de ne pas avoir plus de 6 index dans un tableau, et s’il y en a trop, de se demander s’il est nécessaire de construire des index sur certaines colonnes peu utilisées.
16. Éviter de mettre à jour autant que possible les colonnes de données indexées groupées, car l’ordre des colonnes de données indexées regroupées est l’ordre physique de stockage des enregistrements de table, et une fois que la valeur de la colonne change, cela entraînera un ajustement de l’ordre de l’ensemble des enregistrements de table, ce qui consommera des ressources considérables. Si votre application doit mettre à jour fréquemment les colonnes d’index groupées, vous devez envisager de construire l’index comme un index clusteré.
17. Essayez d’utiliser des champs numériques, et essayez de ne pas concevoir des champs ne contenant que des informations numériques sous forme de caractères, ce qui réduira la performance des requêtes et des connexions, et augmentera la surcharge de stockage. Cela s’explique par le fait que le moteur compare chaque caractère de la chaîne un par un lors du traitement des requêtes et des jointures, alors que pour les types numériques, il n’a besoin d’être comparé qu’une seule fois.
18. Utiliser varchar/nvarchar au lieu de char/nchar autant que possible, car premièrement, l’espace de stockage de champ plus long peut économiser de la place, et deuxièmement, pour les requêtes, l’efficacité de recherche dans un champ relativement petit est évidemment plus élevée.
19. N’utilisez pas select * from t nulle part, remplacez « * » par une liste spécifique de champs, et ne retournez aucun champ qui n’est pas utilisé.
20. Essayez d’utiliser des variables de table au lieu de tables temporaires. Si la variable de table contient une grande quantité de données, notez que l’index est très limité (seul l’index de clé primaire).
21. Éviter de créer et supprimer fréquemment des tables temporaires afin de réduire la consommation des ressources des tables système.
22. Les tables temporaires ne sont pas inutilisables, et les utiliser de manière appropriée peut rendre certaines routines plus efficaces, par exemple lorsqu’il faut référencer à plusieurs reprises un jeu de données dans une grande table ou une table couramment utilisée. Cependant, pour les événements ponctuels, il vaut mieux utiliser une table d’exportation.
23. Lors de la création d’une table temporaire, si la quantité de données insérées à la fois est grande, vous pouvez utiliser select into au lieu de créer table pour éviter d’augmenter la vitesse d’un grand nombre de journaux ; Si la quantité de données n’est pas importante, afin de faciliter les ressources de la table système, vous devez d’abord créer la table puis l’insérer.
24. Si une table temporaire est utilisée, veillez à supprimer explicitement toutes les tables temporaires à la fin de la procédure stockée, tronquez d’abord la table, puis supprimez la table, afin d’éviter que la table système ne soit verrouillée longtemps.
25. Essayez d’éviter d’utiliser le curseur, car l’efficacité du curseur est faible ; si les données opérées par le curseur dépassent 10 000 lignes, vous devriez envisager de la réécrire.
26. Les solutions basées sur des ensembles doivent être recherchées pour résoudre des problèmes avant d’utiliser des méthodes basées sur le curseur ou des tables temporaires, qui sont souvent plus efficaces.
27. Comme les tables temporaires, les curseurs ne sont pas inutilisables. Utiliser FAST_FORWARD curseurs pour de petits ensembles de données est souvent préférable à d’autres méthodes de traitement ligne par ligne, surtout si vous devez référencer plusieurs tables pour obtenir les données nécessaires. Les routines qui incluent le « total » dans le jeu de résultats sont généralement plus rapides que celles exécutées avec le curseur. Si le temps de développement le permet, on peut essayer des méthodes basées sur des curseurs et sur des ensembles pour voir laquelle fonctionne mieux.
28. Définir SET NOCOUNT ON au début de toutes les procédures stockées et déclencheurs, et SET NOCOUNT OFF à la fin. Il n’est pas nécessaire d’envoyer DONE_IN_PROC messages au client après avoir exécuté chaque instruction de la procédure stockée et le déclencheur.
29. Essayez d’éviter de retourner de grosses données au client, si le volume de données est trop important, considérez si la demande correspondante est raisonnable.
30. Essayer d’éviter les opérations de transaction importantes et améliorer les capacités de concurrence du système.
|
Publié sur 04/08/2017 16:08:46
|
|
|
Propriétaire|
Publié sur 04/08/2017 16:14:30
|
