Как запустить пакет в oracle

Обновлено: 07.07.2024

Описание общедоступных подпрограмм пакета можно получить с помощью команды SQL*Plus DESCRIBE. Команда показывает описание подпрограмм только в том случае, если спецификация пакета скомпилирована без ошибок, тело пакета при этом может отсутствовать.

SQL> CREATE OR REPLACE PACKAGE comm_package

3 g_comm NUMBER := 10;

4 FUNCTION avg_comm (v_comm NUMBER) RETURN NUMBER;

5 PROCEDURE max_comm (v_job VARCHAR2);

6 END comm_package;

SQL> DESCRIBE comm_package

FUNCTION AVG_COMM RETURNS NUMBER

Argument Name Type In/Out Default?

V_COMM NUMBER IN

Argument Name Type In/Out Default?

V_JOB VARCHAR2 IN

Поставляемые пакеты Oracle

Основные средства Oracle, например, встроенные функции, находятся в стандартном пакете Oracle, который имеет имя STANDART. Программные конструкции этого пакета автоматически доступны из любого блока PL/SQL любому пользователю базы данных. Если Вы обращаетесь к объектам стандартного пакета STANDART, имя пакета в качестве префикса указывать не обязательно.

Кроме пакета STANDART в поставку Oracle входит ряд пакетов, которыми могут пользоваться разработчики и администраторы базы данных. Эти пакеты отличаются префиксами имен: DBMS_ – пакеты для работы с базой данных, UTL_ – утилиты общего назначения. При обращении к объектам этих пакетов необходимо указывать имя пакета в качестве префикса к имени объекта.

Запуск пользовательских заданий в определенное время

Управление блокировками базы данных

Вывод строк текста в буфер для дальнейшего получения и вывода

Управление транзакциями SQL

Работа с большими объектами

ASCII операции чтения/записи системных файлов

DBMS_OUTPUT

Пакет DBMS_OUTPUT позволяет отображать информацию, выводимую из блоков PL/SQL, для их отладки и тестирования.

Процедуры и функции пакета формируют выходной буфер:

· Каждая строка буфера хранится в закрытой таблице PL/SQL

· Каждая строка буфера завершается символом новой строки

· Каждая строка буфера не должна превышать 255 байт, включая символ новой строки

· Размер буфера должен быть в диапазоне от 2000 до 1000000 байт

Процедуры и функции

Добавляет текст к текущей строке буфера

Добавляет символ конца строки в буфер. Несколько вызовов подряд не формирует пустые строки

Добавляет строку в буфер

Получает текущую строку буфера

Получает массив строк буфера

Включает/выключает вызов подпрограмм пакета. В процедуре ENABLE можно задать размер буфера

5 DBMS_OUTPUT.put('my string');

It is my string

PL/SQL procedure successfully completed.

DBMS_PIPE

Процедуры и функции

4 DBMS_PIPE.pack_message('It is my message');

5 l_var := DBMS_PIPE.send_message('p1');

PL/SQL procedure successfully completed.

3 l_msg VARCHAR2(50);

5 l_var := DBMS_PIPE.receive_message('p1');

It is my message

PL/SQL procedure successfully completed.

UTL_FILE

Пакет UTL_FILE позволяет читать из текстовых файлов операционной системы и писать в них.

Процедуры и функции

Функция открывает файл операционной системы и возвращает указатель на файл (тип данных – RECORD) для последующих операций

Процедура добавляет текст к текущей строке в открытом файле

Процедура добавляет символ конца строки к текущей строке в открытом файле

Процедура записывает текстовую строку с символом конца строки в открытый файл

Процедура читает текстовую строку из открытого файла операционной системы

Пакет PL/SQL представляет собой сгруппированный по определенным правилам именованный набор элементов кода PL/SQL . Он обеспечивает логическую структуру для организации программ и других элементов PL/SQL : курсоров, типов данных и переменных. Пакеты обладают очень важными функциональными возможностями, включая возможность сокрытия логики и данных, а также определения глобальных данных, существующих в течение сеанса.

Для чего нужны пакеты в PL/SQL?

Пакеты — очень важная составная часть языка PL/SQL, краеугольный камень любого сложного проекта. Чтобы это понять, необходимо рассмотреть основные преимущества пакетов:

Упрощение сопровождения и расширения приложений. По мере того как все большая часть кодовой базы перемещается в режим сопровождения, качество приложений PL/SQL определяется не только их производительностью, но и простотой сопровождения. С этой точки зрения пакеты играют исключительно важную роль, поскольку они обеспечивают инкапсуляцию кода (в частности, они позволяют скрыть команды SQL за интерфейсом процедур), дают возможность определять константы для литералов и «волшебных» чисел, и группировать логически связанные функции. Пакетный подход к проектированию и реализации сокращает количество потенциальных сбоев в приложениях.
Повышение производительности приложений. Во многих ситуациях использование пакетов повышает производительность и эффективность работы приложений. Определение постоянных структур данных уровня пакета позволяет кэшировать статические значения из базы данных. Это дает возможность избежать повторных запросов, а следовательно, значительно ускорить получение результата. Кроме того, подсистема управления памятью Oracle оптимизирована для доступа к откомпилированному коду пакетов.
Исправление недостатков приложений или встроенных элементов. Некоторые из существующих программных компонентов Oracle имеют недостатки; в частности, не лучшим образом реализованы важнейшие функции встроенных пакетов UTL_FILE и DBMS_OUTPUT . Мириться с ними не обязательно; можно разработать собственный пакет на базе существующего, исправив как можно больше проблем. Например, сценарий do.pkg, предоставляет замену для встроенной функции DBMS_OUTPUT.PUT_LINE с добавлением перегрузки для типа XMLType. Подобного результата можно достичь и с помощью отдельных функций и процедур PL/SQL, но решение с пакетами более предпочтительно.
Снижение необходимости в перекомпиляции кода. Пакет обычно состоит из двух элементов: спецификации и тела. Внешние программы (не определенные в пакете) могут вызывать только программы, перечисленные в спецификации. Изменение и перекомпиляция тела пакета не отражается на работе этих внешних программ. Снижение необходимости в перекомпиляции кода является важнейшим фактором администрирования больших объемов программного кода приложений. Концепция пакетов очень проста. Единственная сложность заключается в том, чтобы научиться эффективно применять в приложениях их богатые возможности. В этой статье мы начнем с рассмотрения простого пакета; вы увидите, что основные преимущества пакетов проявляются даже в тривиальном коде. Затем будет рассмотрен специальный синтаксис, используемый при определении пакетов.

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

Демонстрация возможностей пакетов PL/SQL

Пакет состоит из двух частей — спецификации и тела. Спецификация является обязательной частью и определяет, как разработчик может использовать пакет: какие программы можно вызывать, какие курсоры открывать и т. д. Тело пакета — необязательная, но почти всегда присутствующая часть; она содержит код перечисленных в спецификации программ (и возможно, курсоров), а также другие необходимые элементы кода. Предположим, нам нужна программа для получения полного имени сотрудника, которое хранится в базе данных в виде двух отдельных элементов: фамилии и имени. На первый взгляд кажется, что задача решается просто:

Однако этот вроде бы тривиальный код обладает рядом скрытых недостатков:

Длина переменной l_fullname жестко закодирована. Поскольку полное имя — производное значение, которое строится конкатенацией содержимого двух столбцов, лучше так не делать. Если длина столбцов last_name и/или first_name будет увеличена, код процедуры придется изменять.
Жестко закодировано правило составления полного имени. Чем это плохо? Тем, что если через какое-то время пользователь захочет получить полное имя в формате «ИМЯ ФАМИЛИЯ», вам придется производить замену во многих местах кода.
Наконец, этот очень распространенный запрос может встречаться в нескольких местах приложения. Дублирование кода SQL затрудняет сопровождение приложения и его оптимизацию.

Приложения должны строиться таким образом, чтобы избежать жесткого кодирования подобных элементов. Определение типа данных для полного имени, представление, запрос к базе данных и т. п. должны кодироваться один раз в строго определенном месте и быть доступны из любой точки приложения. Таким местом и является пакет. Рассмотрим следующую спецификацию пакета:

Фактически здесь перечисляются различные элементы, которые должны использоваться разработчиками. Важнейшие элементы кода представлены в следующей таблице.

