SQL-файл и SQLCMD (продолжение описания технологии SQL-файл)

Технология SQL-файл — это не одни только сценарии, подобные CMD/PS/и т. п. Она скорее от слова “SQL-проект” (или конструктор SQL-проектов) — автономный, однако и доступный для интеграции (FAR, GUI-редактор простого текста, редактор SSMS). SQL-файл предлагает некоторую унификацию для взаимодействия с базовой утилитой MS SQLCMD: исходный(ые) файл(ы) SQL => $SQLTRANS => SQLCMD. Автор осмысленно не стал “отрываться” от SQLCMD (например, используя ADO.NET + C#), поскольку SQLCMD предоставляет уйму известных в документации параметров поведения (и не только поэтому).

I. По поводу препроцессинг-а, осуществляемого подпрограммой SqlCatPP

Исходные скрипты могут быть непростыми для разбора: комментарии, участки строкового литерала и т. п. Скрипты же с динамическими подзапросами (формирование строки подзапроса EXEC) могут оказаться коварными для специального (не от MS) обработчика T-SQL. В SqlCatPP по умолчанию включен т. н. “слабый препроцессинг” (см. ранее п. II.3 основной статьи). Сильный же препроцессинг (реализован в режиме тестирования), если это особо не требуется, включать не рекомендуется! А именно: не следует без необходимости использовать сеттинг “set SqlCatPP.ProcessDirectives=1”; желательно поставить в начале строки префикс комментария “rem …” (рекомендуется), либо установить параметр-опцию в значение 0. (В т. ч. — и в проектах SQLAUX и “MyFlat app. (MVC_Razor+TS+ADO+TSQL)”, где это в целях демонстрации включено.) Данная опция НЕ проверялась на “понимание” сложных скриптов!

Так же, доступно специальное отключение и для слабого режима препроцессинг-а (явно: “set SqlCatPP.InsertSetVarComments=0” и “set SqlCatPP.UnfoldEnvironmentVars=0”), для SqlCatPP. Препроцесинг-и НЕ тестировались на сложных скриптах! Однако, в слабом режиме — намного меньшая вероятность неудачи (ошибки) или иной досадной неприятности с подобной предварительной обработкой SQL. На обычной же сложности примерах-скриптах (таких как в Handicraft-SDK и не только) слабый препроцессинг SQL работает успешно.

SqlCatPP это, во-первых, конкатенатор исходных SQL-скриптов, а также (в зависимости от настроек-опций) и препроцессор. SQL-файл (в текущем исполнении) прежде всего полагается на SQLCMD, в том числе и касательно батч-ей T-SQL с применением разделителя GO. Подпрограмма SqlCatPP НЕ обрабатывает разделитель GO. Конкатенация же (сцепление) исходных скриптов осуществляется с учётом корректирующего файла “$sql_order.list” (“;SQL-TRANSLATION PRIMARY ORDER:”, из каталога файла SQL).

II. Взаимодействие с SQLCMD

Подобную команду можно видеть при т. н. запуске “list_programmatics.sql”:
[[
>> SqlCmd -S”(local)” -d”TEST” -i”C:\Users\serg\AppData\Local\Temp\$SQLTRANS\20210907_122616_89.sql” -o”C:\Users\serg\AppData\Local\Temp\$SQLTRANS\20210907_122616_89.txt” -b -w65535 -u

* Executing SQL …
=== LIST OF PROGRAMMATICS (SQLAUX LIBRARY): ===

Stored procedures
—————————————————————————————————-
AUX:DropFunction
AUX:DropFunctions
AUX:DropProcedure
AUX:DropProcedures
: : : : :
]]

По умолчанию SQLCMD получает от $SQLTRANS, так же (помимо параметров и др. ключей), ключ “-b (terminate batch job if there is an error)”. Однако, если установить “set $sqltrans.ContinueOnBatchError=1”, то ключ “-b” передаваться не будет. Можно, так же, передавать в SQLCMD и другие параметры: “set $sqltrans.AdditionalParams=…”. (Включение режима фиктивной трансляции: “set $sqltrans.TranslateToDatabase=0”. И т. п.)

Т. о. $SQLTRANS и SqlCatPP не пытаются заменить всё то, что умеет (на стороне клиента SQL-Server) многофункциональная утилита SQLCMD от MS.

III. Если отказаться от зависимости SQLCMD (а так же от использования процессора CMD)

Собираясь отказываться от задействования в трансляциях утилиты SQLCMD, разумным будет так же уйти от использования в SQL-файл сценариев CMD. Один из существенных недостатков установки свойств в CMD является, помимо затруднённого включения кодировки UTF-8 (без BOM-префикса), выражение переменной через переменную (в контексте формирования Environment). А именно: когда мы где-то в командном файле ссылаемся на несуществующее свойство (переменную), то это, с точки зрения CMD, не является ошибкой и воспринимается как пустой результат (фрагмент нулевой длины). Если, например, при обработке строки “set dt_Name_AUX=nvarchar(!num_NameCapacity_AUX!)” не было бы установлено заранее свойство “num_NameCapacity_AUX”, то “dt_Name_AUX” получило бы (молча) значение “nvarchar()” (вместо “nvarchar(100)”). SQL такой странный тип данных естественно не пропустит. Однако, не любая подобная ошибочная ситуация может столь успешно разрешаться (явной ошибкой на ранней стадии) на этапе восприятия сервером запроса SQL.

Несмотря на различные трудности, связанные со сценариями CMD, а также принимая во внимание многочисленные плюсы, которые предоставляет данный “legacy” процессор команд в контексте применения SQL-файл, трудно предложить полноценную достойную альтернативу для CMD. Отказываясь от SQLCMD+CMD, возможно, неплохо было бы разработать специальный формат сценария (свойства, типовые действия, условия и т. п.), допускающий так же выход на команды системы. Возможно, какой-нибудь из известных скриптовых кроссплатформенных языков мог бы, наверное, с должным успехом быть использован для подобных сценариев. Данная же реализация SQL-файл для MSSQL осмысленно придерживается SQLCMD, CMD, (опционально PS), сохраняя совместимость (ожидаемое поведение предварительной обработки SQL), а так же не стараясь отрываться от ряда полезных моментов (вещей) из прошлого. Это “кустарная” (handicraft) технология SQL-файл (в текущем её исполнении).

Автор блог-а

Китаев Сергей Юрьевич
Автор ресурса Handicraft-CODE
https://handicraft.remelias.ru/

Задачи SQL-файл в примерах (продолжение описания технологии SQL-файл)

В данной заметке автор приводит некоторые разъяснения относительно того, что из себя представляет технология SQL-файл, отталкиваясь от содержащихся в ней примеров (мелкие/средние/сложные SQL-проекты из загрузок Handicraft-CODE).

I. Рассуждения о различных типах и формах проекта (организация трансляции группы файлов)

Давайте посмотрим, как организован проект VS для C#. Большинству программистов .NET известно расширение “.csproj”. Многие представляют, как выглядит упрощённая конфигурация SDK-проекта для VS (это такой минималистический XML). Кое-кто также знает, что можно с помощью “.user”-файла подключить так же “.targets”, “.props”, а быть может и ещё кое-что (с более высокого уровня расположения, например). И это всё почти одинаково работает как в VS IDE, так и непосредственно через MSBUILD (компиляция в консоли).

Что из себя представляет проект VS Code? В подпапке “.vscode” C#-проекта: “tasks.json” (описывает, как компилировать внешним средством, со ссылками опять же на “.csproj”) и “launch.json” (информация о том, как следует запускать EXE). Для меток “build“, “watch“, “publish” видим: “command”: “dotnet”. Т.е. VS Code не сама всё обрабатывает, а через команду DOTNET (а уже внутри DOTNET, быть может, и через ядро от MSBUILD). Её редактор кода, вообще-то, не на 100% синхронизирован с компиляцией C# внешним средством (используется т. н. наблюдатель).

В SQL-файл для проекта применяются совсем простые сеттинг-и (переменные среды: “set …=…”). Однако, помимо корневых “$sql_settings.cmd” и “@<имя_проекта>.cmd”, кое-что может добавляться/перекрываться и на других уровнях. Используется примитивная, однако, весьма мощная древовидная структура сеттинг-ов (“$sql_settings.cmd” в каждой подпапке проекта на любом уровне). SQL-трансляция базируется на утилите MS SQLCMD. Прежде чем отправить что-либо в SQLCMD, исходный код проходит через слабый (по умолчанию) препроцессинг и конкатенацию SQL-скриптов (осуществляются подпрограммой “SqlCatPP.exe”), с промежуточным результатом-файлом в профильной папке TEMP (как источник для SQLCMD). Подход надёжный, эффективный, гибкий. Препроцессор-конкатенатор поддерживает различные опции. И утилита $SQLTRANS, если просто запустить “$sqltrans.cmd” в Windows-Explorer (без параметров) — тоже выведет на консоль, на что она способна (поддерживаемые параметры, переменные конфигурации, простые примеры вызова). Вы можете видеть синтаксис (JPeg-картинки) всех утилит и обёрток касательно SQL: $sqltrans, $sqlupload, $sql, $sqlcon, $sqltocsvexp, SqlCatPP (все лежат у автора на Яндекс.Диск-е в подпапке “Утилиты (картинки)”). Скриптовая библиотека хелпер-объектов Transact-SQL: https://yadi.sk/d/S-VLJSbEpZYROg (SQLAUX – ссылка на Яндекс.Диск, см. “Утилиты (картинки)”).

II. Примеры сложных и простых проектов SQL-файл как демонстрация её возможностей

Насчёт целей применения технологии SQL-файл: можно привести пример нетривиального проекта SQLAUX. Его (или проект подобный SQLAUX) не просто было бы поддерживать и обрабатывать другими средствами/инструментами/утилитами.

Вот ссылка на папку “Библиотека SQLAUX” (на Яндекс.Диск). Там внутри, помимо синтаксиса командных утилит, приводятся кое-какие фрагменты SQL для объектов библиотеки SQLAUX (точнее одной из её прошлых версий): “Имплементация объектов T-SQL”, “API (псевдо-заголовки SQL)”, “Картинки”.
Скриптовая библиотека хелпер-объектов Transact-SQL:
https://yadi.sk/d/S-VLJSbEpZYROg (ссылка на Яндекс.Диск)
Список хелперов SQLAUX (ссылка на Handicraft-CODE):
https://handicraft.remelias.ru/sdk/sql_file.html#sqlaux_programmatics
Следующим образом выглядит трансляция всех функций SQLAUX (отдельно от ХП):
https://handicraft.remelias.ru/sdk/sql/screenshots_1.html#sqlaux_functions_in_one_go_img
Там, в SQLAUX, довольно много SQL-объектов: 173 шт.
Всё, однако, доступно для трансляции в самых различных вариациях:
отдельный файл из редакторов (FAR, GUI, SSMS);
отдельный файл из панелей FAR-а (как в в окне Far Manager, так и во внешней консоли);
все объекты почти каждой из подпапок (на любом уровне);
все процедуры / все функции / все вспомогательные таблицы;
удаление процедур / удаление функций / удаление вспомогательных таблиц;
составная трансляция всего (SQLAUX): процедуры + функции + таблицы;
удаление всего (SQLAUX): -процедуры -функции -таблицы;
подготовка листинга объектов SQLAUX.
Объекты SQLAUX располагаются в подпапках: “Auxiliary tables”, “Functions”, “Procedures”.
Папки “Functions” и “Procedures” внутри себя содержат другие подпапки (ещё один уровень расположения).

В качестве шаблона пользовательского проекта средней сложности можно заимствовать “MyFlat app. (MVC_Razor+TS+ADO+TSQL)\SQL (DB-modelling)”, исправив содержимое “$sql_settings.cmd” (как “set generate_project_output=0” и “set generate_project_source=0”), а также изменить наименование “@flat_owner_cabinet.cmd” (а во всех CMD, где встретится: “flat_owner_cabinet” => “<имя_проекта>”).

Присутствуют так же и совсем простые примеры (т. н. “мелкие SQL-проекты”):
HandicraftSDK\SQL\Programming samples (SQL-file)\**” (содержит 5 мелких примеров):
GUID-list generation”, “Lists downloading (sys-info)”, “Nested transaction test”, “Trigger test”, “Uploading to DB (used buildings)”.

См.: “HandicraftSDK\SQL-project-list.txt” (примеры SQL -файл в Handicraft-SDK).
А также (CSWEB): “BookRegistry\SQL (DB-modelling)\**” и “BookRegistry\SHARED\$ClientServer\!DB-queries (application SP)\**” (загрузка “BookRegistry app.”).
Немало интересных примеров разной сложности (SQL и не только) находится в загрузках Handicraft-CODE.

Автор блог-а

Китаев Сергей Юрьевич
Автор ресурса Handicraft-CODE
https://handicraft.remelias.ru/

SQL-файл как конструктор (продолжение описания технологии SQL-файл)

Технология SQL-файл представляет из себя набор компонентов (доступных, в определённой мере, для изменения пользователем), не имеющий, однако, особо центрального (сверхярко выраженного среди других по важности) модуля. Наиболее монолитной в данном смысле частью SQL-файл (в Handicraft-SDK) является подпрограмма SqlCatPP.exe. Все части, в определённой степени, полезны и необходимы. Ежели попытаться составить список всего клиентского набора (всё, что не на стороне SQL-сервера), то вместе с базовыми системными (не предусматривающими, как правило, модификации со стороны пользователя) программами, получится примерно следующий перечень составляющих элементов клиентского ядра (см. ниже: I, II, III).

Наиболее точное определение замысла SQL-файл можно обозначить как настраиваемый и расширяемый конструктор SQL-проектов. Важным является то, как SQL располагается в файлах: в соответствующей подпапке, с должными сеттинг-ами, во встроенном в определённый порядок обработки SQL-файле. Файл должен лежать как можно “правильнее”, однако и код, сохраняемый в нём (объект БД и прочее) получает определённые преимущества. Сам же конструктор тоже подвластен для изменения пользователем. Существует возможность исправления любой составляющей конструктора, заимствованной из Handicraft-SDK. (Исходники EXE также присутствуют в пакете: “HandicraftSDK\Auxiliary programs (sources)”). Конструктор становится понятным и полезным, когда в него начинаешь “играть” (т. е. в разной степени применять). Доступны как минимальные, так и более сложные примеры.

I. Компоненты SQL-файл из пакета Handicraft-SDK:

— Утилита трансляции скриптов $SQLTRANS (CMD);
— Препроцессор-конкатенатор скриптов SqlCatPP (EXE);
— Прочие CMD: $SQLUPLOAD, $SQL, $SQLCON, $SQLTOCSVEXP;
— Прочие EXE: SqlToCsvExport, ConfirmationPause, TypeInColor;

— Плагин Far Manager CmdCpAuto для открытия CMD в нужной кодировке;
— Макросы LUA для настройки соответствующего поведения FAR-а, а так же другие инструкции от слов интеграция+оболочка (“CMD-utilities\Shell\Integration\**”);

Сеттинг-и в шаблонах SQL-проектов, как многочисленные примеры файлов “$sql_settings.cmd” (а так же “$sql_settings.sql”);
— Простые и сложные сценарии-команды в виде многочисленных примеров; (новый SQL-проект, как правило, заимствует большинство своих CMD);

— Вариант простого расширения SQL (т. н. “усиленный T-SQL”) со стороны библиотеки SQLAUX, в виде набора дополнительных ключевых слов-расширений (от автора SQL-файл и SQLAUX);
— Хэлпер-объекты T-SQL из пространства “AUX:…”: скалярные функции (137 шт.), табличные функции (3 шт.), хранимые процедуры (28 шт.);

— Набор работающих примеров/шаблонов разной степени сложности, с приложением бекап-а (BAK-файл) и образа (MDF+LDF) тестовой БД (“TEST”).

Описательные файлы псевдо-заголовков объектов SQLAUX а так же доступных слов/типов/констант расширенного SQL смотрите в каталоге “HandicraftSDK\SQL\SQLAUX\API (headers)”. Возможна минимальная зависимость от SQLAUX, без обращения к её программатикам в БД, а лишь использование отдельных её “слов” (переменные “$(…_AUX)”).

II. Базовая (не изменяемая) часть SQL-файл (системные зависимости):

SQLCMD как базовый транслятор предварительно обработанного скрипта (с поддержкой разделителя/повторителя батчей GO, обработкой директив “:SetVar …”, “:r …” и т. п., раскрытием переменных/констант в SQL “$(<ПеременнаяСреды>)”). Данная программа MS вызывается из: $SQLTRANS, $SQLUPLOAD, $SQL, $SQLCON.
BCP — вызывается из $SQLUPLOAD;
DOTNET 4.0 — зависимость для SqlCatPP.exe, SqlToCsvExport.exe, ConfirmationPause.exe, TypeInColor.exe;

Far Manager 3 — SQL-файл IDE — основной командный пульт (доступен, так же, и Windows Explorer), редактор с подкраской синтаксиса (SQL, CMD, TXT), поддержка плагин-ов (CmdCpAuto.dll) и макросов LUA (“CMD-utilities\Shell\Integration(\RU)”);

Командный процессор CMD (т. н. “legacy”, т. е. унаследованный в ОС Windows, не подвержен проблеме изменения версий).

III. Примеры и т.п.

Ниже приводится пример одного из перечней доступных “слов” (из файла-описателя “SQLAUX\API (headers)#SQL_extensions.AUX.sql”).
См. так же: “#Constants.AUX.sql”, “#Data_types.AUX.sql” (другие подобные перечисления слов с комментариями).

Насчёт потребности в т. н. “обёртке основного блока” для T-SQL, представленной в SQLAUX словами “$(BEGIN_AUX)” и “$(END_AUX)”, можно взглянуть (прочитать как предисловие) на следующую заметку с SQL.RU: https://www.sql.ru/forum/actualutils.aspx?action=gotomsg&tid=1331783&msg=22248841
Два занятных вопроса (SQL.RU, от 16 декабря 2020 г., форум – Microsoft SQL Server).

СЛОВА ИЗ “#SQL_extensions.AUX.sql” (ПЕРЕЧЕНЬ):
[[
NOP_AUX, LOOP_AUX, TRUE_AUX, FALSE_AUX, YES_AUX, NO_AUX, SUCCESS_AUX, FAILURE_AUX, FLOAT_1_AUX,

BEGIN_AUX, BEGIN_WITH_XACT_ABORT_ON_AUX, BEGIN_WITH_XACT_ABORT_OFF_AUX, BEGIN_WITHOUT_XACT_ABORT_AUX, END_AUX, BEGIN_TRANSACTION_AUX, COMMIT_TRANSACTION_AUX, COMMIT_OPEN_LT_AUX,

ROLLBACK_TRANSACTION_AUX, ROLLBACK_OPEN_LT_AUX, ROLLBACK_UNCOMMITTABLE_LT_AUX,

INITIAL_TRANCOUNT_AUX, IS_IN_OPEN_LT_AUX, RESET_OPEN_LT_FLAG_AUX,

IS_XACT_ABORT_ON_AUX, IS_NUMERIC_ROUNDABORT_ON_AUX, IS_CONCAT_NULL_YIELDS_NULL_ON_AUX, IS_ANSI_NULL_DFLT_OFF_ON_AUX, IS_ANSI_NULL_DFLT_ON_ON_AUX, IS_NOCOUNT_ON_AUX, IS_QUOTED_IDENTIFIER_ON_AUX, IS_ARITHIGNORE_ON_AUX, IS_ARITHABORT_ON_AUX, IS_ANSI_NULLS_ON_AUX, IS_ANSI_PADDING_ON_AUX, IS_ANSI_WARNING_ON_AUX, IS_CURSOR_CLOSE_ON_COMMIT_ON_AUX, IS_IMPLICIT_TRANSACTIONS_ON_AUX, IS_DISABLE_DEF_CNST_CHK_ON_AUX,

XACT_ABORT_AUX, NUMERIC_ROUNDABORT_AUX, CONCAT_NULL_YIELDS_NULL_AUX, ANSI_NULL_DFLT_OFF_AUX, ANSI_NULL_DFLT_ON_AUX, NOCOUNT_AUX, QUOTED_IDENTIFIER_AUX, ARITHIGNORE_AUX, ARITHABORT_AUX, ANSI_NULLS_AUX, ANSI_PADDING_AUX, ANSI_WARNING_AUX, CURSOR_CLOSE_ON_COMMIT_AUX, IMPLICIT_TRANSACTIONS_AUX, DISABLE_DEF_CNST_CHK_AUX,

TEST_IMPLEMENTATION_AUX, BEGIN_TEST_AUX, END_TEST_AUX, BEGIN_NONTEST_AUX, END_NONTEST_AUX,
META_IMPLEMENTATION_AUX, BEGIN_META_AUX, END_META_AUX, BEGIN_NONMETA_AUX, END_NONMETA_AUX,

LAQUO_AUX, RAQUO_AUX, LANG_AUX, RANG_AUX, LSQM_AUX, RSQM_AUX, LDQUO_AUX, RDQUO_AUX, BULL_AUX, MIDDOT_AUX, PLUSMN_AUX, HELLIP_AUX, DEG_AUX, SECT_AUX, COPY_AUX, REG_AUX, MDASH_AUX, NDASH_AUX, CR_AUX, LF_AUX, CR_LF_AUX, NL_AUX, NLNL_AUX,

LARROW_AUX, RARROW_AUX, BACKSLASH_AUX,

_BACKSLASH_AUX, _DOLLAR_AUX,

NewLineAndErrorMessage_AUX, AppendErrorMessageLine_AUX, AppendScriptLine_AUX
]]

Автор блог-а

Китаев Сергей Юрьевич
Автор ресурса Handicraft-CODE
https://handicraft.remelias.ru/

Презентация SQL-файл на SQL.RU

15 декабря 2020 г. на SQL.RU, в форуме Microsoft SQL Server, автор данной статьи писал (в прошлом) следующее:

Технология SQL-файл (для MSSQL)
https://www.sql.ru/forum/actualutils.aspx?action=gotomsg&tid=1331783&msg=22248193
[[
Добрый день, уважаемые разработчики SQL!

Позвольте представить Вашему вниманию самодельную легковесную технологию, именуемую как SQL-файл (или же SQL в файлах), — для MSSQL и T-SQL. Данная методика успешно применялась в течение достаточно долгого периода для программирования БД расчёта квартирной платы (город Воронеж). Технология базируются на известной утилите SQLCMD и командном процессоре CMD. В качестве IDE (командный пульт SQL + оперативный редактор) эффективно применяется Far Manager 3, со вспомогательными простейшим плагином и макросами. (Также, возможно задействование других редакторов SQL, помимо встроенного в FAR.)

Идея состоит в том, чтобы поддерживать исходный код и/или вспомогательные скрипты в виде SQL-файлов в директориях, транслируя их в базу данных, по отдельности либо группами. Используя утилиту $SQLTRANS и соответствующие шаблоны, можно настроить трансляцию (генерацию) большого количества объектов БД, работающую, так сказать, на раз-два-три. За один приём, например, возможно обновить активную составляющую программы в базе (процедуры, функции, представления, …), или, скажем, создать табличную структуру (и наполнить её некоторым количеством необходимых данных). При умелом обращении подсистема (активные объекты) может вполне свободно корректироваться даже на работающей программе/службе.

Обзорное минимальное описание SQL-файл доступно на страницах Handicraft-CODE (англ. язык):
https://handicraft.remelias.ru/sdk/sql_file.html (Handicraft-CODE :: Handicraft-SDK :: SQL-file technology);
https://handicraft.remelias.ru/sdk/sql_tools.html (Handicraft-CODE :: Handicraft-SDK :: CMD-utilities :: SQL-tools).

А также, см. скриншот-ы:
https://handicraft.remelias.ru/sdk/sql/screenshots_1.html
https://handicraft.remelias.ru/sdk/sql/screenshots_2.html
https://handicraft.remelias.ru/sdk/sql/screenshots_3.html

Вместе с командными утилитами и шаблонами предлагается возможное (опционально) использование так называемого Усиленного Transact-SQL, с препроцессором (на базе переменных среды), представленного множеством соответствующих импорт-определений и широким набором хелпер-объектов прилагаемой библиотеки SQLAUX (полезные программатики).

Помимо краткого обзорного описания и многочисленных скриншот-ов, на страницах доступны соответствующие загрузки 7-Zip:
1) Handicraft Toolkit — объединяющий пакет;
2) Handicraft-SDK — ремесленный SDK;
3) BookRegistry app. — Client-Server.WEB (идея);
4) TEST (DB) — копия БД.

