Происхождение столбцов
функциональныйSQLly запоминает, из какой таблицы и столбца на самом деле пришел каждый результирующий столбец, чтобы инструменты могли работать с источником, а не с меткой.
Заголовок столбца результата — это оформление, а не идентичность. SELECT p.Name AS PermissionName
помечает столбец PermissionName, но такого имени нет ни в одном столбце вашей базы данных — и T-SQL не даст вам упомянуть SELECT псевдоним в WHERE вообще. Поэтому, когда SQLly выполняет оператор, он его ещё и читает: для каждого столбца в сетке он вычисляет какой псевдоним таблицы и исходный столбец дали это значение, и сохраняет этот ответ привязанным к набору результатов.
Именно это делает сетку интерактивной, а не декоративной. Щелкните правой кнопкой мыши по ячейке и запросите WHERE = это значение, и SQLly не вставляет заголовок обратно — он строит предикат по настоящему исходному столбцу, с правильной квалификацией и кавычками для движка, из которого получены результаты.
Два вопроса, два ответа
Происхождение отвечает на два разных вопроса, и при смешении получится SQL, который не скомпилируется. SQLly намеренно держит их отдельно:
- Столбец источника
- «Что мне написать в предикате, добавляемом к этому оператору?» Всегда ссылка, которая действительна в области действия внешнего запроса, поэтому значение, поступающее через производную таблицу или CTE, сохраняет псевдоним этой производной таблицы.
- Происхождение
- «Откуда в конечном итоге взялось это значение?» Прослежено на один уровень сквозь производную таблицу или тело CTE — до базовой таблицы и столбца. Это только для отображения — всплывающие подсказки и статусные панели — и никогда для предикатов.
Разобранный пример: псевдоним
Обычный случай. Две объединенные таблицы, обе с Name столбцом, обе с псевдонимами в списке выборки:
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
Наведите указатель на PermissionName заголовок, и SQLly сообщит вам
Source: p.Name from Shared.Permission p. Щёлкните ячейку в нём правой кнопкой мыши и выберите
WHERE = это значение, и вы получите предикат, который действительно выполняется:
-- what a label-based tool would write (and SQL Server would reject) WHERE PermissionName = 'Export' -- what SQLly writes WHERE p.[Name] = 'Export'
Обратите внимание на использование кавычек: псевдоним остаётся без кавычек, так как в кавычках не нуждается, столбец получает собственные разделители движка, а литерал отображается в диалекте этого движка. Та же логика применяется для каждого оператора в меню - <>, >=, LIKE, starts-with и ends-with, IN по выделению из нескольких ячеек, IS NULL - и для
Сопоставить строку, который разрешает каждый столбец выбранной строки с использованием одного и того же разбора и объединяет их с AND.
Разобранный пример: производный столбец
Значения, поступающие через подзапрос, требуют оба ответа сразу. Предикат должен быть написан во внешней области видимости, где доступны только sub существует; подсказка всё равно должна говорить, где на самом деле лежат данные:
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
Трассировка справляется и с неудобными вариантами записи. Звёздочка внутри подзапроса разрешается сквозь неё, когда тело читает одну таблицу, а список столбцов производной таблицы переименовывает проекции позиционно:
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
Разобранный пример: CTE
CTE ведёт себя так же: внешний запрос видит именованное отношение, поэтому предикаты пишутся по этому имени, а источник столбца прослеживается через тело до базовой таблицы. Явный список столбцов в CTE переименовывает столбцы по позиции, точно так же, как в производной таблице:
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
Несколько CTE в одном выражении разрешаются независимо, поэтому соединение двух CTE приписывает каждый столбец к своей базовой таблице.
Представления и как далеко прослеживается след
Происхождение читает оператор перед ним - то, что находится в вашем редакторе. Представление в FROM поэтому и разрешается как объект, каким он и является: предикаты пишутся к представлению (что корректно, эти столбцы у представления есть), а всплывающая подсказка называет представление и столбец. Идти по следу дальше этой точки означает читать определение представления, которое живёт на сервере, а не в вашем запросе.
Сегодня этот шаг — осознанный и делается одним нажатием клавиши: используйте Навигация по исходному коду DDL чтобы открыть определение представления, и происхождение разрешается внутри которая оператор — включая псевдонимы, производные таблицы и CTE. Автоматическое прохождение по цепочке, чтобы столбец в результате представления над представлением сообщал свою итоговую базовую таблицу без каких-либо действий с вашей стороны, — естественное развитие того же механизма, и именно ради этого и хранится кэшированная модель схемы.
Когда SQLly молчит
Разрешение имён намеренно консервативно — по принципу, что неправильный предикат хуже, чем отсутствие предиката. Когда атрибуция не определена, происхождение ничего не возвращает, заголовок не получает подсказку, а действия в сетке откатываются к обычной метке результата. Случаи:
- Вычисляемые выражения.
COUNT(*) AS Totalилиp.First + p.Last AS FullNameне имеют одного исходного столбца, поэтому у них нет происхождения. - Объединения и скрипты с несколькими инструкциями. С более чем одной верхнеуровневой
SELECT, нет одной инструкции, к которой можно это отнести. - Неоднозначные звёздочки (*).
SELECT *над соединением нельзя соотнести с таблицей без данных каталога;p.*над соединением можно, потому что квалификатор говорит, к какой таблице он относится. Звёздочку, смешанную с явной проекцией с тем же именем, тоже отклонят — столбец, по которому щёлкнули, может оказаться любым из них. - Голые столбцы при соединении.
SELECT Name FROM A a JOIN B b …сохраняет имя столбца, но без уточнения. Над одной таблицей уточнение уже появляется: псевдоним или имя таблицы со схемой, если псевдонима нет. - Любое вложение глубже одного уровня. Производная таблица внутри производной таблицы, CTE, читающий другой CTE, или производная таблица, тело которой читает CTE: внешняя ссылка по-прежнему разрешается для условий, но происхождение сообщается как неизвестное, а не предполагаемое.
- Рекурсивные или
UNIONтела CTE. Непрозрачны по происхождению; внешняя ссылка по-прежнему работает в предикатах.
Повторяющиеся заголовки обрабатываются по позиции, а не по имени: с p.Name, rm.Name
первый столбец сетки приписывается p а второй — к rm. Идентификаторы в кавычках сравниваются без кавычек и без учёта регистра, так что [Name],
"Name", и `Name` все означают один и тот же столбец, а имя с разделителями, содержащее знаки препинания или начинающееся с цифры, читается целиком, а не заново токенизируется.
Что это обеспечивает
Один разбор оператора питает все части приложения, которым нужно говорить о столбце результата на языке SQL:
- Всплывающие подсказки заголовков. Наведите курсор на любой заголовок столбца, чтобы увидеть исходный столбец, а когда трассировка что-то добавляет — и базовую таблицу за ним.
- WHERE из сетки. Каждое сравнение,
LIKE,IN, и проверка на null в контекстном меню ячейки, построенная по исходному столбцу в диалекте движка результатов, с предпросмотром, который рендерится из того же сопоставления, что и будет использовано, — предпросмотр и вставленный SQL не могут разойтись. - Сопоставить строку. Вот
ANDпредикатов равенства для всей выбранной строки, где каждый столбец вычисляется по отдельности. - Фильтры, преобразованные в SQL. Интерактивно отфильтруйте сетку, затем Применить к запросу / Добавить активные фильтры в WHERE: тот же механизм превращает фильтры по столбцам в настоящие предикаты вместо сравнения меток.


Зачем вообще хранить это в модели
Потому что с результатом, который знает своё происхождение, можно работать, а не просто читать. Дополнительные метаданные, которые едут вместе со строками, — это то, что позволяет таблице построить правильный фильтр из случайно замеченной ячейки, не восстанавливая запрос в голове; это фундамент для перехода от значения к объекту, который его создал, и для генерации предикатов по нескольким столбцам через соединения и производные таблицы, которые вручную писать утомительно. Метаданные идут первыми; каждый из этих инструментов — потом небольшой честный шаг поверх них, а не догадка.