<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:media="http://search.yahoo.com/mrss/" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:georss="http://www.georss.org/georss">
<channel>
<title>Программирование - PLSQL.uz — справочник по Oracle SQL и PL/SQL</title>
<link>https://plsql.uz/</link>
<language>ru</language><item>
<title>Динамический SQL</title>
<link>https://plsql.uz/reference/programming/247-dynamic-sql.html</link>
<pdalink>https://plsql.uz/reference/programming/247-dynamic-sql.html</pdalink>
<guid>https://plsql.uz/reference/programming/247-dynamic-sql.html</guid>
<pubDate>Tue, 10 Nov 2026 13:59:10 +0500</pubDate>
<category>index</category>

<content:encoded><![CDATA[<h2>📖 Описание</h2> <p>Динамический SQL в Oracle позволяет строить и выполнять SQL или PL/SQL во время работы программы: EXECUTE IMMEDIATE для отдельных команд, OPEN FOR и FETCH для наборов строк. Значения передаются через bind-переменные; имена объектов требуют отдельной проверки.</p> <ul> <li>Динамический SQL делает ваши программы более гибкими, создавая и обрабатывая SQL предложения во время выполнения программ.</li> <li>С динамическим SQL вы можете напрямую выполнять большинство типов операторов SQL, включая определение данных и операторы управления данными.</li> <li>Вы можете строить запросы, в которых вы заранее не знаете имен таблиц, предложений <a href="https://plsql.uz/reference/sql/queries-commands/171-where.html">WHERE</a> и другой информации.</li> </ul> <hr> <h2>📌 Оператор EXECUTE IMMEDIATE</h2> <p>Oracle/PLSQL оператор EXECUTE IMMEDIATE подготавливает (анализирует) и немедленно выполняет динамический SQL-запрос или анонимный PL/SQL блок.<br>Основным аргументом EXECUTE IMMEDIATE является строка, содержащая SQL-запрос для выполнения. Вы можете создать строку, используя конкатенацию, или использовать предопределенную строку.<br>Динамическая строка может содержать поддерживаемый оператор SQL (без последней точки с запятой), включая запрос с несколькими результирующими строками через BULK COLLECT INTO, либо блок PL/SQL (с последней точкой с запятой).<br>Строка dynamic_string также может содержать заполнители, произвольные имена, которым предшествует двоеточие, для аргументов связывания bind_argument. В этом случае вы указываете, какие переменные PL/SQL соответствуют заполнителям, с помощью операторов INTO, USING и RETURNING INTO. Во время выполнения аргументы связывания заменяют соответствующие заполнители в динамической строке. Каждый заполнитель должен быть связан с аргументом связывания в предложении USING и/или предложении RETURNING INTO.</p> <hr> <h2>🧩 Синтаксис</h2> <p>Синтаксис Oracle/PLSQL оператора EXECUTE IMMEDIATE для передачи значения в переменную или строку:</p> <pre class="language-sql"><code>EXECUTE IMMEDIATE dynamic_string [INTO variable1, variable2] [USING [IN | OUT | IN OUT] bind1, bind2] [RETURNING INTO output1, output2];</code></pre> <p>или синтаксис Oracle/PLSQL оператора EXECUTE IMMEDIATE для передачи значения в коллекцию</p> <pre class="language-sql"><code>EXECUTE IMMEDIATE dynamic_query BULK COLLECT INTO collection1, collection2 [USING bind1, bind2];</code></pre> <hr> <h2>⚙️ Параметры и аргументы</h2> <dl> <dt>dynamic_string</dt> <dd>Строковый литерал, переменная или выражение, представляющее один оператор SQL или блок PL/SQL. В Oracle 19c поддерживаются CHAR, VARCHAR2 и CLOB; для национальных типов действуют ограничения.</dd> <dt>BULK COLLECT</dt> <dd>Сохраняет значения результатов в одной или нескольких коллекциях с уменьшением числа переходов между SQL и PL/SQL. Скорость зависит от задачи, а размер коллекций — от числа строк и памяти.</dd> <dt>INTO</dt> <dd>Используется только для однострочных запросов, в этом разделе указываются переменные или записи, в которые извлекаются значения столбцов. Для каждого значения, полученного запросом, в предложении INTO должна быть соответствующая тип-совместимая переменная или поле.</dd> <dt>define_variable</dt> <dd>Переменная, в которой сохраняется значение выбранного столбца.</dd> <dt>record_name</dt> <dd>Пользовательская запись или запись %ROWTYPE, в которой сохраняется выбранная строка.</dd> <dt>bind_argument</dt> <dd>Выражение, значение которого передается в динамический оператор SQL, или переменная, в которой сохраняется значение, возвращаемое динамическим оператором SQL.</dd> <dt>collection_name</dt> <dd>Объявленная коллекция, в которую извлекаются значения select_item из dynamic_string. Для каждого select_item должна быть соответствующая, совместимая с типом коллекция в списке.</dd> <dt>host_array_name</dt> <dd>Массив (объявленный в хост-среде PL/SQL и переданный PL/SQL как переменная связывания), в который извлекаются значения select_item. Для каждого select_item должен быть соответствующий, совместимый с типом массив в списке. Массивы хоста должны начинаться с двоеточия.</dd> <dt>USING</dt> <dd>По умолчанию - IN. Определяет список входных и/или выходных аргументов привязки.</dd> <dt>returning_clause</dt> <dd>Возвращает значения строк, затронутых поддерживаемым INSERT, UPDATE или DELETE, без отдельного SELECT. Вы можете извлечь значения столбца в переменные или в коллекции. Вы не можете использовать предложение RETURNING для удалённого или параллельного DML. Если инструкция не влияет ни на какие строки, значения переменных, указанных в предложении RETURNING, не определены.</dd> </dl> <hr> <p>Синтаксис выше схематический: INTO и RETURNING INTO выбираются по виду команды. <a href="https://plsql.uz/reference/sql/queries-commands/153-select.html">SELECT</a> одной строки требует INTO, нескольких — BULK COLLECT INTO или OPEN FOR. При EXECUTE IMMEDIATE без INTO/BULK COLLECT запрос SELECT не выполняется. Обычный INTO при отсутствии строк вызывает NO_DATA_FOUND, при нескольких — TOO_MANY_ROWS. Для SQL аргументы должны иметь SQL-совместимые типы; динамический вызов PL/SQL поддерживает также определённые PL/SQL-типы, включая BOOLEAN и объявленные в спецификации пакета типы. Имена объектов нельзя передать через USING.</p> <h2>💻 Общие учебные данные</h2> <p>В одной учебной схеме нужны CREATE TABLE, CREATE SEQUENCE, CREATE PROCEDURE и квота. Примеры с объектными типами ниже дополнительно требуют CREATE TYPE. Создайте собственные таблицы:</p> <pre class="language-sql"><code>CREATE TABLE demo_dyn_studios ( studio_id NUMBER PRIMARY KEY, studio_name VARCHAR2(40 CHAR) NOT NULL, city VARCHAR2(40 CHAR) ); CREATE TABLE demo_dyn_mentors ( mentor_id NUMBER PRIMARY KEY, mentor_name VARCHAR2(40 CHAR) NOT NULL, studio_id NUMBER REFERENCES demo_dyn_studios(studio_id), joined_on DATE NOT NULL, fee NUMBER(8,2) NOT NULL, bonus NUMBER(8,2) ); CREATE SEQUENCE demo_dyn_studio_seq START WITH 101; INSERT ALL INTO demo_dyn_studios VALUES (7, 'River Studio', 'Tashkent') INTO demo_dyn_studios VALUES (8, 'Garden Studio', 'Samarkand') SELECT 1 FROM dual; INSERT ALL INTO demo_dyn_mentors VALUES (41, 'Aziza', 7, DATE '2026-11-14', 120, NULL) INTO demo_dyn_mentors VALUES (42, 'Temur', 7, DATE '2026-11-21', 150, 30) INTO demo_dyn_mentors VALUES (43, 'Zarina', 8, DATE '2026-11-28', 200, NULL) SELECT 1 FROM dual; COMMIT; CREATE OR REPLACE PACKAGE demo_dyn_actions AS PROCEDURE increase_fee(p_id NUMBER, p_amount NUMBER); END demo_dyn_actions; / CREATE OR REPLACE PACKAGE BODY demo_dyn_actions AS PROCEDURE increase_fee(p_id NUMBER, p_amount NUMBER) IS BEGIN UPDATE demo_dyn_mentors SET fee = fee + p_amount WHERE mentor_id = p_id; END; END demo_dyn_actions; /</code></pre> <h3>📌 DDL, DML, запись и RETURNING</h3> <p>Динамический DDL выполняется отдельно до SAVEPOINT: CREATE TABLE фиксирует транзакцию.</p> <pre class="language-sql"><code>BEGIN EXECUTE IMMEDIATE 'CREATE TABLE demo_dyn_bonus_scratch (id NUMBER, amount NUMBER)'; END; / SAVEPOINT before_dynamic_basics; DECLARE l_sql VARCHAR2(1000); l_mentor demo_dyn_mentors%ROWTYPE; l_fee NUMBER; BEGIN l_sql := 'INSERT INTO demo_dyn_studios (studio_id, studio_name, city) VALUES (:1, :2, :3)'; EXECUTE IMMEDIATE l_sql USING 99, 'Hill Studio', 'Bukhara'; EXECUTE IMMEDIATE 'SELECT * FROM demo_dyn_mentors WHERE mentor_id = :id' INTO l_mentor USING 41; DBMS_OUTPUT.PUT_LINE(l_mentor.mentor_name || ': ' || l_mentor.fee); EXECUTE IMMEDIATE 'BEGIN demo_dyn_actions.increase_fee(:id, :amount); END;' USING 42, 25; EXECUTE IMMEDIATE 'UPDATE demo_dyn_mentors SET fee = :fee WHERE mentor_id = :id RETURNING fee INTO :result' USING 135, 41 RETURNING INTO l_fee; DBMS_OUTPUT.PUT_LINE('returned fee=' || l_fee); EXECUTE IMMEDIATE 'DELETE FROM demo_dyn_studios WHERE studio_id = :id' USING 99; END; / SELECT mentor_id, fee FROM demo_dyn_mentors ORDER BY mentor_id; ROLLBACK TO before_dynamic_basics;</code></pre> <p>Вывод: Aziza: 120 и returned fee=135. До отката ставки 41/135, 42/175, 43/200; после — исходные 120, 150 и 200. Учебная таблица DEMO_DYN_BONUS_SCRATCH остаётся, поскольку создана до SAVEPOINT.</p> <p>ALTER SESSION тоже можно передать строкой. Отдельная иллюстрация для сеанса с изначально выключенной SQL-трассировкой:</p> <pre class="language-sql"><code>BEGIN EXECUTE IMMEDIATE 'ALTER SESSION SET SQL_TRACE = TRUE'; -- Здесь выполняется только нужная диагностическая работа. EXECUTE IMMEDIATE 'ALTER SESSION SET SQL_TRACE = FALSE'; END; /</code></pre> <p>Это необязательный диагностический фрагмент; изменение настройки сеанса не откатывается ROLLBACK. Не включайте трассировку как обязательную часть остальных примеров.</p> <h3>💻 Имя таблицы и условие DELETE</h3> <p>Имя объекта не является значением bind-параметра. Принимая имя и условие, выберите допустимую форму запроса заранее. Процедура ниже принимает только одну учебную таблицу и один вариант условия; произвольный WHERE не исполняется. NULL-условие явно означает удаление всех строк именно этой таблицы.</p> <pre class="language-sql"><code>CREATE OR REPLACE PROCEDURE demo_dyn_delete_rows ( p_table VARCHAR2, p_condition VARCHAR2 DEFAULT NULL, p_studio NUMBER DEFAULT NULL ) AUTHID CURRENT_USER IS l_name VARCHAR2(128) := UPPER(TRIM(p_table)); l_sql VARCHAR2(1000); BEGIN IF l_name IS NULL OR l_name != 'DEMO_DYN_MENTORS' THEN RAISE_APPLICATION_ERROR(-20101, 'Table is not allowed'); END IF; l_sql := 'DELETE FROM ' || DBMS_ASSERT.ENQUOTE_NAME(l_name); IF p_condition IS NULL THEN EXECUTE IMMEDIATE l_sql; ELSIF UPPER(TRIM(p_condition)) = 'STUDIO_ID = :ID' THEN EXECUTE IMMEDIATE l_sql || ' WHERE studio_id = :id' USING p_studio; ELSE RAISE_APPLICATION_ERROR(-20102, 'Condition is not allowed'); END IF; DBMS_OUTPUT.PUT_LINE('deleted=' || SQL%ROWCOUNT); END; / SAVEPOINT before_dynamic_delete; BEGIN demo_dyn_delete_rows('demo_dyn_mentors', 'studio_id = :id', 7); END; / -- deleted=2 ROLLBACK TO before_dynamic_delete; BEGIN demo_dyn_delete_rows('demo_dyn_mentors'); END; / -- deleted=3 ROLLBACK TO before_dynamic_delete;</code></pre> <p>Для произвольных пользовательских фильтров нужен разбор и сборка из разрешённых полей и операторов. DBMS_ASSERT проверяет свойства имени, но не делает произвольное условие безопасным и не выдаёт права.</p> <h2>📌 Режимы IN, OUT и IN OUT</h2> <p>USING по умолчанию передаёт IN. RETURNING INTO принимает выходные переменные без слова OUT. При динамическом вызове процедуры режим должен соответствовать её параметру:</p> <pre class="language-sql"><code>CREATE OR REPLACE PROCEDURE demo_dyn_create_studio ( p_id IN OUT NUMBER, p_name IN VARCHAR2, p_city IN VARCHAR2 ) IS BEGIN p_id := demo_dyn_studio_seq.NEXTVAL; INSERT INTO demo_dyn_studios (studio_id, studio_name, city) VALUES (p_id, p_name, p_city); END; / SAVEPOINT before_dynamic_mode; DECLARE l_id NUMBER; BEGIN EXECUTE IMMEDIATE 'BEGIN demo_dyn_create_studio(:id, :name, :city); END;' USING IN OUT l_id, 'Lake Studio', 'Khiva'; DBMS_OUTPUT.PUT_LINE('new studio=' || l_id); END; / ROLLBACK TO before_dynamic_mode;</code></pre> <p>При первом обращении к новой последовательности l_id равен 101. При повторном запуске номер другой, даже после отката. Здесь процедура заменяет входное значение идентификатора; IN OUT сохранён для демонстрации режима связывания.</p> <h3>📌 Многострочный запрос: OPEN, FETCH, CLOSE</h3> <pre class="language-sql"><code>DECLARE l_cursor SYS_REFCURSOR; l_mentor demo_dyn_mentors%ROWTYPE; BEGIN OPEN l_cursor FOR 'SELECT * FROM demo_dyn_mentors WHERE studio_id = :id ORDER BY mentor_id' USING 7; LOOP FETCH l_cursor INTO l_mentor; EXIT WHEN l_cursor%NOTFOUND; DBMS_OUTPUT.PUT_LINE(l_mentor.mentor_name || ': ' || l_mentor.fee); END LOOP; CLOSE l_cursor; EXCEPTION WHEN OTHERS THEN IF l_cursor%ISOPEN THEN CLOSE l_cursor; END IF; RAISE; END; /</code></pre> <p>После отката предыдущих опытов вывод: Aziza: 120, затем Temur: 150. Сначала выполняется FETCH и проверяется %NOTFOUND, затем обрабатывается полученная строка.</p> <h2>💻 Объектные типы и коллекции</h2> <p>Типы создаются на уровне схемы до пакета. Они используются и как типы столбцов, и как bind-значения. Имя таблицы ограничено одним учебным объектом.</p> <pre class="language-sql"><code>CREATE TYPE demo_dyn_person AS OBJECT (full_name VARCHAR2(40 CHAR), age NUMBER); / CREATE TYPE demo_dyn_materials IS VARRAY(10) OF VARCHAR2(40 CHAR); / CREATE OR REPLACE PACKAGE demo_dyn_team_api AS PROCEDURE create_table(p_table VARCHAR2); PROCEDURE insert_row(p_table VARCHAR2, p_person demo_dyn_person, p_items demo_dyn_materials); PROCEDURE print_table(p_table VARCHAR2); END demo_dyn_team_api; / CREATE OR REPLACE PACKAGE BODY demo_dyn_team_api AS FUNCTION checked_name(p_table VARCHAR2) RETURN VARCHAR2 IS l_name VARCHAR2(128) := UPPER(TRIM(p_table)); BEGIN IF l_name IS NULL OR l_name != 'DEMO_DYN_TEAM' THEN RAISE_APPLICATION_ERROR(-20103, 'Team table is not allowed'); END IF; RETURN DBMS_ASSERT.ENQUOTE_NAME(l_name); END; PROCEDURE create_table(p_table VARCHAR2) IS BEGIN EXECUTE IMMEDIATE 'CREATE TABLE ' || checked_name(p_table) || ' (person_info demo_dyn_person, materials demo_dyn_materials)'; END; PROCEDURE insert_row(p_table VARCHAR2, p_person demo_dyn_person, p_items demo_dyn_materials) IS BEGIN EXECUTE IMMEDIATE 'INSERT INTO ' || checked_name(p_table) || ' (person_info, materials) VALUES (:person, :items)' USING p_person, p_items; END; PROCEDURE print_table(p_table VARCHAR2) IS l_cursor SYS_REFCURSOR; l_person demo_dyn_person; l_items demo_dyn_materials; BEGIN OPEN l_cursor FOR 'SELECT t.person_info, t.materials FROM ' || checked_name(p_table) || ' t ORDER BY t.person_info.full_name'; LOOP FETCH l_cursor INTO l_person, l_items; EXIT WHEN l_cursor%NOTFOUND; IF l_person IS NOT NULL THEN DBMS_OUTPUT.PUT_LINE(l_person.full_name || ', age=' || l_person.age); END IF; IF l_items IS NOT NULL THEN FOR i IN 1 .. l_items.COUNT LOOP DBMS_OUTPUT.PUT_LINE(' material=' || l_items(i)); END LOOP; END IF; END LOOP; CLOSE l_cursor; EXCEPTION WHEN OTHERS THEN IF l_cursor%ISOPEN THEN CLOSE l_cursor; END IF; RAISE; END; END demo_dyn_team_api; / BEGIN demo_dyn_team_api.create_table('DEMO_DYN_TEAM'); END; / SAVEPOINT before_dynamic_objects; BEGIN demo_dyn_team_api.insert_row('DEMO_DYN_TEAM', demo_dyn_person('Aziza', 29), demo_dyn_materials('Clay', 'Glaze')); demo_dyn_team_api.insert_row('DEMO_DYN_TEAM', demo_dyn_person('Temur', 34), demo_dyn_materials('Paper', 'Ink')); demo_dyn_team_api.print_table('DEMO_DYN_TEAM'); END; / ROLLBACK TO before_dynamic_objects;</code></pre> <p>Печатаются Aziza, age=29 с Clay/Glaze и Temur, age=34 с Paper/Ink. Тело print_table действительно выводит значения. После отката строки исчезают, а таблица остаётся.</p> <h2>📌 Массовый SQL</h2> <p>BULK COLLECT и FORALL уменьшают число переходов между PL/SQL и SQL при обработке набора. FETCH ... BULK COLLECT INTO допускает LIMIT для размера партии; EXECUTE IMMEDIATE ... BULK COLLECT INTO выбирает весь результат в память. FORALL выполняет DML для элементов коллекции и не предназначен для SELECT.</p> <p>Используются FETCH ... BULK COLLECT INTO, EXECUTE IMMEDIATE ... BULK COLLECT INTO, FORALL, RETURNING BULK COLLECT INTO и SQL%BULK_ROWCOUNT. Правила типов зависят от операции: SQL-объекты и коллекции схемы из предыдущего примера не следует путать с PL/SQL-типами параметров динамического вызова подпрограммы.</p> <h3>💻 BULK COLLECT: курсор и EXECUTE IMMEDIATE</h3> <pre class="language-sql"><code>DECLARE TYPE t_numbers IS TABLE OF NUMBER; TYPE t_names IS TABLE OF VARCHAR2(40 CHAR); l_ids t_numbers; l_names t_names; l_fees t_numbers; l_cursor SYS_REFCURSOR; l_total PLS_INTEGER := 0; BEGIN OPEN l_cursor FOR 'SELECT mentor_id, mentor_name FROM demo_dyn_mentors ORDER BY mentor_id'; LOOP FETCH l_cursor BULK COLLECT INTO l_ids, l_names LIMIT 2; EXIT WHEN l_ids.COUNT = 0; l_total := l_total + l_ids.COUNT; FOR i IN 1 .. l_ids.COUNT LOOP DBMS_OUTPUT.PUT_LINE(l_ids(i) || ': ' || l_names(i)); END LOOP; END LOOP; CLOSE l_cursor; EXECUTE IMMEDIATE 'SELECT fee FROM demo_dyn_mentors ORDER BY mentor_id' BULK COLLECT INTO l_fees; DBMS_OUTPUT.PUT_LINE('fetched=' || l_total || ', fees=' || l_fees.COUNT); EXCEPTION WHEN OTHERS THEN IF l_cursor%ISOPEN THEN CLOSE l_cursor; END IF; RAISE; END; /</code></pre> <p>Строки 41: Aziza, 42: Temur, 43: Zarina выбираются партиями 2 и 1; итог fetched=3, fees=3. Для неограниченного набора выбирайте размер партий и освобождайте курсор при ошибках.</p> <h3>💻 RETURNING BULK COLLECT INTO</h3> <pre class="language-sql"><code>SAVEPOINT before_dynamic_returning; DECLARE TYPE t_names IS TABLE OF VARCHAR2(40 CHAR); l_names t_names; BEGIN EXECUTE IMMEDIATE 'UPDATE demo_dyn_mentors SET bonus = :bonus WHERE studio_id = :studio RETURNING mentor_name INTO :names' USING 25, 7 RETURNING BULK COLLECT INTO l_names; DBMS_OUTPUT.PUT_LINE('returned=' || l_names.COUNT); END; / SELECT mentor_id, bonus FROM demo_dyn_mentors ORDER BY mentor_id; ROLLBACK TO before_dynamic_returning;</code></pre> <p>returned=2, в возвращённой коллекции Aziza и Temur; порядок RETURNING не задан. До отката бонусы 41/25, 42/25, 43/NULL. Затем возвращаются исходные NULL, 30, NULL. RETURNING относится к DML, в то время как OUT-параметры могут быть и у динамически вызванной PL/SQL-подпрограммы.</p> <h3>💻 FORALL с динамическим UPDATE</h3> <pre class="language-sql"><code>SAVEPOINT before_dynamic_forall; DECLARE TYPE t_numbers IS TABLE OF NUMBER; TYPE t_names IS TABLE OF VARCHAR2(40 CHAR); l_ids t_numbers := t_numbers(41, 43, 99); l_names t_names; BEGIN FORALL i IN 1 .. l_ids.COUNT EXECUTE IMMEDIATE 'UPDATE demo_dyn_mentors SET fee = fee * 1.10 WHERE mentor_id = :id RETURNING mentor_name INTO :names' USING l_ids(i) RETURNING BULK COLLECT INTO l_names; DBMS_OUTPUT.PUT_LINE('returned=' || l_names.COUNT); FOR i IN 1 .. l_ids.COUNT LOOP DBMS_OUTPUT.PUT_LINE('id=' || l_ids(i) || ', rows=' || SQL%BULK_ROWCOUNT(i)); END LOOP; END; / SELECT mentor_id, fee FROM demo_dyn_mentors ORDER BY mentor_id; ROLLBACK TO before_dynamic_forall;</code></pre> <p>Вернутся два имени; число изменённых строк для 41, 43 и 99 равно 1, 1 и 0. Ставки до отката: 132, 150 и 220. Отсутствующий идентификатор 99 не является ошибкой <a href="https://plsql.uz/reference/sql/queries-commands/163-update.html">UPDATE</a>. Строка SQL в FORALL одна; переменные значения передаются через простые элементы коллекции в USING, а не заменой имени таблицы на каждой итерации.</p> <h2>📌 Рекомендации по динамическому SQL</h2> <h3>Точка с запятой в SQL и PL/SQL</h3> <p>В строке отдельного SQL-оператора завершающей точки с запятой нет. В строке анонимного блока точка с запятой после END обязательна. Символ / — команда клиента, в строку не включается:</p> <pre class="language-sql"><code>SAVEPOINT before_dynamic_semicolon; BEGIN EXECUTE IMMEDIATE 'UPDATE demo_dyn_mentors SET fee = fee WHERE mentor_id = :id' USING 41; EXECUTE IMMEDIATE 'BEGIN DBMS_OUTPUT.PUT_LINE(''Workshop ready''); END;'; END; / ROLLBACK TO before_dynamic_semicolon;</code></pre> <h3>Переменные связывания вместо конкатенации значений</h3> <p>Фрагмент ниже показывает нежелательный способ построения строки. Он не выполняется: преобразование значения в текст зависит от формата, а конкатенация непроверенного пользовательского текста открывает путь SQL-инъекции.</p> <pre class="language-sql"><code>-- Антипаттерн: l_sql := 'DELETE FROM demo_dyn_mentors WHERE mentor_id = ' || p_id; -- Значение следует передать через USING, как в процедуре ниже.</code></pre> <p>Одинаковый текст SQL с разными аргументами также даёт Oracle возможность повторно использовать разобранный курсор. Это не обещание одинакового плана или фиксированного ускорения.</p> <pre class="language-sql"><code>CREATE OR REPLACE PROCEDURE demo_dyn_remove_mentor(p_id NUMBER) AUTHID CURRENT_USER IS BEGIN EXECUTE IMMEDIATE 'DELETE FROM demo_dyn_mentors WHERE mentor_id = :id' USING p_id; DBMS_OUTPUT.PUT_LINE('deleted=' || SQL%ROWCOUNT); END; / SAVEPOINT before_dynamic_remove; BEGIN demo_dyn_remove_mentor(43); END; / ROLLBACK TO before_dynamic_remove;</code></pre> <p>Для исходных данных deleted=1; после отката Zarina снова присутствует.</p> <h3>Имя объекта как параметр</h3> <p>Имя таблицы нельзя заменить bind-переменной. Здесь разрешено удалять только отдельную учебную таблицу из первого примера. Проверка допустимого имени предшествует DBMS_ASSERT. DROP выполняет DDL с неявной фиксацией транзакции; откат DML его не отменяет.</p> <pre class="language-sql"><code>CREATE OR REPLACE PROCEDURE demo_dyn_drop_table(p_table VARCHAR2) AUTHID CURRENT_USER IS l_name VARCHAR2(128) := UPPER(TRIM(p_table)); BEGIN IF l_name IS NULL OR l_name &lt;&gt; 'DEMO_DYN_BONUS_SCRATCH' THEN RAISE_APPLICATION_ERROR(-20103, 'Only the scratch table is allowed'); END IF; EXECUTE IMMEDIATE 'DROP TABLE ' || DBMS_ASSERT.ENQUOTE_NAME(l_name); END; / BEGIN demo_dyn_drop_table('demo_dyn_bonus_scratch'); END; / SELECT COUNT(*) AS remaining FROM user_tables WHERE table_name = 'DEMO_DYN_BONUS_SCRATCH';</code></pre> <p>При первом последовательном запуске remaining=0. Повторный DROP отсутствующей таблицы завершится ошибкой; процедура намеренно не скрывает её.</p> <h3>Повторяющиеся заполнители</h3> <p>В SQL позиции заполнителей значимы, даже если имена повторяются. Четырём позициям соответствуют четыре аргумента:</p> <pre class="language-sql"><code>CREATE TABLE demo_dyn_bind_values (a NUMBER, b NUMBER, c NUMBER, d NUMBER); SAVEPOINT before_dynamic_binds; BEGIN EXECUTE IMMEDIATE 'INSERT INTO demo_dyn_bind_values VALUES (:x, :x, :y, :x)' USING 4, 4, 9, 4; END; / SELECT a, b, c, d FROM demo_dyn_bind_values; ROLLBACK TO before_dynamic_binds;</code></pre> <table> <thead> <tr> <th>A</th> <th>B</th> <th>C</th> <th>D</th> </tr> </thead> <tbody> <tr> <td>4</td> <td>4</td> <td>9</td> <td>4</td> </tr> </tbody> </table> <p>Для анонимного PL/SQL-блока или CALL повторяющееся имя обозначает одну привязку. Ниже достаточно двух аргументов, по порядку первых появлений x и y:</p> <pre class="language-sql"><code>CREATE OR REPLACE PROCEDURE demo_dyn_stats( p_a NUMBER, p_b NUMBER, p_c NUMBER, p_d NUMBER ) IS BEGIN DBMS_OUTPUT.PUT_LINE('sum=' || (p_a + p_b + p_c + p_d)); END; / BEGIN EXECUTE IMMEDIATE 'BEGIN demo_dyn_stats(:x, :x, :y, :x); END;' USING 4, 9; END; / -- sum=21</code></pre> <h3>Атрибуты курсоров</h3> <p>После динамического DML доступны SQL%ROWCOUNT, SQL%FOUND и SQL%NOTFOUND. Считывайте их до следующего SQL-оператора. SQL%ISOPEN всегда FALSE: неявный курсор закрывается автоматически.</p> <pre class="language-sql"><code>SAVEPOINT before_dynamic_attributes; DECLARE l_count PLS_INTEGER; l_found BOOLEAN; BEGIN EXECUTE IMMEDIATE 'DELETE FROM demo_dyn_mentors WHERE mentor_id &gt; :id' USING 41; l_count := SQL%ROWCOUNT; l_found := SQL%FOUND; DBMS_OUTPUT.PUT_LINE('deleted=' || l_count); IF l_found THEN DBMS_OUTPUT.PUT_LINE('found=TRUE'); END IF; END; / ROLLBACK TO before_dynamic_attributes;</code></pre> <p>Результат deleted=2, found=TRUE. Для переменной REF CURSOR используются её собственные атрибуты; ROWCOUNT накапливает извлечённые строки:</p> <pre class="language-sql"><code>DECLARE TYPE t_ids IS TABLE OF NUMBER; l_ids t_ids; l_cursor SYS_REFCURSOR; BEGIN OPEN l_cursor FOR 'SELECT mentor_id FROM demo_dyn_mentors ORDER BY mentor_id'; FETCH l_cursor BULK COLLECT INTO l_ids; DBMS_OUTPUT.PUT_LINE('fetched=' || l_cursor%ROWCOUNT); CLOSE l_cursor; EXCEPTION WHEN OTHERS THEN IF l_cursor%ISOPEN THEN CLOSE l_cursor; END IF; RAISE; END; / -- fetched=3</code></pre> <h3>Передача NULL</h3> <p>Литерал NULL нельзя непосредственно указать как аргумент USING. Неинициализированная переменная подходящего типа передаёт SQL NULL:</p> <pre class="language-sql"><code>SAVEPOINT before_dynamic_null; DECLARE l_null NUMBER; BEGIN EXECUTE IMMEDIATE 'UPDATE demo_dyn_mentors SET bonus = :value WHERE mentor_id = :id' USING l_null, 42; END; / SELECT mentor_id, bonus FROM demo_dyn_mentors WHERE mentor_id = 42; ROLLBACK TO before_dynamic_null;</code></pre> <p>До отката у наставника 42 бонус NULL, после — исходные 30.</p> <h3>Права вызывающего пользователя</h3> <p>AUTHID CURRENT_USER означает проверку прав вызывающего пользователя во время выполнения. Оно не выдаёт привилегий и не заменяет проверку входных имён. Пример допускает только два конкретных учебных объекта и два вида DDL:</p> <pre class="language-sql"><code>CREATE TABLE demo_dyn_drop_sample (id NUMBER); CREATE VIEW demo_dyn_drop_view AS SELECT id FROM demo_dyn_drop_sample; CREATE OR REPLACE PROCEDURE demo_dyn_drop_object( p_kind VARCHAR2, p_name VARCHAR2 ) AUTHID CURRENT_USER IS l_kind VARCHAR2(10) := UPPER(TRIM(p_kind)); l_name VARCHAR2(128) := UPPER(TRIM(p_name)); BEGIN IF l_kind IS NULL OR l_name IS NULL THEN RAISE_APPLICATION_ERROR(-20104, 'Object kind and name are required'); END IF; IF NOT ((l_kind = 'VIEW' AND l_name = 'DEMO_DYN_DROP_VIEW') OR (l_kind = 'TABLE' AND l_name = 'DEMO_DYN_DROP_SAMPLE')) THEN RAISE_APPLICATION_ERROR(-20104, 'Object is not allowed'); END IF; EXECUTE IMMEDIATE 'DROP ' || l_kind || ' ' || DBMS_ASSERT.ENQUOTE_NAME(l_name); END; / BEGIN demo_dyn_drop_object('VIEW', 'demo_dyn_drop_view'); END; / BEGIN demo_dyn_drop_object('TABLE', 'demo_dyn_drop_sample'); END; /</code></pre> <p>Сначала удаляется представление, затем таблица. Вызовите это отдельно от незавершённых изменений: DDL фиксирует транзакцию.</p> <h3>Не изменяйте выполняемый программный модуль</h3> <p>Не следует выполнять DROP или ALTER самой процедуры, пока она находится в стеке вызовов. Это может привести к ожиданию блокировки и ошибке. Следующий код — отрицательный пример; не создавайте и не вызывайте его для проверки на рабочей БД:</p> <pre class="language-sql"><code>-- Антипаттерн, только для разбора: CREATE OR REPLACE PROCEDURE demo_dyn_self_drop IS BEGIN EXECUTE IMMEDIATE 'DROP PROCEDURE demo_dyn_self_drop'; END; /</code></pre> <p>Удалять или пересоздавать такой объект следует отдельной командой после завершения его выполнения, с учётом других сеансов.</p> <h2>📌 Динамический SQL через связь базы данных</h2> <p>Этот самостоятельный сценарий требует двух изолированных Oracle БД и заранее настроенной связи DEMO_TRAINING_LINK. Она должна подключать к владельцу учебных объектов с необходимыми правами. Пароли и создание связи здесь не приводятся. Без такой среды примеры ниже не запускаются.</p> <p>На удалённой учебной БД один раз создайте собственную таблицу и функцию:</p> <pre class="language-sql"><code>CREATE TABLE demo_remote_studios ( studio_id NUMBER PRIMARY KEY, studio_name VARCHAR2(40 CHAR) ); INSERT INTO demo_remote_studios VALUES (91, 'Remote Clay'); COMMIT; CREATE OR REPLACE FUNCTION demo_remote_count(p_table VARCHAR2) RETURN NUMBER AUTHID CURRENT_USER IS l_name VARCHAR2(128) := UPPER(TRIM(p_table)); l_count NUMBER; BEGIN IF l_name IS NULL OR l_name &lt;&gt; 'DEMO_REMOTE_STUDIOS' THEN RAISE_APPLICATION_ERROR(-20105, 'Table is not allowed'); END IF; EXECUTE IMMEDIATE 'SELECT COUNT(*) FROM ' || DBMS_ASSERT.ENQUOTE_NAME(l_name) INTO l_count; RETURN l_count; END; /</code></pre> <p>В локальной БД можно вызвать удалённую функцию динамическим PL/SQL-блоком. OUT относится к первому заполнителю:</p> <pre class="language-sql"><code>DECLARE l_count NUMBER; BEGIN EXECUTE IMMEDIATE 'BEGIN :result := demo_remote_count@demo_training_link(:table_name); END;' USING OUT l_count, IN 'DEMO_REMOTE_STUDIOS'; DBMS_OUTPUT.PUT_LINE('remote rows=' || l_count); END; /</code></pre> <p>При указанных исходных данных remote rows=1. Для удалённого <a href="https://plsql.uz/reference/sql/queries-commands/162-delete.html">DELETE</a> значение идентификатора передаётся через USING. Имя связи не является bind-параметром; разрешена только одна заранее известная связь:</p> <pre class="language-sql"><code>CREATE OR REPLACE PROCEDURE demo_remote_delete( p_link VARCHAR2, p_id NUMBER ) AUTHID CURRENT_USER IS l_link VARCHAR2(128) := UPPER(TRIM(p_link)); BEGIN IF l_link IS NULL OR l_link &lt;&gt; 'DEMO_TRAINING_LINK' THEN RAISE_APPLICATION_ERROR(-20106, 'Database link is not allowed'); END IF; EXECUTE IMMEDIATE 'DELETE FROM demo_remote_studios@' || l_link || ' WHERE studio_id = :id' USING p_id; DBMS_OUTPUT.PUT_LINE('deleted=' || SQL%ROWCOUNT); END; / -- Начинайте в отдельном сеансе без других незавершённых изменений. BEGIN demo_remote_delete('demo_training_link', 91); END; / SELECT COUNT(*) AS remaining FROM demo_remote_studios@demo_training_link; ROLLBACK; SELECT COUNT(*) AS restored FROM demo_remote_studios@demo_training_link;</code></pre> <p>Для исходной строки: deleted=1, remaining=0, после полного отката restored=1. Не добавляйте COMMIT в вызываемую функцию: контроль транзакции остаётся у вызывающего кода. Доступность сети, свойства database link и права проверяются отдельно; результат здесь описывает ожидаемую логику сценария.</p> <h2>✅ Что проверить перед запуском</h2> <ul> <li>Локальные примеры используют только учебные DEMO_DYN_* объекты в отдельной схеме. Для создания объектов нужны соответствующие привилегии и квота.</li> <li>Сначала создайте исходные таблицы, затем выполняйте сценарии по порядку. DDL фиксирует транзакцию; SAVEPOINT относится только к следующему тестовому DML и его откату.</li> <li>Для вывода включите DBMS Output в клиенте; в SQL*Plus/SQLcl используйте SET SERVEROUTPUT ON.</li> <li>Связывайте значения, проверяйте имена по разрешённому списку; DBMS_ASSERT проверяет форму имени, но не выдаёт права и не определяет разрешённый бизнес-контекст.</li> </ul> <p>Связанные темы: <a href="https://plsql.uz/reference/programming/239-procedures.html">процедуры</a>, <a href="https://plsql.uz/reference/programming/245-packages.html">пакеты</a>, <a href="https://plsql.uz/reference/programming/246-anonymous-blocks.html">анонимные блоки</a>, <a href="https://plsql.uz/reference/programming/234-sequences.html">последовательности</a>.</p> <p>Документация Oracle: <a href="https://docs.oracle.com/en/database/oracle/oracle-database/19/lnpls/native-dynamic-sql.html" target="_blank" rel="noopener noreferrer external">Native Dynamic SQL</a>, <a href="https://docs.oracle.com/en/database/oracle/oracle-database/19/lnpls/EXECUTE-IMMEDIATE-statement.html" target="_blank" rel="noopener noreferrer external">EXECUTE IMMEDIATE</a>, <a href="https://docs.oracle.com/en/database/oracle/oracle-database/19/lnpls/sql-injection.html" target="_blank" rel="noopener noreferrer external">SQL Injection</a>, <a href="https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/DBMS_ASSERT.html" target="_blank" rel="noopener noreferrer external">DBMS_ASSERT</a>.</p>]]></content:encoded>
</item><item>
<title>Анонимные блоки</title>
<link>https://plsql.uz/reference/programming/246-anonymous-blocks.html</link>
<pdalink>https://plsql.uz/reference/programming/246-anonymous-blocks.html</pdalink>
<guid>https://plsql.uz/reference/programming/246-anonymous-blocks.html</guid>
<pubDate>Tue, 10 Nov 2026 13:59:00 +0500</pubDate>
<category>index</category>