Страницы с загрузками (технология SQL-файл, а также связанное с БД):
https://handicraft.remelias.ru/sdk/handicraft_sdk.html (Handicraft-SDK);
https://handicraft.remelias.ru/csweb/client_server_web.html (Client-Server.WEB);
https://handicraft.remelias.ru/handicraft_code.html (Handicraft-CODE).

Домен https://handicraft.remelias.ru (Handicraft-CODE), кроме технологии SQL-файл, содержит также разнообразные экспериментальные примеры программирования (.NET, .Win32, WASM и др.).

Спасибо за внимание!
]]

4 сентября 2021 г. была развёрнута новая дискуссия-продолжение:
Технология SQL-файл, препроцессор для T-SQL, бок-о-бок файлы и др.
https://www.sql.ru/forum/1338551-a/tehnologiya-sql-fayl-preprocessor-dlya-t-sql-bok-o-bok-fayly-i-dr

Автор блог-а

Китаев Сергей Юрьевич
Автор ресурса Handicraft-CODE
https://handicraft.remelias.ru/

Технология SQL-файл, препроцессор для T-SQL, “бок-о-бок” файлы и др.

Завершив свою недавнюю доработку легковесной технологии SQL-файл, применяемой для эффективной трансляции файлового SQL-кода в базу данных, автор данной статьи решил в очередной раз представить (в этой заметке) свои реализованные, хотя бы отчасти, идеи касательно программирования MSSQL, а так же некоторые соображения относительно применения SQL вообще. Автор полагает, что, несмотря на форму предлагаемой им частной реализации SQL-файл (для MSSQL), лежащая в основе подхода концепция имеет определённую силу и смысл.

