Declare sql описание: PostgreSQL : Документация: 9.5: DECLARE : Компания Postgres Professional

Содержание

PostgreSQL : Документация: 9.5: DECLARE : Компания Postgres Professional

RU

EN

RU EN

DECLARE

DECLARE — определить курсор

Синтаксис

DECLARE имя [ BINARY ] [ INSENSITIVE ] [ [ NO ] SCROLL ]
    CURSOR [ { WITH | WITHOUT } HOLD ] FOR запрос

Описание

Оператор DECLARE позволяет пользователю создавать курсоры, с помощью которых можно выбирать по очереди некоторое количество строк из результата большого запроса. Когда курсор создан, через него можно получать строки, применяя команду FETCH.

Примечание

На этой странице описывается применение курсоров на уровне команд SQL. Если вы попытаетесь использовать курсоры внутри функции PL/pgSQL, правила будут другими — см. Раздел 40.7.

Параметры

имя: Имя создаваемого курсора.
BINARY: Курсор с таким свойством возвращает данные в двоичном, а не текстовом формате.
INSENSITIVE: Указывает, что данные, считываемые из курсора, не должны зависеть от изменений, которые могут происходить в нижележащих таблицах после создания курсора. В PostgreSQL это поведение подразумевается по умолчанию, так что это ключевое слово ни на что не влияет и принимается только для совместимости со стандартом SQL.
SCROLL NO SCROLL: Указание SCROLL определяет, что курсор может прокручивать набор данных и получать строки непоследовательно (например, в обратном порядке). В зависимости от сложности плана запроса указание SCROLL может отрицательно отразиться на скорости выполнения запроса. Указание NO SCROLL, напротив, определяет, что через курсор нельзя будет получать строки в произвольном порядке. По умолчанию прокрутка в некоторых случаях разрешается; но это не равнозначно эффекту указания SCROLL. За подробностями обратитесь к Замечания.
WITH HOLD WITHOUT HOLD: Указание WITH HOLD определяет, что курсор можно продолжать использовать после успешной фиксации создавшей его транзакции. WITHOUT HOLD определяет, что курсор нельзя будет использовать за рамками транзакции, создавшей его. Если не указано ни WITHOUT HOLD, ни WITH HOLD, по умолчанию подразумевается WITHOUT HOLD.
запрос: Команда SELECT или VALUES, выдающая строки, которые будут получены через курсор.

Ключевые слова BINARY, INSENSITIVE и SCROLL могут указываться в любом порядке.

Замечания

Обычный курсор выдаёт данные в текстовом виде, в каком их выдаёт SELECT. Однако с указанием BINARY курсор может выдавать их и в двоичном формате. Это упрощает операции преобразования данных для сервера и клиента, за счёт дополнительных усилий, требующихся от программиста для работы с платформозависимыми двоичными форматами. Например, если запрос получает значение 1 из целочисленного столбца, обычный курсор выдаст строку, содержащую 1, тогда как через двоичный курсор будет получено четырёхбайтовое поле, содержащее внутреннее представление значения (с сетевым порядком байтов).

Двоичные курсоры должны применяться с осмотрительностью. Многие приложения, в том числе psql, не приспособлены к работе с двоичными курсорами и ожидают, что данные будут поступать в текстовом формате.

Примечание

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

Если в команде объявления курсора не указано WITH HOLD, созданный ей курсор может использоваться только в текущей транзакции. Таким образом, оператор DECLARE без WITH HOLD бесполезен вне блока транзакции: курсор будет существовать только до завершения этого оператора. Поэтому PostgreSQL сообщает об ошибке, если такая команда выполняется вне блока транзакции. Чтобы определить блок транзакции, примените команды BEGIN и COMMIT (или ROLLBACK).

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

Объявить курсор со свойством WITH HOLD можно, только если запрос не содержит указаний FOR UPDATE и FOR SHARE.

Указание SCROLL добавляется при определении курсора, который будет выбирать данные в обратном порядке. Это поведение требуется стандартом SQL. Однако для совместимости с предыдущими версиями, PostgreSQL допускает выборку в обратном направлении и без указания SCROLL, если план запроса курсора достаточно прост, чтобы реализовать прокрутку назад без дополнительных операций. Тем не менее, разработчикам приложений не следует рассчитывать на то, что курсор, созданный без указания SCROLL, можно будет прокручивать назад. С указанием NO SCROLL прокрутка назад запрещается в любом случае.