<content:encoded><![CDATA[<h2>📖 Описание</h2> <p>Структуры блоков PL/SQL могут быть включены в определения процедур, функций или триггеров PL/SQL или выполняться независимо в форме анонимного блока.</p> <hr> <h2>📌 Структура блока</h2> <p>Структура блока PL/SQL:</p> <pre class="language-sql"><code>DECLARE -- Необязательные объявления BEGIN NULL; -- Исполняемая часть обязательна EXCEPTION WHEN OTHERS THEN RAISE; -- Необязательная обработка ошибок END; /</code></pre> <h3>📌 Описание структуры блока PL/SQL</h3> <dl> <dt>DECLARE</dt> <dd>Необязательный. Раздел объявления переменных, курсоров, типов, процедур и функций для использования в блоке. Область действия является локальной для блока. Каждое объявление должно заканчиваться точкой с запятой.</dd> <dt>BEGIN - END</dt> <dd>Обязательный. Раздел в котором исполняются один или несколько операторов PL/SQL. Должен быть как минимум один исполняемый оператор. Каждый оператор должен заканчиваться точкой с запятой. Блок BEGIN-END может содержать вложенные блоки BEGIN-END.</dd> <dt>EXCEPTION</dt> <dd>Необязательный. Раздел обработки исключительных ситуаций или "отлова" ошибок.</dd> </dl> <hr> <h2>💻 Примеры</h2> <p>В приведённом ниже примере показан самый простейший допустимый блок, который ничего не делает.</p> <pre class="language-sql"><code>BEGIN NULL; -- Допустимая пустая работа блока. END; /</code></pre> <h3>💻 Пример блока PL/SQL с одной переменной</h3> <pre class="language-sql"><code>DECLARE l_seats NUMBER; BEGIN l_seats := 4; DBMS_OUTPUT.PUT_LINE('seats = ' || l_seats); END; /</code></pre> <p>Результат:</p> <pre class="language-text"><code>seats = 4</code></pre> <h3>💻 Пример встроенного блока PL/SQL</h3> <pre class="language-sql"><code>BEGIN DBMS_OUTPUT.PUT_LINE('Workshop preparation'); BEGIN DBMS_OUTPUT.PUT_LINE('Materials ready'); END; END; /</code></pre> <p>Результат:</p> <pre class="language-text"><code>Workshop preparation Materials ready</code></pre> <h3>💻 Пример встроенного блока PL/SQL с переменной</h3> <pre class="language-sql"><code>DECLARE l_outer_fee NUMBER := 85; BEGIN DECLARE l_inner_seats NUMBER := 4; BEGIN DBMS_OUTPUT.PUT_LINE(l_outer_fee || ' ' || l_inner_seats); END; END; /</code></pre> <p>Результат:</p> <pre class="language-text"><code>85 4</code></pre> <h3>💻 Пример встроенный блок PL/SQL и повторяющиеся имена переменных</h3> <pre class="language-sql"><code>&lt;&lt;workshop&gt;&gt; DECLARE l_fee NUMBER := 85; BEGIN DECLARE l_fee NUMBER := 120; BEGIN DBMS_OUTPUT.PUT_LINE(l_fee); DBMS_OUTPUT.PUT_LINE(workshop.l_fee); END; DBMS_OUTPUT.PUT_LINE(l_fee); END; /</code></pre> <p>Результат:</p> <pre class="language-text"><code>120 85 85</code></pre> <p>Внутреннее объявление скрывает имя внешней переменной. Метка workshop позволяет обратиться к внешней через workshop.l_fee. Значение внешней переменной остаётся 85.</p> <h3>💻 Пример видимости переменных в блоках PL/SQL</h3> <pre class="language-sql"><code>DECLARE l_outer_fee NUMBER := 85; BEGIN DECLARE l_inner_seats NUMBER := 4; BEGIN DBMS_OUTPUT.PUT_LINE(l_outer_fee || ' ' || l_inner_seats); END; -- Намеренная ошибка компиляции: внутренняя переменная здесь невидима. DBMS_OUTPUT.PUT_LINE(l_outer_fee || ' ' || l_inner_seats); END; /</code></pre> <p>В этом примере возникнет ошибка компиляции по причине того, что переменная l_inner_seats объявлена во встроенном блоке и для внешнего блока не видна. Переменная l_outer_fee видна в обоих блоках. Из-за ошибки компиляции весь анонимный блок не начнёт выполняться, даже строка вывода перед ошибочным обращением.</p> <h3>💻 Пример блока с вызовом процедуры</h3> <pre class="language-sql"><code>CREATE OR REPLACE PROCEDURE demo_workshop_greeting AS BEGIN DBMS_OUTPUT.PUT_LINE('Welcome to Clay Studio'); END; / BEGIN demo_workshop_greeting; END; /</code></pre> <p>Результат:</p> <pre class="language-text"><code>Welcome to Clay Studio</code></pre> <p>В этом примере мы создали процедуру demo_workshop_greeting, которая выводит на экран простое приветствие. Затем в следующем блоке мы вызываем эту процедуру. Если вам процедура demo_workshop_greeting больше не понадобиться, то ее можно удалить командой <code>DROP PROCEDURE demo_workshop_greeting;</code></p> <h3>💻 Пример с многими вложенными блоками PL/SQL</h3> <p>В следующем примере показаны вложенные блоки.</p> <pre class="language-sql"><code>DECLARE l_stage VARCHAR2(20 CHAR) := 'Festival'; BEGIN DECLARE l_stage VARCHAR2(20 CHAR) := 'Workshop'; BEGIN DECLARE l_stage VARCHAR2(20 CHAR) := 'Clay'; BEGIN DBMS_OUTPUT.PUT_LINE(l_stage); END; DBMS_OUTPUT.PUT_LINE(l_stage); END; DBMS_OUTPUT.PUT_LINE(l_stage); END; /</code></pre> <p>Результат:</p> <pre class="language-text"><code>Clay Workshop Festival</code></pre> <p>Выполнение следует порядку операторов: внешний блок входит во вложенные блоки, затем продолжает работу после их END. В этом примере вывод расположен так, что сначала печатается значение самого глубокого блока.</p> <h3>💻 Пример блока с разделом EXCEPTION</h3> <p>В следующем примере рассмотрим блок с разделом обработки исключительных ситуаций.</p> <pre class="language-sql"><code>DECLARE l_event_day DATE; BEGIN SELECT DATE '2026-12-19' INTO l_event_day FROM dual WHERE 1 = 0; -- Сюда управление не дойдёт: NO_DATA_FOUND. DBMS_OUTPUT.PUT_LINE('Date found'); END; /</code></pre> <p>Отсутствие строки остаётся ожидаемым событием. Обработчик NO_DATA_FOUND объясняет его и завершает внутренний блок; внешний после этого продолжает работу:</p> <pre class="language-sql"><code>BEGIN DECLARE l_event_day DATE; BEGIN SELECT DATE '2026-12-19' INTO l_event_day FROM dual WHERE 1 = 0; DBMS_OUTPUT.PUT_LINE('Date found'); EXCEPTION WHEN NO_DATA_FOUND THEN DBMS_OUTPUT.PUT_LINE('No workshop date'); END; DBMS_OUTPUT.PUT_LINE('Outer block continues'); END; /</code></pre> <p>Вывод: No workshop date, затем Outer block continues. Строка Date found не печатается: после обработчика выполнение не возвращается к месту сбоя.</p> <h3>💻 Пример блока который выводит символьный треугольник</h3> <p>В следующем примере <a href="https://plsql.uz/reference/functions/string-char/61-chr.html">CHR</a> строит шесть строк от P до U в ASCII-совместимом наборе символов. Для другой кодировки числовое соответствие символов необходимо проверить.</p> <pre class="language-sql"><code>DECLARE l_line VARCHAR2(80 CHAR); BEGIN l_line := CHR(80); DBMS_OUTPUT.PUT_LINE(l_line); FOR step IN 1 .. 5 LOOP l_line := l_line || ' ' || CHR(80 + step); DBMS_OUTPUT.PUT_LINE(l_line); END LOOP; END; /</code></pre> <p>Результат:</p> <pre class="language-text"><code>P P Q P Q R P Q R S P Q R S T P Q R S T U</code></pre> <p>Для просмотра вывода включите DBMS Output в клиенте; в SQL*Plus или SQLcl выполните <code>SET SERVEROUTPUT ON</code>. Строка <code>/</code> запускает завершённый блок в режиме сценария.</p> <p>Для создания учебной процедуры нужна CREATE PROCEDURE; отдельный анонимный блок не сохраняется как объект схемы. В примере процедуры добавлена строка / между CREATE PROCEDURE и вызывающим блоком. BEGIN/END обозначают блок, а не автоматические границы транзакции. Подробнее: <a href="https://plsql.uz/reference/programming/238-variable-declarations.html">переменные</a>, <a href="https://plsql.uz/reference/programming/239-procedures.html">процедуры</a> и <a href="https://plsql.uz/reference/programming/exceptions/224-predefined-exceptions.html">исключения</a>.</p> <p>Oracle: <a href="https://docs.oracle.com/en/database/oracle/oracle-database/19/lnpls/block.html" target="_blank" rel="noopener noreferrer external">Block</a>, <a href="https://docs.oracle.com/en/database/oracle/oracle-database/19/lnpls/scope-and-visibility-identifiers.html" target="_blank" rel="noopener noreferrer external">Scope and Visibility</a>.</p>]]></content:encoded>
</item><item>
<title>Пакеты</title>
<link>https://plsql.uz/reference/programming/245-packages.html</link>
<pdalink>https://plsql.uz/reference/programming/245-packages.html</pdalink>
<guid>https://plsql.uz/reference/programming/245-packages.html</guid>
<pubDate>Tue, 10 Nov 2026 13:58:43 +0500</pubDate>
<category>index</category>

<content:encoded><![CDATA[<h2>📖 Описание</h2> <p>В Oracle PL/SQL набор элементов: процедур, функций, определения типов; объявления переменных, констант можно объединить в пакет. После написания пакет PL/SQL компилируется, а затем сохраняется в базе данных Oracle, где его содержимое может использоваться многими приложениями.</p> <ul> <li>Что такое пакет Oracle PL/SQL? <ul> <li>Синтаксис</li> <li>Пример пакета PL/SQL</li> </ul> </li> <li>Преимущества пакетов Oracle PL/SQL</li> <li>Понимание спецификации пакета.</li> <li>Понимание тела пакета.</li> <li>Некоторые примеры функций пакета.</li> <li>Частные и публичные предметы в пакетах.</li> <li>Перегрузка подпрограмм пакета.</li> <li>Как пакет STANDARD определяет среду Oracle PL/SQL</li> <li>Руководство по написанию пакетов</li> </ul> <hr> <h2>📌 Что такое пакет Oracle PL/SQL?</h2> <p>Пакет Oracle PL/SQL - это объект схемы, который группирует логически связанные типы, элементы и подпрограммы. Пакеты обычно состоят из двух частей: спецификации и тела, хотя иногда тело не нужно. Спецификация - это интерфейс для ваших приложений.<br>В <em>спецификации</em> пакета объявляются типы, переменные, константы, исключения, курсоры и подпрограммы, доступные для использования.<br><em>Тело</em> пакета полностью определяет курсоры и подпрограммы и реализует спецификацию.</p> <p>Можно думать о спецификации как о рабочем интерфейсе, а о теле - как о «черном ящике». Вы можете отлаживать, улучшать или изменять тело пакета без изменения интерфейса (спецификации) пакета.</p> <p>Для создания пакетов используйте оператор CREATE PACKAGE.</p> <hr> <h2>🧩 Синтаксис</h2> <p>Синтаксис CREATE PACKAGE в Oracle PL/SQL:</p> <pre class="language-sql"><code>CREATE [OR REPLACE] PACKAGE package_name [AUTHID {CURRENT_USER | DEFINER}] {IS | AS} [PRAGMA SERIALLY_REUSABLE;] [collection_type_definition ...] [record_type_definition ...] [subtype_definition ...] [collection_declaration ...] [constant_declaration ...] [exception_declaration ...] [object_declaration ...] [record_declaration ...] [variable_declaration ...] [cursor_spec ...] [function_spec ...] [procedure_spec ...] [call_spec ...] [PRAGMA RESTRICT_REFERENCES(assertions) ...] END [package_name]; [CREATE [OR REPLACE] PACKAGE BODY package_name {IS | AS} [PRAGMA SERIALLY_REUSABLE;] [collection_type_definition ...] [record_type_definition ...] [subtype_definition ...] [collection_declaration ...] [constant_declaration ...] [exception_declaration ...] [object_declaration ...] [record_declaration ...] [variable_declaration ...] [cursor_body ...] [function_spec ...] [procedure_spec ...] [call_spec ...] [BEGIN sequence_of_statements] END [package_name];]</code></pre> <p>collection_type_definition - определение типа коллекции<br>record_type_definition - определение типа записи<br>subtype_definition - определение подтипа<br>collection_declaration - объявление коллекции<br>constant_declaration - объявление константы<br>exception_declaration - объявление исключения<br>object_declaration - объявление объекта<br>record_declaration - объявление записи<br>variable_declaration - объявление переменной<br>cursor_spec - спецификация курсора<br>function_spec - спецификация функции<br>procedure_spec - спецификация процедуры<br>call_spec - спецификация вызова</p> <p><strong>Спецификация пакета</strong> содержит публичные объявления, которые видны вашему приложению. Размещайте объявления так, чтобы используемые типы и идентификаторы были объявлены до обращения к ним.</p> <p><strong>Тело пакета</strong> содержит детали реализации и приватные объявления, которые скрыты от вашего приложения. За декларативной частью тела пакета следует необязательная часть инициализации, которая обычно содержит операторы, которые инициализируют переменные пакета.</p> <hr> <p>Приведённая развёрнутая схема — шаблон, а не готовый скрипт: многоточия и скобки не вводят буквально. Для основных примеров ниже не нужны SERIALLY_REUSABLE и устаревшая RESTRICT_REFERENCES. AUTHID DEFINER используется по умолчанию; AUTHID CURRENT_USER задаёт контекст прав вызывающего, но не предоставляет ему дополнительных привилегий.</p> <h2>💻 Подготовка и простой пакет</h2> <p>Пример сохраняет идею набора операций добавления и удаления сотрудника, но использует собственный каталог наставников. В учебной схеме нужны CREATE TABLE, CREATE SEQUENCE, CREATE PROCEDURE и квота.</p> <pre class="language-sql"><code>CREATE TABLE demo_pkg_mentors ( mentor_id NUMBER PRIMARY KEY, mentor_name VARCHAR2(40 CHAR) NOT NULL, joined_on DATE NOT NULL, monthly_fee NUMBER(8,2) NOT NULL CHECK (monthly_fee &gt; 0) ); CREATE SEQUENCE demo_pkg_mentor_seq START WITH 601; CREATE TABLE demo_pkg_grades ( grade_id NUMBER PRIMARY KEY, minimum_fee NUMBER NOT NULL, maximum_fee NUMBER NOT NULL ); CREATE TABLE demo_pkg_audit ( started_at TIMESTAMP, actor VARCHAR2(128 CHAR), package_name VARCHAR2(128 CHAR) ); INSERT ALL INTO demo_pkg_mentors VALUES (41, 'Aziza', DATE '2026-02-03', 6200) INTO demo_pkg_mentors VALUES (42, 'Temur', DATE '2026-03-10', 7400) INTO demo_pkg_mentors VALUES (43, 'Zarina', DATE '2026-04-14', 7400) SELECT 1 FROM dual; INSERT INTO demo_pkg_grades VALUES (7, 3000, 10000); COMMIT; CREATE OR REPLACE PACKAGE demo_mentor_basic AS TYPE mentor_rec IS RECORD (mentor_id NUMBER, monthly_fee NUMBER); CURSOR fees_desc RETURN mentor_rec; PROCEDURE add_mentor(p_name VARCHAR2, p_joined DATE, p_fee NUMBER); PROCEDURE remove_mentor(p_id NUMBER); END demo_mentor_basic; / CREATE OR REPLACE PACKAGE BODY demo_mentor_basic AS CURSOR fees_desc RETURN mentor_rec IS SELECT mentor_id, monthly_fee FROM demo_pkg_mentors ORDER BY monthly_fee DESC, mentor_id; PROCEDURE add_mentor(p_name VARCHAR2, p_joined DATE, p_fee NUMBER) IS BEGIN INSERT INTO demo_pkg_mentors (mentor_id, mentor_name, joined_on, monthly_fee) VALUES (demo_pkg_mentor_seq.NEXTVAL, p_name, p_joined, p_fee); END; PROCEDURE remove_mentor(p_id NUMBER) IS BEGIN DELETE FROM demo_pkg_mentors WHERE mentor_id = p_id; END; END demo_mentor_basic; /</code></pre> <p>Тип записи, курсор и две процедуры объявлены в спецификации. Реализация находится в теле. Вызов через точку:</p> <pre class="language-sql"><code>SAVEPOINT before_basic_package; BEGIN demo_mentor_basic.add_mentor('Malika', DATE '2026-12-05', 8300); END; / SELECT mentor_name, monthly_fee FROM demo_pkg_mentors WHERE mentor_name = 'Malika'; -- Malika | 8300 ROLLBACK TO before_basic_package;</code></pre> <p>После отката добавленная строка исчезает. Номер последовательности уже использован и не возвращается; повторный опыт может получить другой идентификатор.</p> <h2>💻 Расширенный пакет: функции, проверка и состояние</h2> <p>Следующий пакет имеет другое имя. Он добавляет приватную проверку диапазона, публичное исключение, счётчик добавлений и получение n-й строки по убыванию ставки. Тип studio_rec иллюстрирует дополнительный публичный тип записи.</p> <pre class="language-sql"><code>CREATE OR REPLACE PACKAGE demo_mentor_admin AS TYPE mentor_rec IS RECORD (mentor_id NUMBER, monthly_fee NUMBER); TYPE studio_rec IS RECORD (studio_id NUMBER, city VARCHAR2(40 CHAR)); CURSOR fees_desc RETURN mentor_rec; invalid_fee EXCEPTION; FUNCTION add_mentor(p_name VARCHAR2, p_joined DATE, p_fee NUMBER) RETURN NUMBER; PROCEDURE remove_mentor(p_id NUMBER); PROCEDURE increase_fee(p_id NUMBER, p_grade NUMBER, p_amount NUMBER); FUNCTION nth_fee(p_position NUMBER) RETURN mentor_rec; FUNCTION added_count RETURN PLS_INTEGER; END demo_mentor_admin; / CREATE OR REPLACE PACKAGE BODY demo_mentor_admin AS g_number_added PLS_INTEGER; CURSOR fees_desc RETURN mentor_rec IS SELECT mentor_id, monthly_fee FROM demo_pkg_mentors ORDER BY monthly_fee DESC, mentor_id; FUNCTION fee_allowed(p_grade NUMBER, p_fee NUMBER) RETURN BOOLEAN IS l_min NUMBER; l_max NUMBER; BEGIN SELECT minimum_fee, maximum_fee INTO l_min, l_max FROM demo_pkg_grades WHERE grade_id = p_grade; RETURN p_fee BETWEEN l_min AND l_max; END; FUNCTION add_mentor(p_name VARCHAR2, p_joined DATE, p_fee NUMBER) RETURN NUMBER IS l_id NUMBER; BEGIN l_id := demo_pkg_mentor_seq.NEXTVAL; INSERT INTO demo_pkg_mentors (mentor_id, mentor_name, joined_on, monthly_fee) VALUES (l_id, p_name, p_joined, p_fee); g_number_added := g_number_added + 1; RETURN l_id; END; PROCEDURE remove_mentor(p_id NUMBER) IS BEGIN DELETE FROM demo_pkg_mentors WHERE mentor_id = p_id; END; PROCEDURE increase_fee(p_id NUMBER, p_grade NUMBER, p_amount NUMBER) IS l_fee NUMBER; BEGIN IF p_amount IS NULL OR p_amount &lt; 0 THEN RAISE invalid_fee; END IF; SELECT monthly_fee INTO l_fee FROM demo_pkg_mentors WHERE mentor_id = p_id FOR UPDATE; IF fee_allowed(p_grade, l_fee + p_amount) THEN UPDATE demo_pkg_mentors SET monthly_fee = l_fee + p_amount WHERE mentor_id = p_id; ELSE RAISE invalid_fee; END IF; END; FUNCTION nth_fee(p_position NUMBER) RETURN mentor_rec IS l_result mentor_rec; CURSOR c_rank IS SELECT mentor_id, monthly_fee FROM demo_pkg_mentors ORDER BY monthly_fee DESC, mentor_id; BEGIN IF p_position IS NULL OR p_position &lt; 1 OR p_position != TRUNC(p_position) THEN RAISE_APPLICATION_ERROR(-20092, 'Position must be a positive integer'); END IF; OPEN c_rank; FOR i IN 1 .. p_position LOOP FETCH c_rank INTO l_result; IF c_rank%NOTFOUND THEN CLOSE c_rank; RAISE NO_DATA_FOUND; END IF; END LOOP; CLOSE c_rank; RETURN l_result; END; FUNCTION added_count RETURN PLS_INTEGER IS BEGIN RETURN g_number_added; END; BEGIN g_number_added := 0; INSERT INTO demo_pkg_audit (started_at, actor, package_name) VALUES (SYSTIMESTAMP, SYS_CONTEXT('USERENV', 'SESSION_USER'), 'DEMO_MENTOR_ADMIN'); END demo_mentor_admin; /</code></pre> <p>Для nth_fee используются стабильный порядок и локальный курсор: функция не открывает общий публичный fees_desc, который мог открыть вызывающий код. При n вне выборки возникает NO_DATA_FOUND; при NULL, нуле, отрицательном или дробном n — ошибка -20092. Это номер строки, а не номер различной ставки.</p> <pre class="language-sql"><code>SAVEPOINT before_admin_package; DECLARE l_mentor demo_mentor_admin.mentor_rec; l_new_id NUMBER; BEGIN l_mentor := demo_mentor_admin.nth_fee(2); DBMS_OUTPUT.PUT_LINE(l_mentor.mentor_id || ' / ' || l_mentor.monthly_fee); demo_mentor_admin.increase_fee(41, 7, 350); BEGIN demo_mentor_admin.increase_fee(41, 7, 20000); EXCEPTION WHEN demo_mentor_admin.invalid_fee THEN DBMS_OUTPUT.PUT_LINE('Fee increase rejected'); END; l_new_id := demo_mentor_admin.add_mentor('Malika', DATE '2026-12-12', 8300); demo_mentor_admin.remove_mentor(l_new_id); DBMS_OUTPUT.PUT_LINE('added=' || demo_mentor_admin.added_count); END; / SELECT monthly_fee FROM demo_pkg_mentors WHERE mentor_id = 41; -- 6550 ROLLBACK TO before_admin_package; SELECT monthly_fee FROM demo_pkg_mentors WHERE mentor_id = 41; -- 6200 BEGIN DBMS_OUTPUT.PUT_LINE('added after rollback=' || demo_mentor_admin.added_count); END; /</code></pre> <p>При первом запуске в свежем сеансе вывод: 43 / 7400, Fee increase rejected, added=1; после отката added after rollback=1. Счётчик отражает успешные вызовы добавления в сеансе, а не число строк после отката. Инициализация вставляет строку аудита при создании экземпляра пакета; если она попала после SAVEPOINT, откат удалит запись, но сам по себе не запустит инициализацию повторно. Значения времени и пользователя аудита зависят от среды.</p> <h2>📌 Преимущества пакетов Oracle PL/SQL</h2> <h3>📌 Модульность</h3> <p>Пакеты позволяют инкапсулировать логически связанные типы, элементы и подпрограммы в именованный модуль PL/SQL. Каждый пакет прост для понимания, а интерфейсы между пакетами просты, понятны и хорошо определены. Это помогает разработке приложений.</p> <h3>📌 Более простой дизайн приложений</h3> <p>При разработке приложения все, что вам первоначально нужно, это информация об интерфейсе в спецификации пакета. Вы можете кодировать и компилировать спецификацию без ее тела. Затем сохраненные подпрограммы, которые ссылаются на пакет, также могут быть скомпилированы.</p> <h3>📌 Сокрытие информации</h3> <p>С помощью пакетов вы можете указать, какие типы, элементы и подпрограммы являются общедоступными (видимыми и доступными) или приватными (скрытыми и недоступными). Например, если пакет содержит четыре подпрограммы, три могут быть открытыми и одна закрытая. Пакет скрывает реализацию закрытой подпрограммы, поэтому при изменении реализации затрагивается только пакет (не ваше приложение). Это упрощает обслуживание и улучшение. Кроме того, скрывая детали реализации от пользователей, вы защищаете целостность пакета.</p> <h3>📌 Добавленная функциональность</h3> <p>Обычный пакет может хранить переменные и состояние курсоров в течение сеанса. У SERIALLY_REUSABLE и при перекомпиляции действуют отдельные правила. Таким образом, они могут быть общими для всех подпрограмм, которые выполняются в среде. Кроме того, они позволяют поддерживать данные между транзакциями, не сохраняя их в базе данных.</p> <h3>📌 Лучшая производительность</h3> <p>Разделение интерфейса и реализации позволяет менять тело, сохраняя спецификацию и вызовы публичных элементов. Это уменьшает ненужные зависимости от деталей реализации. Само объединение в пакет не гарантирует ускорения конкретного запроса: измеряйте рабочую нагрузку.</p> <hr> <h2>📌 Понимание спецификации</h2> <p>Спецификация — публичный интерфейс. По заголовку видно, какие аргументы нужны и какой тип возвращается; алгоритм скрыт в теле. Например, объявление внутри спецификации:</p> <pre class="language-sql"><code>FUNCTION total_fee(p_seats NUMBER) RETURN NUMBER;</code></pre> <p>Если спецификация содержит только типы, константы, переменные и исключения, тело не требуется. Пример с вложенной записью:</p> <pre class="language-sql"><code>CREATE OR REPLACE PACKAGE demo_booking_data AS TYPE slot_rec IS RECORD (starts_at DATE, duration_minutes PLS_INTEGER); TYPE booking_rec IS RECORD ( workshop_name VARCHAR2(60 CHAR), registration_id NUMBER, seats PLS_INTEGER, slot slot_rec ); seat_fee CONSTANT NUMBER := 45; number_processed PLS_INTEGER := 0; invalid_booking EXCEPTION; END demo_booking_data; /</code></pre> <p>Тип используется как demo_booking_data.booking_rec, константа — demo_booking_data.seat_fee. Для доступа из другой схемы обычно указывают и владельца, и имеют необходимое право EXECUTE. Публичность объявления сама по себе не выдаёт это право всем пользователям.</p> <h3>📌 Ограничения удалённых ссылок</h3> <p>Удалённые переменные пакета нельзя читать прямо или косвенно. Например, значение по умолчанию ниже ссылается на состояние пакета:</p> <pre class="language-sql"><code>CREATE OR REPLACE PACKAGE demo_random_state AS seed NUMBER := 17; PROCEDURE initialize(p_start NUMBER := seed); END demo_random_state; / CREATE OR REPLACE PACKAGE BODY demo_random_state AS PROCEDURE initialize(p_start NUMBER := seed) IS BEGIN seed := p_start; END; END demo_random_state; /</code></pre> <p>Это локальный пример; он не настраивает связь баз. При проектировании RPC не переносите ссылку на seed через удалённый вызов: передавайте необходимое значение явным аргументом. Пакет также не должен зависеть от переменных хоста SQL-клиента.</p> <h2>📌 Тело пакета и соответствие заголовков</h2> <p>Тело реализует объявления спецификации и может содержать приватные элементы. Использование DATE в теле вместо указанного в спецификации %TYPE не считается одинаковым объявлением, даже если базовый тип совпадает. Следующий отдельный диагностический пример намеренно создаёт ошибку тела:</p> <pre class="language-sql"><code>CREATE OR REPLACE PACKAGE demo_pkg_date_match AS PROCEDURE show_day(p_day demo_pkg_mentors.joined_on%TYPE); END demo_pkg_date_match; / CREATE OR REPLACE PACKAGE BODY demo_pkg_date_match AS PROCEDURE show_day(p_day DATE) IS BEGIN DBMS_OUTPUT.PUT_LINE(TO_CHAR(p_day, 'YYYY-MM-DD')); END; END demo_pkg_date_match; /</code></pre> <p>Ожидается ошибка соответствия объявления, например PLS-00323. Исправленное тело использует то же объявление параметра:</p> <pre class="language-sql"><code>CREATE OR REPLACE PACKAGE BODY demo_pkg_date_match AS PROCEDURE show_day(p_day demo_pkg_mentors.joined_on%TYPE) IS BEGIN DBMS_OUTPUT.PUT_LINE(TO_CHAR(p_day, 'YYYY-MM-DD')); END; END demo_pkg_date_match; / BEGIN demo_pkg_date_match.show_day(DATE '2026-12-19'); END; / -- 2026-12-19</code></pre> <h2>📌 Приватные, публичные элементы и состояние</h2> <p>В demo_mentor_admin счётчик g_number_added и функция fee_allowed доступны только телу. Тип mentor_rec, исключение invalid_fee и объявленные подпрограммы доступны через спецификацию. Счётчик можно прочесть только через публичную added_count.</p> <p>Каждый сеанс имеет свой экземпляр пакета. Инициализация относится к этому экземпляру, а не ко всем пользователям сразу. COMMIT и ROLLBACK не откатывают обычные переменные пакета. Перекомпиляция тела пакета с состоянием может привести к сбросу состояния и ORA-04068 при следующем обращении. SERIALLY_REUSABLE ограничивает срок состояния серверным вызовом; это отдельный выбор конструкции пакета.</p> <h2>💻 Учебная модель банковских операций</h2> <p>Пример показывает очередь операций, приватные подпрограммы, предварительные объявления и обработку ожидаемых ошибок. Он рассчитан на один учебный сеанс обработки и не описывает полноценную банковскую систему. Все таблицы имеют отдельные имена:</p> <pre class="language-sql"><code>CREATE TABLE demo_pkg_accounts ( account_id NUMBER PRIMARY KEY, balance NUMBER(10,2) NOT NULL ); CREATE TABLE demo_pkg_transactions ( transaction_id NUMBER PRIMARY KEY, account_id NUMBER NOT NULL, kind CHAR(1) NOT NULL, amount NUMBER(10,2) NOT NULL CHECK (amount &gt; 0), status VARCHAR2(30 CHAR) NOT NULL, recorded_on DATE NOT NULL ); CREATE SEQUENCE demo_pkg_tx_seq START WITH 701; CREATE TABLE demo_pkg_ledger ( account_id NUMBER, kind CHAR(1), new_balance NUMBER(10,2), recorded_at TIMESTAMP ); INSERT INTO demo_pkg_accounts VALUES (51, 1200); COMMIT; CREATE OR REPLACE PACKAGE demo_bank_actions AS minimum_balance CONSTANT NUMBER := 200; PROCEDURE enqueue(p_account NUMBER, p_kind CHAR, p_amount NUMBER, p_day DATE); PROCEDURE apply_pending; END demo_bank_actions; / CREATE OR REPLACE PACKAGE BODY demo_bank_actions AS g_status VARCHAR2(30 CHAR); PROCEDURE credit_account(p_account NUMBER, p_amount NUMBER); PROCEDURE debit_account(p_account NUMBER, p_amount NUMBER); PROCEDURE enqueue(p_account NUMBER, p_kind CHAR, p_amount NUMBER, p_day DATE) IS BEGIN INSERT INTO demo_pkg_transactions (transaction_id, account_id, kind, amount, status, recorded_on) VALUES (demo_pkg_tx_seq.NEXTVAL, p_account, p_kind, p_amount, 'Pending', p_day); END; PROCEDURE apply_pending IS CURSOR c_pending IS SELECT account_id, kind, amount FROM demo_pkg_transactions WHERE status = 'Pending' ORDER BY recorded_on, transaction_id FOR UPDATE OF status; BEGIN FOR tx IN c_pending LOOP g_status := 'Rejected'; IF tx.kind = 'C' THEN credit_account(tx.account_id, tx.amount); ELSIF tx.kind = 'D' THEN debit_account(tx.account_id, tx.amount); END IF; UPDATE demo_pkg_transactions SET status = g_status WHERE CURRENT OF c_pending; END LOOP; END; PROCEDURE journal_entry(p_account NUMBER, p_kind CHAR, p_balance NUMBER) IS BEGIN INSERT INTO demo_pkg_ledger (account_id, kind, new_balance, recorded_at) VALUES (p_account, p_kind, p_balance, SYSTIMESTAMP); END; PROCEDURE credit_account(p_account NUMBER, p_amount NUMBER) IS l_balance NUMBER; BEGIN SELECT balance INTO l_balance FROM demo_pkg_accounts WHERE account_id = p_account FOR UPDATE; l_balance := l_balance + p_amount; UPDATE demo_pkg_accounts SET balance = l_balance WHERE account_id = p_account; journal_entry(p_account, 'C', l_balance); g_status := 'Credit applied'; EXCEPTION WHEN NO_DATA_FOUND THEN g_status := 'Bad account number'; END; PROCEDURE debit_account(p_account NUMBER, p_amount NUMBER) IS l_balance NUMBER; insufficient_funds EXCEPTION; BEGIN SELECT balance INTO l_balance FROM demo_pkg_accounts WHERE account_id = p_account FOR UPDATE; l_balance := l_balance - p_amount; IF l_balance &lt; minimum_balance THEN RAISE insufficient_funds; END IF; UPDATE demo_pkg_accounts SET balance = l_balance WHERE account_id = p_account; journal_entry(p_account, 'D', l_balance); g_status := 'Debit applied'; EXCEPTION WHEN NO_DATA_FOUND THEN g_status := 'Bad account number'; WHEN insufficient_funds THEN g_status := 'Insufficient funds'; END; END demo_bank_actions; /</code></pre> <p>Предварительные объявления позволяют apply_pending вызывать приватные процедуры, определённые ниже. Для каждой строки статус начинается с Rejected и не наследуется от предыдущей операции. Ограничение CHECK отклоняет нулевую или отрицательную сумму; отсутствующий счёт намеренно не блокируется внешним ключом, чтобы показать обработчик.</p> <pre class="language-sql"><code>SAVEPOINT before_bank_package; BEGIN demo_bank_actions.enqueue(51, 'C', 150, DATE '2026-12-20'); demo_bank_actions.enqueue(51, 'D', 200, DATE '2026-12-20'); demo_bank_actions.enqueue(51, 'D', 2000, DATE '2026-12-20'); demo_bank_actions.enqueue(99, 'C', 50, DATE '2026-12-20'); demo_bank_actions.enqueue(51, 'X', 25, DATE '2026-12-20'); demo_bank_actions.apply_pending; END; / SELECT account_id, kind, amount, status FROM demo_pkg_transactions ORDER BY transaction_id; SELECT balance FROM demo_pkg_accounts WHERE account_id = 51; SELECT COUNT(*) AS ledger_rows FROM demo_pkg_ledger;</code></pre> <table> <thead> <tr> <th>ACCOUNT_ID</th> <th>KIND</th> <th>AMOUNT</th> <th>STATUS</th> </tr> </thead> <tbody> <tr> <td>51</td> <td>C</td> <td>150</td> <td>Credit applied</td> </tr> <tr> <td>51</td> <td>D</td> <td>200</td> <td>Debit applied</td> </tr> <tr> <td>51</td> <td>D</td> <td>2000</td> <td>Insufficient funds</td> </tr> <tr> <td>99</td> <td>C</td> <td>50</td> <td>Bad account number</td> </tr> <tr> <td>51</td> <td>X</td> <td>25</td> <td>Rejected</td> </tr> </tbody> </table> <p>Баланс равен 1200 + 150 − 200 = 1150, в журнале две строки. Повторный apply_pending не применит обработанные строки снова, поскольку выбирает только Pending.</p> <pre class="language-sql"><code>ROLLBACK TO before_bank_package; SELECT balance FROM demo_pkg_accounts WHERE account_id = 51; -- 1200 SELECT COUNT(*) FROM demo_pkg_transactions; -- 0 SELECT COUNT(*) FROM demo_pkg_ledger; -- 0</code></pre> <p>COMMIT внутри пакета отсутствует. Баланс, статусы и журнал изменяются в транзакции вызывающего кода; неожиданные ошибки не скрываются. Для совместной обработки несколькими сеансами потребовалось бы отдельно спроектировать порядок блокировок, повторные попытки и управление очередью.</p> <h2>📌 Перегрузка подпрограмм</h2> <p>Одинаковое имя допустимо при различимых списках параметров. Здесь две процедуры принимают дату либо строкой YYYY-MM-DD, либо числом юлианского дня. Таблица журнала отдельная и не конфликтует с банковским примером.</p> <pre class="language-sql"><code>CREATE TABLE demo_pkg_date_journal ( amount NUMBER(8,2), event_day DATE ); CREATE OR REPLACE PACKAGE demo_date_entries AS PROCEDURE journalize(p_amount NUMBER, p_day VARCHAR2); PROCEDURE journalize(p_amount NUMBER, p_day NUMBER); END demo_date_entries; / CREATE OR REPLACE PACKAGE BODY demo_date_entries AS PROCEDURE journalize(p_amount NUMBER, p_day VARCHAR2) IS BEGIN INSERT INTO demo_pkg_date_journal (amount, event_day) VALUES (p_amount, TO_DATE(p_day, 'FXYYYY-MM-DD')); END; PROCEDURE journalize(p_amount NUMBER, p_day NUMBER) IS BEGIN IF p_day IS NULL OR p_day != TRUNC(p_day) THEN RAISE_APPLICATION_ERROR(-20093, 'Julian day must be an integer'); END IF; INSERT INTO demo_pkg_date_journal (amount, event_day) VALUES (p_amount, TO_DATE(TO_CHAR(p_day, 'TM9'), 'J')); END; END demo_date_entries; / SAVEPOINT before_overload_demo; BEGIN demo_date_entries.journalize(125, '2026-12-20'); demo_date_entries.journalize(75, TO_NUMBER(TO_CHAR(DATE '2026-12-20', 'J'))); END; / SELECT amount, TO_CHAR(event_day, 'YYYY-MM-DD') AS event_day FROM demo_pkg_date_journal ORDER BY amount; ROLLBACK TO before_overload_demo;</code></pre> <table> <thead> <tr> <th>AMOUNT</th> <th>EVENT_DAY</th> </tr> </thead> <tbody> <tr> <td>75</td> <td>2026-12-20</td> </tr> <tr> <td>125</td> <td>2026-12-20</td> </tr> </tbody> </table> <p>Перегрузка выбрана по типу второго аргумента. Одного различия возвращаемого типа функции недостаточно. Явные типы и преобразования помогают избежать неоднозначности при NULL и неявных преобразованиях.</p> <h2>📌 Пакет STANDARD</h2> <p>STANDARD объявляет встроенные типы, исключения и подпрограммы, доступные без префикса пакета. Например, заголовок <a href="https://plsql.uz/reference/functions/numeric-math/96-abs.html">ABS</a>:</p> <pre class="language-sql"><code>FUNCTION ABS(n NUMBER) RETURN NUMBER;</code></pre> <p>Это справочное объявление, а не команда создания встроенной функции. Вызов ABS(-45) возвращает 45. Локальная одноимённая функция скрывает встроенное имя; квалификация STANDARD.ABS выбирает встроенную реализацию:</p> <pre class="language-sql"><code>DECLARE FUNCTION abs(p_value NUMBER) RETURN NUMBER IS BEGIN RETURN 0; -- Намеренная учебная заглушка для демонстрации скрытия имени. END; BEGIN DBMS_OUTPUT.PUT_LINE('local=' || abs(-45)); DBMS_OUTPUT.PUT_LINE('standard=' || STANDARD.ABS(-45)); END; / -- local=0 -- standard=45</code></pre> <p>Перегруженные варианты <a href="https://plsql.uz/reference/functions/string-char/32-to_char.html">TO_CHAR</a> принимают разные типы и наборы аргументов; среди них:</p> <pre class="language-sql"><code>FUNCTION TO_CHAR(right DATE) RETURN VARCHAR2; FUNCTION TO_CHAR(left NUMBER) RETURN VARCHAR2; FUNCTION TO_CHAR(left DATE, right VARCHAR2) RETURN VARCHAR2; FUNCTION TO_CHAR(left NUMBER, right VARCHAR2) RETURN VARCHAR2;</code></pre> <p>Эти справочные заголовки иллюстрируют выбор по числу и типам аргументов. Для вывода дат в примерах используется явный формат.</p> <h2>📌 Руководство по написанию пакетов</h2> <p>При написании пакетов держите их как можно более общими, чтобы их можно было использовать в будущих приложениях. Избегайте написания пакетов, которые дублируют некоторые функции, уже предоставленные Oracle.</p> <p>Спецификации пакета отражают дизайн вашего приложения. Определяйте их перед телом пакета. Поместите в спецификацию только те типы, элементы и подпрограммы, которые должны быть видны пользователям пакета. Таким образом, другие разработчики не могут неправильно использовать пакет, основывая свой код на нерелевантных деталях реализации.</p> <p>Чтобы уменьшить необходимость перекомпиляции при изменении кода, поместите как можно меньше элементов в спецификацию пакета. Изменения в теле пакета не требуют, чтобы Oracle перекомпилировал зависимые процедуры. Изменения спецификации могут инвалидировать зависимые объекты; последствия зависят от изменённого интерфейса и зависимостей.</p> <h2>📌 Проверка и запуск</h2> <p>У каждого сценария свои имена. DDL создаёт объекты до SAVEPOINT, а тестовые изменения откатываются до следующего DDL. Не запускайте отрицательный пример несовпадения заголовков без последующего исправления. Ошибки компиляции видны в USER_ERRORS:</p> <pre class="language-sql"><code>SELECT name, type, line, position, text FROM user_errors WHERE name IN ('DEMO_MENTOR_BASIC', 'DEMO_MENTOR_ADMIN', 'DEMO_BANK_ACTIONS', 'DEMO_BOOKING_DATA', 'DEMO_RANDOM_STATE', 'DEMO_PKG_DATE_MATCH', 'DEMO_DATE_ENTRIES') ORDER BY name, type, sequence;</code></pre> <p>После исправленного тела список ошибок должен быть пуст. Включите DBMS Output в клиенте; в SQL*Plus/SQLcl — SET SERVEROUTPUT ON. Числа счётчиков приведены для первого запуска соответствующего пакета в новом сеансе.</p> <p>Связанные темы: <a href="https://plsql.uz/reference/programming/239-procedures.html">процедуры</a>, <a href="https://plsql.uz/reference/programming/242-functions.html">функции</a>, <a href="https://plsql.uz/reference/programming/collections-records/196-record.html">записи</a> и <a href="https://plsql.uz/reference/programming/234-sequences.html">последовательности</a>.</p> <p>Документация Oracle: <a href="https://docs.oracle.com/en/database/oracle/oracle-database/19/lnpls/plsql-packages.html" target="_blank" rel="noopener noreferrer external">plsql-packages</a>, <a href="https://docs.oracle.com/en/database/oracle/oracle-database/19/lnpls/package-body.html" target="_blank" rel="noopener noreferrer external">package-body</a>, <a href="https://docs.oracle.com/en/database/oracle/oracle-database/19/lnpls/package-instantiation-and-initialization.html" target="_blank" rel="noopener noreferrer external">package-instantiation-and-initialization</a>, <a href="https://docs.oracle.com/en/database/oracle/oracle-database/19/lnpls/package-state.html" target="_blank" rel="noopener noreferrer external">package-state</a>, <a href="https://docs.oracle.com/en/database/oracle/oracle-database/19/lnpls/how-standard-package-defines-pl-sql-environment.html" target="_blank" rel="noopener noreferrer external">how-standard-package-defines-pl-sql-environment</a>.</p>]]></content:encoded>
</item><item>
<title>WITH</title>
<link>https://plsql.uz/reference/programming/244-with.html</link>
<pdalink>https://plsql.uz/reference/programming/244-with.html</pdalink>
<guid>https://plsql.uz/reference/programming/244-with.html</guid>
<pubDate>Tue, 10 Nov 2026 13:58:32 +0500</pubDate>
<category>index</category>

<content:encoded><![CDATA[<h2>📖 Описание</h2> <p>WITH в Oracle задаёт имя блоку подзапроса, на который можно ссылаться в основном запросе и последующих блоках WITH. Это помогает разделить вычисление на понятные шаги. WITH не создаёт постоянную таблицу или представление.</p> <h2>🧩 Синтаксис</h2> <p>Один именованный подзапрос:</p> <pre class="language-sql"><code>WITH query_name AS ( SELECT column_list FROM source_table WHERE condition ) SELECT column_list FROM query_name;</code></pre> <p>Несколько блоков перечисляются через запятую; второй может использовать первый:</p> <pre class="language-sql"><code>WITH query_a AS ( SELECT column_list FROM source_table ), query_b AS ( SELECT column_list FROM query_a WHERE condition ) SELECT column_list FROM query_b;</code></pre> <p>query_a и query_b — имена подзапросов, column_list — нужные столбцы или выражения, condition — условие. Способ выполнения выбирает оптимизатор: WITH не гарантирует материализацию или единственное вычисление блока.</p> <h2>📌 Применение</h2> <p>Факторинг подзапросов доступен с семейства Oracle 9i. С Oracle 12.1 WITH также поддерживает объявления локальных функций и процедур. Ниже рассматриваются обычные подзапросы, повторное использование, агрегирование, локальные подпрограммы, динамический вызов и PRAGMA UDF.</p> <h2>💻 Данные для подзапросов</h2> <p>В учебной схеме с CREATE TABLE и квотой создайте собственные студии и наставников:</p> <pre class="language-sql"><code>CREATE TABLE demo_with_studios ( studio_id NUMBER PRIMARY KEY, studio_name VARCHAR2(40 CHAR) NOT NULL ); CREATE TABLE demo_with_mentors ( mentor_id NUMBER PRIMARY KEY, mentor_name VARCHAR2(40 CHAR) NOT NULL, joined_on DATE NOT NULL, monthly_fee NUMBER(8,2) NOT NULL, studio_id NUMBER NOT NULL REFERENCES demo_with_studios(studio_id) ); INSERT ALL INTO demo_with_studios VALUES (7, 'River Studio') INTO demo_with_studios VALUES (8, 'Garden Studio') INTO demo_with_studios VALUES (9, 'Hill Studio') INTO demo_with_studios VALUES (10, 'Lake Studio') SELECT 1 FROM dual; INSERT ALL INTO demo_with_mentors VALUES (41, 'Aziza', DATE '2026-02-03', 6000, 7) INTO demo_with_mentors VALUES (42, 'Temur', DATE '2026-03-10', 8000, 7) INTO demo_with_mentors VALUES (43, 'Zarina', DATE '2026-04-14', 5000, 8) INTO demo_with_mentors VALUES (44, 'Behruz', DATE '2026-05-19', 7000, 8) INTO demo_with_mentors VALUES (45, 'Nilufar', DATE '2026-06-23', 9000, 9) INTO demo_with_mentors VALUES (46, 'Kamol', DATE '2026-07-28', 4000, 9) SELECT 1 FROM dual; COMMIT;</code></pre> <h3>💻 Один подзапрос, два использования</h3> <pre class="language-sql"><code>WITH mentors AS ( SELECT mentor_id, mentor_name, monthly_fee FROM demo_with_mentors ) SELECT mentor_id, mentor_name, monthly_fee FROM mentors WHERE mentor_id &gt;= 45 UNION ALL SELECT mentor_id, mentor_name, monthly_fee FROM mentors WHERE monthly_fee &gt; 8000 ORDER BY mentor_id;</code></pre> <table> <thead> <tr> <th>MENTOR_ID</th> <th>MENTOR_NAME</th> <th>MONTHLY_FEE</th> </tr> </thead> <tbody> <tr> <td>45</td> <td>Nilufar</td> <td>9000</td> </tr> <tr> <td>45</td> <td>Nilufar</td> <td>9000</td> </tr> <tr> <td>46</td> <td>Kamol</td> <td>4000</td> </tr> </tbody> </table> <p>Nilufar попадает в обе ветви и присутствует дважды: <a href="https://plsql.uz/reference/sql/queries-commands/159-union-all.html">UNION ALL</a> сохраняет повторы.</p> <h3>💻 Число наставников в студии</h3> <pre class="language-sql"><code>WITH studio_counts AS ( SELECT studio_id, COUNT(*) AS mentor_count FROM demo_with_mentors GROUP BY studio_id ) SELECT m.mentor_name, c.mentor_count FROM demo_with_mentors m JOIN studio_counts c ON c.studio_id = m.studio_id ORDER BY m.mentor_id;</code></pre> <p>Для всех шести наставников MENTOR_COUNT равен 2. Студия 10 не появляется, потому что наставников в ней нет.</p> <h3>💻 Два подзапроса: общая ставка выше среднего</h3> <pre class="language-sql"><code>WITH studio_costs AS ( SELECT s.studio_id, s.studio_name, SUM(m.monthly_fee) AS studio_total FROM demo_with_studios s JOIN demo_with_mentors m ON m.studio_id = s.studio_id GROUP BY s.studio_id, s.studio_name ), average_cost AS ( SELECT AVG(studio_total) AS average_total FROM studio_costs ) SELECT studio_name, studio_total FROM studio_costs WHERE studio_total &gt; (SELECT average_total FROM average_cost) ORDER BY studio_name;</code></pre> <table> <thead> <tr> <th>STUDIO_NAME</th> <th>STUDIO_TOTAL</th> </tr> </thead> <tbody> <tr> <td>River Studio</td> <td>14000</td> </tr> </tbody> </table> <p>Суммы студий 7, 8 и 9 равны 14000, 12000 и 13000; среднее их сумм — 13000. Это не средняя ставка одного наставника. Пустая студия исключена внутренним соединением. Если нужно учитывать её как ноль, потребуется LEFT JOIN и соответствующая обработка NULL.</p> <h2>💻 WITH с функцией</h2> <p>Для следующих опытов подготовьте 12000 строк с количеством мест от 1 до 6. Небольшой набор подходит для проверки результата; это не готовый тест производительности конкретной системы.</p> <pre class="language-sql"><code>CREATE TABLE demo_with_samples AS SELECT LEVEL AS sample_id, MOD(LEVEL - 1, 6) + 1 AS seats FROM dual CONNECT BY LEVEL &lt;= 12000;</code></pre> <p>Локальная функция рассчитывает стоимость по 45 за место:</p> <pre class="language-sql"><code>WITH FUNCTION local_fee(p_seats NUMBER) RETURN NUMBER IS BEGIN RETURN p_seats * 45; END; SELECT local_fee(seats) AS total_fee FROM demo_with_samples WHERE sample_id = 11 /</code></pre> <p>У строки 11 пять мест, TOTAL_FEE = 225. Локальное имя функции имеет приоритет перед одноимённой функцией схемы в этом запросе. В SQL*Plus/SQLcl запрос WITH с объявлениями подпрограмм завершается строкой /; внутренние точки с запятой относятся к PL/SQL.</p> <h2>💻 WITH с процедурой</h2> <p>Процедуру можно объявить, но само объявление её не вызывает:</p> <pre class="language-sql"><code>WITH PROCEDURE trace_seats(p_seats NUMBER) IS BEGIN DBMS_OUTPUT.PUT_LINE('seats=' || p_seats); END; SELECT seats FROM demo_with_samples WHERE sample_id = 11 /</code></pre> <p>Результат <a href="https://plsql.uz/reference/sql/queries-commands/153-select.html">SELECT</a> — 5. Сообщение seats=5 не печатается, поскольку вызова процедуры нет. Для вызова из выражения SQL используйте функцию, которая обращается к процедуре:</p> <pre class="language-sql"><code>WITH PROCEDURE trace_seats(p_seats NUMBER) IS BEGIN DBMS_OUTPUT.PUT_LINE('seats=' || p_seats); END; FUNCTION local_fee(p_seats NUMBER) RETURN NUMBER IS BEGIN trace_seats(p_seats); RETURN p_seats * 45; END; SELECT local_fee(seats) AS total_fee FROM demo_with_samples WHERE sample_id = 11 /</code></pre> <p>Значение TOTAL_FEE — 225; при включённом DBMS Output вызов процедуры пишет seats=5. Не используйте число таких сообщений как гарантию числа вызовов функции: SQL может вычислять выражения по выбранному плану.</p> <h2>📌 Контекст PL/SQL и динамический запрос</h2> <p>Поддержка WITH с объявлениями подпрограмм в SQL-клиенте и внутри статического PL/SQL — разные вопросы. Следующий диагностический вариант не следует включать в основной сценарий: в контексте, не поддерживающем такой синтаксис, он приводит к ошибке компиляции (например, ORA-06550 вместе с ORA-00905). Текст и позиции диагностики зависят от версии.</p> <pre class="language-sql"><code>BEGIN FOR r IN ( WITH FUNCTION local_fee(p_seats NUMBER) RETURN NUMBER IS BEGIN RETURN p_seats * 45; END; SELECT local_fee(seats) AS total_fee FROM demo_with_samples WHERE sample_id = 11 ) LOOP DBMS_OUTPUT.PUT_LINE(r.total_fee); END LOOP; END; /</code></pre> <p>Рабочий способ передать SQL-парсеру весь запрос — <a href="https://plsql.uz/reference/programming/247-dynamic-sql.html">динамический SQL</a>. Здесь запрос постоянный, внешние строки к нему не добавляются:</p> <pre class="language-sql"><code>DECLARE l_sql VARCHAR2(32767) := q'~ WITH FUNCTION local_fee(p_seats NUMBER) RETURN NUMBER IS BEGIN RETURN p_seats * 45; END; SELECT local_fee(seats) FROM demo_with_samples WHERE sample_id = 11 ~'; l_cursor SYS_REFCURSOR; l_value NUMBER; BEGIN OPEN l_cursor FOR l_sql; FETCH l_cursor INTO l_value; IF l_cursor%FOUND THEN DBMS_OUTPUT.PUT_LINE('total_fee=' || l_value); END IF; CLOSE l_cursor; EXCEPTION WHEN OTHERS THEN IF l_cursor%ISOPEN THEN CLOSE l_cursor; END IF; RAISE; END; /</code></pre> <p>Вывод: total_fee=225. В строке динамического SQL нет завершающей строки / и нет точки с запятой после SELECT; разделители внутри объявления функции сохранены. Обычный WITH без локальных подпрограмм также применяется в статическом SQL.</p> <h2>📌 Сравнение выполнения и PRAGMA UDF</h2> <p>Локальная функция удобна и не создаёт отдельный объект схемы. Скорость нельзя вывести из одного вида синтаксиса. Для сравнения создайте обычную функцию и отдельный вариант с PRAGMA UDF; нужна CREATE PROCEDURE:</p> <pre class="language-sql"><code>CREATE OR REPLACE FUNCTION demo_fee_regular(p_seats NUMBER) RETURN NUMBER IS BEGIN RETURN p_seats * 45; END; / CREATE OR REPLACE FUNCTION demo_fee_udf(p_seats NUMBER) RETURN NUMBER IS PRAGMA UDF; BEGIN RETURN p_seats * 45; END; /</code></pre> <p>PRAGMA UDF сообщает компилятору о преимущественных вызовах из SQL и может уменьшить накладные расходы. Она не гарантирует ускорения и не запрещает вызов из PL/SQL.</p> <p>Следующий блок полностью выбирает результаты четырёх вариантов, включая обычное SQL-выражение. BULK COLLECT ограничен партиями по 500 строк. Сравнивайте строки и контрольную сумму прежде времени:</p> <pre class="language-sql"><code>DECLARE PROCEDURE measure_query(p_label VARCHAR2, p_sql VARCHAR2) IS l_cursor SYS_REFCURSOR; TYPE t_values IS TABLE OF NUMBER; l_batch t_values; l_rows PLS_INTEGER := 0; l_total NUMBER := 0; l_time NUMBER := DBMS_UTILITY.GET_TIME; l_cpu NUMBER := DBMS_UTILITY.GET_CPU_TIME; l_elapsed NUMBER; l_cpu_elapsed NUMBER; BEGIN OPEN l_cursor FOR p_sql; LOOP FETCH l_cursor BULK COLLECT INTO l_batch LIMIT 500; EXIT WHEN l_batch.COUNT = 0; l_rows := l_rows + l_batch.COUNT; FOR i IN 1 .. l_batch.COUNT LOOP l_total := l_total + l_batch(i); END LOOP; END LOOP; CLOSE l_cursor; l_elapsed := MOD(DBMS_UTILITY.GET_TIME - l_time + 4294967296, 4294967296); l_cpu_elapsed := MOD(DBMS_UTILITY.GET_CPU_TIME - l_cpu + 4294967296, 4294967296); IF l_rows != 12000 OR l_total != 1890000 THEN RAISE_APPLICATION_ERROR(-20091, 'Unexpected benchmark result'); END IF; DBMS_OUTPUT.PUT_LINE(p_label || ': rows=' || l_rows || ', sum=' || l_total); DBMS_OUTPUT.PUT_LINE('elapsed_hsecs=' || l_elapsed || ', cpu_hsecs=' || l_cpu_elapsed); EXCEPTION WHEN OTHERS THEN IF l_cursor%ISOPEN THEN CLOSE l_cursor; END IF; RAISE; END; BEGIN FOR pass IN 1 .. 2 LOOP DBMS_OUTPUT.PUT_LINE('pass=' || pass); measure_query('SQL', 'SELECT seats * 45 FROM demo_with_samples'); measure_query('WITH', q'~ WITH FUNCTION local_fee(p_seats NUMBER) RETURN NUMBER IS BEGIN RETURN p_seats * 45; END; SELECT local_fee(seats) FROM demo_with_samples ~'); measure_query('REGULAR', 'SELECT demo_fee_regular(seats) FROM demo_with_samples'); measure_query('UDF', 'SELECT demo_fee_udf(seats) FROM demo_with_samples'); END LOOP; END; /</code></pre> <p>Каждый вариант должен вернуть rows=12000 и sum=1890000: значения 1–6 встречаются по 2000 раз, (1+2+3+4+5+6) × 2000 × 45 = 1890000. Фактические времена здесь не приведены: этот материал не содержит результата запуска на конкретной Oracle.</p> <p>hsecs — сотые доли секунды. GET_TIME измеряет прошедшее время, GET_CPU_TIME — процессорное. Для короткого опыта возможны нули из-за разрешения таймера. Сравнение включает разбор, выборку, передачу значений в PL/SQL и контрольную сумму. Первый проход может прогревать кэш; для выводов повторяйте серии, меняйте порядок вариантов и учитывайте планы, статистику и нагрузку. <a href="https://plsql.uz/reference/functions/numeric-math/76-mod.html">MOD</a> учитывает переход 32-битного счётчика для коротких измерений; это не таймер для опыта длиной в полный цикл счётчика.</p> <h3>💻 Прямой вызов UDF из PL/SQL</h3> <pre class="language-sql"><code>DECLARE l_total NUMBER; BEGIN l_total := demo_fee_udf(4); DBMS_OUTPUT.PUT_LINE('total_fee=' || l_total); END; / -- total_fee=180</code></pre> <p>Включите DBMS Output в клиенте; в SQL*Plus/SQLcl используйте SET SERVEROUTPUT ON. Пример не требует автоматического удаления таблиц или предположения, что CTAS всегда собрал все необходимые статистики. Проверьте их отдельно при полноценном исследовании производительности.</p> <p>См. <a href="https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/SELECT.html" target="_blank" rel="noopener noreferrer external">документацию Oracle: SELECT</a>.</p> <p>Документация Oracle: <a href="https://docs.oracle.com/en/database/oracle/oracle-database/19/lnpls/UDF-pragma.html" target="_blank" rel="noopener noreferrer external">UDF Pragma</a>, <a href="https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/DBMS_UTILITY.html" target="_blank" rel="noopener noreferrer external">DBMS_UTILITY</a>, <a href="https://docs.oracle.com/en/database/oracle/oracle-database/19/adfns/coding-subprograms-and-packages.html" target="_blank" rel="noopener noreferrer external">вызовы функций из SQL</a>.</p>]]></content:encoded>
</item><item>
<title>MERGE</title>
<link>https://plsql.uz/reference/programming/243-merge.html</link>
<pdalink>https://plsql.uz/reference/programming/243-merge.html</pdalink>
<guid>https://plsql.uz/reference/programming/243-merge.html</guid>
<pubDate>Tue, 10 Nov 2026 13:58:22 +0500</pubDate>
<category>index</category>

<content:encoded><![CDATA[<h2>📖 Описание</h2> <p>SQL-оператор MERGE в Oracle позволяет выбрать строки из одной таблицы для обновления или вставки в другую таблицу. Решение о том, обновлять или вставлять данные в целевую таблицу, основывается на условии в предложении ON. Оператор MERGE - это удобный способ совместить как минимум две операции. Это позволяет избежать использования нескольких DML операторов <a href="https://plsql.uz/reference/sql/queries-commands/165-insert.html">INSERT</a> и <a href="https://plsql.uz/reference/sql/queries-commands/163-update.html">UPDATE</a>.<br>У вас должны быть объектные привилегии INSERT и UPDATE для целевой таблицы и привилегии <a href="https://plsql.uz/reference/sql/queries-commands/153-select.html">SELECT</a> для исходной таблицы.</p> <hr> <h2>🧩 Синтаксис</h2> <p>Синтаксис Oracle PL/SQL оператора MERGE:</p> <pre class="language-sql"><code>MERGE INTO target_table t USING source_table s ON (t.key_column = s.key_column) WHEN MATCHED THEN UPDATE SET t.value_column = s.value_column WHEN NOT MATCHED THEN INSERT (key_column, value_column) VALUES (s.key_column, s.value_column);</code></pre> <h3>⚙️ Параметры или аргумент</h3> <dl> <dt>schema</dt> <dd>схема базы данных.</dd> <dt>INTO</dt> <dd>используйте оператор INTO, чтобы указать целевую таблицу, которую вы обновляете или вставляете данные.</dd> <dt>table_A</dt> <dd>целевая таблица.</dd> <dt>t_alias</dt> <dd>алиас (псевдоним).</dd> <dt>USING { table | view | subquery }</dt> <dd>указывает источник данных, из которого нужно обновить или вставить данные в table_A. Это может быть таблица, представление или результат подзапроса.</dd> <dt>ON ( condition )</dt> <dd>указывает условие, при котором операция MERGE либо обновляет, либо вставляет данные. Для каждой строки table_A, для которой выполняется условие поиска, Oracle обновляет строку, используя соответствующие данные из исходной таблицы. Если условие не выполняется ни для одной строки, Oracle вставляет в table_A данные на основе соответствующей строки исходной таблицы.</dd> <dt>WHEN MATCHED | NOT MATCHED</dt> <dd>Используйте эти предложения, чтобы указать Oracle, как реагировать на результаты условия соединения в предложении ON. Вы можете указать эти два предложения в любом порядке.</dd> <dt>merge_update_clause</dt> <dd>определяет новые значения столбцов table_A. Oracle выполняет это обновление, если условие предложения ON истинно. Если предложение обновления выполняется, то активируются все триггеры обновления, определенные в table_A.<br>Пример <strong>merge_update_clause</strong>: <code>UPDATE SET column = { expr | DEFAULT } [, column = { expr | DEFAULT }]</code> <p><strong>Ограничения обновления</strong></p> <ul> <li>Вы не можете указать DEFAULT при обновлении View.</li> <li>Нельзя изменять столбец целевой таблицы, участвующий в ON; это правило действует не только для представлений.</li> </ul> </dd> <dt>merge_insert_clause</dt> <dd>определяет значения для вставки в столбец table_A, если условие предложения ON ложно. Если предложение вставки выполняется, то активируются все триггеры вставки, определенные в table_A.<br>Пример <strong>merge_insert_clause</strong>: <code>INSERT ( column [, column]... ) VALUES ( expr [, expr]... )</code> <p><strong>Ограничение на слияние с View</strong></p> <ul> <li>Вы не можете указать DEFAULT при обновлении View.</li> </ul> </dd> </dl> <hr> <h2>💻 Подготовка: премии наставников</h2> <p>Сценарий сохраняет две ветви: существующая премия увеличивается на 1% ставки, а новая равна 10% ставки. Все таблицы создаются в своей учебной схеме с CREATE TABLE и квотой.</p> <pre class="language-sql"><code>CREATE TABLE demo_merge_mentors ( mentor_id NUMBER PRIMARY KEY, mentor_name VARCHAR2(40 CHAR) NOT NULL, monthly_fee NUMBER(8,2) NOT NULL, studio_id NUMBER NOT NULL ); CREATE TABLE demo_merge_events ( event_id NUMBER PRIMARY KEY, mentor_id NUMBER REFERENCES demo_merge_mentors(mentor_id), event_day DATE NOT NULL ); CREATE TABLE demo_merge_awards ( mentor_id NUMBER PRIMARY KEY, award NUMBER(8,2) DEFAULT 60 NOT NULL ); INSERT ALL INTO demo_merge_mentors VALUES (41, 'Aziza', 7200, 7) INTO demo_merge_mentors VALUES (42, 'Temur', 6500, 7) INTO demo_merge_mentors VALUES (43, 'Zarina', 8200, 7) INTO demo_merge_mentors VALUES (44, 'Behruz', 9100, 8) SELECT 1 FROM dual; INSERT ALL INTO demo_merge_events VALUES (901, 41, DATE '2026-11-21') INTO demo_merge_events VALUES (902, 42, DATE '2026-11-28') INTO demo_merge_events VALUES (903, 42, DATE '2026-12-05') INTO demo_merge_events VALUES (904, 44, DATE '2026-12-12') SELECT 1 FROM dual; INSERT INTO demo_merge_awards (mentor_id) SELECT m.mentor_id FROM demo_merge_mentors m JOIN demo_merge_events e ON e.mentor_id = m.mentor_id GROUP BY m.mentor_id; COMMIT; SELECT mentor_id, award FROM demo_merge_awards ORDER BY mentor_id;</code></pre> <table> <thead> <tr> <th>MENTOR_ID</th> <th>AWARD</th> </tr> </thead> <tbody> <tr> <td>41</td> <td>60</td> </tr> <tr> <td>42</td> <td>60</td> </tr> <tr> <td>44</td> <td>60</td> </tr> </tbody> </table> <p><a href="https://plsql.uz/reference/sql/queries-commands/169-group-by.html">GROUP BY</a> не даёт повторить наставника 42 из двух мероприятий; DEFAULT назначает 60. Наставника 43 ещё нет в премиях.</p> <h2>💻 MERGE: обновление и вставка</h2> <pre class="language-sql"><code>SAVEPOINT before_merge_demo; MERGE INTO demo_merge_awards t USING ( SELECT mentor_id, monthly_fee FROM demo_merge_mentors WHERE studio_id = 7 ) s ON (t.mentor_id = s.mentor_id) WHEN MATCHED THEN UPDATE SET t.award = t.award + s.monthly_fee * 0.01 WHEN NOT MATCHED THEN INSERT (mentor_id, award) VALUES (s.mentor_id, s.monthly_fee * 0.10); SELECT mentor_id, award FROM demo_merge_awards ORDER BY mentor_id;</code></pre> <table> <thead> <tr> <th>MENTOR_ID</th> <th>AWARD</th> <th>Причина</th> </tr> </thead> <tbody> <tr> <td>41</td> <td>132</td> <td>60 + 7200 × 0.01</td> </tr> <tr> <td>42</td> <td>125</td> <td>60 + 6500 × 0.01</td> </tr> <tr> <td>43</td> <td>820</td> <td>8200 × 0.10 — новая строка</td> </tr> <tr> <td>44</td> <td>60</td> <td>Студия 8 не входит в источник</td> </tr> </tbody> </table> <p>Источник уникален по mentor_id благодаря первичному ключу. MERGE не должен обновлять одну целевую строку несколько раз: заранее устраните неоднозначность источника. Повторный запуск этого примера снова прибавит премию существующим строкам, поэтому он не является идемпотентной загрузкой.</p> <pre class="language-sql"><code>ROLLBACK TO before_merge_demo; SELECT mentor_id, award FROM demo_merge_awards ORDER BY mentor_id; -- Снова 41/60, 42/60 и 44/60; строки 43 нет.</code></pre> <h2>📌 Условия и ограничения</h2> <p>Допустима только ветвь UPDATE или только INSERT, но хотя бы одна обязательна. Условие <a href="https://plsql.uz/reference/sql/queries-commands/171-where.html">WHERE</a> ветви UPDATE может обращаться к источнику и цели; WHERE ветви INSERT — только к источнику. Пропуск UPDATE из-за его WHERE не превращает совпавшую строку во вставку.</p> <p>DELETE WHERE в ветви UPDATE удаляет только строки, обновлённые этим MERGE, и проверяет уже изменённые значения. Оно не удаляет автоматически строки, отсутствующие в источнике; для него нужна также привилегия DELETE. Срабатывают соответствующие <a href="https://plsql.uz/reference/programming/triggers/212-after-delete.html">триггеры</a> DML. Действие MERGE можно откатить до фиксации транзакции.</p> <p>См. <a href="https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/MERGE.html" target="_blank" rel="noopener noreferrer external">документацию Oracle: MERGE</a>.</p>]]></content:encoded>
</item><item>
<title>Функции</title>
<link>https://plsql.uz/reference/programming/242-functions.html</link>
<pdalink>https://plsql.uz/reference/programming/242-functions.html</pdalink>
<guid>https://plsql.uz/reference/programming/242-functions.html</guid>
<pubDate>Tue, 10 Nov 2026 13:55:29 +0500</pubDate>
<category>index</category>