В качестве вступления предлагается прочитать короткую заметку о презентации технологии SQL-файл на SQL.RU (от 15 декабря 2020 г.):
Технология SQL-файл (для MSSQL)
https://www.sql.ru/forum/1331783-a/tehnologiya-sql-fayl-dlya-mssql
(форум – Microsoft SQL Server);
Презентация SQL-файл на SQL.RU
https://blog-hc.remelias.ru/presenting-sql-file-at-sql-ru/
(BLOG-HC, настоящий домен).

I. Предыстория (что не так с языком Transact-SQL, расширения SQLCMD и др.)

Автор данной статьи в течение долгого времени имел дело с СУБД MS SQL Server. Когда-то в прошлом к автору пришло осознание того, что режим исполнения инструкций (Control Flow) в языке Transact-SQL, который MSSQL предлагает по умолчанию (режим), не является надёжным. Без использования специальных блоков-обёрток для перехвата исключения — необходимо везде-везде проверять состояние последней ошибки @@ERROR. Исходя из желания использовать эффективный (полуавтоматический, с исключениями) контроль ошибок, а так же и по другим (тоже веским) причинам, в течение длительного времени вырабатывалась и применялась интересная технология SQL-файл, основанная на расширениях SQLCMD. SQL-код хранится в файлах, организованных специальным образом в виде SQL-проекта (в дереве вложенных файловых папок). Для трансляции файлов в базу данных применяется легковесный обработчик — препроцессор-конкатенатор скриптов: SqlCatPP (EXE) в связке с вызывающей его обёрткой $SqlTrans (CMD). Так же, подразумевается использование вспомогательной библиотеки элементарных хелпер-объектов и констант (вида “$(<ПеременнаяСреды>)”) SQLAUX (в приложение к основному транслятору/препроцессору). В качестве редактора SQL в настоящее время, помимо встроенного редактора Far-Manager, а так же одного из GUI-редакторов для простого текста (см. в загрузках), доступно так же использование SQL Server Management Studio (+Environment), в немного ограниченном, однако, виде (см. устройство “SSMS.cmd” в загрузках).