Строки	Описание
3	Объявление нового типа данных fullname_t. В этой версии его максимальная длина составляет 200 символов, но впоследствии ее будет легко изменить
5-8	Объявление функции fullname , которая строит полное имя по фамилии и имени. Обратите внимание: способ построения полного имени в спецификации пакета не указан
10-13	Объявление второй функции с тем же именем fullname ; новая версия получает первичный ключ таблицы и возвращает соответствующее ему полное имя. Это типичный пример перегрузки, о которой говорилось в этой статье

Но прежде чем рассматривать реализацию пакета, давайте перепишем исходный блок кода таким образом, чтобы в нем использовались элементы пакета (обратите внимание на точечный синтаксис, аналогичный синтаксису таблица.столбец):

Переменная l_name объявляется с новым типом данных, а для присваивания ей нужного значения вызывается соответствующая функция этого же пакета. Таким образом, формула построения полного имени и SQL-запрос вынесены из кода приложения в специальный «контейнер» для всей функциональности, относящейся к обработке данных о сотрудниках. Код стал проще и лаконичнее. Если потребуется изменить формулу построения полного имени или увеличить размер его типа данных, достаточно внести соответствующие изменения в спецификацию или тело пакета и перекомпилировать его код.

Реализация employee_pkg выглядит так:

В следующей таблице перечислены важные элементы этого кода.

Строки	Описание
3-11	Функция-«обертка» для определения формата полного имени «ФАМИЛИЯ, ИМЯ»
13-27	Типичный запрос на выборку одной строки, выполняемый с помощью неявного курсора
18	Вызов функции fullname, возвращающей комбинацию двух компонентов имени

Если теперь пользователь потребует изменить формат представления полного имени, нам не придется искать по всему приложению все вхождения || ', ' || — для установки нового формата достаточно модифицировать в пакете employee_pkg функцию fullname .

Основные концепции пакетов

Прежде чем переходить к подробному изучению синтаксиса и структуры пакетов, следует изучить некоторые концепции пакетов:

Сокрытие информации. Сокрытие информации о системе или приложении обычно преследует две цели. Во-первых, возможности человека по работе со сложными системами ограничены. Исследования показали, что у среднего «мозга» при запоминании даже семи (плюс/минус двух) элементов в группе возникают проблемы. Таким образом, пользователь (или разработчик) освобождается от необходимости вникать в ненужные подробности и может сосредоточиться на действительно важных аспектах. Во-вторых, сокрытие информации препятствует доступу к закрытым сведениям. Например, разработчик может вызвать в своем приложении готовую функцию для вычисления некоторого значения, но при этом формула вычислений может быть секретной. Кроме того, в случае изменения формулы все модификации будут вноситься только в одном месте.
Общие и приватные элементы. Концепция общих и приватных элементов тесно связана с концепцией сокрытия информации. Общедоступный код определяется в спецификации пакета и доступен любой схеме, обладающей для этого пакета привилегией EXECUTE . Приватный код виден только в пределах пакета. Внешние программы, работающие с пакетом, не видят приватный код и не могут использовать его.

Приступая к разработке пакета, вы решаете, какие из его элементов будут общими, а какие — приватными. Кроме того, тело пакета можно скрыть от других схем/разработчиков. В таком случае пакет используется для сокрытия деталей реализации программ. Это особенно полезно для изоляции переменных компонентов приложения — фрагментов кода, зависящих от платформы, часто меняющихся структур данных и временных обходных решений.

На ранних стадиях развития программы в теле пакета также могут реализоваться в виде «заглушек» с минимальным объемом кода, необходимым для компиляции пакета. Этот прием позволяет сосредоточиться на интерфейсах программы и их взаимных связях.

