La mesure de la complexité des instructions SQL

La complexité des méthodes, dans la plupart des langages de programmation peuvent être mesurés dans la complexité cyclomatique de l'électricité statique du code source des analyseurs. Est-il similaire métrique pour mesurer la complexité d'une requête SQL?

Il est assez simple de mesurer le temps nécessaire à une requête de retour, mais si je veux juste être en mesure de quantifier le degré de complexité d'une requête?

[Modifier/Note]
Tout en obtenant le plan d'exécution est utile, ce n'est pas forcément ce que je cherche à identifier dans ce cas. Je ne suis pas à la recherche de comment il est difficile pour le serveur pour exécuter la requête, je suis à la recherche d'une métrique qui définit la façon dont il était difficile pour le développeur d'écrire la requête, et comment il est susceptible de contenir un défaut.

[Modifier/Note 2]
Certes, il y a des moments lors de la mesure de la complexité n'est pas utile, mais il ya aussi des moments où il est. Pour une discussion approfondie sur ce sujet, voir cette question.

Est-ce la complexité du code source, ou de la complexité du traitement l'exige, que vous êtes intéressé par la mesure?
Je suis acutally demandais si il existe un moyen de mesurer la complexité du code source. Avec C#/C++/Java, je l'ai souvent utilisé la Complexité Cyclomatique de déterminer les méthodes qui devrait être testé en premier. Ici, je voudrais savoir qui queiries besoin de plus d'attention de test.
Avez-vous l'intention d'élargir notre VIEW définitions dans les requêtes? L'utilisation de SQL, la fonction définie par l'utilisateur de rendre le code moins complexe ou ne sa définition doivent être élargis trop?
Notez que certaines de mes questions plus complexes sont en fait tout simplement un "copier & copier-coller" d'un SQL "pattern" par exemple, un relationnel de la division de la construction.
Je ne sais pas s'il serait utile de comparer une requête à une procédure stockée, mais on pourrait comparer la complexité des multiples procédures stockées pour voir qui est la plus complexe.
Je n'avais pas entendu parler de la complexité cyclomatique jusqu'à ce que vous avez posté cette question. Merci pour me forcer à m'instruire.
Gideon Vous pouvez aussi regarder dans la métrique connexe, Halsted complexité. Voir Ira Baxter réponse ci-dessous.

InformationsquelleAutor epotter | 2010-07-28

10