II. Технология SQL-файл на страницах https://handicraft.remelias.ru/

Вот ссылки на страницы автора статьи (минимальное описание + картинки и примеры):

Ещё картинки (вспомогательное применение SQL-файл, бок-о-бок файлы SQL/C# и др.):

Так же, в авторском блог-е https://blog-hc.remelias.ru/, по SQL-файл присутствует серия заметок (хронологический порядок пост-ов):

  1. https://blog-hc.remelias.ru/sql-file-technology-pp-for-t-sql-sbs-files-etc/
  2. https://blog-hc.remelias.ru/presenting-sql-file-at-sql-ru/
  3. https://blog-hc.remelias.ru/sql-file-as-constructor/
  4. https://blog-hc.remelias.ru/sql-file-tasks-in-examples/
  5. https://blog-hc.remelias.ru/sql-file-and-sqlcmd/

II.1. Запуск SQL-файлов с учётом подготовленного окружения

После настройки, проведённой соответствующим образом, легковесных инструментов, появляется возможность “запускать” правильно сконфигурированные (снабжённые лежащим в том же каталоге “$sql_settings.cmd”) файлы кода с усиленным Transact SQL. В Far-Manager подобная трансляция срабатывает (приводится в действие) из панели по <Enter> (для ассоциации SQL), из встроенного редактора по <Ctrl+Enter> (простейший макрос); в отдельном окне (запуск из панели) — по <Ctrl+PgDown>, в отдельном окне (запуск из встроенного редактора) — по <Ctrl+F12>. Утилита $SQLTRANS “подхватывает” “$sql_settings.cmd”; файлы из подкаталогов, как правило, наследуют (и, возможно, расширяют) сеттинг-и (окружение) более высокого уровня расположения. Корневой же “$sql_settings.cmd” подключает, как правило, “SQLAUX.cmd” (из каталога библиотеки), а так же “@<имя_проекта>.cmd” (в UTF-8). Запустив же SQL Server Management Studio посредством стартера “SSMS.cmd” (располагается в корне SQL-проекта), данный процесс так же получает возможность использовать все тонкости настроенного окружения:

– Доступны слова для обёртки основного блока: $(BEGIN_AUX), $(END_AUX), с автоматической защитой от ошибки (т. н. “заворачивание” в “begin try”/“end try”/ … и т. д.), которые, так же, инициализируют некоторые T-SQL-установки SET (при раскрытии “$(BEGIN_AUX)”);

– Многочисленные ключевые слова и константы: $(LOOP_AUX), $(TRUE_AUX), $(DropFunctionScript_AUX), $(num_IntStrMaxLength_AUX), $(dt_Name_AUX), и т.п.;

– Ссылки на собственные переменные проекта “$(<ИмяПеременной>)”.

Необходимо сначала должным образом установить и настроить поддержку SQL-файл!!!

– При установленном плагин-е для Far Manager CmdCpAuto, появляется возможность комфортно просматривать (по F4) многочисленные CMD (с автоматическим переключением на нужную кодировку).

– После прописывания в системе пути (PATH) к командным утилитам “…\HandicraftSDK\CMD-utilities” (папка с CMD, EXE) — становится работоспособным следующее: $sqltrans.cmd, $sqlupload.cmd, $sql.cmd, $sqlcon.cmd, $sqltocsvexp.cmd и прочие “$”-команды.

– Так же, в системе потребуется определить путь к библиотеке скриптов и констант окружения SQLAUX: SQLAUX_ROOT = …\HandicraftSDK\SQL\SQLAUX.

– При установленных макросах LUA из “HandicraftSDK\CMD-utilities\Shell\Integration(\RU)”, а так же после настройки ассоциаций FAR-а согласно “!Integration of $SqlTrans with FAR Manager.txt” (или “RU\!Интеграция $SqlTrans с FAR Manager.txt”) — всё становится довольно-таки удобным для программирования с применением SQL-файл.

Обратите внимание на папку(и): “HandicraftSDK\CMD-utilities\Shell\Integration(\RU)”.

II.2. Трансляция множеств (файлы SQL)

Помимо простой трансляции отдельного файла, имеется возможность обработать группу / подгруппу SQL. Для запуска подобной трансляции применяются, как правило, простые стартеры CMD. В одну трансляцию могут попадать не только файлы шаблона “*.sql”, но так же (при соответствующем запуске $SqlCmd) и сразу несколько подпапок, а так же и некоторый специальный SQL-файл. Порядок обработки файлов перестраивается посредством простейших файлов коррекции “$sql_order.list”. Сложные же (составные) трансляции описываются соответствующими CMD-сценариями. Подобные сценарии играют в SQL-файл значительную роль (удаление файла, запрос подтверждения, формирование текстового отчёта, и т. п.)

В загрузке, соответствующей Handicraft-SDK, присутствуют три условных SQL-проекта (перечислены в “SQL-project-list.txt”), а в состав “BookRegistry app.” входит один сложный (из 2-х разнесённых частей) SQL-проект.

II.3. Слабый и сильный препроцессинг (осуществляется подпрограммой SqlCatPP)

При использовании Environment зачастую нормальным будет положиться на поведение базового средства SQLCMD. По умолчанию (при обращении к $SQLTRANS) SqlCatPP (EXE) применяет так называемый “слабый препроцессинг”, затрагивающий одну лишь директиву “:SetVar”. Он попросту добавляет перед ней одну строчку-комментарий: ––:SetVar … (чтобы иметь неиспорченную диагностику относительно номера строки ошибки). Однако, когда Вы не взаимодействуете с БД напрямую, а отдаёте свои скрипты дилеру (посреднику), то возникает потребность в тщательной подготовке такого скрипта, с учётом Environment SQL-проекта. (Навряд ли удастся на стороне дилера использовать какие-либо окружения.) В данном случае необходим так называемый “сильный препроцессинг”, который реализуется в SqlCatPP в тестовом виде, затрагивает директивы “:SetVar”, “:r”, а так же ссылки на переменные среды: “$(<ИмяПеременной>)”. Результат подобной обработки доступен для примера в подкаталогах $OUTPUT и $GENERATED проектов SQLAUX и “Extralight-ORM test legacy sample (En+Ru)\MyFlat app. (MVC_Razor+TS+ADO+TSQL)\SQL (DB-modelling)”. В состав “sqlaux_library.sql” (из $OUTPUT), например, входят (как минимум) 173 исходных SQL-скрипта (фрагменты с разделителем GO), присутствующие так же и в $GENERATED (с порядковым префиксом имени файла: “XNNN.<BaseFileName>.sql”).

Так же, утилита $SQLTRANS имеет возможность производить фиктивную трансляцию (“set $sqltrans.TranslateToDatabase=0”), выводить данные в текстовый файл результатов (для этого необходимо задать действительный 2-й параметр, например: $SqlTrans “%~n0.sql” “%~n0.txt”), а так же поддерживает передачу дополнительных параметров в базовый SQLCMD (например: “set $sqltrans.AdditionalParams=-y0”, “set $sqltrans.ContinueOnBatchError=1”). И не только это (см. страницы, картинки и загрузки).

II.4. Два основных направления в использовании SQL-файл

Технология SQL-файл применяется для достижения следующих 2-х основных целей:

1) Хозяйственная обработка базы данных MSSQL: добавление таблиц, наполнение их данными, правка структуры БД, прочие рутинные операции административного характера. Поскольку всё оформляется в виде файлов, то то или иное действие может быть повторно воспроизведено впоследствии (с соответствующей доработкой скриптов).