Спецификация пакета. Она содержит определения всех общедоступных элементов пакета, на которые можно ссылаться извне. Спецификация напоминает большой раздел объявлений; она не содержит блоков PL/SQL или исполняемого кода. Из хорошо спроектированной спецификации разработчик может получить всю необходимую для использования пакета информацию и ему никогда не придется заглядывать «за интерфейс» (то есть в тело пакета, содержащее реализацию его компонентов).
Тело пакета. Здесь находится весь код, который необходим для реализации элементов, определенных в спецификации пакета. Тело может содержать отсутствующие в спецификации личные элементы, на которые нельзя ссылаться извне пакета, в частности объявления переменных и определения пакетных модулей. Кроме того, в теле пакета может находиться исполняемый (инициализационный) раздел, который выполняется только один раз для инициализации пакета.
Инициализация. Концепция инициализации хорошо известна любому программисту, однако в контексте пакетов она имеет особое значение. В данном случае инициализируется не отдельная переменная, а весь пакет путем выполнения кода произвольной сложности. При этом Oracle следит за тем, чтобы пакет инициализировался только один раз за сеанс.
Постоянство в течение сеанса. Концепция постоянства (или сохраняемости) тоже хорошо знакома программистам. Когда вы подключаетесь к Oracle и выполняете программу, присваивающую значение переменной уровня пакета (то есть переменной, объявленной в пакете вне содержащихся в нем программ), эта переменная сохраняет значение в течение всего сеанса, даже если выполнение присвоившей его программы завершается.

Также существует концепция сеансового постоянства. Если я подключаюсь к базе данных Oracle (создаю сеанс) и выполняю программу, которая присваивает значение пакетной переменной (то есть переменной, объявленной в спецификации или теле пакета, за пределами всех входящих в него программ), то эта переменная продолжает существовать на всем протяжении сеанса и сохраняет свое значение даже при завершении программы, выполнившей присваивание.

Именно пакеты обеспечивают поддержку структур данных с сеансовым постоянством в языке PL/SQL.

Графическое представление приватности

Различия между общедоступными и приватными элементами пакета дают разработчикам PL/SQL беспрецедентные средства управления структурами данных и программами. Грэди Буч предложил визуальное средство описания этих аспектов пакета (которое было вполне естественно названо диаграммой Буча).

Взгляните на рис. 1. Обратите внимание на надписи «Внутренняя часть» и «Внешняя часть». Первая часть содержит тело пакета (внутренняя реализация пакета), а вторая — все программы, написанные вами и не являющиеся частью пакета (внешние программы).

Рис. 1. Диаграмма Буча с общедоступными и приватными элементами пакета

Пакет PL / SQL представляет собой логическое объединение связанной подпрограммы (процедуры / функции) в один элемент. Пакет компилируется и сохраняется как объект базы данных, который можно использовать позже.

В этом уроке вы узнаете

Компоненты пакетов

Пакет PL / SQL состоит из двух компонентов.

Спецификация упаковки

Спецификация пакета состоит из объявления всех открытых переменных, курсоров, объектов, процедур, функций и исключений.

Ниже приведены некоторые характеристики спецификации пакета.

Синтаксис

Приведенный выше синтаксис показывает создание спецификации пакета.

Корпус

Он состоит из определения всех элементов, которые присутствуют в спецификации пакета. Он также может иметь определение элементов, которые не объявлены в спецификации, эти элементы называются частными элементами и могут вызываться только из пакета.

Ниже приведены характеристики корпуса упаковки.

Синтаксис:

Приведенный выше синтаксис показывает создание тела пакета.

Теперь мы увидим, как ссылаться на элементы пакета в программе.

Ссылающиеся элементы пакета

Как только элементы объявлены и определены в пакете, нам нужно обратиться к элементам, чтобы использовать их.

Все общедоступные элементы пакета могут быть переданы путем вызова имени пакета, за которым следует имя элемента, разделенное точкой, т.е. «<имя_пакета>. <Имя_элемента>».

Открытая переменная пакета также может быть использована таким же образом для назначения и извлечения значений из них, то есть «<имя_пакета>. <Имя_переменной>».

Создать пакет в PL / SQL

В PL / SQL всякий раз, когда пакет вызывается / вызывается в сеансе, для этого пакета будет создан новый экземпляр.

Oracle предоставляет возможность инициализировать элементы пакета или выполнять какие-либо действия во время создания этого экземпляра с помощью «Инициализация пакета».

Это не что иное, как блок выполнения, который записывается в теле пакета после определения всех элементов пакета. Этот блок будет выполняться всякий раз, когда пакет передается в первый раз в сеансе.

Синтаксис