Commun de mesures de la complexité du logiciel comprennent La Complexité Cyclomatique (une mesure de la complexité du flux de contrôle est) et Halstead complexité (une mesure de la complexité de l'arithmétique est).

Le "contrôle de flux" dans une requête SQL est mieux "et" et "ou" opérateurs de requête.

La "complexité algorithmique" est le meilleur liées à des opérateurs comme SOMME ou implicite REJOINT.

Une fois que vous avez décidé de la façon de classer chaque unité de la syntaxe d'une requête SQL pour savoir si elle est "contrôle de flux" ou "calcul", vous pouvez carrément calculer La ou les mesures Halstead.

Ce que l'optimiseur SQL ne aux questions que je pense est absolument hors de propos. Le but de la complexité des mesures est de caractériser comment est dur pour une personne de comprendre la requête, pas comment efficace elle peut être évaluée.

De même, que le DDL dit ou si les vues sont impliqués ou non ne devrait pas être inclus dans ces mesures de complexité. L'hypothèse à l'origine de ces mesures est que la complexité de la machinerie à l'intérieur d'une abstraction n'est pas intéressant lorsque vous suffit de l'appeler, parce que sans doute que l'abstraction fait quelque chose de bien comprise par le programmeur. C'est pourquoi Halstead et Cyclomatique mesures n'incluent pas appelé sous-routines dans leur dépouillement, et je pense que vous pouvez faire une bonne affaire que les vues et les DDL de l'information sont ceux "invoquée" abstractractions.

Enfin, comment parfaitement droit ou de façon parfaitement mal la complexité de ces numéros ne sont pas beaucoup d'importance, aussi longtemps qu'elles reflètent une certaine vérité à propos de la complexité et de vous permettre de les comparer par rapport à une autre. De cette façon, vous pouvez choisir SQL fragments sont les plus complexes, donc les trier tous, et de concentrer vos tests d'attention sur les plus complexes.
- Comme vous le savez, n'importe quel outil de ce type n'existe pas?
- Eh bien, sorte de oui. Mon entreprise offre un Code Source du Moteur de Recherche (SCSE) (semanticdesigns.com/Products/SearchEngine) qui balaye d'un ensemble de fichiers afin de préparer un index pour la recherche. La SCSE arrive à calculer un certain nombre de mesures simples (SLOC, CommentCount, Cyclomatique, Halstead) sur chaque fichier comme un tout au cours de l'analyse, et, il sera procédé à de nombreuses langues, y compris PLSQL. PLSQL, bien sûr, a SQL comme une sous-langue, et autant que je me souvienne, SCSE calcule de la complexité du logiciel numéros à peu près comme je l'ai décrit ci-dessus. Si vous mettez votre SQL fragments dans des fichiers, la SCSE serait probablement le faire.
- ... Il y a toujours la question de la où sont vos SQL fragments? Si elles sont intégrées dans les fragments de chaîne dans les appels ODBC, leur extraction et leur mesure va être difficile, car les pièces sont dispersés à travers le code, et il n'est pas immédiatement évident que toute chaîne de caractères littérale est une partie d'une requête ou si donc où il va. Si vos requêtes SQL sont intégrées dans une procédure stockée de la langue tels que PLSQL, ils sont évidemment beaucoup plus facile à "extraire". Mais l'outil idéal dans ce cas est l'une des mesures les requêtes SQL séparément, in situ, de sorte que vous n'avez pas les extraire à la main ou hack.
- ... dans ce dernier cas, ce que vous avez besoin est un outil pour calculer la complexité de fragements de la procédure stockée fichier. Mon entreprise offre également des outils de suivi pour de nombreux langages (mais pas à l'heure actuelle et de la procédure stockée de la langue) qui calcule les métriques sur les éléments du programme (par exemple, les fonctions/méthodes) et sommaires cumulatifs, basé sur un cadre pour le calcul de ces métriques sur l'arbre de syntaxe abstraite produites par l'analyse du code source. Que les métriques de machines pourrait être axé sur PLSQL ou TSQL pour produire probablement exactement ce que vous voulez, mais il est de coutume de travail.
- J'ai trouvé qu'une fois que vous décidez sur la "notation" il est extrêmement facile à mettre en œuvre et de mesurer des paramètres comme la complexité cyclomatique! J'étais en train de penser au sujet d'une mesure qui a eu COCOMO / complexité cyclomatique. Mon raisonnement derrière cela est que si vous avez eu un 1000 requête de ligne qui a une complexité en mesure de dire 20, peut-être que c'est moins compliqué qu'un 20 ligne de la requête de la même complexité... juste une pensée.
InformationsquelleAutor Ira Baxter
10

Je ne suis pas sûr de la recherche, les plans de requête de répondre à la question: les plans de requête en cacher une partie de la complexité sur le calcul effectué sur les données avant de les retourner (ou utilisée dans un filtre); les plans de requêtes nécessitent significative de la base de données pertinents. En fait, la complexité et la longueur de l'exécution est un peu ci-contre; quelque chose comme "Bon, Rapide, pas Cher - ramassez tous les deux".

Finalement, c'est sur les chances de faire une erreur, ou ne pas comprendre le code que j'ai écrit?

Quelque chose comme:
- nombre de tables de fois (1
- +1 par expression de la jointure (+1 par jointure externe?)
- +1 par le prédicat après WHERE ou HAVING
- +1 par GROUP BY expression
- +1 par UNION ou INTERSECT
- +1 par appel de fonction
- +1 par CASE expression
- )
- C'est exactement le genre de chose que je suis à la recherche d'. Si je ne peux pas en trouver un, je risque de brasser ma propre semblable à cela.
- Vous pouvez aussi enlever des points(un demi-point?) pour faire une recherche sur un champ indexé. Et n'oubliez pas votre Commande En est trop.
- Comme quelqu'un l'a dit, cette mesure ne serait pas à propos de l'efficacité des instructions SQL. C'est à propos de leur complexité, ou les risques qu'ils présentent pour les tests (par exemple, manque un prédicat, ou à l'aide d'un intérieur au lieu d'une jointure gauche, ou l'infâme pourquoi mon simple requête qui prend une éternité à s'exécuter?, alias le manque de jointure). En ce sens, je ne vois pas pourquoi la présence d'un index doit être pris en compte.
InformationsquelleAutor pascal
4

Sentez-vous svp libre pour essayer 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é

InformationsquelleAutor Aalamjeet Rangi
2

Requêtes SQL sont déclaratives et non de procédure: ils ne précisent pas comment atteindre leur but. Le moteur SQL permettra de créer une procédure de plan d'attaque, et qui pourrait être un bon endroit pour chercher de la complexité. Essayez l'examen de la sortie de l'EXPLIQUER (ou d'EXPLIQUER le PLAN d') déclaration, il sera brut de description des étapes que le moteur va utiliser pour exécuter votre requête.
- "Les requêtes SQL sont déclaratives et non de procédure", ce qui est pourquoi vous ne pouvez pas envisager de le SQL DML en isolement à partir de SQL DDL.
- En principe, donc la complexité cyclomatique a pu être calculée pour un plan d'exécution et donc de donner une mesure indirecte de la complexité de la source SQL qui l'a produite. Le problème est que les plans d'exécution sont généralement d'une fusion contenant de l'exécution décrits par toutes les sous-routines (dans ce cas, les vues, les fonctions à valeur de table, etc.), donc ça ne fonctionne pas non plus!
InformationsquelleAutor Ned Batchelder
1

Eh bien, je ne sais pas du tout outil qui a fait une telle chose, mais il me semble que ce serait faire une requête plus complexe 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 conversions à divers 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 semblent être ceux avec le plus possible les défauts, je trouve que les plus simples, sont très susceptibles de contenir des défauts, car ils sont plus susceptibles d'être écrit par quelqu'un qui ne veut pas comprendre le modèle de données et ainsi, ils peuvent apparaître à travailler correctement, mais en fait le retour des données erronées. Donc, je ne suis pas sûr que telle métrique wouild vous en dire beaucoup.
- Comme toute analyse de code statique, l'utilité est limitée. Je suis d'accord avec ce que vous dites. Mais laisse envisager une situation où un seul développeur ou trois tout aussi talentueux développeurs écrit 20 requêtes. S'il était possible de déterminer les requêtes qui ont été les plus complexes et donc plus likly à contenir des défauts, les tests peuvent se concentrer d'abord et/ou plus d'une de ces requêtes. Statique des analyseurs de code ne sont jamais les indicateurs de justesse, ils ne sont que des indices. Ils vous donnent quelque chose d'autre à renifler pour les "odeurs de code'.
InformationsquelleAutor HLGEM
0

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

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

InformationsquelleAutor Abe Miessler
0

En fonction de votre SGBDR, il pourrait y avoir de plan de requête outils qui peuvent vous aider à analyser les étapes du SGBDR tiendra durant le chargement de votre requête.

SQL Server Management Studio Express est doté d'un plan d'exécution de requête. Pervasive PSQL a son Plan de Requête Finder. DB2 a outils similaires (oublié qu'on les appelle).

InformationsquelleAutor duraz0rz
0

Une bonne question. Le problème, c'est que pour une requête SQL comme:
```
SELECT * FROM foo;
```
la complexité peut dépendre de ce que "foo" est et sur la base de données de mise en œuvre. Pour une fonction comme:
```
int f( int n ) {
   if ( n == 42 ) {
      return 0;
   }
   else {
      return n;
   }
}
```
il n'existe pas de dépendance.

Cependant, je pense qu'il devrait être possible de trouver des métriques utiles pour une sélection, même si elles ne sont pas très précis, et je serai curieux de voir quelles réponses il obtient.
- Je suis plutôt en désaccord à propos de la foo exemple. Ce serait comme la prise en compte de la complexité des fonctions appelées, lors de la mesure de la complexité d'un code de procédure.
- D'accord. La complexité cyclomatique d'exemple vous indique le nombre de chemins possibles à travers une section de code source, et dans l'utilisation normale ne permet pas de calculer les nouvelles sous-chemins avec des sous-routines sont appelées. C'est à propos de la complexité de la section de code à la main, c'est à dire la façon lisible et donc maintenable est-il.
InformationsquelleAutor
0

En l'absence d'outils qui vont ce faire, une approche pragmatique serait de s'assurer que les requêtes en cours d'analyse sont régulièrement mises en forme, puis de compter les lignes de code.

Vous pouvez également utiliser la taille des requêtes en octets lors de l'enregistrement du fichier (être attentif à ce que toutes les requêtes sont enregistrées en utilisant le même codage de caractères).

Pas génial mais une approximation raisonnable de la complexité en l'absence de quoi que ce soit d'autre je pense.

InformationsquelleAutor redcalx

Vous devez vous connecter pour publier un commentaire.