<content:encoded><![CDATA[<h2>📖 Описание</h2> <p>Функция — подпрограмма PL/SQL, возвращающая значение оператором RETURN.</p> <hr> <h2>📌 СОЗДАТЬ ФУНКЦИЮ (CREATE FUNCTION)</h2> <p>Как и на других языках программирования, вы можете создавать свои собственные функции в Oracle.</p> <hr> <h2>🧩 Синтаксис:</h2> <pre class="language-sql"><code>CREATE [OR REPLACE] FUNCTION имя_функции [ (параметр [, параметр, ...]) ] RETURN тип_данных {IS | AS} [локальные объявления] BEGIN исполняемые предложения [EXCEPTION обработчики исключений] END [имя_функции];</code></pre> <p>Режим IN передаёт входное значение; OUT возвращает значение вызывающему коду; IN OUT передаёт начальное значение и возвращает изменённое. По умолчанию используется IN.</p> <hr> <p>Фигурные и квадратные скобки в шаблоне показывают выбор и необязательные части; в выполняемом коде ниже их нет. Для вызова функции из SQL используйте параметры IN и допустимый SQL-тип результата.</p> <h2>💻 Подготовка</h2> <p>Сохраним сценарий поиска числового кода по названию через явный курсор. Учебная схема имеет CREATE TABLE, CREATE PROCEDURE и квоту:</p> <pre class="language-sql"><code>CREATE TABLE demo_fn_workshops ( workshop_code NUMBER PRIMARY KEY, workshop_name VARCHAR2(60 CHAR) NOT NULL UNIQUE ); INSERT INTO demo_fn_workshops VALUES (851, 'Clay Lantern'); INSERT INTO demo_fn_workshops VALUES (852, 'Paper Mosaic'); COMMIT;</code></pre> <p>Название уникально, поэтому один FETCH даёт определённый результат. Код 0 в этом опыте — маркер отсутствия, а не существующий ключ каталога.</p> <h2>💻 Создание функции</h2> <pre class="language-sql"><code>CREATE OR REPLACE FUNCTION demo_find_workshop ( p_workshop_name IN VARCHAR2 ) RETURN NUMBER IS l_code demo_fn_workshops.workshop_code%TYPE; CURSOR c_workshop IS SELECT workshop_code FROM demo_fn_workshops WHERE workshop_name = p_workshop_name; BEGIN OPEN c_workshop; FETCH c_workshop INTO l_code; IF c_workshop%NOTFOUND THEN l_code := 0; END IF; CLOSE c_workshop; RETURN l_code; END demo_find_workshop; /</code></pre> <p>Для Clay Lantern результат 851; для неизвестного названия — 0. NULL также не совпадает ни с одним названием и даёт 0. %NOTFOUND обрабатывает отсутствие строки после FETCH. Неожиданные ошибки передаются вызывающему коду.</p> <h2>💻 Вызов из SQL</h2> <p>Запрос использует собственный список заявок через <a href="https://plsql.uz/reference/programming/244-with.html">WITH</a>; отдельная таблица заявок не требуется:</p> <pre class="language-sql"><code>WITH requests (workshop_name, material, event_day) AS ( SELECT 'Clay Lantern', 'CLAY', DATE '2026-12-05' FROM dual UNION ALL SELECT 'Glass Bead', 'GLASS', DATE '2026-12-12' FROM dual UNION ALL SELECT 'Paper Mosaic', 'PAPER', DATE '2026-12-19' FROM dual ) SELECT workshop_name, demo_find_workshop(workshop_name) AS workshop_code, TO_CHAR(event_day, 'YYYY-MM-DD') AS event_day FROM requests WHERE material IN ('CLAY', 'GLASS') ORDER BY workshop_name;</code></pre> <table> <thead> <tr> <th>WORKSHOP_NAME</th> <th>WORKSHOP_CODE</th> <th>EVENT_DAY</th> </tr> </thead> <tbody> <tr> <td>Clay Lantern</td> <td>851</td> <td>2026-12-05</td> </tr> <tr> <td>Glass Bead</td> <td>0</td> <td>2026-12-12</td> </tr> </tbody> </table> <p>Вызов в PL/SQL тоже возможен:</p> <pre class="language-sql"><code>DECLARE l_code NUMBER; BEGIN l_code := demo_find_workshop('Paper Mosaic'); DBMS_OUTPUT.PUT_LINE('workshop_code=' || l_code); END; / -- workshop_code=852</code></pre> <p>Включите DBMS Output в клиенте; для SQL*Plus/SQLcl — SET SERVEROUTPUT ON. Возвращаемое значение присваивается переменной или используется в выражении. Функция должна выполнить RETURN на каждом нормально завершающемся пути; иначе возникает ошибка отсутствующего результата.</p> <p>Этот поиск демонстрирует синтаксис. Для большого набора заявок обычный JOIN с каталогом часто удобнее, чем отдельный SQL-запрос внутри функции для каждой строки. Ограничения побочных действий функции, вызываемой из SQL, зависят от контекста; функция примера только читает данные, не выполняет DML или COMMIT.</p> <h2>📌 Проверка компиляции</h2> <pre class="language-sql"><code>SELECT line, position, text FROM user_errors WHERE name = 'DEMO_FIND_WORKSHOP' AND type = 'FUNCTION' ORDER BY sequence;</code></pre> <p>При успешной компиляции ошибок нет. OR REPLACE меняет определение функции и сохраняет ранее выданные объектные права.</p> <h2>📌 DROP FUNCTION</h2> <h3>🧩 Синтаксис</h3> <pre class="language-sql"><code>DROP FUNCTION function_name;</code></pre> <h3>💻 Пример</h3> <pre class="language-sql"><code>DROP FUNCTION demo_find_workshop; SELECT object_name FROM user_objects WHERE object_name = 'DEMO_FIND_WORKSHOP' AND object_type = 'FUNCTION';</code></pre> <p>Проверка не возвращает строк. Таблица каталога сохраняется. DROP FUNCTION удаляет самостоятельную функцию; для функции внутри <a href="https://plsql.uz/reference/programming/245-packages.html">пакета</a> меняют пакет. CREATE/DROP фиксируют транзакцию и не отменяются обычным ROLLBACK. Подробнее о действиях без возвращаемого выражения: <a href="https://plsql.uz/reference/programming/239-procedures.html">процедуры</a>.</p> <p>См. <a href="https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/CREATE-FUNCTION.html" target="_blank" rel="noopener noreferrer external">документацию Oracle: CREATE-FUNCTION</a>.</p> <p>См. <a href="https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/DROP-FUNCTION.html" target="_blank" rel="noopener noreferrer external">документацию Oracle: DROP-FUNCTION</a>.</p>]]></content:encoded>
</item><item>
<title>Типы данных</title>
<link>https://plsql.uz/reference/programming/241-data-types.html</link>
<pdalink>https://plsql.uz/reference/programming/241-data-types.html</pdalink>
<guid>https://plsql.uz/reference/programming/241-data-types.html</guid>
<pubDate>Tue, 10 Nov 2026 13:55:19 +0500</pubDate>
<category>index</category>

<content:encoded><![CDATA[<h2>📖 Описание</h2> <p>Краткий справочник основных типов Oracle. Ограничения ниже относятся к SQL в Oracle 19c, если отдельно не указан PL/SQL. Размеры строк зависят от семантики BYTE/CHAR, набора символов и MAX_STRING_SIZE.</p> <hr> <h2>📌 Символьные типы данных</h2> <p>Ниже перечислены символьные типы данных в Oracle/PLSQL:</p> <table> <tbody> <tr> <th>Типы данных</th> <th>Размер</th> <th>Описание</th> </tr> <tr> <td>char(размер)</td> <td>Максимальный размер 2000 байт.</td> <td>Размер CHAR задаётся в байтах или символах (BYTE/CHAR). Если сохраняемое значение короче, то дополняется пробелами; если длиннее, то выдается ошибка.</td> </tr> <tr> <td>nchar(размер)</td> <td>Максимальный размер 2000 байт.</td> <td>Где размер - количество символов фиксированной длины в кодировке Unicode. Если сохраняемое значение короче, то дополняется пробелами; если длиннее, то выдается ошибка.</td> </tr> <tr> <td>nvarchar2(размер)</td> <td>SQL: 4000 байт при STANDARD или 32767 при EXTENDED.</td> <td>Где размер – количество сохраняемых символов в кодировке Unicode переменной длины.</td> </tr> <tr> <td>varchar2(размер)</td> <td>SQL: 4000 байт при STANDARD или 32767 при EXTENDED. PL/SQL: до 32767 байт.</td> <td>Переменная длина; размер задаётся в BYTE или CHAR. Даже при CHAR действует предельный размер значения в байтах.</td> </tr> <tr> <td>long</td> <td>Максимальный размер 2 GB − 1 байт.</td> <td>Символьные данные переменной длины.</td> </tr> <tr> <td>raw</td> <td>SQL: 2000 байт при STANDARD или 32767 при EXTENDED.</td> <td>Содержит двоичные данные переменной длины</td> </tr> <tr> <td>long raw</td> <td>Максимальный размер 2 GB − 1 байт.</td> <td>Содержит двоичные данные переменной длины</td> </tr> </tbody> </table> <hr> <h2>📌 Числовые типы данных</h2> <p>Ниже приведены числовые типы данных в Oracle/PLSQL:</p> <table> <tbody> <tr> <th>Типы данных</th> <th>Размер</th> <th>Описание</th> </tr> <tr> <td>number(точность,масштаб)</td> <td>Точность может быть в диапазоне от 1 до 38.<br>Масштаб может быть в диапазоне от -84 до 127.</td> <td>Например, NUMBER(7,2) допускает до 5 цифр слева и 2 справа от десятичной точки; 147.256 округляется до 147.26.</td> </tr> <tr> <td>numeric(точность,масштаб)</td> <td>Точность может быть в диапазоне от 1 до 38.</td> <td>NUMERIC(7,2) соответствует NUMBER(7,2): до 5 цифр слева и 2 справа от десятичной точки.</td> </tr> <tr> <td>dec(точность,масштаб)</td> <td>Точность может быть в диапазоне от 1 до 38.</td> <td>DEC(6,2) соответствует NUMBER(6,2): до 4 цифр слева и 2 справа от десятичной точки.</td> </tr> <tr> <td>decimal(точность,масштаб)</td> <td>Точность может быть в диапазоне от 1 до 38.</td> <td>DECIMAL(6,2) соответствует NUMBER(6,2): до 4 цифр слева и 2 справа от десятичной точки.</td> </tr> <tr> <td>PLS_INTEGER</td> <td>Целые числа в диапазоне от -2,147,483,648 до<br>2,147,483,647</td> <td>Тип PL/SQL, не SQL-тип столбца в 19c. Целочисленные вычисления используют машинную арифметику; выход за диапазон вызывает переполнение.</td> </tr> </tbody> </table> <hr> <h2>📌 Дата/время типы данных</h2> <p>Ниже приведены типы данных дата/время в Oracle/PLSQL:</p> <table> <tbody> <tr> <th>Типы данных</th> <th>Размер</th> <th>Описание</th> </tr> <tr> <td>date</td> <td>date может принимать значения от 1 января 4712 года до н.э. до 31 декабря 9999 года нашей эры.</td> <td>Хранит дату и время с точностью до секунды, без часового пояса.</td> </tr> </tbody> </table> <hr> <h2>📌 Большие объекты (LOB) типы данных</h2> <p>Ниже перечислены типы данных LOB в Oracle/PLSQL:</p> <table> <tbody> <tr> <th>Типы данных</th> <th>Размер</th> <th>Описание</th> </tr> <tr> <td>bfile</td> <td>Размер ограничен платформой и файловой системой; данные доступны только для чтения.</td> <td>Локатор указывает на двоичный файл в файловой системе сервера (вне базы данных).</td> </tr> <tr> <td>blob</td> <td>Предел зависит от размера блока: (4 GB − 1) × DB_BLOCK_SIZE, примерно от 8 до 128 ТБ.</td> <td>Хранит неструктурированные двоичные большие объекты.</td> </tr> <tr> <td>clob</td> <td>Предел зависит от размера блока: (4 GB − 1) × DB_BLOCK_SIZE, примерно от 8 до 128 ТБ.</td> <td>Хранит однобайтовые и многобайтовые символьные данные.</td> </tr> <tr> <td>nclob</td> <td>Предел зависит от размера блока: (4 GB − 1) × DB_BLOCK_SIZE, примерно от 8 до 128 ТБ.</td> <td>Символьный LOB в национальном наборе символов.</td> </tr> </tbody> </table> <hr> <h2>📌 Rowid тип данных</h2> <p>Ниже перечислены типы данных Rowid в Oracle/PLSQL:</p> <table> <tbody> <tr> <th>Типы данных</th> <th>Формат</th> <th>Описание</th> </tr> <tr> <td>rowid</td> <td>Расширенный ROWID обычно представлен 18 символами; кодирует объект, файл, блок и позицию строки.</td> <td>Двоичные данные фиксированной длины. ROWID не заменяет первичный ключ и может меняться при перемещении строки.</td> </tr> </tbody> </table> <hr> <h2>📌 Булевы (BOOLEAN) типы данных</h2> <table> <tbody> <tr> <th>Типы данных</th> <th>Формат</th> <th>Описание</th> </tr> <tr> <td>BOOLEAN</td> <td>TRUE или FALSE. Может принимать значение NULL</td> <td>Хранит логические значения, которые вы можете использовать в логических операциях.</td> </tr> </tbody> </table> <hr> <h2>📌 Дополнительные типы даты и времени</h2> <table> <thead> <tr> <th>Тип</th> <th>Особенность</th> </tr> </thead> <tbody> <tr> <td>TIMESTAMP(p)</td> <td>Дата и время с p цифрами долей секунды: 0–9, по умолчанию 6. Часового пояса нет.</td> </tr> <tr> <td>TIMESTAMP WITH TIME ZONE</td> <td>Сохраняет информацию о часовом поясе вместе со значением.</td> </tr> <tr> <td>TIMESTAMP WITH LOCAL TIME ZONE</td> <td>Нормализуется к часовому поясу базы; при чтении отображается в часовом поясе сеанса. Исходный пояс не сохраняется.</td> </tr> <tr> <td>INTERVAL YEAR TO MONTH</td> <td>Продолжительность в годах и месяцах.</td> </tr> <tr> <td>INTERVAL DAY TO SECOND</td> <td>Продолжительность в днях, часах, минутах и секундах.</td> </tr> </tbody> </table> <p>В Oracle 19c BOOLEAN применяется в PL/SQL, но не как SQL-тип столбца. LONG и LONG RAW устарели: для новых схем рассматривайте CLOB и BLOB.</p> <p>Справочник: <a href="https://docs.oracle.com/en/database/oracle/oracle-database/19/refrn/datatype-limits.html" rel="external noopener">Oracle — Datatype Limits</a>.</p> <h2>💻 Пример: типы в учебной таблице</h2> <p>В своей схеме с CREATE TABLE и квотой создайте таблицу. Числовая точность проверяет количество цифр, а не размер значения в байтах.</p> <pre class="language-sql"><code>CREATE TABLE demo_type_sessions ( session_id NUMBER(6) PRIMARY KEY, session_title VARCHAR2(40 CHAR) NOT NULL, fee NUMBER(7,2), event_day DATE, precise_start TIMESTAMP(3), marker RAW(4) ); SAVEPOINT before_type_demo; INSERT INTO demo_type_sessions VALUES ( 491, 'Clay Bowl', 147.256, DATE '2026-12-05', TIMESTAMP '2026-12-05 09:30:15.250', HEXTORAW('0A10') ); SELECT session_id, session_title, fee, TO_CHAR(event_day, 'YYYY-MM-DD HH24:MI:SS') AS day_text, TO_CHAR(precise_start, 'YYYY-MM-DD HH24:MI:SS.FF3') AS start_text, RAWTOHEX(marker) AS marker_hex FROM demo_type_sessions; ROLLBACK TO before_type_demo;</code></pre> <table> <thead> <tr> <th>SESSION_ID</th> <th>SESSION_TITLE</th> <th>FEE</th> <th>DAY_TEXT</th> <th>START_TEXT</th> <th>MARKER_HEX</th> </tr> </thead> <tbody> <tr> <td>491</td> <td>Clay Bowl</td> <td>147.26</td> <td>2026-12-05 00:00:00</td> <td>2026-12-05 09:30:15.250</td> <td>0A10</td> </tr> </tbody> </table> <p>Таблица показывает результат <a href="https://plsql.uz/reference/sql/queries-commands/153-select.html">SELECT</a> до отката. Затем таблица остаётся пустой. DATE содержит время, но DATE-литерал задаёт полночь. RAW хранит байты: 0A10 здесь — два байта, хотя шестнадцатеричная запись состоит из четырёх символов.</p> <h2>💻 Фиксированная и переменная длина</h2> <pre class="language-sql"><code>SELECT LENGTH(CAST('OK' AS CHAR(4))) AS char_length, LENGTH(CAST('OK' AS VARCHAR2(4))) AS varchar_length FROM dual; -- CHAR_LENGTH = 4, VARCHAR_LENGTH = 2</code></pre> <p>CHAR дополнен пробелами, VARCHAR2 — нет. Для многобайтового текста различайте число символов и байтов. Подробнее: <a href="https://plsql.uz/reference/programming/237-literals.html">литералы</a> и <a href="https://plsql.uz/reference/programming/238-variable-declarations.html">объявление переменных</a>. Приведённые в справочнике границы исторических дат и максимумы типов не являются датами учебных событий.</p> <p>См. <a href="https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/Data-Types.html" target="_blank" rel="noopener noreferrer external">документацию Oracle: Data-Types</a>.</p> <p><a href="https://docs.oracle.com/en/database/oracle/oracle-database/19/lnpls/pls_integer-and-binary_integer-data-types.html" target="_blank" rel="noopener noreferrer external">Oracle: PLS_INTEGER и BINARY_INTEGER</a>.</p>]]></content:encoded>
</item><item>
<title>Псевдонимы</title>
<link>https://plsql.uz/reference/programming/240-aliases.html</link>
<pdalink>https://plsql.uz/reference/programming/240-aliases.html</pdalink>
<guid>https://plsql.uz/reference/programming/240-aliases.html</guid>
<pubDate>Tue, 10 Nov 2026 13:55:08 +0500</pubDate>
<category>index</category>