Выборка в обратном направлении также запрещается, если запрос содержит указания FOR UPDATE и FOR SHARE; в этом случае указание SCROLL не принимается.

Внимание

Прокручиваемые и удерживаемые (WITH HOLD) курсоры могут выдавать неожиданные результаты, если они вызывают изменчивые функции (см. Раздел 35.6). Когда повторно выбирается ранее прочитанная строка, функции могут вызываться снова и выдавать результаты, отличные от полученных в первый раз. Один из способов обойти эту проблему — объявить курсор с указанием WITH HOLD и зафиксировать транзакцию, прежде чем читать из него какие-либо строки. В этом случае весь набор данных курсора будет материализован во временном хранилище, так что изменчивые функции будут выполнены для каждой строки лишь единожды.

Если запрос в определении курсора включает указания FOR UPDATE или FOR SHARE, возвращаемые курсором строки блокируются в момент первой выборки, так же, как это происходит при выполнении SELECT с этими указаниями. Кроме того, при чтении строк будут возвращаться их наиболее актуальные версии; таким образом, с этими указаниями курсор будет вести себя как «чувствительный курсор», определённый в стандарте SQL. (Указать INSENSITIVE для курсора с запросом FOR UPDATE или FOR SHARE нельзя.)

Внимание

Обычно рекомендуется использовать FOR UPDATE, если курсор предназначается для применения в командах UPDATE . .. WHERE CURRENT OF и DELETE ... WHERE CURRENT OF. Указание FOR UPDATE предотвращает изменение строк другими сеансами после того, как они были считаны, и до того, как выполнится команда. Без FOR UPDATE последующая команда с WHERE CURRENT OF не сработает, если строка будет изменена после создания курсора.

Ещё одна причина использовать указание FOR UPDATE в том, что без него последующие команды с WHERE CURRENT OF могут выдать ошибку, если запрос курсора не удовлетворяет оговоренному в стандарте SQL критерию «простой изменяемости» (в частности, курсор должен ссылаться только на одну таблицу и не должен использовать группировку и сортировку (ORDER BY)). Курсоры, не удовлетворяющие этому критерию, могут работать либо не работать, в зависимости от конкретного выбранного плана; так что в худшем случае приложение может работать в тестовой, но сломается в производственной среде. С указанием FOR UPDATE курсор гарантированно будет изменяемым.

Не использовать же FOR UPDATE для команд с WHERE CURRENT OF в основном имеет смысл, только если требуется получить прокручиваемый курсор или курсор, не отражающий последующие изменения (то есть, продолжающий показывать прежние данные). Если это действительно необходимо, обязательно учтите при реализации приведённые выше замечания.

В стандарте SQL механизм курсоров предусмотрен только для встраиваемого SQL. Сервер PostgreSQL не реализует для курсоров оператор OPEN; курсор считается открытым при объявлении. Однако ECPG, встраиваемый препроцессор SQL для PostgreSQL, следует соглашениям стандарта, в том числе поддерживая для курсоров операторы DECLARE и OPEN.

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

Примеры

Объявление курсора:

DECLARE liahona CURSOR FOR SELECT * FROM films;

Другие примеры использования курсора можно найти в FETCH.

Совместимость

В стандарте SQL говорится, что чувствительность курсоров к параллельному обновлению нижележащих данных по умолчанию определяется реализацией. В PostgreSQL курсоры по умолчанию нечувствительные, а чувствительными их можно сделать с помощью указания FOR UPDATE. Другие СУБД могут работать иначе.

Стандарт SQL допускает курсоры только во встраиваемом SQL и в модулях. PostgreSQL позволяет использовать курсоры интерактивно.

Двоичные курсоры являются расширением PostgreSQL.

См. также

CLOSE, FETCH, MOVE

Declare SQL: краткое описание. Transact-SQL

Сегодня практически каждый современный программист знает, что такое Transact-SQL. Это расширение, которое используется в SQL Server. Данная разработка тесно интегрирована в язык Microsoft SQL и добавляет конструкторы программирования, которые изначально не предусмотрены в базах данных. T-SQL поддерживает переменные, как и в большинстве других разработках. Однако это расширение ограничивает использование переменных способами, которые не распространены в других средах.

Объявление переменных в DECLARE SQL

