Выполняемая секция
Выполняемая секция начинается с ключевого слова BEGIN и заканчивается либо ключевым словом EXCEPTION, если присутствует секция исключений, либо ключевым словом END, за которым следуют необязательное имя функции или процедуры и точка с запятой. Выполняемая секция содержит один и более PL/SQL-операторов, выполняемых при передаче управления данному блоку. Структура выполняемой секции показана ниже.
BEGIN
один и более PL/SQL-операторов
END ;
|
1 |
BEGIN секцияисключений ENDимяфункцииилипроцедуры; |
В выполняемом коде PL/SQL чаще всего встречается оператор присваивания (:=). Он указывает, что нужно вычислить выражение справа и поместить результат в переменную слева.
Объявление переменных PL/SQL
При объявлении переменной PL/SQL выделяет память для значения переменной и присваивает этому хранилищу имя, используя которое вы сможете извлекать и изменять данное значение. В объявлении также указывается тип данных переменной, который будет использован для проверки корректности значений, присваиваемых переменной.
Для объявления используется следующая синтаксическая конструкция:
где имя — это имя объявляемой переменной или константы, а тип_данных — это тип или подтип значений, которые могут присваиваться этой переменной. Включение в объявление выражения NOT NULL означает, что если в коде будет предпринята попытка присвоения вашей переменной значения NULL, то Oracle инициирует исключение. Выражение позволяет инициализировать переменную; оно необязательно для всех объявлений, кроме объявлений констант.
Рассмотрим пример объявления переменных различных типов данных:
Для задания значения по умолчанию ключевое слово DEFAULT и оператор присваивания эквиваленты и взаимозаменяемы. Что же следует использовать? Я предпочитаю использовать оператор присваивания (:=) для указания значений по умолчанию для констант, а ключевое слово DEFAULT — для переменных. Для констант присваиваемое значение в действительности является не значением по умолчанию, а исходным (и неизменным) значением, поэтому использование DEFAULT кажется мне неуместным.
Название переменной
После var стоит название переменной («Фамилия») — своего рода название данных. Данных много, а их название разработчики придумывают сами. К примеру, мы можем назвать переменную для ключевых слов:
- keywords
- kluchevye_slova
- kwords
— как хочешь, так и записывай! В хороших скриптах названия обычно прописаны понятно. Это помогает пользователю сразу понять, какие данные тут используются.
Собственно, все данные, которые существуют, как-то названы. А существует их ооооочень много. Всё в вашем аккаунте Google Ads — это данные. Ставки, бюджет, ключи, заголовки объявлений, пути, ссылки на посадочные… — это всё данные. И все они — разные. Соответственно, если вы хотите что-то сделать с любыми из этих данных, вам нужно назвать, с какими из них вы хотите работать.
- var keywords — название переменной keywords, будем работать с ключами;
- var campaign — название переменной campaign, будем работать с кампаниями;
- var period — название переменной period, будем работать с каким-то периодом времени.
Название данных разработчик придумывает и прописывает сам. Здесь есть подвох: скрипты часто не работают (или работают некорректно) из-за ошибок в названиях. К примеру, в них важен регистр: переменные accountSelector и accountselector — это две разных переменных.
Если в начале скрипта стоит переменная accountSelector (наш первый пример про 50 аккаунтов с меткой, помните?), то скрипт соберет в эту строку аккаунты, которые подходят под условия. Если потом вы захотите, к примеру, чтобы скрипт изменил в них метки, нужно, чтобы скрипт снова обратился к строке accountSelector. Если написать эту задачу с переменной accountselector, задача не будет выполнена. Потому что переменной accountselector у вас в скрипте нет. А accountSelector — есть.
Повторим!
Переменная — это контейнер, в котором хранятся данные. Строка с переменной начинается с var. У переменной есть название («Фамилия») и значение («Иванов»). К переменным можно применять условия (название метки содержит) и лимиты на сбор данных (50 штук). Самый быстрый способ понять, какие данные использует скрипт, просмотреть строки с var.
Идем дальше!
Шпаргалка по SQL*Plus
SQL*Plus — программа для работы с СУБД Oracle посредством командной строки. Используя SQL*Plus можно выполнять команды SQL и PL/SQL в интерактивном режиме или используя сценарий.
Основное преимущество SLQ*Plus — доступность, т.к. инструмент доступен практически всегда, когда в системе установлен Oracle. При этом это достаточно мощный инструмент, используя который можно
решать различные задачи на удаленных машинах.
К написанию этой статьи меня подтолкнула книга «Oracle SQL*Plus: The Definitive Guide, 2nd Edition», написанная Jonathan
Gennick. Как обычно, появилось желание систематизировать информацию и представить ее в удобном виде.
При этом сразу считаю нужным оговориться, что я использую SQLplus для написания и выполнения скриптов на удаленных машинах, в этой статье описываю именно используемые для этого команды.
Область возможного использования SQLplus при этом гораздо шире, например — построение отчетов, в том числе в формате HTML.
Придумывайте правильные (корректные) имена
В разговоре о переменных необходимо упомянуть, что есть ещё одна чрезвычайно важная вещь.
Название переменной должно иметь ясный и понятный смысл, говорить о том, какие данные в ней хранятся.
Именование переменных – это один из самых важных и сложных навыков в программировании. Быстрый взгляд на имена переменных может показать, какой код был написан новичком, а какой – опытным разработчиком.
В реальном проекте большая часть времени тратится на изменение и расширение существующей кодовой базы, а не на написание чего-то совершенно нового с нуля. Когда мы возвращаемся к коду после какого-то промежутка времени, гораздо легче найти информацию, которая хорошо размечена. Или, другими словами, когда переменные имеют хорошие имена.
Пожалуйста, потратьте время на обдумывание правильного имени переменной перед её объявлением. Делайте так, и будете вознаграждены.
Несколько хороших правил:
- Используйте легко читаемые имена, такие как или .
- Избегайте использования аббревиатур или коротких имён, таких как , , , за исключением тех случаев, когда вы точно знаете, что так нужно.
- Делайте имена максимально описательными и лаконичными. Примеры плохих имён: и . Такие имена ничего не говорят. Их можно использовать только в том случае, если из контекста кода очевидно, какие данные хранит переменная.
- Договоритесь с вашей командой об используемых терминах. Если посетитель сайта называется «user», тогда мы должны называть связанные с ним переменные или , а не, к примеру, или .
Звучит просто? Действительно, это так, но на практике для создания описательных и кратких имён переменных зачастую требуется подумать. Действуйте.
Повторно использовать или создавать новую переменную?
И последняя заметка. Есть ленивые программисты, которые вместо объявления новых переменных повторно используют существующие.
В результате их переменные похожи на коробки, в которые люди бросают разные предметы, не меняя на них этикетки. Что сейчас находится внутри коробки? Кто знает? Нам необходимо подойти поближе и проверить.
Такие программисты немного экономят на объявлении переменных, но теряют в десять раз больше при отладке.
Дополнительная переменная – это добро, а не зло.
Современные JavaScript-минификаторы и браузеры оптимизируют код достаточно хорошо, поэтому он не создаёт проблем с производительностью. Использование разных переменных для разных значений может даже помочь движку оптимизировать ваш код.
Функции
Мы написали скрипт. Он делает много разных вещей: выгружает все кампании, показывает количество групп в кампании, количество объявлений в группе, проверяет наличие модификаторов… А потом создает новую папку на Google Диске, создает новую Google Таблицу и в ней выводит все собранные данные. Это, кстати, .
Как видите, довольно много задач. Одна задача — это как минимум пара строчек кода. К примеру, есть задача — получить Google Таблицу по URL от пользователя. Если пользователь не дал URL, тогда скрипт должен создать Google Таблицу. Вот код, который ее выполняет:
А теперь представьте, сколько строк занимает код всего скрипта. Подскажем: 566 строк. Неплохо, да? А теперь представьте, каково управлять 566 строками… Уууу…
Проведем аналогию с РРС. Когда вы настраиваете рекламу в Google Покупках, вы не запихиваете все товары в одну группу, правда? Обычно вы как-то разделяете товары, к примеру, по кампаниям. Кампания «Штаны», кампания «Футболки», кампания «Носки». Элементами проще управлять, когда они как-то гранулированы. Разделяй и властвуй!
Или, к примеру, текст. Одно дело — полотно текста без подзаголовков, сплошные абзацы. Другое дело — текст с понятными разделами: вот тут говорим про переменные, вот тут — названия, вот тут — типы.
С кодом то же самое. Чтобы поделить код на какие то понятные и завершенные блоки, используют функции. Функция — это способ показать, что весь код в ней связан, в идеале — что он делает одно действие.
Чтобы обозначить функцию, строку начинают с function:
Функция — это готовый кусок кода, который можно использовать повторно. К примеру, разработчик может один раз написать код для исключения ключей. В первый раз он прописывает код полностью. Если дальше в коде снова нужно исключить ключи, он не пишет такой же код еще раз, а просто вызывает функцию, которую написал раньше.
То есть можно каждый раз в скрипте набирать одинаковый код. А можно написать его раз, «завернуть» в функцию и в следующий раз сразу вызвать функцию.
Основная задача функции для разработчика — избавить от необходимости дублировать код, чтобы не раздувать скрипт до 100500 строк.
Чтобы вызвать функцию, которая создана где-то в другой части кода, пишут ее название и скобки ():
А вот весь код, который входит в функцию, записан ниже. Он начинается со слова function и уже дальше идет название, по которому можно вызвать функцию в другом месте:
Кстати, весь скрипт — это ведь тоже готовый кусок кода, так? Чтобы показать это, весь скрипт от начала и до конца «заворачивается» в функцию. Она называется main — главная. То есть каждая функциональная часть скрипта начинается с таких строк:
Секция объявлений
Секция объявлений не является обязательной. В случае использования она начинается после секции заголовка и оканчивается перед ключевым, словом BEGIN. Эта секция содержит объявления переменных, констант, курсоров, исключений, функций и процедур PL/SQL, которые будут использоваться в выполняемой секции и секции исключений. Все объявления переменных и констант должны размещаться до объявлений функций или процедур. О переменных и константах PL/SQL будет подробно рассказано в следующем разделе. Объявление сообщает PL/SQL о том, что нужно создать переменную, константу, курсор, функцию или процедуру согласно приведенной спецификации. Когда выполнение базового блока завершается, все элементы, объявленные в секции объявлений, перестают существовать. Элементы, объявленные в секции объявлений базового блока, могут использоваться только в пределах этого блока. Одним словом, все, что находится в секции объявлений, при надлежит блоку и может использоваться только внутри него, а следовательно, существует только на протяжении его времени жизни. Часть кода, в которой может использоваться переменная, называется областью видимости (scope).
Триггеры
Триггер — это процедура PL/SQL, которая выполняется автоматически, когда происходит некоторое заданное событие, называемое триггерным событием (triggering event).
Например, можно писать триггеры, срабатывающие при выполнении над таблицей операций INSERT, UPDATE или DELETE; при выдаче команд DDL; при входе пользователя в систему или его выходе из системы; при запуске или останове базы данных; при возникновении ошибок.Между триггерами и процедурами PL/SQL есть три различия:
- Триггеры нельзя вызывать из кода программы. Oracle вызывает их автоматически в ответ на определенное событие.
- Триггеры не имеют списка параметров.
- Спецификация триггера немного отличается от спецификации процедуры.
Переменные (ключевые слова var, let и const)
Переменная – это именованный участок памяти для хранения данных.
Представить себе переменную можно как некоторую область памяти, в которую вы можете как записать некоторую информацию, так и прочитать её из неё. Доступ к этому месту в памяти выполняется по имени, которое вы установили переменной при её создании.
Данные, хранящиеся в переменной, называются её значением.
В процессе выполнения программы значения переменной могут меняться. Но в определённый момент времени переменная всегда имеет какое-то одно значение.
В JavaScript до ES6 (ECMAScript 2015) объявление (создание) переменных осуществлялось с использованием только ключевого слова .
// объеявление переменной message (message - это имя переменной) var message;
При создании переменной ей сразу же можно присвоить некоторое значение. Эту операцию называют инициализацией переменной.
Присвоение переменной значения выполняется через оператор .
// например, создадим переменную email и присвоим ей в качестве значения строку "[email protected]" var email = '[email protected]'; // установим переменной email новое значение email = '[email protected]';
Для того чтобы получить значение переменной к ней нужно просто обратиться по имени.
// например, выведем в консоль браузера значение переменной email console.log(email);
Переменная, которая объявлена без инициализации имеет по умолчанию значение .
var phone; // например, выведем в консоль браузера значение переменной phone console.log(phone); // undefined
Для того чтобы объявить не одну, а сразу несколько переменных с помощью одного ключевого слова , их необходимо просто отделить друг от друга с помощью запятой.
// например, объявим с помощью одного ключевого слова var сразу три переменные, и двум из них сразу присвоим значения var price = 78.55, quantity = 10, message;
Объявление переменных с помощью let и const
Сейчас ключевое слово практически не используется, вместо него новый стандарт (ES6) рекомендует использовать и .
В чем отличия от ?
1. Переменная объявленная посредством имеет область видимости, ограниченную блоком. Т.е. она видна только внутри фигурных скобок, в которых она создана, а также в любых других скобках, вложенных в эти. Вне них она не существует.
{
let name = 'John';
console.log(name); // "John"
{
console.log(name); // "John"
}
}
console.log(name); // Uncaught ReferenceError: name is not defined
Переменная, объявленная через ключевое слово имеет функциональную область видимости. Т.е. она ограничена только пределами функции.
Такая переменная будет видна за пределами блока, в котором она создана.
{
var name = 'John';
console.log(name); // "John"
{
console.log(name); // "John"
}
}
console.log(name); // "John"
2. Переменные, созданные с помощью не поднимаются к началу текущего контекста, т.е. hoisting для них не выполняется. Другими словами, к такой переменной нельзя обратиться до её объявления.
age = 10; // ReferenceError: Cannot access 'age' before initialization let age = 28;
Переменные, созданные с помощью поднимаются к началу текущего контекста. Это означает что к таким переменным вы можете обратиться до их объявления.
age = 10; var age = 28;
Константы (const)
Мы разобрали отличия от . А что же насчёт ? Переменные, созданные с помощью ведут себя также как с . Единственное отличие между ними заключается в том, что непосредственное значение переменной созданной через вы не можете изменить. Таким образом, – это ключевое слово, предназначенное для создания своего рода констант.
const COLOR_RED = '#ff0000';
Именование констант рекомендуется выполнять прописными буквами. Если константа состоит из несколько слов, то их между собой желательно отделять с помощью нижнего подчёркивания.
При попытке изменить значение константы вам будет брошена ошибка.
const COLOR_RED = '#ff0000'; COLOR_RED = '#f44336'; // Uncaught TypeError: Assignment to constant variable.
Когда переменной вы присваиваете значение, имеющее объектный тип данных, в ней уже будет храниться не сам этот объект, а ссылка на него. Это необходимо учитвать при работе с переменными в JavaScipt.
В этом случае когда вы константе присваиваете некий объект, то вы не можете изменить ссылку, хранящуюся в самой константе. Но сам объект доступен для изменения.
const COLORS = ;
// присвоить другой объект или значение константе нельзя
COLORS = []; // Uncaught TypeError: Assignment to constant variable.
COLORS = { red: '#ff0000', green: '#00ff00', blue: '#00ff00' }; // Uncaught TypeError: Assignment to constant variable.
COLORS = '#00ff00'; // Uncaught TypeError: Assignment to constant variable
// но имзменить сам объект можно
COLORS.push('#4caf50');
console.log(COLORS); //
Массив
Массив — это упорядоченный набор данных, его используют для хранения данных одного типа. К примеру, нам нужно собрать вместе три ID кампаний, чтобы потом делать с этими кампаниями одинаковые действия. Мы соберем их в массив такого вида:
Тут используются данные одного типа — числового, number. И все они собран в один набор — массив.
Вот как можно использовать массив:
То есть в этой переменной скрипт соберет ключевые слова из группы объявлений. Чтобы собрать данные не из всех групп, а только из определенных, мы используем селектор .withIds (тот же принцип, что и withCondition, который мы упоминали на старте). Чтобы указать, какие конкретно ID нужны, мы обращаемся к массиву с названием ids:
.withIds(ids)
Это название отсылает скрипт к строчке, где прописан массив (var ids = ;).
Объявление переменной PL/SQL
Когда вы объявляете переменную, PL/SQL выделяет память для хранения ее значения и присваивает выделенной области памяти имя, по которому это значение можно извлекать и изменять. В объявлении также задается тип данных переменной; он используется для проверки присваиваемых ей значений. Базовый синтаксис объявления переменной или константы:
имя тип_данных ;
Здесь имя — имя переменной или константы, — тип или подтип данных PL/SQL, определяющий, какие значения могут присваиваться переменной. При желании можно включить в объявление выражение ; если такой переменной не присвоено значение, то база данных инициирует исключение. Секция значение_по_умолчанию инициализирует переменную начальным значением; ее присутствие обязательно только при объявлении констант. Если переменная объявляется с условием , то при объявлении ей должно быть присвоено начальное значение.
Примеры объявления переменных разных типов:
Конструкция (см. в приведенном примере) и конструкция с оператором присваивания ( в приведенном примере) эквивалентны и взаимозаменяемы. Какой из двух вариантов использовать? Мы предпочитаем для констант использовать оператор присваивания (:=), а для инициализации переменных — ключевое слово . При объявлении константы задается не значение по умолчанию, а значение, которое не может быть изменено впоследствии, поэтому кажется неуместным.
Команда EXECUTE в T-SQL
EXECUTE (сокращенно EXEC) – команда для запуска хранимых процедур и SQL инструкций в виде текстовых строк.
Перед тем как переходить к примерам, следует отметить, что использование динамического кода с использованием команды EXEC – это не безопасно! Дело в том, что для того чтобы сформировать динамическую SQL инструкцию, необходимо использовать переменные для динамически изменяющихся значений. Так вот, если эти значения будут приходить от клиентского приложения, т.е. от пользователя, злоумышленники могут передать и, соответственно, внедрить в нашу инструкцию вредоносный код в виде текста, а мы его просто исполним в БД, думая, что нам передали обычные параметры. Поэтому все такие значения следует очень хорошо проверять, перед тем как подставлять в инструкцию.
Пример использования EXEC в T-SQL
Сейчас мы с Вами сформируем динамический SQL запрос, текст которого мы сохраним в переменной, и затем выполним его с помощью команды EXEC.
Текст запроса будет храниться в переменной @SQL_QUERY, в переменной @Var1 будет храниться значение, которое мы будем подставлять в наш запрос, для того чтобы этот запрос стал динамическим (в нашем случае мы вручную присвоим статическое значение в переменную, хотя это значение можно узнавать, например, с помощью запроса или каких-то вычислений).
Для формирования строки мы будет использовать конкатенацию строк, а именно оператор + (плюс), только стоит понимать, что в этом случае выражения, участвующие в операции, должны иметь текстовый тип данных. Переменная @Var1 у нас будет иметь тип данных INT, поэтому, чтобы соединить ее со строкой, мы предварительно преобразуем ее значение к типу данных VARCHAR.
Для наглядности того, какой именно SQL запрос у нас получился, мы просто посмотрим, что у нас хранится в переменной @SQL_QUERY инструкцией SELECT.
--Объявляем переменные DECLARE @SQL_QUERY VARCHAR(200), @Var1 INT; --Присваиваем значение переменным SET @Var1 = 1; --Формируем SQL инструкцию SET @SQL_QUERY = 'SELECT * FROM TestTable WHERE ProductID = ' + CAST(@Var1 AS VARCHAR(10)); --Смотрим на итоговую строку SELECT @SQL_QUERY AS --Выполняем текстовую строку как SQL инструкцию EXEC (@SQL_QUERY)
Примеры:
Некоторые примеры динамического SQL
Oracle PL/SQL
DECLARE
sql_stmt VARCHAR2(200);
plsql_block VARCHAR2(500);
emp_id NUMBER(4) := 7566;
salary NUMBER(7,2);
dept_id NUMBER(2) := 50;
dept_name VARCHAR2(14) := ‘PERSONNEL’;
location VARCHAR2(13) := ‘DALLAS’;
emp_rec emp%ROWTYPE;
BEGIN
—EXECUTE IMMEDIATE c SQL предложением
EXECUTE IMMEDIATE ‘CREATE TABLE bonus (id NUMBER, amt NUMBER)’;
—присвоим sql_stmt строковое SQL предложение с заполнителями :1, :2, :3
sql_stmt := ‘INSERT INTO dept VALUES (:1, :2, :3)’;
—запустим EXECUTE IMMEDIATE с sql_stmt используя аргументы связывания dept_id, dept_name, location
EXECUTE IMMEDIATE sql_stmt USING dept_id, dept_name, location;
—присвоим sql_stmt SQL предложение с заполнителем :id
sql_stmt := ‘SELECT * FROM emp WHERE empno = :id’;
—запустим EXECUTE IMMEDIATE с sql_stmt используя аргумент связывания emp_id и сохраним результат в emp_rec
EXECUTE IMMEDIATE sql_stmt INTO emp_rec USING emp_id;
—присвоим plsql_block запуск анонимного блока с подпрограммой raise_salary пакета emp_pkg с заполнителями :id, :amt
plsql_block := ‘BEGIN emp_pkg.raise_salary(:id, :amt); END;’;
—запустим EXECUTE IMMEDIATE с plsql_block используя аргументы связывания :id, :amt
EXECUTE IMMEDIATE plsql_block USING 7788, 500;
—присвоим sql_stmt SQL предложение с заполнителем :1, :2
sql_stmt := ‘UPDATE emp SET sal = 2000 WHERE empno = :1 RETURNING sal INTO :2′;
—запустим EXECUTE IMMEDIATE с sql_stmt используя аргументы связывания emp_id, salary
EXECUTE IMMEDIATE sql_stmt USING emp_id RETURNING INTO salary;
—EXECUTE IMMEDIATE c SQL предложение с заполнителем :num и аргументом связывания dept_id
EXECUTE IMMEDIATE ‘DELETE FROM dept WHERE deptno = :num’ USING dept_id;
—EXECUTE IMMEDIATE c SQL предложением
EXECUTE IMMEDIATE ‘ALTER SESSION SET SQL_TRACE TRUE’;
END;
|
1 |
DECLARE sql_stmtVARCHAR2(200); plsql_blockVARCHAR2(500); emp_idNUMBER(4):=7566; salaryNUMBER(7,2); dept_idNUMBER(2):=50; dept_nameVARCHAR2(14):=’PERSONNEL’; locationVARCHAR2(13):=’DALLAS’; emp_recemp%ROWTYPE; EXECUTEIMMEDIATE’CREATE TABLE bonus (id NUMBER, amt NUMBER)’; sql_stmt:=’INSERT INTO dept VALUES (:1, :2, :3)’; EXECUTEIMMEDIATEsql_stmtUSINGdept_id,dept_name,location; sql_stmt:=’SELECT * FROM emp WHERE empno = :id’; EXECUTEIMMEDIATEsql_stmtINTOemp_recUSINGemp_id; plsql_block:=’BEGIN emp_pkg.raise_salary(:id, :amt); END;’; EXECUTEIMMEDIATEplsql_blockUSING7788,500; sql_stmt:=’UPDATE emp SET sal = 2000 WHERE empno = :1 RETURNING sal INTO :2′; EXECUTEIMMEDIATEsql_stmtUSINGemp_idRETURNINGINTOsalary; EXECUTEIMMEDIATE’DELETE FROM dept WHERE deptno = :num’USINGdept_id; EXECUTEIMMEDIATE’ALTER SESSION SET SQL_TRACE TRUE’; END; |
Пример процедуры динамического SQL, которая принимает имя таблицы и предложение WHERE
В этом примере автономная процедура принимает имя таблицы базы данных и необязательное условие предложения WHERE. Если вы пропустите условие, процедура удалит все строки из таблицы. В противном случае процедура удаляет только те строки, которые соответствуют условию.
Oracle PL/SQL
CREATE OR REPLACE PROCEDURE delete_rows (
table_name IN VARCHAR2,
condition IN VARCHAR2 DEFAULT NULL) AS
where_clause VARCHAR2(100) := ‘ WHERE ‘ || condition;
BEGIN
IF condition IS NULL THEN where_clause := NULL; END IF;
EXECUTE IMMEDIATE ‘DELETE FROM ‘ || table_name || where_clause;
END;
|
1 |
CREATEORREPLACEPROCEDUREdelete_rows( table_nameINVARCHAR2, conditionINVARCHAR2DEFAULTNULL)AS
where_clauseVARCHAR2(100):=’ WHERE ‘||condition; IFconditionISNULLTHENwhere_clause:=NULL;ENDIF; EXECUTEIMMEDIATE’DELETE FROM ‘||table_name||where_clause; END; |
Преимущества объявлений с привязкой
Во всех объявлениях тип переменной (символьный, числовой, логический и т. д.) задается явно. В каждом объявлении непосредственно указывается тип данных и, как правило, ограничение, налагаемое назначение этого типа. Это распространенный подход к объявлению переменных, но в некоторых ситуациях он может вызвать проблемы.
- Синхронизация со столбцами базы данных. часто «представляет» информацию из таблицы базы данных. Если явно объявить переменную, а затем изменить структуру таблицы, это может привести к нарушению работы программы.
- Нормализация локальных переменных. Допустим, переменная PL/SQL хранит вычисляемые значения, которые используются в разных местах приложения. К каким последствиям может привести повторение (жесткое кодирование) одних и тех же типов данных и ограничений во всех объявлениях?
Использование Bulk (множественного) SQL в динамическом SQL
SQL Bulk связывает целые коллекции, а не только отдельные элементы. Этот метод повышает производительность за счет минимизации количества переключений контекста между механизмами PL/SQL и SQL. Вы можете использовать один оператор вместо цикла, который выдает оператор SQL на каждой итерации.
Используя следующие команды, предложения и атрибут курсора, ваши приложения могут создавать объемные операторы SQL, а затем выполнять их динамически во время выполнения:
- BULK FETCH предложение
- BULK EXECUTE IMMEDIATE предложение
- FORALL предложение
- COLLECT INTO выражение
- RETURNING INTO выражение
- %BULK_ROWCOUNT атрибут курсора
Аналогия из жизни
Мы легко поймём концепцию «переменной», если представим её в виде «коробки» для данных с уникальным названием на ней.
Например, переменную можно представить как коробку с названием и значением внутри:
Мы можем положить любое значение в коробку.
Мы также можем изменить его столько раз, сколько захотим:
let message;
message = ‘Hello!’;
message = ‘World!’; // значение изменено
alert(message);
При изменении значения старые данные удаляются из переменной:
Мы также можем объявить две переменные и скопировать данные из одной в другую.
let hello = ‘Hello world!’;
let message;
// копируем значение ‘Hello world’ из переменной hello в переменную message
message = hello;
// теперь две переменные содержат одинаковые данные
alert(hello); // Hello world!
alert(message); // Hello world!
Повторное объявление вызывает ошибку
Переменная может быть объявлена только один раз.
Повторное объявление той же переменной является ошибкой:
let message = «Это»;
// повторение ключевого слова ‘let’ приводит к ошибке
let message = «Другое»; // SyntaxError: ‘message’ has already been declared
Поэтому следует объявлять переменную только один раз и затем использовать её уже без .
Функциональные языки программирования
В таких языках однажды сохранённое «в коробку» значение остаётся там навсегда. Если нам нужно сохранить что-то другое, язык заставляет нас создать новую коробку (объявить новую переменную). Мы не можем использовать старую переменную.
Хотя на первый взгляд это может показаться немного странным, эти языки вполне подходят для серьёзной разработки. Более того, есть такая область, как параллельные вычисления, где это ограничение даёт определённые преимущества. Изучение такого языка (даже если вы не планируете использовать его в ближайшее время) рекомендуется для расширения кругозора.
Объявление констант PL/SQL
Синтаксис объявления константы имеет следующий вид:
имя_переменной тип_данных CONSTANT := выражение;
| 1 | имя_переменнойтип_данныхCONSTANT=выражение; |
В отличие от переменных константам обязательно присваивается значение, которое нельзя изменять на протяжении времени жизни константы. Константы очень полезны для поддержания безопасности и дисциплины при разработке больших и сложных приложений. Например, если вы хотите гарантировать, что процедура PL/SQL не будет модифицировать передаваемые ей данные, можете объявить их константами. Если процедура все же попытается их модифицировать, PL/SQL возбудит исключение.
Придумывайте правильные имена
В разговоре о переменных необходимо упомянуть, что есть ещё одна чрезвычайно важная вещь.
Название переменной должно иметь ясный и понятный смысл, говорить о том, какие данные в ней хранятся.
Именование переменных – это один из самых важных и сложных навыков в программировании. Быстрый взгляд на имена переменных может показать, какой код был написан новичком, а какой – опытным разработчиком.
В реальном проекте большая часть времени тратится на изменение и расширение существующей кодовой базы, а не на написание чего-то совершенно нового с нуля. Когда мы возвращаемся к коду после какого-то промежутка времени, гораздо легче найти информацию, которая хорошо размечена. Или, другими словами, когда переменные имеют хорошие имена.
Пожалуйста, потратьте время на обдумывание правильного имени переменной перед её объявлением. Делайте так, и будете вознаграждены.
Несколько хороших правил:
- Используйте легко читаемые имена, такие как или .
- Избегайте использования аббревиатур или коротких имён, таких как , , , за исключением тех случаев, когда вы точно знаете, что так нужно.
- Делайте имена максимально описательными и лаконичными. Примеры плохих имён: и . Такие имена ничего не говорят. Их можно использовать только в том случае, если из контекста кода очевидно, какие данные хранит переменная.
- Договоритесь с вашей командой об используемых терминах. Если посетитель сайта называется «user», тогда мы должны называть связанные с ним переменные или , а не, к примеру, или .
Звучит просто? Действительно, это так, но на практике для создания описательных и кратких имён переменных зачастую требуется подумать. Действуйте.
Повторно использовать или создавать новую переменную?
И последняя заметка. Есть ленивые программисты, которые вместо объявления новых переменных повторно используют существующие.
В результате их переменные похожи на коробки, в которые люди бросают разные предметы, не меняя на них этикетки. Что сейчас находится внутри коробки? Кто знает? Нам необходимо подойти поближе и проверить.
Такие программисты немного экономят на объявлении переменных, но теряют в десять раз больше при отладке.
Дополнительная переменная – это добро, а не зло.
Современные JavaScript-минификаторы и браузеры оптимизируют код достаточно хорошо, поэтому он не создаёт проблем с производительностью. Использование разных переменных для разных значений может даже помочь движку оптимизировать ваш код.