<content:encoded><![CDATA[<h2>📖 Описание</h2> <p>Oracle <strong>ALIASES</strong> можно использовать для создания псевдонима для столбца или таблицы.</p> <p><strong>ALIASES столбцов</strong> используются для упрощения чтения столбцов в вашем результирующем наборе.<br><strong>ALIASES таблиц</strong> используются для сокращения вашего SQL-кода, чтобы упростить его чтение или когда вы выполняете самостоятельное соединение (то есть: перечисление одной и той же таблицы более одного раза в предложении <a href="https://plsql.uz/reference/sql/queries-commands/172-from.html">FROM</a>).</p> <hr> <h2>🧩 Синтаксис</h2> <p>Синтаксис для ALIAS столбцов в Oracle / PLSQL:</p> <pre class="language-sql"><code>column_name AS alias_name</code></pre> <p>ИЛИ<br>Синтаксис для ALIAS таблиц в Oracle / PLSQL:</p> <pre class="language-sql"><code>table_name alias_name</code></pre> <hr> <h2>⚙️ Параметры и аргументы</h2> <p>column_name - исходное имя столбца, которому вы хотите указать псевдоним.<br>table_name - исходное имя таблицы, которой вы хотите указать псевдоним.<br>alias_name - псевдоним для назначения.</p> <h3>📝 Примечание</h3> <p>Если alias_name содержит пробелы, вы должны заключить alias_name в двойные кавычки.</p> <hr> <h2>💻 Пример ALIAS как столбец</h2> <p>Данные трёх наставников заданы непосредственно через <a href="https://plsql.uz/reference/programming/244-with.html">WITH</a>; создавать таблицы не нужно. Все три запроса выбирают Азизу и Зарину с фамилией Karimova, меняя только заголовок второго столбца.</p> <p>Как правило, псевдонимы используются для упрощения чтения заголовков столбцов в вашем результирующем наборе. Например, при конкатенации полей вы можете получить следующий результат.</p> <p>Например:</p> <pre class="language-sql"><code>WITH mentors (mentor_id, first_name, last_name) AS ( SELECT 61, 'Aziza', 'Karimova' FROM dual UNION ALL SELECT 62, 'Temur', 'Karimov' FROM dual UNION ALL SELECT 63, 'Zarina', 'Karimova' FROM dual ) SELECT mentor_id, first_name || ' ' || last_name AS mentor_name FROM mentors WHERE last_name = 'Karimova' ORDER BY mentor_id;</code></pre> <p>В этом примере мы заменили второй столбец (то есть: first_name и last_name конкатенировали) как MENTOR_NAME. В результате MENTOR_NAME будет отображаться как заголовок для второго столбца при возврате результирующего набора. Поскольку наше имя alias_name не содержит пробелов, мы не обязаны оборачивать alias_name в кавычки.</p> <p>Однако было бы вполне приемлемо написать этот пример, используя кавычки следующим образом:</p> <pre class="language-sql"><code>WITH mentors (mentor_id, first_name, last_name) AS ( SELECT 61, 'Aziza', 'Karimova' FROM dual UNION ALL SELECT 62, 'Temur', 'Karimov' FROM dual UNION ALL SELECT 63, 'Zarina', 'Karimova' FROM dual ) SELECT mentor_id, first_name || ' ' || last_name AS "MENTOR_NAME" FROM mentors WHERE last_name = 'Karimova' ORDER BY mentor_id;</code></pre> <p>Затем давайте посмотрим на пример, где мы должны заключить alias_name в двойные кавычки.<br>Например:</p> <pre class="language-sql"><code>WITH mentors (mentor_id, first_name, last_name) AS ( SELECT 61, 'Aziza', 'Karimova' FROM dual UNION ALL SELECT 62, 'Temur', 'Karimov' FROM dual UNION ALL SELECT 63, 'Zarina', 'Karimova' FROM dual ) SELECT mentor_id, first_name || ' ' || last_name AS "MENTOR NAME" FROM mentors WHERE last_name = 'Karimova' ORDER BY mentor_id;</code></pre> <p>В этом примере мы сменили второй столбец (то есть: first_name и last_name конкатенировали) как "MENTOR NAME". Поскольку в этом псевдониме есть пробелы, "MENTOR NAME" должно быть заключено в кавычки.</p> <hr> <table> <thead> <tr> <th>MENTOR_ID</th> <th>MENTOR NAME</th> </tr> </thead> <tbody> <tr> <td>61</td> <td>Aziza Karimova</td> </tr> <tr> <td>63</td> <td>Zarina Karimova</td> </tr> </tbody> </table> <h2>💻 Пример ALIAS таблица</h2> <p>Когда вы создаете псевдоним для таблицы, это либо потому, что вы планируете перечислить одно и то же имя таблицы более одного раза в предложении FROM (т.е.: join), или вы хотите сократить имя таблицы, чтобы сделать оператор SQL короче и легче читаемый.</p> <p>Давайте рассмотрим пример ALIAS имя таблицы в Oracle / PLSQL.<br>Например:</p> <pre class="language-sql"><code>WITH demo_alias_sessions (session_id, session_title, studio_id) AS ( SELECT 81, 'Clay Bowl', 7 FROM dual UNION ALL SELECT 82, 'Paper Lantern', 8 FROM dual UNION ALL SELECT 83, 'Clay Tile', 7 FROM dual ), demo_alias_studios (studio_id, studio_name) AS ( SELECT 7, 'River Studio' FROM dual UNION ALL SELECT 8, 'Garden Studio' FROM dual ) SELECT s.session_id, s.session_title, demo_alias_studios.studio_name FROM demo_alias_sessions s INNER JOIN demo_alias_studios ON s.studio_id = demo_alias_studios.studio_id ORDER BY s.session_title, demo_alias_studios.studio_name;</code></pre> <p>В этом примере мы создали псевдоним для таблицы demo_alias_sessions s. Теперь в этой инструкции SQL мы можем ссылаться на таблицу demo_alias_sessions в виде s.</p> <p>При создании псевдонимов таблиц нет необходимости создавать псевдонимы для всех таблиц, перечисленных в предложении FROM. Вы можете создавать псевдонимы на любой или всех таблицах.</p> <p>Например, мы могли бы изменить наш пример выше и создать псевдоним для таблицы demo_alias_studios таким образом.</p> <pre class="language-sql"><code>WITH demo_alias_sessions (session_id, session_title, studio_id) AS ( SELECT 81, 'Clay Bowl', 7 FROM dual UNION ALL SELECT 82, 'Paper Lantern', 8 FROM dual UNION ALL SELECT 83, 'Clay Tile', 7 FROM dual ), demo_alias_studios (studio_id, studio_name) AS ( SELECT 7, 'River Studio' FROM dual UNION ALL SELECT 8, 'Garden Studio' FROM dual ) SELECT s.session_id, s.session_title, t.studio_name FROM demo_alias_sessions s INNER JOIN demo_alias_studios t ON s.studio_id = t.studio_id ORDER BY s.session_title, t.studio_name;</code></pre> <p>Теперь у нас есть псевдоним для таблицы demo_alias_studios t, а также псевдоним для таблицы demo_alias_sessions s.</p> <p>В Oracle 19c ключевое слово AS допустимо для псевдонима столбца, но не для псевдонима таблицы. Псевдоним действует в пределах запроса и не переименовывает объект в базе.</p> <p>Оба запроса соединения возвращают одинаковые данные:</p> <table> <thead> <tr> <th>SESSION_ID</th> <th>SESSION_TITLE</th> <th>STUDIO_NAME</th> </tr> </thead> <tbody> <tr> <td>81</td> <td>Clay Bowl</td> <td>River Studio</td> </tr> <tr> <td>83</td> <td>Clay Tile</td> <td>River Studio</td> </tr> <tr> <td>82</td> <td>Paper Lantern</td> <td>Garden Studio</td> </tr> </tbody> </table> <p>В Oracle 19c псевдоним столбца можно использовать в <a href="https://plsql.uz/reference/sql/queries-commands/170-order-by.html">ORDER BY</a>, но не в <a href="https://plsql.uz/reference/sql/queries-commands/171-where.html">WHERE</a>, <a href="https://plsql.uz/reference/sql/queries-commands/169-group-by.html">GROUP BY</a> или <a href="https://plsql.uz/reference/sql/queries-commands/168-having.html">HAVING</a> того же блока запроса. Для фильтрации по вычисленному имени оберните запрос подзапросом или WITH. После назначения псевдонима таблице обращайтесь к её столбцам через этот псевдоним.</p> <p>Псевдоним запроса отличается от <a href="https://plsql.uz/reference/programming/235-synonyms.html">синонима</a>: он не создаёт постоянный объект схемы.</p> <p>См. <a href="https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/SELECT.html" target="_blank" rel="noopener noreferrer external">документацию Oracle: SELECT</a>.</p>]]></content:encoded>
</item><item>
<title>Процедуры</title>
<link>https://plsql.uz/reference/programming/239-procedures.html</link>
<pdalink>https://plsql.uz/reference/programming/239-procedures.html</pdalink>
<guid>https://plsql.uz/reference/programming/239-procedures.html</guid>
<pubDate>Tue, 10 Nov 2026 13:54:57 +0500</pubDate>
<category>index</category>

<content:encoded><![CDATA[<h2>📖 Описание</h2> <p>Процедура — подпрограмма PL/SQL для выполнения действий. Она может принимать и возвращать значения через параметры.</p> <hr> <h2>📌 СОЗДАТЬ ПРОЦЕДУРУ (CREATE PROCEDURE)</h2> <p>Как и на других языках программирования, вы можете создавать свои собственные процедуры в Oracle.</p> <hr> <h2>🧩 Синтаксис</h2> <pre class="language-sql"><code>CREATE [OR REPLACE] PROCEDURE имя_процедуры [ (параметр [, параметр, ...]) ] IS [локальные объявления] BEGIN исполняемые предложения [EXCEPTION обработчики исключений] END [имя_процедуры];</code></pre> <p>Режим IN передаёт входное значение; OUT возвращает значение вызывающему коду; IN OUT передаёт начальное значение и возвращает изменённое. По умолчанию используется IN.</p> <hr> <h2>💻 Подготовка</h2> <p>Пример сохраняет исходную идею: найти код занятия явным курсором и записать выбранное название с найденным кодом или маркером отсутствия. В своей учебной схеме нужны CREATE TABLE, CREATE PROCEDURE и квота.</p> <pre class="language-sql"><code>CREATE TABLE demo_proc_workshops ( workshop_code NUMBER PRIMARY KEY, workshop_name VARCHAR2(60 CHAR) NOT NULL UNIQUE ); CREATE TABLE demo_proc_requests ( workshop_name VARCHAR2(60 CHAR) NOT NULL, workshop_code NUMBER NOT NULL, requested_on DATE NOT NULL ); INSERT INTO demo_proc_workshops VALUES (841, 'Paper Mosaic'); INSERT INTO demo_proc_workshops VALUES (842, 'Wood Carving'); COMMIT;</code></pre> <p>UNIQUE гарантирует не больше одной строки по названию. В таблице заявок код 0 означает неизвестное занятие; поэтому здесь намеренно нет внешнего ключа на каталог. В прикладной схеме вместо маркера можно выбрать NULL или отклонение заявки.</p> <h2>💻 Создание процедуры</h2> <pre class="language-sql"><code>CREATE OR REPLACE PROCEDURE demo_add_workshop_request ( p_workshop_name IN VARCHAR2, p_requested_on IN DATE DEFAULT DATE '2026-12-12' ) IS l_code demo_proc_workshops.workshop_code%TYPE; CURSOR c_workshop IS SELECT workshop_code FROM demo_proc_workshops WHERE workshop_name = p_workshop_name; BEGIN OPEN c_workshop; FETCH c_workshop INTO l_code; IF c_workshop%NOTFOUND THEN l_code := 0; END IF; CLOSE c_workshop; INSERT INTO demo_proc_requests (workshop_name, workshop_code, requested_on) VALUES (p_workshop_name, l_code, p_requested_on); END demo_add_workshop_request; /</code></pre> <p>При отсутствии строки FETCH не выбрасывает NO_DATA_FOUND: проверяется %NOTFOUND. Курсор закрывается до <a href="https://plsql.uz/reference/sql/queries-commands/165-insert.html">INSERT</a>. Процедура не фиксирует транзакцию; вызывающий код выбирает COMMIT или ROLLBACK. Пустое имя или NULL-дата не проходят ограничения таблицы, и ошибка передаётся вызывающему коду.</p> <p>OR REPLACE пересоздаёт определение существующей самостоятельной процедуры. Для проверки компиляции:</p> <pre class="language-sql"><code>SELECT line, position, text FROM user_errors WHERE name = 'DEMO_ADD_WORKSHOP_REQUEST' AND type = 'PROCEDURE' ORDER BY sequence;</code></pre> <p>При успешной компиляции ошибок нет. В SQL*Plus/SQLcl символ / запускает завершённый блок в режиме сценария.</p> <h2>📌 Вызов</h2> <p>Вызовы расположены до удаления процедуры. Один использует значение даты по умолчанию, другой — именованные аргументы:</p> <pre class="language-sql"><code>SAVEPOINT before_procedure_demo; BEGIN demo_add_workshop_request('Paper Mosaic'); demo_add_workshop_request( p_workshop_name =&gt; 'Glass Lantern', p_requested_on =&gt; DATE '2026-12-19' ); END; / SELECT workshop_name, workshop_code, TO_CHAR(requested_on, 'YYYY-MM-DD') AS request_day FROM demo_proc_requests ORDER BY workshop_code, workshop_name;</code></pre> <table> <thead> <tr> <th>WORKSHOP_NAME</th> <th>WORKSHOP_CODE</th> <th>REQUEST_DAY</th> </tr> </thead> <tbody> <tr> <td>Glass Lantern</td> <td>0</td> <td>2026-12-19</td> </tr> <tr> <td>Paper Mosaic</td> <td>841</td> <td>2026-12-12</td> </tr> </tbody> </table> <pre class="language-sql"><code>ROLLBACK TO before_procedure_demo; SELECT COUNT(*) AS requests_left FROM demo_proc_requests; -- REQUESTS_LEFT = 0</code></pre> <p>IN — входной параметр и режим по умолчанию. OUT возвращает значение через переменную вызывающего кода; IN OUT принимает и возвращает значение. Процедура отличается от <a href="https://plsql.uz/reference/programming/242-functions.html">функции</a>: у неё нет возвращаемого выражения RETURN value. RETURN без выражения может досрочно завершить процедуру.</p> <h2>📌 DROP PROCEDURE</h2> <h3>🧩 Синтаксис</h3> <pre class="language-sql"><code>DROP PROCEDURE procedure_name;</code></pre> <h3>💻 Пример</h3> <pre class="language-sql"><code>DROP PROCEDURE demo_add_workshop_request; SELECT object_name FROM user_objects WHERE object_type = 'PROCEDURE' AND object_name = 'DEMO_ADD_WORKSHOP_REQUEST';</code></pre> <p>Проверка не возвращает строк. Таблицы сохраняются; определение процедуры удалено и ROLLBACK его не восстановит. DDL фиксирует транзакцию, поэтому демонстрационные заявки откатываются заранее. DROP PROCEDURE применяется к самостоятельной процедуре, а для процедуры внутри <a href="https://plsql.uz/reference/programming/245-packages.html">пакета</a> меняют определение пакета.</p> <p>См. <a href="https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/CREATE-PROCEDURE.html" target="_blank" rel="noopener noreferrer external">документацию Oracle: CREATE-PROCEDURE</a>.</p> <p>См. <a href="https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/DROP-PROCEDURE.html" target="_blank" rel="noopener noreferrer external">документацию Oracle: DROP-PROCEDURE</a>.</p> <p>Обработка ошибок: <a href="https://plsql.uz/reference/programming/exceptions/223-when-others.html">WHEN OTHERS</a> и <a href="https://plsql.uz/reference/programming/exceptions/224-predefined-exceptions.html">предопределённые исключения</a>.</p>]]></content:encoded>
</item><item>
<title>Объявление переменных</title>
<link>https://plsql.uz/reference/programming/238-variable-declarations.html</link>
<pdalink>https://plsql.uz/reference/programming/238-variable-declarations.html</pdalink>
<guid>https://plsql.uz/reference/programming/238-variable-declarations.html</guid>
<pubDate>Tue, 10 Nov 2026 13:54:47 +0500</pubDate>
<category>index</category>

<content:encoded><![CDATA[<h2>📖 Описание</h2> <p>В Oracle PL/SQL переменная позволяет программисту временно хранить данные во время выполнения кода.</p> <hr> <h2>🧩 Синтаксис</h2> <p>Синтаксис объявления переменных в Oracle PL/SQL:</p> <pre class="language-sql"><code>variable_name [CONSTANT] datatype [NOT NULL] [{:= | DEFAULT} initial_value];</code></pre> <hr> <h2>⚙️ Параметры и аргументы</h2> <p>variable_name - имя для назначения переменной.<br>CONSTANT - необязательный. Если указано, значение переменной является константой и не может быть изменено.<br>datatype - тип данных для назначения переменной.</p> <hr> <h2>💻 Пример. Объявление переменной</h2> <p>Ниже приведен пример объявления переменной в Oracle PL/SQL под названием l_workshop.</p> <pre class="language-sql"><code>l_workshop VARCHAR2(60 CHAR);</code></pre> <p>Затем вы можете установить или изменить значение переменной l_workshop следующим образом:</p> <pre class="language-sql"><code>l_workshop := 'Clay Studio';</code></pre> <hr> <h2>💻 Пример. Объявление переменной с присвоением начального значения (не константы)</h2> <p>Ниже приведен пример того, как объявить переменную в Oracle PL/SQL и присвоить ей начальное значение. Это отличается от константы тем, что значение переменной может быть изменено позже.</p> <pre class="language-sql"><code>l_workshop VARCHAR2(100 CHAR) := 'Clay Studio';</code></pre> <p>После этого, в программе, вы можете изменить значение переменной следующим образом:</p> <pre class="language-sql"><code>l_workshop := 'Glass Studio';</code></pre> <hr> <h2>💻 Пример. Объявление константы</h2> <p>Ниже приведен пример объявления константы в Oracle. Значение константы не может быть изменено.</p> <pre class="language-sql"><code>c_seat_fee CONSTANT NUMBER(6,2) := 85;</code></pre> <p>Объявления помещают до BEGIN: в DECLARE анонимного блока либо в разделе IS/AS подпрограммы. Присваивания выполняют после BEGIN. CONSTANT и NOT NULL требуют начального значения.</p> <hr> <h2>📌 Полный пример</h2> <pre class="language-sql"><code>DECLARE l_workshop VARCHAR2(60 CHAR); l_label VARCHAR2(60 CHAR) DEFAULT 'Clay Studio'; c_seat_fee CONSTANT NUMBER(6,2) := 85; l_seats PLS_INTEGER NOT NULL := 3; l_total NUMBER(8,2); l_event_date DATE := DATE '2026-12-12'; BEGIN IF l_workshop IS NULL THEN DBMS_OUTPUT.PUT_LINE('workshop is NULL'); END IF; l_workshop := l_label; l_label := 'Glass Studio'; l_seats := l_seats + 1; l_total := l_seats * c_seat_fee; DBMS_OUTPUT.PUT_LINE(l_workshop || ' / ' || l_label); DBMS_OUTPUT.PUT_LINE('seats=' || l_seats || ', total=' || l_total); DBMS_OUTPUT.PUT_LINE(TO_CHAR(l_event_date, 'YYYY-MM-DD')); END; /</code></pre> <p>Для просмотра вывода включите DBMS Output в клиенте; в SQL*Plus или SQLcl выполните <code>SET SERVEROUTPUT ON</code>. Строка <code>/</code> запускает завершённый блок в режиме сценария.</p> <p>Ожидаемый вывод:</p> <pre class="language-sql"><code>workshop is NULL Clay Studio / Glass Studio seats=4, total=340 2026-12-12</code></pre> <p>Присваивание скалярной строки копирует значение: последующая смена l_label не меняет l_workshop. CONSTANT запрещает новое присваивание, а NOT NULL разрешает изменение значения, если оно остаётся ненулевым. У обычной переменной без инициализации значение NULL, а не 0 или пустой текст.</p> <p>Фрагменты объявлений выше не выполняются как отдельные SQL-команды. Объявляйте идентификатор до использования, учитывайте его <a href="https://plsql.uz/reference/programming/241-data-types.html">тип данных</a> и область блока. Здесь := выполняет присваивание; = используется при сравнении.</p> <p>Документация Oracle: <a href="https://docs.oracle.com/en/database/oracle/oracle-database/19/lnpls/declarations.html" target="_blank" rel="noopener noreferrer external">Declarations</a>, <a href="https://docs.oracle.com/en/database/oracle/oracle-database/19/lnpls/assigning-values-variables.html" target="_blank" rel="noopener noreferrer external">Assigning Values to Variables</a>.</p>]]></content:encoded>
</item></channel></rss>