что такое курсор и зачем он нужен
Что такое курсор?
Операции в реляционной базе данных выполняются над множеством строк. Набор строк, возвращаемый инструкцией SELECT, содержит все строки, которые удовлетворяют условиям, указанным в предложении WHERE инструкции. Такой полный набор строк, возвращаемых инструкцией, называется результирующим набором. Приложения, особенно интерактивные и интерактивные, не всегда эффективно работают с результирующим набором как единое целое. Им нужен механизм, позволяющий обрабатывать одну строку или небольшое их число за один раз. Курсоры являются расширением результирующих наборов, которые предоставляют такой механизм.
Курсор реализуется библиотекой курсоров. Библиотека курсоров — это программное обеспечение, которое часто реализуется как часть системы базы данных или API доступа к данным, которое используется для управления атрибутами данных, возвращаемых из источника данных (результирующий набор). Эти атрибуты включают управление параллелизмом, положение в результирующем наборе, число возвращаемых строк и возможность перемещения вперед или назад (или и то, и другое) с помощью результирующего набора (прокрутка).
Курсор отслеживает позицию в результирующем наборе и позволяет выполнять несколько операций по строкам в результирующем наборе с возвратом к исходной таблице или без него. Иными словами, курсоры основываются на концептуальном возврате результирующего набора на основе таблиц в базах данных. Курсор имеет имя, так как указывает текущую позицию в результирующем наборе, так же как курсор на экране компьютера указывает на текущую позицию.
Прежде чем перейти к изучению особенностей использования в ADO, важно ознакомиться с понятием курсоров.
С помощью курсоров можно выполнять следующие задачи:
Укажите положение в конкретных строках результирующего набора.
Получение одной строки или блока строк на основе текущего расположения результирующего набора.
Изменение данных в строках в текущей позиции результирующего набора.
Определите различные уровни чувствительности к изменениям данных, внесенным другими пользователями.
Например, рассмотрим приложение, которое отображает список доступных продуктов для потенциального покупателя. Покупатель прокручивает список, чтобы просмотреть сведения о продукте и стоимость, и, наконец, выбирает продукт для покупки. В оставшейся части списка появляется дополнительная прокрутка и выбор. С точки зрения покупателя продукты появятся по одному за раз, но приложение использует прокручиваемый курсор для просмотра результирующего набора.
Курсоры можно использовать различными способами:
С некоторыми или всеми строками в одной таблице.
С некоторыми или всеми строками из логически соединяемых таблиц.
Для чтения или обновления на уровне курсора или поля.
Как однопроходные или полностью прокручиваемые.
С набором ключей курсора, расположенным на сервере.
Конфиденциальные изменения базовой таблицы, вызванные другими приложениями (например, членство, сортировка, вставка, обновления и удаления).
Существующий на сервере или клиенте.
Курсоры только для чтения помогают пользователям просматривать результирующий набор, а курсоры чтения и записи могут реализовывать отдельные обновления строк. Сложные курсоры можно определять с помощью формируются, которые указывают на строки базовой таблицы. Хотя некоторые курсоры доступны только для чтения в прямом направлении, другие могут перемещаться назад и выполнять динамическое обновление результирующего набора на основе изменений, внесенных другими приложениями в базу данных.
Не все приложения должны использовать курсоры для доступа к данным и их обновления. Некоторые запросы просто не нуждаются в непосредственной обновлении строк с помощью курсора. Курсоры должны быть одним из последних методов, выбранных для получения данных, а затем следует выбирать наименьший возможный курсор. При создании результирующего набора с помощью хранимой процедуры результирующий набор не обновляется с помощью методов изменения или обновления курсора.
Параллелизм
В некоторых многопользовательских приложениях очень важно, чтобы данные, представляемые конечному пользователю, были как можно более актуальными. Классическим примером такой системы является система резервирования авиакомпании, где многие пользователи могут полагаться на одно и то же место на данном полете (и, следовательно, в одну запись). В таком случае проект приложения должен выполнять параллельные операции над одной записью.
В других приложениях параллелизм не так важен. В таких случаях затраты, связанные с своевременным хранением данных, не могут быть выровнены по ширине.
Положение
Курсор также отслеживает текущую позицию в результирующем наборе. Можно рассматривать положение курсора как указатель на текущую запись, аналогично тому, как индекс массива указывает на значение в определенном месте в массиве.
Прокручиваемость
Тип курсора, используемый приложением, также влияет на возможность перемещения по строкам в результирующем наборе вперед и назад. Иногда это называется прокруткой. Возможность перемещаться вперед и назад по результирующему набору увеличивает сложность курсора и поэтому реализуется более затратно. По этой причине следует запрашивать курсор с этой функцией только при необходимости.
Курсоры в Mysql.
)ENGINE=InnoDB
AUTO_INCREMENT=11 CHARACTER SET ‘utf8’ COLLATE ‘utf8_bin’
Допустим нам нужно получать по очереди каждый банк и производить с ним какие то действия, помочь в этом нам мог бы такой вот запрос
Select `bank`.* FROM `bank` LIMIT НОМЕР_НУЖНОЙ_НАМ_ЗАПИСИ,1
Поясним теперь подробнее. Сначала HANDLER, он нужен для обработки исключения — что делать когда данные закончатся ( то есть курсор будет пустым ). Таким образом когда данные закончатся, не с генерируется сообщение об ошибке, а значение переменной done выставиться в 1, изначально done = 0; подробнее об SQLSTATE читаем тут — dev.mysql.com/doc/refman/5.1/en/error-messages-server.html;
Error: 1329 SQLSTATE: 02000 (ER_SP_FETCH_NO_DATA)
Message: No data — zero rows fetched, selected, or processed
SQLSTATE: 02000 срабатывает когда достигнут конец курсора, или когда select или update возвращяет пустую строку.
Следующей строкой мы объявили курсор DECLARE cursor_name CURSOR FOR select_statement;
Открываем курсор Open cursor_name;
Дальше пока не достигаем конец курсора (WHILE done = 0 DO ) извлекаем данные и обрабатываем их.
Перед выходом из хранимой процедуры необходимо курсор закрыть. Close cursor_name;
Вроде ничего сложного. Но с SQLSTATE ‘02000’ связанно много подводных камней.
WHILE done = 0 DO
FETCH BankCursor INTO vBankId,vBankName,vAddress,vPhone;
/* извлечем для банка сумму любого из его вкладов */
Select (ContributeAmount) INTO vContributeAmountSUM FROM bankdistribution where BankId = vBankId limit 1;
делаем какие то действия
END WHILE ;
WHILE done = 0 DO
FETCH BankCursor INTO vBankId,vBankName,vAddress,vPhone;
/* извлечем для банка сумму любого из его вкладов */
Select Сount(ContributeAmount) INTO vContributeAmountSUM FROM bankdistribution where BankId = vBankId limit 1;
/* проверим действительно ли есть вклады в этом банке */
if (vContributeAmountSUM > 0) then
/* извлечем для банка сумму любого из его вкладов */
Select ContributeAmount INTO vContributeAmountSUM FROM bankdistribution where BankId = vBankId limit 1;
end if ;
делаем какие то действия
END WHILE ;
первым запросом мы проверили а есть ли вклады (если их нет то vContributeAmountSUM == 0 ) и только если таковые имеются мы извлекаем данные.
теперь допустим нам нужно излечь общую сумму на счетах в разных банках у каждого клиента
Declare ClientSummCursor Cursor for Select sum
Declare ClientSummCursor Cursor for Select sum (`bankdistribution`.`ContributeAmount`),`bankdistribution`.`ClientId` FROM `bankdistribution` Inner Join client on (client.ClientId = bankdistribution.`ClientId`) where 1 group by `bankdistribution`.`ClientId`;
может возникнуть та же ситуация, когда данные в курсоре ClientSummCursor, закончатся раньше чем данные в BankCursor, сработает SQLSTATE: 02000, переменная done установится в 1, и цикл while закончиться раньше чем мы ожидали. Этого можно избежать поступив следующим образом
Всем дочитавшим до этого места спасибо, надеюсь это статься покажется кому то полезной.
SQL-Ex blog
Новости сайта «Упражнения SQL», статьи и переводы
Работа с курсорами SQL
В языке SQL курсоры служат указателями, которые позволяют языку написания приложений обрабатывать результаты запросов построчно. В данной статье вкратце объясняется концепция и показывается, как объявить курсор, открыть, извлечь из него данные, а затем закрыть.
Курсоры SQL
Данные в реляционной базе данных рассматриваются как множества. Как следствие, результаты запроса возвращаются операторами SELECT в виде результирующих наборов. Эти результирующие наборы есть не что иное, как одна или более строк и столбцов, извлеченных из одной или более таблиц. Вы можете пролистать результирующие наборы, чтобы вытащить необходимую вам информацию. Возвращаемые элементы данных используются языками программирования типа Java или любыми другими в конкретных целях приложения. Однако здесь имеется проблема, обусловленная несоответствием структур модели базы данных и моделью языка программирования.
Таким образом, курсор служит указателем, который позволяет языку программирования обрабатывать результаты запроса по одной записи за раз. Курсор может перемещаться по всем строкам результата запроса, позиционируясь всякий раз на отдельной строке. Рассмотрим следующий запрос SQL:
Вышеприведенный оператор вернет информацию о тех сотрудниках, чей день рождения попадает на текущие день и месяц. Результат может содержать много строк, но базовый язык приложения может обработать одновременно только одну строку. В результате, курсор объявляется как встроенный в соответствующий язык программирования оператор SQL. Затем курсор открывается подобно файлу, и извлекается отдельная строка из результата запроса. Остальные строки извлекаются последовательно до тех пор, пока курсор не будет закрыт.
Объявление курсора
Курсоры объявляются во многом подобно переменной. Курсору дается имя, имеются операторы для открытия курсора, извлечения результатов запроса и, наконец, закрытия курсора. Отметим, что различные реализации SQL поддерживают использование курсоров по-разному. Но здесь имеется общее соглашение как должен записываться курсор.
Мы должны использовать несколько операторов SQL для полной реализации функциональности курсора, т.к. одно лишь объявление курсора недостаточно для извлечения данных из базы данных. Вот 4 основных шага для работы с курсором:
DECLARE CURSOR: Объявление начинается с задания имени курсору и присвоения ему выражения запроса, которое будет вызываться при открытии курсора.
OPEN: Оператор open выполняет выражение запроса курсора и подготавливает результат запроса для последующего обхода (FETCH).
FETCH: Извлекает значения данных в переменные, которые затем могут передаваться базовому языку программирования или другим встроенным операторам SQL.
CLOSE: Курсор закрывается, и больше не может извлекать результаты запроса.
Основной частью объявления курсора является:
Необязательная часть, такая как [SENSITIVE | INSENSITIVE | ASENSITIVE] определяет, будет ли курсор чувствителен к изменениям, и будет ли отражать эти изменения в результатах запроса. SENSITIVE означает, что курсор реагирует на изменения, INSENSITIVE означает, что на курсор изменения не влияют, а ASENSITIVE означает, что изменения могут быть видны или не видны в курсоре. Если не указано, то предполагается опция ASENSITIVE.
Необязательные [SCROLL | NOSCROLL] определяют возможность пролистывания курсора. Если не указано, предполагается опция NOSCROLL.
Необязательные [ WITH HOLD | WITHOUT HOLD] определяют, сохранять ли курсор или автоматически закрывать его, когда связанная с курсором транзакция фиксируется. Если не указано, поддерживается опция WITHOUT HOLD.
Необязательные [ WITH RETURN | WITHOUT RETURN] определяют, следует ли возвращать результирующий набор курсора вызывающей стороне, такой как другая подпрограмма SQL или базовый язык. Если не указано, предполагается WITHOUT RETURN.
Предложение ORDER BY используется для сортировки возвращаемых результатов запроса.
Опция UPDATE относится к использованию операторов UPDATE или DELETE, связанных со строками, возвращаемыми оператором SELECT в определении курсора. Любая подобная модификация невозможна, если мы указываем опцию READ ONLY. Если не указана, то по умолчанию принимается опция UPDATE.
Итак, простой курсор может быть объявлен следующим образом:
Курсоры в MySQL
В MySQL имеется два основных типа курсоров: только на чтение (read-only) и только вперед (forward-only). Эти курсоры могут использоваться в хранимых процедурах MySQL. Они помогают нам итерационно обходить результаты запроса по одной строке за раз и извлекать значения в переменные для последующей обработки. Имеется возможность объявлять более одного курсора и вкладывать их в циклы. Заметим, что курсоры являются курсорами только на чтение, поскольку они для итераций используют временные таблицы. Обычно курсор выполняет запрос при его открытии.
Одной из проблем, связанных с курсорами в MySQL, является их отрицательное влияние на производительность из-за дополнительных операций ввода/вывода, которые они производят. Это особенно справедливо для больших типов данных, таких как BLOB и TEXT. Т.к. курсоры работают с временными таблицами, эти типы не поддерживаются в таблицах в памяти (in-memory). Следовательно, при работе с этими типами данных MySQL должна создавать временные таблицы на диске, что требует множества операций ввода/вывода, что особенно плохо для таких медленных устройств, которыми являются диски. Это основная причина низкой производительности курсоров.
MySQL также не поддерживает курсоров на стороне клиента, однако клиентское API может эмулировать их при необходимости. Но тогда это не сильно отличается от извлечения результата в массив на языке программирования типа Java, и манипулирования этим массивом вместо использования курсора.
Вот пример написания курсора в MySQL:
Вызвать хранимую процедуру можно так:
Процедура извлекает те строки из таблицы с именем employee, для которых дата рождения совпадает с текущим днем и месяцем, в курсор с именем mycursor и просто печатает их с помощью оператора SELECT.
Заключение
Обратные ссылки
Нет обратных ссылок
Комментарии
Показывать комментарии Как список | Древовидной структурой
Курсоры в хранимых процедурах MySQL
После предыдущей статьи о хранимых процедурах, я получил целый ряд комментариев. В одном из них читатель попросил меня уделить больше внимания курсорам, одному из важных элементов хранимых процедур.
Так как курсоры являются частью хранимой процедуры, то в этой статье мы еще детальнее рассмотрим ХП. В частности, как извлечь из ХП набор данных.
Что такое курсор?
С помощью курсора мы можем перебрать набор данных и обработать каждую запись в соответствии с определенными задачами.
Такая операция по обработке записи может быть также исполнена на PHP-уровне, что значительно уменьшает объем передаваемых на PHP-уровень данных, так как мы можем просто вернуть обработанный сводный / статистический результат обратно (тем самым устраняя процесс обработки select – foreach на стороне клиента).
Поскольку курсор реализуется в хранимой процедуре, он имеет все преимущества (и недостатки), присущие ХП (контроль доступа, пре-компиляция, трудность отладки и т.д.)
Пример практического применения
Структура таблицы этой страницы довольно проста:
Рис 1. Структура таблицы результатов игр Лейкерс
Я заполняю эту таблицу с 2008 года. Некоторые из последних записей с результатами игр Лейкерс в сезоне 2013-14 приведены ниже:
Рис. 2. Данные таблицы результатов игр Лейкерс (частичные) в сезоне 2013-2014
(Я использую MySQL Workbench в качестве GUI-инструмента для управления базой данных MySQL. Вы можете использовать другой инструмент по своему выбору).
Что ж, должен признать, что баскетболисты Лейкерс в последнее время играют не очень здорово. 6 поражений подряд по состоянию на 15 января. Я определил эти « 6 поражений подряд », посчитав вручную, сколько матчей подряд, начиная с текущей даты (и вниз к более ранним играм) имеют в колонке winlose значение « L » (поражение).
Это, конечно, не невыполнимая задача, однако если условия усложнятся, и таблица данных будет намного больше, то это займет больше времени, и вероятность ошибки также увеличивается.
Можем ли мы сделать то же самое с помощью одного оператора SQL? Я не являюсь экспертом SQL, потому не смог придумать, как достичь нужного результата (« 6 поражений подряд ») через один оператор SQL. Мнения гуру будут для меня очень ценными — оставьте их в комментариях ниже.
Можем ли мы сделать это через PHP? Да, конечно. Мы можем получить данные по играм (конкретно, столбец winlos ) этого сезона и перебрать записи для вычисления длительности текущей серии побед / поражений подряд.
Но чтобы сделать это, нам придется охватить все данные за этот год и большая часть данных будет для нас бесполезна (не слишком вероятно, что какая-то команда будет иметь серию длиннее, чем 20+ игр подряд в регулярном сезоне, который состоит из 82 матчей).
Тем не менее, мы не знаем наверняка, сколько записей должно быть извлечено в PHP для определения серии. Так что нам не обойтись без напрасного извлечения ненужных данных. И, наконец, если текущее количество выигрышей /поражений подряд это единственное, что мы хотим узнать из этой таблицы, зачем нам тогда извлекать все строки данных?
Можем ли мы сделать это другим способом? Да, это возможно. Например, мы можем создать резервную таблицу, специально предназначенную для хранения текущего значения количества побед /поражений подряд.
Добавление каждой новой записи будет автоматически обновлять и эту таблицу. Но это слишком громоздкий и чреватый ошибками способ.
Так как же можно сделать это лучше?
Использование курсора в хранимой процедуре
Как вы могли догадаться из названия нынешней статьи, лучшей альтернативой (на мой взгляд) для решения этой проблемы является использование курсора в хранимой процедуре.
Давайте создадим в MySQL Workbench первую ХП:
В этой ХП у нас есть один входящий параметр и два исходящих. Это определяет подпись ХП.
В теле ХП мы также объявили несколько локальных переменных для серии результатов (выигрышей или проигрышей, current_win ), текущей серии и текущего статуса выигрыш /проигрыш конкретного матча:
Эта строка является объявлением курсора. Мы объявили курсор с именем cur и набор данных, связанных с этим курсором, который является статусом победа /поражение для тех матчей (значение столбца winlose может быть либо « W », либо « L », но не пустое) в конкретном году, которые упорядочены по идентификатору id (последние сыгранные игры будут иметь более высокий ID) в порядке убывания.
Хотя это не видно наглядно, но мы можем себе представить, что этот набор данных будет содержать последовательность значений « L » и « W ». На основании данных, приведенных на рисунке 2, она должна быть следующей: « LLLLLLWLL… » (6 значений « L », 1 « W » и т.д.)
Для расчета количества побед / поражений подряд мы начинаем с последнего (и первого в приведенном наборе данных) матча. Когда курсор открыт, он всегда начинается с первой записи в соответствующем наборе данных.
После того, как первые данные загружены, курсор перемещается к следующей записи. Таким образом, поведение курсора похоже на очередь, перебирающую набор данных по системе FIFO (First In First Out). Это именно то, что нам нужно.
После получения текущего статуса победа / поражение и количества последовательных одинаковых элементов в наборе, мы продолжаем обрабатывать по циклу (перебирать) оставшуюся часть набора данных. В каждой итерации цикла курсор будет « переходить » на следующую запись, пока мы не разорвем цикл или пока все записи не будут перебраны.
Если статус следующей записи такой же, как у текущего последовательного набора побед / поражений, это означает, что серия продолжается, тогда мы увеличиваем количество последовательных побед (или поражений) еще на 1 и продолжаем перебирать данные.
Если статус отличается, это означает, что серия прервана, и мы можем остановить цикл. Наконец, мы закрываем курсор и оставляем исходные данные. После этого выводится результат.
Далее мы можем повысить контроль доступа ХП, как это описано в моей предыдущей статье.
Чтобы проверить работу этой ХП, мы можем написать короткий PHP-скрипт:
Результат обработки должен выглядеть приблизительно так, как показано на следующем рисунке:
(Этот результат основан на данных по играм « Лейкерс » по состоянию на 15 января 2014 года).
Вывод набора данных из хранимой процедуры
Несколько раз по ходу этой статьи разговор касался того, как вывести набор данных из ХП, которая составляет набор данных из результатов обработки нескольких последовательных вызовов другой ХП.
Пользователь может захотеть получить с помощью ранее созданной нами ХП больше информации, чем просто непрерывная серия побед / поражений за год; например мы можем сформировать таблицу, в которой будут выводиться серии побед /поражений за разные годы:
(В принципе, более полезной информацией будет длительность самой длинной серии побед или поражений в определенном сезоне. Для решения этой задачи можно легко расширить описанную ХП, поэтому я оставлю эту задачу тем читателям, кому это будет интересно. В рамках текущей статьи мы продолжим обработку текущей серии побед / поражений).
Хранимые процедуры MySQL могут возвращать только скалярные значения (целое число, строку, и т.д.), в отличие от операторов select … from … (результаты преобразуются в набор данных). Проблема в том, что таблица, в которой мы хотим получить результаты, в существующей структуре базы данных не существует, она составляется из результатов обработки хранимой процедуры.
Для решения этой проблемы нам нужна временная таблица или, если это возможно и необходимо, резервная таблица. Давайте посмотрим, как мы можем решить имеющуюся задачу с помощью временной таблицы.
Сначала мы создадим вторую ХП, код которой показан ниже:
Несколько существенных замечаний к приведенному выше коду:
Чтобы получить результаты, мы создаем еще один небольшой PHP-скрипт, код которого показан ниже:
Выведенные на экран результаты будут выглядеть приблизительно следующим образом:
Обратите внимание, что приведенный выше способ немного отличается от вызова нашей первой ХП.
Вуаля! Мы сделали это!
Заключение
В этой статье мы продолжили изучение хранимых процедур MySQL и рассмотрели применение курсоров. Мы рассказали, как извлечь скалярные данные с помощью выходных параметров (определяемых как out var_name vartype в объявлении ХП), а также как выводить результативный набор данных через временную таблицу. По ходу данной статьи мы также коснулись различных вариантов применения операторов в хранимых процедурах.
Не стесняйтесь оставлять комментарии, пишите, что вы думаете по этому поводу!
Введение в процедуры и курсоры в SQL
Дата публикации Nov 17, 2018
Узнайте, как писать процедуры и курсоры дляRDBMS,
Если вы хотите больше узнать о SQL с точки зрения Data Science, вы можете воспользоваться бесплатной программой DataCamp.«Введение в SQL для науки о данных»курс.
Как специалист по данным, очень важно знать SQL и связанные с ним методы. Для того, чтобы иметь возможность запрашивать СУБД и получать ответы на конкретные вопросы о данных, с которыми вы будете иметь дело, SQL является минимальной необходимостью.
В своем последнем видео с DataCamp,Дэвид Робинсон(Главный специалист по данным @ DataCamp)показал нам, как он использует SQL в задаче Data Science, Пожалуйста, проверьте это, его рабочий процесс очень интересен.
В этом уроке вы узнаете:
Звучит увлекательно? Давайте начнем.
Что такое процедура в СУРБД?
Прежде чем приступить к процедурам и курсорам, вам нужно немного узнать о PL/SQL это язык с блочной структурой, который позволяет таким разработчикам, как вы, сочетать мощь SQL с процедурными выражениями. Но вы не будете учиться обычным способом, вы узнаете это по ходу дела и по мере необходимости.
Теперь вы увидите, как написать процедуру.
Написание процедуры:
Общий синтаксис написания процедуры выглядит следующим образом:
Обратите внимание, что эти синтаксисы применимы практически к любой СУБД, будь то Oracle, будь то PostgreSQL или MySQL.
После того, как вы создали процедуру, вам придется ее выполнить. Ниже приводится синтаксис для этого.
казнить SelectAllCustomers по:
Процедуры также могут быть автономными блоками операторов, что делает их независимыми от любых таблиц в отличие от предыдущей. В следующем примере создается простая процедура, которая отображает строку «Hello World!» В качестве вывода при выполнении.
Существует два способа выполнения отдельной процедуры.
Вышеуказанная процедура с именем «welcome» может быть вызвана с EXEC Ключевое слово как:
Теперь вы увидите следующий метод, то есть вызов процедуры из другого блока PL / SQL.
Процедура также может быть заменена. Вам просто нужно добавить REPLACE Ключевое слово при создании процедуры. Это заменит уже существующую процедуру (если), иначе создаст новую.
Удаление хранимой процедуры не составляет большого труда:
Процедуры могут отличаться в зависимости от параметров. Могут быть процедуры с одним параметром, а также процедуры с несколькими параметрами. Теперь вы будете изучать эти варианты.
Вы будете использовать ту же таблицу Customers за это. Для вашего удобства снимок приведен снова в следующем разделе.
Вы напишите хранимую процедуру, которая выбирает клиентов из определенного города из таблицы:
Давайте рассмотрим общие принципы здесь:
Процедура выполняется как:
Давайте посмотрим другой вариант сейчас.
Написание процедур снесколько параметровточно так же, как и предыдущий. Вам просто нужно добавить их.
Выполните процедуру как:
Разве вышеприведенные коды не очень удобочитаемы? Когда код читается, это веселее. Это все для процедур Теперь вы будете изучать курсоры.
Что такое курсор в РСУБД?
Курсоры могут быть двух типов:
Теперь вы увидите, как писать разные типы курсоров.
Написание курсоров:
Вы начнете с этого раздела, поняв, что такое неявные курсоры.
Неявные курсорысоздаются автоматически Oracle всякий раз, когда выполняется оператор SQL, когда для оператора не определен явный курсор. Программисты не могут контролировать неявные курсоры и информацию в них. Всякий раз, когда выдается оператор DML (язык манипулирования данными) (INSERT, UPDATE и DELETE), с этим оператором связывается неявный курсор. Для операций INSERT курсор содержит данные, которые необходимо вставить. Для операций UPDATE и DELETE курсор определяет строки, которые будут затронуты.
Вы можете ссылаться на самый последний неявный курсор как на курсор SQL, который всегда имеет такие атрибуты, как:
Следующее изображение кратко описывает эти атрибуты:
Давайте рассмотрим снимок базы данных, состоящей из таблицы под названием Employee :
Теперь вы напишите курсор, который увеличит зарплату на 1000 человек тех, чей возраст меньше 30 лет.
Давайте теперь рассмотрим то, что вы написали:
Большой! У тебя все хорошо!
Когда приведенный выше код выполняется в командной строке SQL, он дает следующий результат:
2 сотрудника обновлены (предположим, что есть 2 записи, где возраст
Теперь вы узнаете больше о каждом из этих шагов.
Объявление курсора:
Вы объявляете курсор вместе с SELECT заявление. Например:
Открытие курсора:
Когда вы открываете курсор, CPU выделяет память для курсора и делает его готовым для выборки строк, возвращаемых оператором SQL, который в него влечет. Например, мы откроем выше определенный курсор следующим образом:
Выбор курсора:
Извлечение курсора включает в себя доступ к одной строке за раз из связанной таблицы в SQL-коде, введенном для курсора.
Закрытие курсора:
Закрытие курсора означает освобождение выделенной памяти. Вы закроете выше открытый курсор как:
Теперь вы сложите все эти кусочки осмысленно.
Сборка этих частей:
Используя LOOP Вы перебрали курсор, извлекли записи и отобразили их. Вы также обработали случай, если курсор не нашел записи.
Когда код выполняется в командной строке SQL, он выдает:
Вывод:
Ниже приведены некоторые ссылки, которые были взяты для написания этого урока: