Mesure de la complexité des énoncés SQL

Je ne suis pas sûr que la récupération des plans de requête répondra à la question: les plans de requête cachent une partie de la complexité du calcul effectué sur les données avant qu'elles ne soient retournées (ou utilisées dans un filtre); les plans de requête exigent une base de données significative pour être pertinent. En fait, la complexité et la durée de l'exécution sont quelque peu opposées; quelque chose comme "Bon, Rapide, Bon Marché - choisir n'importe lequel de deux".

en fin de compte, il est question des chances de faire une erreur, ou pas comprendre le code que j'ai écrit?

quelque chose comme:

• nombre de tables fois (1
• +1 par expression de jointure (+1 par jointure externe?)
• +1 par prédicat après WHERE ou HAVING
• +1 pour GROUP BY expression
• +1 par UNION ou INTERSECT
• +1 par appel de fonction
• +1 pour CASE expression
• )

s'il vous Plaît n'hésitez pas à tester mon script qui donne un aperçu de la procédure stockée taille, le nombre de dépendances d'objet et le nombre de paramètres -

Calculer TSQL Procédure Stockée Complexité

les requêtes SQL sont déclaratives plutôt que procédurales: elles ne précisent pas comment accomplir leur but. Le moteur SQL créera un plan d'attaque procédural, et ce pourrait être un bon endroit pour chercher la complexité. Essayez d'examiner la sortie de la déclaration expliquer (ou expliquer PLAN), ce sera une description rudimentaire des étapes que le moteur utilisera pour exécuter votre requête.

Eh bien, je ne connais aucun outil qui a fait une telle chose, mais il me semble que ce qui ferait une requête plus compliquée serait mesurée par: le nombre de jointures le nombre de cas où les conditions le nombre de fonctions le nombre de sous-requêtes le nombre de moulages pour différents types de données le nombre de cas relevés le nombre de boucles ou des curseurs le nombre d'étapes d'une transaction

Toutefois, s'il est vrai que le plus comlex requêtes peuvent sembler être le ceux avec les défauts les plus possibles, je trouve que les simples sont très susceptibles de contenir des défauts car ils sont plus susceptibles d'être écrits par quelqu'un qui ne comprend pas le modèle de données et donc ils peuvent sembler fonctionner correctement, mais en fait retourner les mauvaises données. Donc je ne suis pas sûr qu'une telle métrique vous dise grand chose.

Eh bien, si vous utilisez SQL Server, je dirais que vous devriez examiner le coût de la requête dans le plan d'exécution (en particulier le coût de sous-arborescence).

Ici est un lien qui va au-dessus de certaines choses que vous devriez regarder dans le plan d'exécution.

selon votre SGBDR, il peut y avoir des outils de plan de requête qui peuvent vous aider à analyser les étapes que les SGBDR prendront pour récupérer votre requête.

SQL Server Management Studio Express a un plan d'exécution des requêtes intégré. Pervasive PSQL a son plan D'interrogation Finder. DB2 a des outils similaires (oublié comment ils s'appellent).

bonne question. Le problème est que pour une requête SQL comme:

SELECT * FROM foo;

la complexité peut dépendre de ce qu'est" foo " et de l'implémentation de la base de données. Pour une fonction comme:

int f( int n ) {
   if ( n == 42 ) {
      return 0;
   }
   else {
      return n;
   }
}

il n'y a pas de telle dépendance.

cependant, je pense qu'il devrait être possible de trouver des mesures utiles pour un SELECT, même si elles ne sont pas très exactes, et je serai intéressé de voir quelles réponses cela obtient.

en l'absence de tout outil permettant de le faire, une approche pragmatique consisterait à s'assurer que les requêtes analysées sont formatées de manière cohérente et à compter ensuite les lignes de code.

utilisez alternativement la taille des requêtes en octets lorsqu'elles sont enregistrées dans le fichier (en veillant à ce que toutes les requêtes soient enregistrées en utilisant le même codage de caractères).

pas brillant, mais une approximation raisonnable de la complexité en l'absence de tout autre je pense.