===========================================

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

Встроенный SQL позволяет использовать преимущества многих мощных расширений SQL. В рамках Cache ObjectScript можно:

Эта глава описывает работу встроенного SQL в Cache ObjectScript. Предполагается, что читатель знаком с концепциями объектов Cache, языком Cache ObjectScript и стандартом ANSI SQL.

Использование встроенного SQL в методах и программах ограничено рамками функции препроцессора &sql (...). Например:

METHOD MethodName(methodargs)

{

CODE =

{

&sql(SELECT * FROM Table)

}

}

Используя синтаксис языка CDL, можно определить класс Patient со следующими атрибутами:

class Patient

{

DESCRIPTION = "Patient Info";

SUPER = %Persistent;

PERSISTENT;

ATTRIBUTE Name {TYPE = %String;}

ATTRIBUTE Number {TYPE = %Integer;}

ATTRIBUTE PIN {TYPE = %String;}

INDEX Keys {ATTRIBUTE = PIN;IDKEY;}

}

Тогда можно создать метод FindPatient класса, который содержит встроенный SQL, который находит пациента по имени и возвращает OREF объекта:

METHOD FindPatient(name:%String)

{

DESCRIPTION = "Finds a patient and returns its OREF";

RETURNTYPE = Patient;

CLASSMETHOD;

CODE =

{

NEW id,SQLCODE

&sql(SELECT ID

INTO :id

FROM Patient

WHERE Name = :name)

IF SQLCODE QUIT $$$NULLREF

QUIT ..%OpenId(id)

}

}

METHOD ListPatients()

{

DESCRIPTION = "Prints patient info";

CLASSMETHOD;

CODE =

{

NEW name,num,pin,SQLCODE

&sql(DECLARE PatCur CURSOR for

SELECT Name,Number,PIN INTO :name,:num,:pin

FROM Patient)

&sql(OPEN PatCur)

FOR &sql(FETCH PatCur) QUIT:SQLCODE

WRITE name," ",num," ",pin,!

&sql(CLOSE PatCur)

QUIT

}

}

Можно также создать метод Insert класса, который использует встроенный SQL для вставки новых записей в набор пациентов:

METHOD Insert(name:%String,num:%Integer,pin:%String)

{

CLASSMETHOD;

CODE =

{

NEW SQLCODE

&sql(INSERT INTO Patient (Name,Number,PIN)

VALUES (:name,:num,:pin))

QUIT

}

}

Как другая альтернатива, можно создать метод класса, использующий встроенный SQL для определения таблицы, используя Язык Описания Данных SQL (DDL – Data Definition Language):

METHOD DefineTable()

{

RETURNTYPE = "%Status";

CLASSMETHOD;

CODE =

{

NEW SQLCODE

&sql(CREATE TABLE NewTable(Name CHAR(30),

Title CHAR(30)))`

IF SQLCODE<0 QUIT $$$ERROR($$$SQLError,SQLCODE)

QUIT $$$OK

}

}

Данные, найденные через запросы SQL, могут быть возвращены в любом из следующих форматов данных:

Можно определить формат данных через макро-флажок #SQLCOMPILE препроцессора. Если используется встроенный SQL и объекты привязываются к переменным Cache ObjectScript, следует использовать логическую установку компилятора SQL. Эта директива компилятора определяет формат для данных, найденных через внедренный SQL. Например,

#sqlcompile select=logical

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

#define TABLE Patients

#define FIELDS Name,Phone

#define VARS :n,:p

#define COND Name %STARTSWITH "JO"

...

&sql(SELECT $$$FIELDS INTO $$$VARS

FROM $$$TABLE WHERE $$$COND)

Наоборот, можно использовать макро-ссылку, чтобы вставить функцию препроцессора &sql:

#define GETNEXT &sql(FETCH xcurs INTO :a,:y)

...

FOR i=1:1 $$$GETNEXT QUIT:SQLCODE=100 DO object.method()

При обработке последней строки, макро-препроцессор заменяет макро-ссылку $$$GETNEXT &sql(FETCH ...); тогда вместо встроенного выражения SQL будет следующий текст:

FOR i=1:1 &sql(FETCH xcurs INTO :a,:y) QUIT:SQLCODE=100 DO object.method()

Не-курсор SQL состоит из индивидуальных инструкций SELECT, INSERT, UPDATE и DELETE. Не-курсор встроенная инструкция запроса SQL всегда возвращает одиночную строку данных. Эти запросы возвращают первую строку, которая удовлетворяет критериям SELECT. Например:

&sql(SELECT Name FROM Person INTO :name)

Курсор SQL позволяет отыскивать множественные строки в наборе результатов запроса. При использовании курсора необходимо выполнить следующую последовательность задач:

Действия курсора подобно указателю – он сосредотачивается на доступе и обработке сначала одной строки, затем перемещается от этой строки к следующей в последовательности строк.

Чтобы объявить курсор, используется инструкция SQL DECLARE. Инструкция DECLARE содержит имя курсора и инструкцию SELECT, которая определяет курсор.

Имя курсора может состоять из любого числа алфавитно-цифровых символов; существенны только первые 29 символов, а первый символ должен быть алфавитным. Инструкция DECLARE для курсора должна предшествовать любым другим инструкциям, включающим этот курсор. Как только курсор объявлен, он может использовать одну или более инструкций OPEN, FETCH и CLOSE. Все операции курсора для данного имени курсора должны постоянно находится в одиночной программе Cache ObjectScript. Например,

&sql(DECLARE PatCur CURSOR FOR

SELECT Name,Telephone FROM Patients

Пример объявляет курсор PatCur, который отыскивает имена и номера телефонов во всех строках в таблице Patients с именем Boswell. Инструкция DECLARE самостоятельно не выполняет никакой код.

Cache SQL расширяет поддерживаемую SQL инструкцию DECLARE с предложением INTO, чтобы связать результаты курсор-основанной выборки с локальными переменными.

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

&sql(OPEN PatCur)

В запросе SQL можно использовать инструкцию FETCH с предложением INTO, чтобы отыскать результаты в переменных. Например,

&sql(FETCH PatCur INTO :name,:tel)

Используя собственное предложение INTO, каждая инструкция FETCH может читать один и тот же курсор в различные наборы переменных.

Когда завершено использование курсора в программе, его следует закрыть следующим образом:

&sql(CLOSE PatCur)

Сначала нужно сохранить данные запроса SQL в локальных переменных. Затем следует установить объектные свойства в локальные переменные.

Чтобы сохранить данные запроса SQL в переменных Cache ObjectScript, используется предложение INTO. В курсор-основанном SQL разработчик определяет предложение INTO как часть инструкции DECLARE для курсора. Например,

&sql(DECLARE state CURSOR for

SELECT Name,Abbreviation,Capitol

INTO :name,:abbr,:capitol

FROM state)

...

&sql(FETCH state)

&sql(DECLARE state CURSOR FOR

SELECT Name,Abbreviation,Capital

FROM state)

...

&sql(FETCH state INTO :name,:abbr,:capital)

Используя собственное предложение INTO, каждая инструкция FETCH может читать один и тот же курсор в различные наборы переменных.

Следует обратить внимание, что INTO может только сохранять данные в локальных переменных, но не объектные свойствах. Это означает, что данные хранятся в локальной переменной; для сохранения значения нужно установить объектное свойство непосредственно в локальную переменную:

set state.Name=name

Можно также сохранять результаты запроса SQL в узле переменной (в массиве) Cache ObjectScript. Cache SQL позволяет предложению INTO в инструкции SELECT сохранять значения из одиночной таблицы в массиве.

Чтобы сделать это, предложение INTO сохраняет значения в узле переменной Cache ObjectScript, у которой последний индекс Cache ObjectScript неопределен. Например,

INTO :a("Emp",)

помещает каждое найденное значение поля в элемент массива:

a("Emp",col)

Если выполняется запрос:

&sql(SELECT *

INTO :emp()

FROM Employee

WHERE Name = "Smith")

для следующей таблицы Employee:

то поле Employee читается в emp(1), поле Name – в emp(2), и так далее.

Если формат $List:

emp(3)=$LISTBUILD(instance1,instance2,...instanceN)

Если формат $Piece:

emp(3)=instance1^instance2^...^instanceN)

где ^ – разделитель списка SQL.

Как правило, запросы INSERT используют следующий синтаксис:

INSERT INTO <tablename> (<fieldname>,<fieldname>,...)

VALUES (...,...)

Запросы UPDATE используют следующий синтаксис:

UPDATE <tablename> (<fieldname>,<fieldname>,...)

VALUES (...,...)

В этих инструкциях элементы в предложении VALUES последовательно соответствуют полям, указанныv после имени таблицы.

Cache SQL позволяет запросам INSERT и UPDATE использовать любой синтаксис без требования явного определения списка имен полей после имени таблицы.

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

Например, запрос

INSERT INTO tabl1 VALUES (5,"John")

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

INSERT INTO tabl1 (age,name) VALUES (5,"John")

если таблица "tabl1" имеет только два поля данных.

В этом примере, значение 5 назначено для поля с более низким номером столбца, а значение John назначено для другого поля.

Можно устанавливать значение переменной и затем обновлять реляционную базу Cache, используя следующий синтаксис:

Set sname="Montana”

&sql(INSERT INTO State VALUES :sname)

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

Cache SQL позволяет использовать переменную ссылку с неопределенным последним нижним индексом, чтобы передать массив значений запросам INSERT или UPDATE встроенного SQL. Например, встроенный SQL-запрос:

&sql(INSERT INTO Employee VALUES :emp("profile",))

устанавливает каждое поле во вставленной строке Employee в:

emp("profile",col)

Следует обратить внимание, что, если используется ссылка на массив, Cache SQL не требует списка имен полей после имени таблицы. Присутствие и отсутствие элементов массива определяют поля, в которые запрос вставляет значения. Это дает возможность по содержанию массива определять поля, которые получают значения вставки.

INSERT INTO Employee VALUES :emp("profile",)

является эквивалентной инструкции SQL стандарта ANSI:

INSERT INTO Employee (Name,Telephone) VALUES (:name,:tel)

В Cache имеются расширения SQL для некоторых операторов Cache ObjectScript. Это увеличивает выразительную мощь SQL и помогает лучше интегрировать эти два языка.

Символы, показанные в следующей таблице, представляют расширения Cache для SQL:

Cache SQL разрешает использование двойных кавычек ("..."), чтобы разграничивать литеральные значения, в дополнение к символу апострофа ("..."), используемого ANSI-Стандартом SQL.

Можно использовать префиксы "не" и "НЕ" для отрицания сравнения и логических операторов. Например,

не= (эквивалентно <>)

не< (эквивалентно >=)

не> (эквивалентно <=)

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

Поле cписка ищется как одиночная строка данных в преобразованном в последовательную форму формате. Она может быть сохранена в одном из двух форматов:

Cache SQL позволяет использовать поля списка и в запросах SELECT, INSERT и UPDATE.

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

426 Sunday

DriveApt. 12C

Roberta, CA 90126

&sql(SELECT Address INTO :addr

FROM Patient

WHERE Patient = 758)

Cache SQL расширяет стандартный SQL включением двух дополнительных типов объединений:

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

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

При определении одностороннего внешнего объединения, порядок, в котором вызываются таблицы в предложении FROM, очень важен. Первая определяемая таблица – исходная таблица для объединения. Определить внешнее объединение можно, используя символ = * на месте = в предложении WHERE запроса SQL.

Например, таблица Suppliers определена как исходная таблица для односторонней внешней операции объединения (= *) с таблицей Parts, где поле SCity соответствует полю Pcity:

SELECT SName,PName,SCity

FROM Suppliers,Parts

WHERE Suppliers.SCity=*Parts.PCity

Предложение SELECT определяет поля, которые будут включены в проецируемую таблицу. Таблица Cartesian Product получена из таблиц, названных в предложении FROM вышеупомянутой инструкции SQL, и объединяет таблицы Suppliers и Parts. Предложение WHERE в вышеупомянутой инструкции (Suppliers.SCity =*Parts. PCity) определяет одностороннее внешнее условие объединения.

Этот запрос возвращает все строки от таблицы источника Suppliers, также как любых строк из таблицы Parts, где поле SCity соответствует полю PCity.

Cache SQL поддерживает два типа неявных объединений - ссылки и зависимые отношения:

Ссылка – связь "многие к одному" между таблицами. Ссылка, как считают, не зависимая связь, потому что строки в ссылающейся таблице существуют независимо от строк в таблице, на которую делается ссылка. В Cache SQL таблица, на которую производится ссылка, имеет указатель на ссылающуюся таблицу. В Cache поле, которое определяет другую таблицу, называется полем ссылки.

Чтобы определить ссылку, можно в определении запроса использовать неявный синтаксис объединения Cache SQL.

Например, если поле A.b определяет таблицу B, и x – поле в таблице B, ссылка

A.b->x

Указывает на значение x в строке таблицы B передающий к A.b. Это интерпретируется как ссылка к B.x с B, добавленным неявно к предложению FROM и дополнительному внешнему условию объединения, добавленному неявно к предложению WHERE.

Следующий запрос отыскивает имя пациента и имя доктора для каждого пациента, живущего в Бостоне:

SELECT Patient.Pname, Patient.Doctor->Dname

FROM Patient

WHERE Patient.City = "Boston"

Предположение Patient.Doctor – ссылка к таблице Doctor, вышеупомянутый запрос эквивалентен такому:

SELECT Patient.Pname,Doctor.Dname

FROM Patient,Doctor

WHERE Patient.City = "Boston"

AND Patient.Doctor = *Doctor.ID

В объектах Cache отношения родитель/ребенок называются идентифицирующими отношениями и определены параметром класса IDENTIFIEDBY.

Например, язык CDL создает зависимые отношения между родительской таблицей Invoice и дочерней (порожденной) таблицей InvoiceLine:

CLASS Invoice

{

SUPER = %Persistent;

ATTRIBUTE InvoiceNumber {TYPE = %String;}

INDEX MyKey {attribute = InvoiceNumber;IDKEY;}

...

}

CLASS InvoiceLine

{

PARAMETER IDENTIFIEDBY {DEFAULT = "InvoiceParent";}

SUPER = %Persistent;

ATTRIBUTE InvoiceParent {TYPE = Invoice;}

...

}

Имеются два типа зависимых отношений: Child-Parent (Ребенок-Родитель) и Parent-Child (Родитель-Ребенок). Обозначения зависимых отношений в Cache SQL используют неявный синтаксис объединения.

Если P – ссылка к родителю C, а x – поле в P, неявный синтаксис объединения:

C.P->x

для данной строки указывает на значение поля x в родительской строке этой строки. Это интерпретируется как ссылка к P.x с P, добавленная неявно к предложению FROM, и дополнительное внешнее условие объединения, добавленное неявно к предложению WHERE.

Например, учитывая родительскую таблицу Customer и дочернюю (порожденную) таблицу Invoice, следующий запрос:

SELECT Invoice.Customer->Name

FROM Invoice

WHERE Invoice.Number = 51140

будет эквивалентен такому:

SELECT Customer.Name

FROM Invoice,Customer

WHERE Invoice.Number = 51140

AND Invoice.Customer = Customer.ID

Если P – ссылка к родителю C, а x – поле в C, неявный синтаксис объединения:

P.C->x

для данной строки P указывает на значение поля x в дочерней (порожденной) строке этой родительской строки. Это интерпретируется как ссылка к C.x с C, добавленная неявно к предложению FROM, и дополнительное внешнее условие объединения, добавленное неявно к предложению WHERE.

Например, учитывая родительскую таблицу Customer и дочернюю (порожденную) таблицу Invoice, следующий запрос всех счетов всех заказчиков (customer) по имени Smith:

SELECT Customer.Invoice->Number

FROM Customer

WHERE Customer.Name = "Smith"

будет эквивалентен такому:

SELECT Invoice.Number

FROM Customer,Invoice

WHERE Customer.Name = "Smith"

AND Customer.ID = Invoice.Customer

Когда Cache генерирует промежуточный код для метода, который содержит встроенный SQL, то автоматически генерируются имена переменных. Не-курсор имена переменных в инструкциях SQL начинаются с %mmmsql. Для курсор-основанных инструкций SQL (предполагается, что операции выполнены на курсоре по имени "PatCur") все сгенерированные имена переменных начинаются с %PatCur или %mmmsql.

Чтобы избежать конфликта со сгенерированными именами переменных, методы, содержащие встроенный код SQL, не должны иметь переменных с именами, начинающимися с %mmmsql. Имена переменных также не должны начинаться с любого имени курсора, которое появляется в программе.

Всякий раз, когда запускается инструкция SQL, в переменную SQLCODE Cache ObjectScript возвращается числовой код состояния. Этот код состояния может быть:

===========================================

===========================================

По вопросам поддержки любых продуктов InterSystems Corporation обращайтесь:

Россия 121019, Москва, Волхонка, 6, #14