Для объявления переменной в T-SQL используется оператор DECLARE (<var_name>). Например, в случае объявления переменной i как целое с использованием данного оператора команда будет выглядеть так: DECLARE @i int.

Узнаем что делает функция SQL CONCAT?

Работа с базами данных постоянно связана с получением результатов запросов. И в некоторых случаях…

Хотя Microsoft не документирует эту функцию, T-SQL также поддерживает указание ключевого слова AS между именем переменной и ее типом данных, как в следующем примере: DECLARE @i AS int. Ключевое слово AS упрощает чтение инструкции DECLARE. Единственный тип данных, который не позволяет указать ключевое слово AS, — это тип данных таблицы, который является новым в SQL Server 2000. Он дает возможность определить переменную, содержащую полную таблицу.

DECLARE SQL: описание

T-SQL поддерживает только локальные переменные, которые доступны исключительно в той партии, которая их создала. Пакет — это оператор (или группа операторов), который база данных анализирует как единицу. Каждый клиентский инструмент или интерфейс имеет свой собственный способ указания, где заканчивается пакет. Например, в Query Analyzer вы используете команду GO, чтобы указать, где заканчивается пакет. Если у вас есть синтаксическая ошибка в любом заявлении, пакет не проходит фазу разбора, поэтому клиентский инструмент не отправляет пакет на SQL Server для дальнейшей обработки. Вы можете запустить код, который объявляет переменную таблицы, а затем вставляет строку в таблицу в той же партии.

Пошаговое создание таблицы SQL

Статья о том, как создать таблицу SQL. Как работать с таблицей, как ее изменять и удалять. Описание…

Пример SQL Declare Table:

DECLARE @mytable table
col1 int NOT NULL
INSERT INTO @mytable VALUES (1)
GO

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

DECLARE @mytable table
col1 int NOT NULL
INSERT INTO @mytable VALUES (1)GO

Оператор INSERT терпит неудачу, потому что переменная таблицы выходит за пределы области видимости, и появляется следующее сообщение об ошибке:
Сервер: Msg 137, уровень 15, состояние 2, строка 2.

Переменные в процедурах (инструкции DECLARE, SET)

Поддержка локальных переменных в процедурах SQL позволяет назначать и извлекать значения данных в поддержку логики процедур. Переменные в процедурах определяются с помощью оператора DECLARE SQL. Значения могут присваиваться переменным с помощью инструкции SET или в качестве значения по умолчанию при объявлении переменной. Литералам, выражениям, результатам запроса и специальным значениям регистра могут быть присвоены переменные.
Значения переменных могут быть назначены параметрам процедуры, другим переменным, а также могут быть указаны как параметры в операторах SQL, выполняемых в рамках процедуры.

HAVING SQL: краткое описание, синтаксис, примеры

Среди прочих параметров оператора SELECT в языке SQL параметр HAVING является крайне полезным. Это…

Алгоритм

При объявлении переменной вы можете указать значение по умолчанию, используя предложение DEFAULT. Строка показывает объявление переменной типа Boolean со значением по умолчанию FALSE. Оператор SET может использоваться для назначения одного значения переменной. Переменные также могут быть установлены путем выполнения инструкции SELECT или FETCH в сочетании с предложением INTO. Оператор VALUES INTO может использоваться для оценки функции или специального регистра и присваивать значение нескольким переменным.

Вы также можете присвоить результат оператора GET DIAGNOSTICS переменной. GET DIAGNOSTICS может использоваться для получения дескриптора количества затронутых строк (обновляется для оператора UPDATE, DELETE — для оператора DELETE) или статуса возврата только что выполненного SQL-оператора

Особенности

Строка DECLARE SQL демонстрирует, как часть логики может использоваться для определения значения, которое должно быть присвоено переменной. В этом случае, если строки были изменены как часть более раннего оператора DELETE, а выполнение GET DIAGNOSTICS привело к тому, что переменной v_rcount присвоено значение, большее нуля, переменной is_done присваивается значение TRUE.

Процедуры

Процедуры DECLARE SQL — это процедуры, полностью реализованные с использованием SQL, которые могут использоваться для инкапсуляции логики. Та же в свою очередь может быть вызвана как подпрограмма программирования.

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

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

Создание процедур

