Оглавление
- Введение
- Вызов переопределенного метода в типе-потомке
- Наследование конструкторов
- Реализация констант-атрибутов типа
- Заключение
Введение
Многие из нас с появлением Oracle9i Database и далее Oracle10g Database начали активно разрабатывать приложения с помощью объектно-ориентированного PL/SQL. Однако вскоре выяснилось, что корпорация Oracle не полностью реализовала возможности присущие объектно-ориентированным языкам. В результате многие разработчики приложений на Oracle Database "охладели" к объектным возможностям PL/SQL.
В предлагаемой вашему вниманию статье предлагается ряд решений проблем, с которыми сталкиваются разработчики. Я уверен, что Oracle9i PL/SQL позволяет реализовывать развитую объектную модель, и, надеюсь, мое мнение разделит читатель.
Каждый раздел статьи сопровождается исходными текстами скриптов, демонстрирующими сответствующий подход. Все скрипты запускались и проверялись с помощью последней доступной на текущий момент версии Oracle10g Database - 10.1.0.2 Скрипты тестировались на следующей версии: Oracle 10.1.0.2 Enterprise Edition for linux x86 (Intel Xeon)
Вызов переопределенного метода в типе-потомке
С этой проблемой PL/SQL-программисты сталкиваются наиболее часто. Проблема связана с тем, что в PL/SQL отсутствует синтаксическая конструкция для вызова метода типа-предка. В случае порождения нового объектного типа от родительского, виртуальный метод переопределеяется, далее в этом порожденном типе нам необходимо вызвать данный метод типа-предка.
Например: пусть у нас есть класс t_ParentType в котором определен метод getName:
------------------------------------------------------------ --спецификация объектного типа t_ParentType: - ------------------------------------------------------------ create or replace type t_ParentType as object ( v_Field1 varchar2(32), member function getName return varchar2 ) not final; ------------------------------------------------------------ --тело объектного типа t_ParentType: - ------------------------------------------------------------ create or replace type body t_ParentType as member function getName return varchar2 is begin return self.v_Field1; end; end;
Теперь мы определяем объектный тип t_ChildType, который является наследником t_ParentType. В типе t_ChildType метод getName является виртуальным и переопределен. Для этого использовано ключевое слово OVERRIDING:
------------------------------------------------------------ --Спецификация объектного типа t_ChildType, - --который является наследником : t_ParentType - --Внимание: метод getName переопределен - ------------------------------------------------------------ create or replace type t_ChildType under t_ParentType ( v_Field2 varchar2(64), overriding member function getName return varchar2 ) not final;
В реализации метода getName попытаемся вызвать унаследованный метод getName (объектного типа t_ParentType)
------------------------------------------------------------ --Тело объектного типа t_ChildType, - --в методе getName необходимо вызвать унаследованный метод - ------------------------------------------------------------ create or replace type body t_ChildType is overriding member function getName return varchar2 is begin return (???) getName // ' ' // v_Field2; -- как вызвать -- метод предка ??? end; end;
Таким образом, выясняется, что в PL/SQL нет синтаксической конструкции, для того чтобы сослаться на метод типа-предка.
В объектно-ориентированных языках для этого существуют специальные языковые конструкции. В Java это ключевое слово super (супер-класс), в Object Pascal - Inherited. Данный механизм обеспечивает доступ к унаследованной логике и устраняет избыточность кода. Документация по языку PL/SQL (Oracle10g Rel.1 PL/SQL User's Guide and Reference, Oracle10g Rel.1 Application Developer's Guide - Object-Relational Features) хранит по этому поводу молчание.
Для решения этой проблемы предлагается следующий алгоритм:
- Создается экземпляр типа-предка
- Затем копируется в него содержимое полей текущего экземпляра
- Происходит вызов нужного метода экземпляра типа-предка
- Поля экземпляра типа-предка копируются в текущий экземпляра.
Модифицируем исходный текст для реализации этого подхода, добавив в родительский тип копирующий конструктор:
------------------------------------------------------------ --спецификация объектного типа t_ParentType, - --добавлен копирующий конструктор - ------------------------------------------------------------ create or replace type t_ParentType as object ( v_Field1 varchar2(32), --копирующий конструктор: constructor function t_ParentType(v_pObject in out nocopy t_ParentType) return self as result, member function getName(self in out nocopy t_ParentType) return varchar2 ) not final; ------------------------------------------------------------ --тело объектного типа t_ParentType - ------------------------------------------------------------ create or replace type body t_ParentType is constructor function t_ParentType(v_pObject in out nocopy t_ParentType) return self as result is begin self.v_Field1 := v_pObject.v_Field1; return; end; member function getName(self in out nocopy t_ParentType) return varchar2 is begin return self.v_Field1; end; end;
В типе-потомке нам также будет необходим метод присваивания, который будет копировать все поля переменной экземпляра типа в текущий экземпляр, - назовем его assign. Далее добавим функцию inherited_getName, которая будет реализовывать алгоритм вызова функции getName родительского типа t_ParentType. Фактически метод inherited_getName представляет собой оболочку для метода getName типа-предка t_ParentType.
------------------------------------------------------------ --Спецификация объектного типа t_ChildType, - --который является наследником : t_ParentType - --Добавлен метод присваивания - assign - ------------------------------------------------------------ create or replace type t_ChildType under t_ParentType ( v_Field2 varchar2(64), constructor function t_ChildType(v_pField1 varchar2, v_pField2 varchar2) return self as result, --метод для вызова унаследованного метода getName: member function inherited_getName(self in out nocopy t_ChildType) return varchar2, --метод присваивания: member procedure assign(self in out nocopy t_ChildType, v_pObject in out nocopy t_ChildType), overriding member function getName(self in out nocopy t_ChildType) return varchar2 ) not final; ------------------------------------------------------------ --Тело объектного типа t_ChildType - ------------------------------------------------------------ create or replace type body t_ChildType is constructor function t_ChildType(v_pField1 varchar2, v_pField2 varchar2) return self as result is begin self.v_Field1 := v_pField1; self.v_Field2 := v_pField2; return; end; member function inherited_getName(self in out nocopy t_ChildType) return varchar2 is v_xInheritedObject t_ParentType; --экземпляр объекта-предка v_xRes varchar2(32); begin -- создаем экземпляр предка с помощью копирующего конструктора v_xInheritedObject := new t_ParentType(self); -- вызываем метод getName класса-предка v_xRes := v_xInheritedObject.getName; -- в общем случае вызов метода предка мог изменить поля self.assign(v_xInheritedObject); -- поэтому необходимо обратно скопировать их в текущий объект (self) return v_xRes; end; ---------------------------------------------------------- -- метод присваивания: - -- просто копируем все поля-объекта источника в текущий - -- экземпляр (self) - ---------------------------------------------------------- member procedure assign(v_pObject in out nocopy t_ChildType) is begin self.v_Field1 := v_pObject.v_Field1; self.v_Field2 := v_pObject.v_Field2; end; ---------------------------------------------------------- -- переопределенный метод getName: - -- через вызов inherited_getName происходит обращение к - -- унаследованному методу getName - ---------------------------------------------------------- overriding member function getName(self in out nocopy t_ChildType) return varchar2 is begin return inherited_getName // '-' // v_Field2; end; end;
В заключение, можно заметить, что данная методика применима для иерархий типов произвольного числа уровней. Если же необходимо обеспечить вызов переопределенного метода из произвольного родительского класса, то нужно иметь уникальные имена для методов-оболочек.
Например: в следующей иерархии классов: t_ParentType -> t_ChildType -> t_SubChildType для вызова метода произвольного типа-предка можно использовать следующие правило: к имени метода добавляется цифра - номер уровня в иерархии. В этом случае имена методов-оболочек соответственно будут выглядеть следующим образом: getName0->getName1->getName2
Наследование конструкторов
Очередная трудность связана с тем, что в PL/SQL не поддерживает прямой вызов унаследованного конструктора. (Проще говоря, конструкторы базового типа не наследуются!). Например: пусть у нас есть класс t_ParentType в котором определен пользовательский (user-defined) конструктор:
---------------------------------------------------------------- --спецификация объектного типа t_ParentType: - ---------------------------------------------------------------- create or replace type t_ParentType as object ( v_Field1 varchar2(32), constructor function t_ParentType(v_pName varchar2) return self as result ) not final; ---------------------------------------------------------------- --тело объектного типа t_ParentType: - ---------------------------------------------------------------- create or replace type body t_ParentType as constructor function t_ParentType(v_pName varchar2) return self as result is begin self.v_Field1 := v_pName; return; end; end;
Теперь мы определяем объектный тип t_ChildType, который является наследником t_ParentType. В типе t_ChildType также определен пользовательский конструктор:
---------------------------------------------------------------- --Спецификация объектного типа t_ChildType, - --который является наследником : t_ParentType - ---------------------------------------------------------------- create or replace type t_ChildType under t_ParentType ( v_Field2 varchar2(64), constructor function t_ChildType(v_pName varchar2, v_pDescription varchar2) return self as result );
В реализации конструктора типа t_ChildType попытаемся вызвать унаследованный конструктор:
---------------------------------------------------------------- --Тело объектного типа t_ChildType - --в конструкторе необходимо вызвать унаследованный конструктор - ---------------------------------------------------------------- create or replace type body t_ChildType is constructor function t_ChildType(v_pName varchar2, v_pDescription varchar2) return self as result is begin t_ParentType(v_pName => v_pName); self.v_Field2 := v_pDescription; return; end; end;
Выясняется, что сделать это не удается:
liNE/COL ERROR -------- ----------------------------------------------------------------- 6/5 PLS-00306: wrong number or types of arguments in call to 'T_PARENTTYPE'
Итак: как же вызвать конструктор родительского типа, чтобы не дублирвать уже реализованный в нем код ?
Предлагается примерно тот же самый метод, что и в предыдущем разделе: создание экземпляра типа-предка, с последующим присвоением его полей полям текущего экземпляра. Для этого нам понадобится метод присвоения assign:
---------------------------------------------------------------- --Спецификация объектного типа t_ChildType, - --который является наследником : t_ParentType - --добавлен метод присваивания assign - ---------------------------------------------------------------- create or replace type t_ChildType under t_ParentType ( v_Field2 varchar2(64), constructor function t_ChildType(v_pName varchar2, v_pDescription varchar2) return self as result, member procedure assign(self in out nocopy t_ChildType, v_pObject in out nocopy t_ParentType), member function getName return varchar2 ); ---------------------------------------------------------------- --Тело объектного типа t_ChildType - --в конструкторе вызывается конструктор базового типа - ---------------------------------------------------------------- create or replace type body t_ChildType is constructor function t_ChildType(v_pName varchar2, v_pDescription varchar2) return self as result is --экземпляр объекта-предка v_xInheritedObject t_ParentType; begin --вызов конструктора базового типа v_xInheritedObject := new t_ParentType(v_pName => v_pName); -передача данных текущему экземпляру self.assign(v_xInheritedObject); - self.v_Field2 := v_pDescription; return; end; -------------------------------------------------------------- --метод присваивания экземпляра базового типа текущему - --оьъекту (self) - -------------------------------------------------------------- member procedure assign(self in out nocopy t_ChildType, v_pObject in out nocopy t_ParentType) is begin self.v_Field1 := v_pObject.v_Field1; end; member function getName return varchar2 is begin return self.v_Field1 // ' - ' // self.v_Field2; end; end;
Вышеописанная методика демонстрируется в данном примере.
Реализация констант-атрибутов типа
Объектно-ориентированное расширение языка PL/SQL поддерживает статические методы типа, однако во многих случаях бывает необходимо использовать статические атрибуты класса, к сожалению PL/SQL не поддерживает такие поля. Нам бы хотелось иметь подобный код:
create or replace type t_ParentType as object ( v_Name varchar2(50), static v_Const varchar2(32) := 'Scott Tiger' );
Увы, мы получаем ошибку:
ORA-06545: PL/SQL: compilation error - compilation aborted ORA-06550: line 5, column 12: PLS-00103: Encountered the symbol "V_CONST" when expecting one of the following: function procedure
Для реализации таких атрибутов можно использовать статический метод, который бы возвращал требуемое значение. Если значение атрибута также имеет объектный тип, то в качестве места хранения значения такого атрибута можно использовать вспомогательный пакет. Для защиты переменной от модификации необходимо поместить её объявление в тело пакета.
Следующий листинг реализует данный подход:
-------------------------------------------------------------- --Значение данного типа должен иметь атрибут объектного типа - -------------------------------------------------------------- create or replace type t_DictConst as object ( v_Id number(9), v_Name varchar2(50), v_Code varchar2(15), v_Description varchar2(250) ); -------------------------------------------------------------- --Спецификация вспомогательного пакета для типа t_ParentType:- --функция getConst возвращает объект типа t_DictConst - -------------------------------------------------------------- create or replace package serv$ParentType is function getConst return t_DictConst; end; -------------------------------------------------------------- --Тело пакета: объект-константа формируется в процедуре init - -------------------------------------------------------------- create or replace package body serv$ParentType is v_gDictConst t_DictConst; function getConst return t_DictConst is begin return v_gDictConst; end; procedure init is begin v_gDictConst := new t_DictConst(1,'Scott Tiger', '01','Scott Tiger - Oracle demo-user'); end; begin init; end;
Следующий объектный тип реализует статический метод, который возвращает объект-константу:
-------------------------------------------------------------- --Спецификация объектного типа t_ParentType - --Статический метод возвращает константу - -------------------------------------------------------------- create or replace type t_ParentType as object ( v_Name varchar2(50), static function getConst return t_DictConst ); create or replace type body t_ParentType is static function getConst return t_DictConst is begin return serv$ParentType.getConst; end; end;
Вышеописанная методика демонстрируется в данном примере.
Заключение
Мы рассмотрели методы решения наиболее часто встречающихся проблем при использовании объектно-ориентированных возможностей PL/SQL. Конечно, многие проблемы могут быть решены только самими разработчика корпорации Oracle. Например, отсутствие защищенных полей объектного типа (так называемых private-полей), отсутствие поддержки интерфейсов и т.д.
Будем надеяться, что в следующих версиях Oracle Database эти недоработки будут устранены.