2) Программирование в базе данных MSSQL, а именно — написание подсистемы хранимых объектов кода SQL (процедуры, функции, триггеры, представления), которые в терминологии SQL-файл обозначаются как “программатики” (общий термин). Серверную SQL-часть приложения принято, зачастую, генерировать целиком — удалять все (или подгруппу) программатики (соответствующие, например, такому-то именному префиксу) и создавать их заново. (Данное действие можно производить на разных экземплярах сервера и БД, указываемых в корневом “$sql_settings.cmd” соответствующего SQL-проекта.)

III. Небольшая попытка создания экспериментальной псевдо-микро-ORM для доступа к своим SQL-запросам и ХП, бок-о-бок файлы (SQL/C#) и прочее

III.1. Техника Side-by-Side (SQL/C#)

В экспериментальных проектах “Client-Server.WEB (idea)” а так же “MyFlat app. (MVC_Razor+TS+ADO+TSQL)” была предпринята небольшая попытка непрямого соединения исполняемого SQL-сервером кода Transact-SQL с исполняемым веб-сервером ASP C#-кодом для .NET. В 1-м случае подобный CS-код, так же (с учётом соответствующих директив условной компиляции), работает в браузере (применяется WASM-Blazor), что привносит дополнительные усложнения. Каждый запрос к БД оформляется в виде 2-х рядом лежащих файлов с одним и тем же базовым именем: “<ИмяЗапроса>.sql” и “<ИмяЗапроса>.cs”. В данном случае под SQL-запросом понимается код хранимой процедуры T-SQL, который “попадает” на сервер в момент трансляции SQL-файла, каталога с файлами либо всего большого проекта (с применением $SqlTrans+SqlCatPP).

Соединение SBS-файлов условное (смешения кода нет). Данное исполнение стремится видеть (представлять) SQL-запросы в довольно унифицированной форме: с параметрами ХП, статусом возврата “@Status uniqueidentifier = null out” (параметр), сообщением ошибки “@Message $(dt_Message_AUX) = null out”, с возможными несколькими резалт-сетами. (В последующей неопубликованной версии аналогичного SDK данные параметры имеют, соответственно, имена “@RStatus” и “@RMessage”.)

Легковесный ORM к ХП и SQL-запросам (Handicraft-CODE):
https://handicraft.remelias.ru/csweb/lightweight_orm.html

Попытки успешного смешивания разнородного кода известны. Например: “.razor” и “.cshtml” (смешение HTML+C#) — используются для генерации HTML-разметки посредством C#, с частичной проверкой правильности разметки. При компиляции же SQL-процедуры (например, из файла SQL) — так же проводится определённая проверка правильности SQL. Совмещение SQL+CS возможно было бы, в определённой степени, усовершенствовать. Например, в некоторых трудоёмких случаях — использовать объявление параметра (с типом) по месту его применения в теле запроса, “поручив” оформление заголовка(ов) запроса(ов) генератору-препроцессору SQL (добавив в него соответствующую функциональность). Так же, используя специальный вспомогательный формат двойственного (SQL-сервер/SQL-клиент) определения значений и типов, теоретически возможно было бы достичь определённого успеха. Однако, смешивание кода, работающего в совершенно разных средах и местах, навряд ли должно выглядеть просто.

В примере “BookRegistry app.” излишнюю сложность, однако, привносит использование JSON, а так же желание надёжно “защититься” (проверки-исключения) от Null-ов на стороне C# (после передачи данных через HTTP в упакованном виде, посредством JSON). В примере же “MyFlat app. (MVC_Razor+TS+ADO+TSQL)” применяется сочетание 2-х языков для наименований: английский (ASP веб-сервер) <=> русский (объекты в SQL-БД).

III.2. Зачем всё это нужно (или же почему не всё так складно в ORM)?

Данный пункт можно отнести к области фантастики. Он предполагает существование возможности вносить изменения/дополнения в некоторую реляционную СУБД, поддерживающую расширяемый диалект языка SQL.

В настоящее время, при доступности применения ORM для взаимодействия с БД, её (одну из ORM) естественно будут использовать очень многие. Несмотря даже на то, что подобное применение зачастую ведёт к определённому перевороту, когда, например, язык C# может быть поставлен выше базы данных, как принято на это смотреть в контексте применения EF Code First, и любое общение/взаимодействие с БД (даже не от имени разрабатываемого приложения) подчиняется уже C# и особенностям Entity Framework (при использовании Code First). А ежели подход с центральным Code First — это востребованное передовое, то всё, что не Code First — уже не годится (не то, что надо) и т. п. Есть и другие причины, так же говорящие в пользу применения своих SQL-запросов для общения с сервером SQL. (Крупные базы данных, кстати, способны пережить и несколько клиентских фреймворков и ORM.)

Что же касается использования хранимых процедур в БД для приложения, то существует обоснованное мнение, что это (1) не современно, (2) не кроссплатформенно, а так же (3) тяжело в поддержке. Поэтому — опять приходим к ORM, большой ORM. (И даже микро-ORM применять, как правило, обычно не рекомендуется.)

Непростая идея компилируемых запросов SQL:

Бок-о-бок файлы (приводятся выше), реализованные автором статьи в экспериментальном виде на базе классических хранимых процедур-запросов MSSQL, могли бы, так же (потенциально), при должной поддержке со стороны СУБД, быть исполнены, по части обработки SQL, в виде так называемых “компилируемых запросов SQL” (Compiled SQL Queries с ограниченным управляемым временем жизни), поддерживаемых гипотетическим SQL-сервером (с функцией Compiled SQL Queries). Компилируемые SQL-запросы возможно было бы унифицировать по части заголовков с параметрами-значениями, параметрами-таблицами, резалт-сет-ами, кодом/статусом/сообщением возврата и т. п. (Т.е. — такие специальные кроссплатформенные по отношению к диалектам SQL заголовки для SQL-запросов.) Хранящийся в SQL-файле клиента SQL-сервера параметризованный код (параметры запроса + клиентская Environment) должен соответствующим образом подготавливаться (“на лету” при первом запуске запроса, или, возможно, на старте приложения):

сначала (на стороне клиента SQL) — применение аналога Environment SQL-проекта;

далее (на стороне клиента) — препроцессинг SQL (раскрытие аналогов переменных среды);

затем — подготовка на SQL-сервере, с проверкой ошибок (компиляция аналога временной ХП с параметрами, со специальным уникальным наименованием временно сохраняемого запроса).

Исправление же кода в файле с SQL-запросом приложения на работающей программе (желательно это делать, конечно, не в части заголовка) — должно восприниматься как необходимость повторной компиляции (когда потребуется) временного запроса: уничтожение/создание временного запроса+имени на сервере SQL.

Таким вот примерно образом автор статьи представляет себе общение с базой данных SQL на языке SQL, со стороны программы (например веб-сервера), использующей какой-либо компилируемый либо скриптовый язык. Для работы такого приложения потребуется технология, подобная SQL-файл (обозначим расширение как “SQL-file-app.”). Компилируемые запросы приложения (SQL-файлы) могли бы заранее (на этапе разработки) проверяться специальными командами трансляции (отсылаться на сервер) на предмет ошибок предварительной подготовки (компиляция запроса на стороне SQL). Более того: базирующиеся на SQL-файлах компилируемые запросы должны быть доступны из папок SQL-проекта для исполнения их отдельно от, собственно, приложения, — как из подготовившего запрос файла сценариев, так и из специального проверочного или хозяйственного SQL-скрипта, работающего в контексте того же (подготовившего запрос) SQL-подключения.

Кроме того, обычная (подобная существующей в исполнении автора статьи, для MSSQL) не расширенная функциональность технологии SQL-файл, так же могла бы оказаться весьма полезной для работы вокруг подобного приложения.

IV. Завершение (резюме)

Как было обозначено в начале пункта III.2, то, о чём (в п. III.2) фантазируется автором статьи, весьма удалено от нашей реальности. И всё же (насчёт реальности): несмотря на могущество отдельных диалектов SQL, длительную историю знаменитых СУБД, трудно, в контексте понимания того, как обычно оформляются/выглядят запросы к базе данных (SQL-вкрапления в другую программу, либо посредством драйвера большой и умной ORM, либо же с применением отдельного SQL-файла или объекта с кодом, открываемом в консоли-редакторе БД), — трудно называть SQL первосортным языком программирования, который мы можем полноценно поддерживать (с тем же комфортом, что и классические языки ООП), когда применяем SQL для взаимодействия с БД из кода приложения или из отдельного скрипта.

V. SQL-Query-Bridge (абстрактный набросок идеи)

На корневой странице Handicraft-CODE (https://handicraft.remelias.ru/) присутствует загрузка “SQL-Query-Bridge Outline YYYY-MM-DD.7z”, содержащая набросок воображаемого SQL-проекта, для трансляции исходников запросов абстрактной утилитой-препроцессором SQL-Query-Bridge-PP. Предполагается, что существует специальный формат (структура), предназначенный для записи SQL-запроса (файлы вида “*.q.sql”, а также настройки “@*.*”), на основании чего утилита генерирует скрипт T-SQL создания хранимой процедуры, а также генерируется код C#, доступный для расширения пользователем (посредством partial-классов), CS-код для взаимодействия с соответствующим SQL-запросом, вместе с моделями данных Си-шарп (также создаются препроцессором). Пример содержит всего один запрос (T-SQL / C#): SelectBooks, являющийся аналогом одноимённого запроса из примера BookRegistry app. (из пакета Handicraft Toolkit). Данный набросок (формат запроса, проект, настройки) является фантазийным (чистая абстракция).

Автор блог-а

Китаев Сергей Юрьевич
Автор ресурса Handicraft-CODE
https://handicraft.remelias.ru/

Аналогичная заметка автора на сайте Хабр (https://habr.com/)

Технология SQL-файл, препроцессор для T-SQL, “бок-о-бок” файлы и др: https://habr.com/ru/post/672084/