Внедрение SQL-процедур может играть важную роль в архитектуре базы данных, разработке приложений и производительности системы. Разработка требует четкого понимания требований, возможностей и использования функций, а также знания любых ограничений. Процедуры SQL создаются по инструкции CREATE PROCEDURE. Когда создается алгоритм, запросы в теле процедуры отделяются от процедурной логики. Чтобы максимизировать производительность, SQL-запросы статически компилируются в разделы в пакете

Переменные

Локальная переменная Transact-SQL — это объект, который может содержать одно значение данных определенного типа. Обычно используются переменные в партиях и сценариях:

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

Имена ряда функций Transact-SQL начинаются со знаков (@@). Хотя в более ранних версиях Microsoft SQL Server функции @@ называются глобальными переменными. @@ — это системные функции, и их использование подчиняется правилам синтаксиса для функций.

Объявление переменной

Оператор DECLARE определяет переменную Transact-SQL согласно следующему алгоритму:

определение имени, которое должно иметь один символ @ в качестве первого символа;
назначение заданного или определенного пользователем типа данных и длины;
для числовых переменных также назначаются точность и масштаб.
для переменных типа XML может быть назначена дополнительная сборка схемы.
Установка значения в NULL. Например, оператор DECLARE в SQL-запросе создает локальную переменную с именем @mycounter с типом данных int.

Чтобы объявить несколько локальных переменных, используйте запятую после определения первой локальной переменной, а затем укажите следующее имя локальной сети и тип данных. Например, следующий оператор создает три локальные переменные с именем @LastName, @FirstName и @StateProvince и инициализирует каждый из NULL. Объем переменной — это диапазон операторов Transact-SQL, которые могут ссылаться на переменную. Объем переменной длится от той точки, которая объявляется до конца партии или хранимой процедуры, в которой она объявлена.

Обзор использования переменных SQL

Переменная SQL — это локальная переменная, которая может временно хранить одно значение данных. Его жизненный цикл начинается с объявления и заканчивается пакетом. Точно так же, если вы используете локальную переменную в хранимой процедуре, ее область действия находится в пределах выполнения SP.

Несколько типичных случаев использования переменных SQL приведены ниже.

Одноточечное объявление: вы можете объявить переменную и вызывать ее в сценарии T-SQL много раз (в пределах области действия). Он может хранить значение по умолчанию и переопределять значение во время выполнения.
Счетчик: Много раз вам требуется счетчик для выполнения сценария в цикле. Переменная SQL может использоваться для хранения и обновления значения счетчика при выполнении цикла.
Сохранить или вернуть значение: переменная может хранить код возврата хранимой процедуры или выходное значение.

Как объявить переменную SQL

Чтобы объявить переменную в сценарии T-SQL, используйте следующий подход.

Используйте оператор DECLARE для объявления переменной
Укажите уникальное имя для переменной в рамках оператора T-SQL. В скрипте не может быть двух переменных с одинаковыми именами, и имя переменной должно указывать один и тот же @ в качестве первого символа.
Укажите тип данных для значения, которое будет храниться в переменной.
Вы также можете присвоить переменной значение по умолчанию во время объявления. Однако необязательно присваивать значение во время объявления.

Например, следующий сценарий T-SQL объявляет переменную и печатает ее значение.

 DECLARE @Temp varchar(10) = 'SQL Server'
PRINT @Temp

Если мы хотим присвоить значение после объявления переменной, мы можем использовать оператор SET с именем переменной ниже.

 DECLARE @Temp varchar(10)
УСТАНОВИТЕ @Temp = 'сервер SQL'
PRINT @Temp

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

 DECLARE @Temp varchar(10)
Выберите @Temp = 'SQL Server'
PRINT @Temp

Например, в приведенном ниже T-SQL переменная хранит значение столбца [CompanyName], возвращенное оператором SELECT.

 DECLARE @Temp varchar(50)
Выберите @Temp = [CompanyName]
ОТ SalesLT.Customer, ГДЕ CustomerID=1
ПЕЧАТЬ при температуре

Если оператор SELECT возвращает несколько строк, переменная получает значение, возвращаемое для последней строки результирующего набора. Например, в приведенном ниже сценарии мы удалили предикаты where. Таким образом, инструкция SELECT возвращает все строки, хранящиеся в таблице [SalesLT].[Customer].

 DECLARE @Temp varchar(50)