Приведенный выше синтаксис показывает определение инициализации пакета в теле пакета.

Форвардные декларации

На частные элементы можно ссылаться, только если они уже объявлены в теле пакета. По этой причине используется предварительное объявление. Но это довольно необычно в использовании, потому что в большинстве случаев закрытые элементы объявляются и определяются в первой части тела пакета.

Синтаксис:

Приведенный выше синтаксис показывает предварительное объявление. Закрытые элементы объявляются отдельно в передней части пакета, и они были определены в более поздней части.

Использование курсоров в пакете

В отличие от других элементов, нужно соблюдать осторожность при использовании курсоров внутри пакета.

Если курсор определен в спецификации пакета или в глобальной части тела пакета, то один раз открытый курсор будет сохраняться до конца сеанса.

перегрузка

Это полезно, когда многие подпрограммы должны выполнять одну и ту же задачу, но способ вызова каждой из них должен быть разным. В этом случае имя подпрограммы будет оставаться одинаковым для всех, а параметры будут изменены в соответствии с оператором вызова.

Пример 1 : В этом примере мы собираемся создать пакет для получения и установки значений информации о сотруднике в таблице «emp». Функция get_record возвращает вывод типа записи для данного номера сотрудника, а процедура set_record вставляет запись типа записи в таблицу emp.

Шаг 1) Создание спецификации пакета

Вывод:

Код Объяснение

Строка кода 1-5 : создание спецификации пакета для guru99_get_set с одной процедурой и одной функцией. Эти два в настоящее время являются открытыми элементами этого пакета.

Шаг 2) Пакет содержит тело пакета, в котором будут определены все действительные процедуры и функции. На этом шаге создается тело пакета.

Вывод:

Код Объяснение

Строка кода 7 : создание тела пакета.
Строка кода 9-16 : определение элемента set_record, который объявлен в спецификации. Это то же самое, что и определение автономной процедуры в PL / SQL.
Строка кода 17-24: определение элемента get_record. Это то же самое, что и определение автономной функции.
Строка кода 25-26: определение части инициализации пакета.

Шаг 3) Создание анонимного блока для вставки и отображения записей, ссылаясь на созданный выше пакет.

Вывод:

Объяснение кода:

Строка кода 34-37: заполнение данных для переменной типа записи в анонимном блоке для вызова элемента set_record пакета.
Строка кода 38: был сделан вызов set_record пакета guru99_get_set. Теперь пакет создается и сохраняется до конца сеанса.
Часть инициализации пакета выполняется, так как это первый вызов пакета.
Запись вставляется элементом set_record в таблицу.
Строка кода 41: вызов элемента get_record для отображения сведений о введенном сотруднике.
Пакет передается во второй раз во время вызова get_record. Но на этот раз часть инициализации не выполняется, поскольку пакет уже инициализирован в этом сеансе.
Строка кода 42-45: печать сведений о сотруднике.

Зависимость в пакетах

Поскольку пакет представляет собой логическую группу связанных вещей, он имеет некоторые зависимости. Ниже приведена зависимость, которую нужно позаботиться.

Информация о пакете

Как только информация о пакете создана, информация о пакете, такая как источник пакета, детали подпрограммы и информация о перегрузке, доступна в таблицах определения данных Oracle.

Ниже в таблице приведены таблица определения данных и информация о пакете, которая доступна в таблице.

Программист может использовать это для записи файлов операционной системы любого типа, и файл будет записан непосредственно на сервер базы данных. Имя и путь к каталогу будут указаны при написании.

Резюме

Теперь мы изучили пакеты на PL / SQL, и теперь вы сможете работать следующим образом.

Пакет - это объект схемы, который объединяет логически зависимые типы PL/SQL, данные и подпрограммы . Пакет состоит из двух частей: спецификации пакета и тела пакета .

В спецификации пакета объявляются доступные типы, переменные, константы, исключения, курсоры и подпрограммы .

В теле пакета содержится определение курсоров и реализация подпрограмм . Все элементы, объявляемые в теле пакета , невидимы для приложения, что позволяет скрывать от пользователя детали реализации подпрограмм .

Определение спецификации пакета выполняется оператором CREATE PACKAGE , который может иметь следующее формальное описание:

Определение тела пакета выполняется оператором CREATE PACKAGE BODY , который может иметь, с некоторыми сокращениями, следующее формальное описание:

На общедоступные элементы пакета - типы, переменные и методы - можно ссылаться из триггеров, хранимых подпрограмм или OCI -приложений, используя следующий синтаксис: package_name.item_name .

Вызов пакетной процедуры из встроенного SQL может быть реализован в анонимном блоке PL/SQL, для выполнения которого используется SQL-оператор EXECUTE .

Подпрограммы

Подпрограммами называются именованные блоки PL/SQL, которые могут иметь параметры.

Язык PL/SQL позволяет создавать подпрограммы и как процедуры, и как функции PL/SQL .

Подпрограммы могут быть объявлены в любом блоке PL/SQL , подпрограмме или пакете . Любая процедура или функция должна быть объявлена до ее использования. В том случае, если одной подпрограмме требуется использовать другую подпрограмму , объявляемую позже, то следует использовать механизм предварительного объявления. При этом предварительно объявляемая подпрограмма содержит только спецификацию, а полное объявление подпрограммы может быть выполнено ниже в соответствии с обычным синтаксисом.

Для того чтобы подпрограмму пакета можно было вызвать извне, она должна быть объявлена в спецификации пакета , определяемой оператором CREATE PACKAGE .

Для того чтобы самостоятельную подпрограмму можно было вызвать извне она должна храниться в базе данных. Такие подпрограммы называются хранимыми процедурами или хранимыми функциями. Для их создания применяются SQL- операторы CREATE PROCEDURE и CREATE FUNCTION .

Определение процедуры может иметь следующее формальное описание:

Параметры в списке параметров определяются как:

Параметры, используемые при объявлении процедуры или функции, называются формальными параметрами , а при вызове - фактическими параметрами .

Язык PL/SQL позволяет, чтобы количество фактических параметров было меньше, чем количество формальных параметров . В этом случае будут использованы значения по умолчанию, которые обязательно должны присутствовать для отсутствующих значений параметров.

Для определения соответствия между формальными и фактическими параметрами предусмотрены два типа нотаций:

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

При именованной нотации порядок указания параметров не имеет значения, но перед значением параметра указывается имя формального параметра и символ =>. Список параметров может содержать оба типа нотаций одновременно, но именованная нотация располагается только в конце списка.

Процедура имеет две части:

спецификацию , начинающуюся ключевым словом PROCEDURE и завершающуюся именем процедуры или списком параметров;
тело процедуры , начинающееся ключевым словом IS и завершающееся ключевым словом END .

Тело процедуры , как и любой блок PL/SQL , имеет секцию объявлений, секцию выполняемого кода и необязательную секцию обработчиков исключений.

Определение функции может иметь следующее формальное описание:

Параметры в списке параметров определяются как:

Язык PL/SQL позволяет создавать перегружаемые подпрограммы , имеющие одинаковое имя, но различный список формальных параметров . Параметры перегружаемых функций должны различаться хотя бы по одному из следующих признаков: по типу, по количеству, по порядку следования параметров.

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

Рекурсивные и взаимно рекурсивные вызовы подпрограмм

Рекурсивным вызовом называется вызов подпрограммы из тела этой же подпрограммы .

При каждом рекурсивном вызове :

создается новый экземпляр всех элементов, объявленных в подпрограмме , включая параметры, переменные, курсоры и исключения;
создается свой экземпляр SQL-оператора.

Рассмотрим в качестве примера рекурсивных вызовов создание последовательности Фибоначчи ( 1, 1, 2, 3, 5, 8, 13, 21, .. .), в которой каждый следующий элемент является суммой двух предыдущих.

Следующая функция fibonati1 реализует формирование последовательности Фибоначчи с применением рекурсии:

Вместо рекурсивного способа можно использовать и итерационный способ, который менее нагляден, но требует и меньше памяти, и быстрее выполняется.

Так, следующая функция fibonati2 реализует формирование последовательности Фибоначчи итерационным способом:

Язык PL/SQL позволяет реализовывать взаимно рекурсивные вызовы , при которых подпрограммы прямо или опосредованно вызывают друг друга.

Читайте также: