Ordre d'exécution de la requête SQL

Je suis confondu avec l'ordre de l'exécution de cette requête, veuillez m'expliquer ce.
Je suis confus lors de la jointure est appliquée, la fonction est appelée, une nouvelle colonne est ajoutée avec le Cas et lorsque le numéro de série est ajouté. Veuillez expliquer l'ordre d'exécution de tout cela.

select Row_number() OVER(ORDER BY (SELECT 1))  AS 'Serial Number', 
    EP.FirstName,Ep.LastName,[dbo].[GetBookingRoleName](ES.UserId,EP.BookingRole) as RoleName,  
    (select top 1 convert(varchar(10),eventDate,103)from [3rdi_EventDates] where EventId=13) as EventDate,
    (CASE [dbo].[GetBookingRoleName](ES.UserId,EP.BookingRole)  
            WHEN    '90 Day Client' THEN 'DC'
            WHEN    'Association Client'  THEN  'DC'
            WHEN    'Autism Whisperer'    THEN  'DC'
            WHEN    'CampII'             THEN   'AD' 
            WHEN    'Captain'              THEN 'AD' 
            WHEN    'Chiropractic Assistant' THEN 'AD'
            WHEN    'Coaches'               THEN 'AD'
            END) as Category from [3rdi_EventParticipants] as EP  
    inner join [3rdi_EventSignup] as ES on EP.SignUpId = ES.SignUpId  
    where EP.EventId = 13
    and userid in (  
    select distinct userid from userroles  
    --where roleid not in(6,7,61,64) and roleid not in(1,2))  
    where roleid not in(19, 20, 21, 22) and roleid not in(1,2))

C'est la fonction qui est appelée à partir de la requête ci-dessus.

CREATE function [dbo].[GetBookingRoleName]  
(  
 @UserId as integer,
 @BookingId as integer
)  
RETURNS varchar(20)  
as  
begin  
declare @RoleName varchar(20)  

if @BookingId = -1
Select Top 1 @RoleName=R.RoleName From UserRoles UR inner join Roles R on UR.RoleId=R.RoleId Where UR.UserId[email protected]UserId and R.RoleId not in(1,2)  
else
Select @RoleName= RoleName From Roles where RoleId = @BookingId

return @RoleName  
end

source d'informationauteur NoviceToDotNet

sql-server

29

SQL n'a pas d'ordre d'exécution. Est un langage déclaratif. L'optimiseur est libre de choisir toute ordonnance qu'il estime appropriés pour produire le meilleur moment de l'exécution. Compte tenu de toute requête SQL, est pratiquement impossible pour quiconque de prétendre qu'il sait que l'ordre d'exécution. Si vous ajoutez des informations détaillées sur le schéma impliqués (exact de tables et d'index définition) et de l'estimation des cardinalités (taille des données et la sélectivité des touches), alors on peut prendre un deviner à la probable ordre d'exécution.

En fin de compte, le seul bon "ordre" est décrit ci-ion le plan d'exécution. Voir Affichage des Plans d'Exécution à l'Aide de SQL Server Profiler des Classes d'Événements et Affichage Graphique des Plans d'Exécution (SQL Server Management Studio).

Est une chose complètement différente si est de savoir comment faire des requêtes, des sous-requêtes et les expressions se projettent dans la 'validité'. Par exemple, si vous avez un alias de l'expression dans le SÉLECTIONNEZ la liste de projection, vous pouvez utiliser l'alias dans la clause where? Comme ceci:
```
SELECT a+b as c
FROM t
WHERE c=...;
```
Est l'utilisation de c alias valide dans la clause where? La réponse est NON. Les requêtes de la forme d'un arbre de syntaxe, et une branche inférieure de l'arbre ne peut pas être quelque chose de référence défini plus haut dans l'arbre. Ce n'est pas nécessairement un ordre de "exécution", est plus d'une syntaxe problème d'analyse. Il est équivalent à l'écriture de ce code en C#:
```
void Select (int a, int b)
{
   if (c = ...) then {...}
   int c = a+b;
}
```
Tout comme en C# ce code ne compile pas car la variable c est utilisé avant est défini, SÉLECTIONNEZ ci-dessus ne compile pas correctement, parce que l'alias c est référencé plus bas dans l'arbre qu'est réellement définie.

Malheureusement, à la différence de la bien connue des règles de C/C# d'analyse de langage, les règles SQL de la façon dont l'arborescence de la requête est construite sont quelque peu ésotérique. Il y a une brève mention d'eux dans Seul Traitement d'une Instruction SQL mais une discussion détaillée de la façon dont ils sont créés, et de quel ordre est valide et ce n'est pas, je ne sais pas de n'importe quelle source. Je ne dis pas qu'il n'y a pas de bonnes sources, je suis sûr que certains de la bonne SQL ouvrages couvrir ce sujet.

Noter que l'arbre de syntaxe de commande ne correspond pas à l'ordre visuel du texte SQL. Par exemple, la clause ORDER BY est généralement la dernière dans le texte SQL, mais comme un arbre de syntaxe, il se trouve au dessus de tout le reste (il trie les sortie de la SÉLECTIONNER, de sorte qu'il se trouve au-dessus des colonnes Sélectionnées façon de parler) et en tant que tel est est valable pour faire référence à la c alias:
```
SELECT a+b as c
FROM t
ORDER BY c;
```
Mis à jour

Fait il y a ceci: Le Traitement logique de Commande de l'instruction SELECT
Les étapes suivantes montrent la logique
l'ordre de traitement, ou de l'ordre de liaison,
pour une instruction SELECT. Cette commande
détermine si les objets définis dans
une étape sont mis à la disposition des
clauses dans les étapes suivantes. Pour
exemple, si le processeur de requête peut
lier (accès) les tables ou les vues
défini dans la clause from, ces
les objets et leurs colonnes sont faites
disponible pour toutes les étapes suivantes.
À l'inverse, parce que la clause SELECT
est l'étape 8, tous les alias de colonne ou
dérivé colonnes définies dans la clause
ne peut pas être référencée par le précédent
les clauses. Cependant, ils peuvent être
référencé par les clauses de ces
que la clause ORDER BY. Notez que l'
physique réel de l'exécution de la
l'énoncé est déterminé par la requête
processeur et l'ordre peut varier d'
de cette liste.
1. DE
2. SUR
3. REJOINDRE
4. OÙ
5. GROUPE PAR
6. AVEC CUBE ou AVEC le correctif CUMULATIF
7. AVOIR
8. SÉLECTIONNEZ
9. DISTINCTES
10. COMMANDE PAR
11. HAUT

Requêtes sont généralement traitées dans l'ordre (SQL Server). Je n'ai aucune idée si d'autres SGBDR de faire de cette façon.

FROM [MyTable]
    ON [MyCondition]
  JOIN [MyJoinedTable]
 WHERE [...]
 GROUP BY [...]
HAVING [...]
SELECT [...]
 ORDER BY [...]

3

SQL est un langage déclaratif, ce qui signifie qu'il indique au moteur SQL quoi faire, pas comment. Ceci est en contraste à un langage impératif comme le C, dans laquelle la façon de faire quelque chose est claire.

Cela signifie que tous les énoncés s'exécuter comme prévu. De note particulière sont des expressions booléennes, qui ne peut pas évaluer de gauche à droite comme à l'écrit. Par exemple, le code suivant n'est pas garanti de fonctionner sans une erreur de division par zéro:
```
SELECT 'null' WHERE 1 = 1 OR 1 / 0 = 0
```
La raison pour cela est l'optimiseur de requête choisit la meilleure (la plus efficace) de manière à exécuter une instruction. Cela signifie que, par exemple, une valeur peut être chargé et filtré avant la transformation prédicat est appliqué, ce qui provoque une erreur. Voir le second lien ci-dessus pour un exemple

Voir: ici et ici.
2

"Ordre d'exécution" est probablement un mauvais modèle mental pour les requêtes SQL. C'est dur d'écrire une requête unique qui serait en fait dépendre de l'ordre d'exécution (ce qui est une bonne chose). Au lieu de cela, vous devriez penser à toutes les joindre et où l'une des clauses qui se passe simultanément (presque comme un modèle)

Qui dit que vous pouvez afficher le Les Plans D'Exécution qui devrait vous donner un aperçu.

Cependant depuis son n'est pas clair pourquoi vous voulez connaître l'ordre de l'exécution, je devine votre essayant d'obtenir un modèle mental pour cette question, de sorte que vous pouvez le fixer en quelque sorte. C'est comment "traduire" votre requête, bien que je l'ai bien fait avec ce type d'analyse, il y a quelques zone grise avec son degré de précision.

ET OÙ LA CLAUSE
- De me donner tous les Participants d'un Événement lignes. from [3rdi_EventParticipants
- Aussi de me donner tous les Cas d'Inscription de lignes qui correspondent aux Participants d'un Événement lignes sur SignUpID inner join 3rdi_EventSignup] as ES on EP.SignUpId = ES.SignUpId
- Mais Seulement pour l'Événement 13 EP.EventId = 13
- Et seulement si l'utilisateur a un dossier dans les rôles d'utilisateur table où le rôle de l'id n'est pas dans 1,2,19,20,21,22
  userid in ( select distinct userid from userroles --where roleid not in(6,7,61,64) and roleid not in(1,2)) where roleid not in(19, 20, 21, 22) and roleid not in(1,2))
CLAUSE SELECT
- Pour chacune des lignes de me donner un ID unique
  Row_number() OVER(ORDER BY (SELECT 1)) AS 'Serial Number',
- Les participants prénom EP.FirstName
- Les participants Nom Ep.LastName
- La Réservation du nom de Rôle GetBookingRoleName
- Aller chercher dans les Dates de l'Événement et découvrir ce que le premier eventDate où l'EventId = 13 que vous trouvez
  (select top 1 convert(varchar(10),eventDate,103)from [3rdi_EventDates] where EventId=13) as EventDate
- Enfin traduire le GetBookingRoleName dans la Catégorie. Je n'ai pas de table pour cela, je vais donc la carte manuellement (CASE [dbo].[GetBookingRoleName](ES.UserId,EP.BookingRole) WHEN '90 Day Client' THEN 'DC' WHEN 'Association Client' THEN 'DC' WHEN 'Autism Whisperer' THEN 'DC' WHEN 'CampII' THEN 'AD' WHEN 'Captain' THEN 'AD' WHEN 'Chiropractic Assistant' THEN 'AD' WHEN 'Coaches' THEN 'AD' END) as Category
Quelques notes ici. Vous n'êtes pas de la commande par quoi que ce soit lorsque vous sélectionnez HAUT. Vous devriez probablement na afin de. Vous pourriez tout aussi facilement mettre cela dans votre clause from par exemple
```
from [3rdi_EventParticipants] as EP  
    inner join [3rdi_EventSignup] as ES on EP.SignUpId = ES.SignUpId,   
       (select top 1 convert(varchar(10),eventDate,103)
       from [3rdi_EventDates] where EventId=13
       Order by eventDate) dates
```

Annuler la réponse

Vous devez vous connecter pour publier un commentaire.