Происхождение столбцов

функциональный

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: тот же механизм превращает фильтры по столбцам в настоящие предикаты вместо сравнения меток.
SQLly
Подсказка в заголовке сетки результатов показывает таблицу и столбец — источник значенияПодсказка в заголовке сетки результатов показывает таблицу и столбец — источник значения
Наведение на заголовок столбца результата с псевдонимом: SQLly указывает исходный столбец и базовую таблицу, из которой он взят.

Зачем вообще хранить это в модели

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