Origine de la colonne
fonctionnelSQLly se souvient de la table et de la colonne dont provient réellement chaque colonne de résultat, afin que les outils puissent agir sur la source plutôt que sur le libellé.
L’en-tête d’une colonne de résultat relève de la présentation, pas de l’identité. SELECT p.Name AS PermissionName
étiquette la colonne PermissionName, mais ce nom n’existe comme colonne nulle part dans votre base de données - et T-SQL ne vous permettra pas de mentionner un SELECT alias dans une clause WHERE clause du tout. Donc lorsque SQLly exécute une instruction, il la lit aussi : pour chaque colonne de la grille, il détermine quel alias de table et quelle colonne sous-jacente ont produit cette valeur, et garde cette réponse attachée à l’ensemble de résultats.
C’est ce qui rend la grille exploitable plutôt que décorative. Faites un clic droit sur une cellule et demandez WHERE = cette valeur, et SQLly ne vous renvoie pas l'intitulé ; il écrit le prédicat sur la colonne source réelle, correctement qualifiée et entre guillemets pour le moteur d'où proviennent les résultats.
Deux questions, deux réponses
La provenance répond à deux questions différentes, et les confondre produirait un SQL qui ne se compile pas. SQLly les garde séparées intentionnellement :
- Colonne source
- « Que dois-je écrire dans un prédicat ajouté à cette instruction ? » Toujours une référence valide dans la portée de la requête externe, si bien qu'une valeur arrivant via une table dérivée ou un CTE conserve l'alias de cette table dérivée.
- Origine
- « D'où cette valeur provient-elle finalement ? » Remontée d’un niveau à travers une table dérivée ou le corps d’une CTE jusqu’à la table et la colonne de base. Elle est destinée à l’affichage - info-bulles et zones d’état - jamais aux prédicats.
Exemple pratique : un alias
Le cas courant. Deux tables jointes, toutes deux avec une Name colonne, toutes deux aliasées dans la liste de sélection :
SELECT rm.Name AS ModelName, p.Name AS PermissionName FROM Shared.ReferenceModelPermissions rmp INNER JOIN Shared.Permission p ON p.PermissionId = rmp.PermissionId INNER JOIN Shared.ReferenceModel rm ON rm.ReferenceModelId = rmp.ReferenceModelId
Survolez l' PermissionName en-tête et SQLly vous indique
Source: p.Name from Shared.Permission p. Cliquez avec le bouton droit sur une cellule et choisissez
WHERE = cette valeur, et vous obtenez le prédicat qui s'exécute réellement :
-- what a label-based tool would write (and SQL Server would reject) WHERE PermissionName = 'Export' -- what SQLly writes WHERE p.[Name] = 'Export'
Notez les guillemets : l'alias reste sans guillemets car il n'en a pas besoin, la colonne prend les délimiteurs propres au moteur, et la valeur littérale est rendue dans le dialecte de ce moteur. La même résolution s'applique à chaque opérateur du menu - <>, >=, LIKE, commence-par et se-termine-par, IN sur une sélection multi-cellules, IS NULL - et pour
Correspondre à la ligne, qui résout chaque colonne de la ligne cliquée contre la même analyse unique et les combine avec AND.
Exemple pratique : une colonne dérivée
Les valeurs qui arrivent via une sous-requête ont besoin des deux réponses à la fois. Le prédicat doit être écrit dans le scope externe, où seul sub existe ; l'infobulle devrait toujours vous indiquer où les données se trouvent réellement :
SELECT sub.y AS Z FROM (SELECT x AS y FROM T) sub predicate → sub.y = … (valid outside; T.x would not be) tooltip → Source: T.x
Le traçage gère également les orthographes inhabituelles. Une étoile à l'intérieur de la sous-requête se résout à travers elle lorsque le corps lit une table, et la liste de colonnes d'une table dérivée renomme les projections positionnellement :
SELECT sub.Name AS N FROM (SELECT * FROM Shared.Permission p) sub → Source: p.Name from Shared.Permission p SELECT d.b AS Out FROM (SELECT p.Name, p.Id FROM P p) d (a, b) → b is the second projection: Source: p.Id from P p
Exemple pratique : une CTE
Un CTE se comporte de la même manière : la requête externe voit une relation nommée, donc les prédicats sont écrits par rapport à ce nom, tandis que l'origine suit le corps jusqu'à la table de base. Une liste de colonnes explicite sur le CTE renomme positionnellement, exactement comme sur une table dérivée :
WITH x AS (SELECT p.Name AS a FROM Shared.Permission p) SELECT x.a AS Alpha FROM x predicate → x.a = … tooltip → Source: p.Name from Shared.Permission p WITH x (u, v) AS (SELECT p.Name, p.Id FROM P p) SELECT v FROM x → Source: p.Id from P p
Plusieurs CTE dans une même requête se résolvent indépendamment, donc une jointure à deux CTE attribue chaque colonne à sa propre table de base.
Vues, et jusqu'où va la piste
La provenance lit l'instruction qui la précède - celle qui se trouve dans votre éditeur. Une vue dans la FROM clause est donc résolue pour ce qu'elle est : les prédicats sont écrits sur la vue (ce qui est correct, la vue a ces colonnes), et l'infobulle nomme la vue et la colonne. Aller plus loin dans la piste revient à lire la définition de la vue, qui vit sur le serveur et non dans votre requête.
Aujourd'hui, cette étape est délibérée et tient en une seule touche : utilisez Navigation source DDL pour ouvrir la définition de la vue, et la provenance se résout à l'intérieur que instruction - alias, tables dérivées et CTE inclus. Les chaîner automatiquement, de sorte qu'une colonne dans un résultat de vue-sur-vue indique sa table de base ultime sans que vous ayez à ouvrir quoi que ce soit, est l'extension naturelle de ce même mécanisme et c'est pourquoi le modèle de schéma mis en cache est conservé.
Lorsque SQLly ne dit rien
La résolution est délibérément conservatrice, selon le principe que un prédicat incorrect est pire qu’aucun prédicat. Lorsque l'attribution n'est pas certaine, la provenance ne renvoie rien, l'en-tête ne reçoit aucun infobulle, et les actions de la grille retombent sur l'étiquette de résultat simple. Les cas :
- Expressions calculées.
COUNT(*) AS Totaloup.First + p.Last AS FullNamen'ont pas de colonne source unique, donc elles n'ont pas de provenance. - Unions et scripts multi-instructions. Avec plus d'un niveau supérieur
SELECT, il n'y a pas une seule instruction à attribuer. - Étoiles ambiguës.
SELECT *sur une jointure ne peuvent pas être attribuées sans données de catalogue ;p.*sur une jointure peuvent l'être, car le qualificateur indique quelle table. Mélanger une étoile avec une projection explicite qui partage son nom est également refusé - la colonne cliquée pourrait être l'une ou l'autre. - Colonnes nues sur une jointure.
SELECT Name FROM A a JOIN B b …conserve le nom de la colonne mais ne gagne aucun qualificateur. Sur une seule table, elle en gagne un : l'alias, ou le nom de table qualifié par le schéma lorsqu'il n'y a pas d'alias. - Tout ce qui est imbriqué à plus d'un niveau. Une table dérivée à l'intérieur d'une table dérivée, un CTE lisant un autre CTE, ou une table dérivée dont le corps lit un CTE : la référence externe se résout toujours pour les prédicats, mais l'origine est signalée comme inconnue plutôt que devinée.
- Récursif ou
UNIONCorps de CTE. Opaque à des fins d'origine ; la référence externe fonctionne toujours pour les prédicats.
Les en-têtes en double sont gérés par position plutôt que par nom : avec p.Name, rm.Name
la première colonne de la grille est attribuée à p et la seconde à rm. Les identifiants entre guillemets sont comparés sans leurs guillemets et sans tenir compte de la casse, donc [Name],
"Name", et `Name` tous signifient la même colonne, et un nom délimité contenant une ponctuation ou commençant par un chiffre est lu en entier plutôt que re-tokenisé.
Ce qu'il alimente
Une seule analyse par instruction alimente tout ce qui doit décrire une colonne de résultat en termes SQL :
- Infobulles des en-têtes. Survolez n'importe quel en-tête de colonne pour voir la colonne source, et la table de base derrière elle lorsque le traçage ajoute quelque chose.
- WHERE depuis la grille. Chaque comparaison,
LIKE,IN, et une vérification de null dans le menu contextuel de la cellule, écrite sur la colonne source dans le dialecte du moteur des résultats, avec un aperçu rendu par la même résolution que celle qui sera utilisée, de sorte que l'aperçu et le SQL inséré ne peuvent pas diverger. - Correspondre à la ligne. Une
ANDdes prédicats d'égalité pour toute la ligne cliquée, chaque colonne étant résolue individuellement. - Filtres, promus en SQL. Filtrer la grille de manière interactive, puis Appliquer à la requête / Ajouter les filtres actifs à WHERE: le même résolveur transforme vos filtres de colonnes en véritables prédicats au lieu de comparaisons d’étiquettes.


Pourquoi conserver cela dans le modèle
Parce qu'un ensemble de résultats qui connaît sa propre provenance peut être manipulé, pas seulement lu. Embarquer les métadonnées supplémentaires avec les lignes, c'est ce qui permet à la grille de construire un filtre correct à partir d'une cellule que vous avez remarquée en passant, sans avoir à reconstruire la requête dans votre tête, et c'est la fondation qui permet de remonter d'une valeur à l'objet qui l'a produite, et de générer des prédicats multicolonnes à travers des jointures et des tables dérivées qui seraient fastidieux à écrire à la main. Les métadonnées d'abord ; chacun de ces outils devient ensuite une petite étape honnête par-dessus, plutôt qu'une supposition.