Выберите @Temp = [CompanyName]
ОТ SalesLT. Customer
PRINT @Temp

Сценарий работает нормально. Однако он возвращает значение последней строки результирующего набора.

Мы можем объявить несколько локальных переменных в сценарии SQL. Мы можем либо использовать несколько операторов DECLARE, либо один с оператором, разделенным запятыми, для объявления нескольких переменных.

 DECLARE @a int = 1
ОБЪЯВИТЬ @b int = 2
DECLARE @c varchar(10) = 'Тест'
ПЕЧАТЬ @a
Распечатать @b
Print @c

В качестве альтернативы приведенный ниже оператор SQL объявляет все переменные с помощью одного оператора DECLARE.

 DECLARE @a int = 1 , @b int = 2 , @c varchar(10) = 'Тест'
ПЕЧАТЬ @a
Распечатать @b
Печать @c

Область действия локальной переменной

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

 DECLARE @CustID INT;
УСТАНОВИТЬ @CustID = 1;
ВЫБЕРИТЕ * ОТ salesLT. Customer
ГДЕ CustomerID= @CustID

SQL Server использует оператор GO для разделения различных пакетов. Поэтому следующий сценарий отделяет объявление переменной от инструкции SELECT.

 DECLARE @CustID INT;
УСТАНОВИТЬ @CustID = 1;
идти
ВЫБЕРИТЕ * ОТ salesLT.Customer
ГДЕ CustomerID= @CustID

Оператор SELECT генерирует синтаксическую ошибку, поскольку переменная @CustID больше недействительна.

Область действия локальных переменных находится в пакете или процедуре, в которой они определены. Следующий сценарий также генерирует ошибку из-за вложенной области в sp_executesql.

 DECLARE @Temp INT;
УСТАНОВИТЬ @Temp = 1;
EXECUTE sp_executesql N'SELECT @Temp';

Переменные в хранимой процедуре

Хранимая процедура может содержать локальные переменные в качестве параметра или может быть встроена в сценарий T-SQL. Например, в нижеприведенной хранимой процедуре мы использовали локальную переменную @ProductID.

 СОЗДАТЬ ПРОЦЕДУРУ [dbo]. [GetProductNumber]
(@ProductID AS int)
КАК
НАЧИНАТЬ
    ВЫБЕРИТЕ ProductNumber ИЗ SalesLT.Product
    ГДЕ ProductID = @ProductID
КОНЕЦ
GO

Чтобы выполнить SP, нам нужно указать значение переменной @ProductID, как показано ниже.

В другом примере мы объявляем еще одну локальную переменную @ProductCategoryID внутри тела хранимой процедуры. Как только мы выполняем SP с указанием значения переменной @ProductID, он извлекает значение @ProductCategoryID с помощью первого оператора SELECT. Он фильтрует записи во второй оператор SELECT в соответствии со значением, присвоенным локальной переменной @ProductCategoryID.

 СОЗДАТЬ ИЛИ ИЗМЕНИТЬ ПРОЦЕДУРУ [dbo].[GetProductNumber]
(@ProductID AS int)
КАК
НАЧИНАТЬ
DECLARE @ProductCategoryID int
    ВЫБЕРИТЕ @ProductCategoryID= ProductCategoryID FROM SalesLT.Product
    ГДЕ ProductID = @ProductID
ВЫБЕРИТЕ имя, цвет, стандартную стоимость из SalesLT.Product
ГДЕ [электронная почта защищена]
КОНЕЦ
GO

Область действия локальной переменной находится в пакете сценариев. Мы также можем использовать его для вложенных пакетов. Например, в приведенном ниже сценарии мы используем переменную @ProductCategoryID внутри другого цикла.

 СОЗДАТЬ ИЛИ ИЗМЕНИТЬ ПРОЦЕДУРУ [dbo].[GetProductNumber]
(@ProductID AS int)
КАК
НАЧИНАТЬ
DECLARE @ProductCategoryID int
    ВЫБЕРИТЕ @ProductCategoryID= ProductCategoryID FROM SalesLT.Product
    ГДЕ ProductID = @ProductID
НАЧИНАТЬ
ВЫБЕРИТЕ имя, цвет, стандартную стоимость из SalesLT.Product
ГДЕ [электронная почта защищена]
КОНЕЦ
END

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

 Создать или изменить процедуру TestSP
как
объявить @ID int
установить @ID = 1
распечатать @ID
ВПЕРЕД

Теперь, если мы вызываем переменную вне SP, она генерирует ошибку, даже если мы не разделили транзакции с оператором GO.

Локальная переменная в качестве счетчика в сценарии T-SQL

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

Например, мы определили переменную @ProductID и присвоили ей значение 707. Позже я запустил цикл WHILE, который выполняется до тех пор, пока идентификатор продукта не станет меньше 710.

При каждом выполнении он печатает имя продукта и увеличивает значение переменная на 1.

 CREATE OR ALTER PROCEDURE [dbo].[GetProductNumber]
КАК
ОБЪЯВИТЬ @ProductID varchar(10) =707
пока(@ProductID<710)
НАЧИНАТЬ
    ВЫБЕРИТЕ Имя ИЗ SalesLT.Product
    ГДЕ ProductID = @ProductID
PRINT 'ID продукта' + @ProductID + 'подробности'
SET @[email protected]+1
КОНЕЦ
ВПЕРЕД

Вы получаете следующие выходные данные хранимой процедуры для локальной переменной в качестве счетчика.

Заключение

В этой статье мы рассмотрели использование локальных переменных и их область действия в операторах SQL Server. Локальные переменные используются довольно часто, и поэтому я рекомендую вам ознакомиться с ними в скрипте T-SQL. Чтобы получить помощь в кодировании SQL, вы можете использовать надстройку SSMS dbForge SQL Complete.

Последнее изменение: 15 декабря 2022 г.

DECLARE VARIABLE

RDX

реализует оператор DECLARE VARIABLE в качестве поддерживающей структуры для других операторов SQL, требующих явного определения типа данных и атрибутов переменной (таких как длина и CCSID). Вам может понадобиться изменить тип данных столбца, возвращаемый Db2 с помощью оператора DESCRIBE, на какой-либо другой тип данных. Например, чтобы извлечь или сохранить столбцы XML, вы должны сначала изменить тип данных на VARCHAR или LOB, поскольку Db2 не поддерживает столбцы XML напрямую. Вы можете вручную создать SQLDA из переменных REXX. Это устраняет необходимость в объявленных переменных, но требует дополнительных усилий по программированию и требует глубокого понимания динамического интерфейса SQL.

В следующем примере описывается синтаксис оператора DECLARE STATEMENT, реализованный с помощью

RDX

. Обратите внимание, что этот синтаксис

не совместим

с синтаксисом оператора SQL DECLARE VARIABLE.

  ОБЪЯВИТЬ имя_переменной ПЕРЕМЕННОЙ
 DATATYPE(sqltype) {ДЛИНА(длина) | ДЛИНА(точность,масштаб)} |
 имя_типа_данных
   ВВОД | ВЫХОД
   ПОКАЗАТЕЛЬ

где:

SQLTYPE Имя типа данных 384 ДАТА 388 ВРЕМЯ 392 ОТМЕТКА ВРЕМЕНИ 400 NULL SEP GR STRING 404 BLOB 408 КЛОБ 412 ДБКЛОБ 448 ВАРЧАР 452 СИМВ. 456 ДЛИННЫЙ ВАРЧАР 460 НУЛЕВАЯ СИЛОВАЯ СТРОКА 464 ВАРГРАФИКА 468 ГРАФИКА 472 ДЛИННЫЙ ВАРГРАФИЧЕСКИЙ 480 ПЛАВАЮЩИЙ 484 ДЕСЯТИЧНЫЙ 492 БОЛЬШОЕ ЦЕЛОЕ ЧИСЛО 496 ЦЕЛОЕ ЧИСЛО 500 МАЛЕНЬКИЙ 504 ОТОБРАЖЕНИЕ ЗНАКА 904 РОВИД 908 ВАРБИНАРИЙ 912 ДВОИЧНЫЙ 916 BLOB-ФАЙЛ 920 CLOB-ФАЙЛ 924 ФАЙЛ DBCLOB 960 ЛОКАТОР BLOB 964 КЛОБ ЛОКАТОР 968 ЛОКАТОР DBCLOB 972 РЕЗУЛЬТАТ НАБОР ЛОКАТОР 976 ТАБЛИЦА ЛОКАТОР 988 XML 996 DECFLOAT

Длина — для всех недесятичных типов данных эта переменная указывает длину переменной.