Роман Игнатьев
Введение
Необходимые знания: Перед прочтением рекомендуется ознакомиться с технологией MIDAS хотя бы на уровне демонстрационных приложений, поставляющихся с Delphi.
Технология MIDAS (Multi-tier Distributed Application Services Suite, Сервис для создания многоуровневых распределенных приложений) была предложена фирмой Borland уже довольно давно, первое приложение с ее использованием я написал еще в 98 году, на Delphi 4. И с тех пор практически все приложения для работы с базами данных создаются мной именно на основе MIDAS. О преимуществах, думаю, говорить не надо – даже простое разделение приложения на две части, одна из которых работает с базой данных (сервер приложений), а другая обеспечивает интерфейс пользователя, создает значительные удобства как при разработке приложения, так и при его использовании.
Сейчас существует множество статей и книг по технологии создания многозвенных приложений на Delphi, но, к сожалению, мне не удалось найти литературы, в которой бы рассматривались некоторые интересующие меня вопросы. Дело в том, что во всех примерах создается трехзвенное приложение, в котором сервер приложений просто соединяет сервер БД с клиентской частью, просто абстрагируя работу с базой данных.
С одной стороны, это дает некоторое преимущество при переходе с двухуровневой технологии (клиент-сервер) на трехуровневую, для чего компоненты доступа к базе данных из клиентской части переносятся в сервер приложений. С другой стороны, хочется большего, а именно переноса на сервер не только работы с таблицами базы данных, но и основной логики приложения, оставляя клиентской части только задачу взаимодействия с пользователем.
Ниже рассматривается очень простое приложение для работы с сервером БД. База данных, с которой работает это приложение, содержит всего 3 таблицы. С его помощью мне хотелось бы показать некоторые способы создания полноценного сервера приложений, обеспечивающего полную обработку данных.
Все, что написано ниже, относится к Delphi 5, в качестве сервера выбран Interbase 5.6. Именно эти продукты я использовал в большинстве проектов. Однако база данных работает и на более старших версиях Interbase, я проверял ее работоспособность, в частности, на IB6, а исходные тексты приложения с минимальными изменениями можно компилировать на старших версиях Delphi. К сожалению, некоторые изменения делать все же придется, так как MIDAS постоянно развивается. Но, как правило, такие изменения носят косметический характер, и сделать их несложно. Как изменить проект для компиляции на Delphi 6, будет рассказано в заключительной части. Несмотря на то, что в сервере приложений используются компоненты прямого доступа Interbase Express (IBX), нетрудно перейти на другой сервер БД, просто заменив компоненты доступа и немного изменив текст методов.
Исходя из практических соображений ниже описано создание трехуровневого приложения, включая разработку структуры базы данных. Мне не хотелось пользоваться готовыми примерами, входящими в поставку Interbase и Delphi, чтобы не придерживаться шаблонов, навязываемых ими.
Постановка задачи
Я собираюсь на простом примере показать возможности технологии, поэтому приложение будет работать всего с одним логическим объектом – некоторым абстрактным документом, состоящим из заголовка и содержимого. Такая структура была выбрана из-за того, что связь “мастер-таблица - подчиненная таблица” (master-detail) очень часто встречается на практике, и также часто в приложениях встречается обработка различных документов.
“Документ” здесь понимается как некоторая абстракция, напоминающая реальные документы, такие, как накладная или счет.
Разумеется, необходимо обеспечить одновременную работу с документами нескольких пользователей.
Описание документа
Заголовок документа прост, и состоит из следующих полей:
Номер – номер документа.
Дата – дата выписки, по умолчанию текущая.
Поставщик – имя, телефон.
Получатель – также имя и телефон.
Сумма – общая сумма по документу.
Поставщик и получатель будут выбираться из единого справочника клиентов, содержащего только два поля: имя и телефон.
Документ содержит записи со сведениями о перемещении неких товаров. Содержимое документа – это таблица в базе данных, записи которой состоят из следующих полей:
Порядковый номер
Номер документа, к которому относится.
Наименование - наименование товара.
Количество.
Цена.
Сумма.
Результат может выглядеть следующим образом:
| номер п/п | наименование | количество | цена | сумма |
| Что-то | 30.00 | 30.00 | ||
| Что-то еще | 10.50 | 21.00 | ||
| ... |
Пользователю должен выдаваться список документов с указанием реквизитов документа и его итоговой суммы.
Сумма документа будет рассчитываться сервером приложений на основе его содержимого.
Кроме этого, создадим итоговый отчет – "шахматную" ведомость, где по одной оси расположены поставщики, а по другой – получатели:
| За период с <дата> по <дата> (по дате документа) | |||
| От кого | Кому | ||
| Получатель1(имя) | Получатель2(имя) | ... | |
| Поставщик1(имя) | Сумма | Сумма | |
| Поставщик2(имя) | Сумма | Сумма | |
| ... |
В отчет будут входить суммы из документов, даты которых попадают в заданный период.
Отчет, разумеется, получается также достаточно оторванным от жизни, мне просто хотелось показать с его помощью дополнительные возможности MIDAS.
Блокировки
Поскольку работать с БД будут сразу несколько пользователей, важно заблокировать документ на время редактирования документа пользователем. “Почетная обязанность” синхронизации работы пользователей возлагается в данном случае на сервер приложений. В принципе, все это можно реализовать и средствами SQL сервера, но, во-первых, для сервера Interbase блокировки записей довольно неестественны, во-вторых, как будет видно ниже, сервер приложений позволяет легко блокировать сразу весь документ как единый объект.
Структура БД
Требования к приложению описаны, и теперь можно приступить к следующему этапу – созданию БД. Нам нужны три таблицы (магическое число три выбрано исключительно для простоты): для документа, содержимого документа и справочника клиентов. Документ содержит две ссылки на справочник клиентов – “Поставщик” и "Получатель", а содержимое документа имеет ссылку на документ. На рисунке 1 представлена ER-диаграмма этой БД.
Рисунок 1. ER-модель БД.
В данной базе целостность данных обеспечивается по следующим правилам:
При упоминании в каком-либо документе поставщика или получателя удаление этой строки из справочника клиентов не допускается.
При удалении документа удаляются и все связанные с ним строки из таблицы "Содержимое документа".
Вставка в таблицу "Содержимое документа" допускается только при условии, что поле ID ссылается на существующий документ.
Как видно, в таблице "Заголовок документа" есть поле "Сумма". Это поле должно содержать полную сумму документа (сумму полей "Сумма" содержимого документа). При изменении содержимого документа приходится пересчитывать значение этого поля. Наличие такого поля, является нарушением принципов нормализации. Эту сумму всегда можно посчитать в SQL-запросе при выводе данных пользователю. Но при выдаче списка документов расчет суммы каждого из них увеличивает нагрузку на сервер БД. Отслеживать актуальность этого поля можно на триггерах СУБД, но раз уж мы создаем сервер приложений, почему бы не возложить на него эту задачу? К тому же, это обеспечивает некоторую независимость от особенностей функционирования сервера БД, что может оказаться полезным, например, при переходе на другой сервер.
Ниже приведен скрипт, создающий подопытную БД:
| /* Определены следующие типы данных: Имя клиента Количество для содержимого документа Цена Сумма */ create domain DName varchar(180); create domain DCount numeric(15,4) default 1 not null; create domain DCurrency numeric(15,2) default 0 not null; create domain DSum numeric(15,4) default 0 not null; /* Справочник поставщиков и получателей */ create table CLIENT ( CLIENT_ID integer not null, NAME DName not null, /* Имя */ PHONE varchar(40), /* Телефон */ constraint PK_CLIENT primary key (CLIENT_ID) ); /*Заголовок документа*/ create table DOC_TITLE ( DOC_ID integer not null, /* ID */ DOC_NUM varchar(40) not null, /* Номер */ DOC_DATE date not null, /* Дата */ FROM_ID integer default 0 not null, /* Поставщик */ TO_ID integer default 0 not null, /* Получатель */ DOC_SUM DSum, /* Сумма */ constraint PK_DOC_TITLE primary key (DOC_ID), constraint FK_DOC_FROM_CLIENT foreign key (FROM_ID) references Client (CLIENT_ID) on update cascade, constraint FK_DOC_TO_CLIENT foreign key (TO_ID) references Client (CLIENT_ID) on update cascade ); /*Содержимое*/ create table DOC_BODY ( DOC_ID integer not null, /* сcылка на заголовок */ LINE_NUM integer not null, /* Номер п/п */ CONTENT varchar(250) not null, /* Наименование */ COUNT_NUM DCount, /* Количество */ PRICE DCurrency, /* Цена */ constraint PK_DOC_BODY primary key (DOC_ID, LINE_NUM), constraint FK_DOC_BODY_TITLE foreign key (DOC_ID) references DOC_TITLE (DOC_ID) on delete cascade on update cascade ); |
Скрипт создает три таблицы: CLIENT (поставщики/получатели), DOC_TITLE (документ), DOC_BODY (содержимое документа).
Следующий этап – формирование списка документов. В заголовке документа содержится только ссылка на поставщика и получателя. Вывод списка удобно организовать отдельным запросом, а в данном случае – хранимой процедурой. Пусть для удобства имя клиента в списке показывается в виде "Имя (Телефон)". Для этого сделаем процедуру CLIENT_FULL_NAME, которая извлекает эту строку, и будем вызывать ее из процедуры выдачи списка LIST_DOC. Эта же процедура пригодится для отображения имени поставщика и получателя на форме редактирования документа:
| create procedure CLIENT_FULL_NAME(ID integer) returns (FULL_NAME varchar(224)) as declare variable NAME varchar(180); declare variable PHONE varchar(180); begin select NAME,PHONE from client where CLIENT_ID =:ID into:NAME,:PHONE; FULL_NAME = ''; if (NAME is not NULL) then FULL_NAME = NAME; if (PHONE is not NULL) then FULL_NAME = FULL_NAME || ' (' || PHONE || ')'; end create procedure LIST_DOC (FROM_DATE date, TO_DATE date) returns (DOC_ID integer, DOC_NUM varchar(40), DOC_DATE date, FROM_ID integer, TO_ID integer, FROM_NAME varchar(224), TO_NAME varchar(224), DOC_SUM numeric(15,4)) as begin for select DOC_ID, DOC_NUM, DOC_DATE, FROM_ID, TO_ID, DOC_SUM from DOC_TITLE where DOC_DATE >=:FROM_DATE and DOC_DATE <=:TO_DATE into:DOC_ID,:DOC_NUM,:DOC_DATE,:FROM_ID,:TO_ID,:DOC_SUM do begin FROM_NAME = NULL; TO_NAME = NULL; execute procedure CLIENT_FULL_NAME (:FROM_ID) returning_values:FROM_NAME; execute procedure CLIENT_FULL_NAME (:TO_ID) returning_values:TO_NAME; suspend; end end |
Осталась процедура для отчета:
| create procedure REP_INOUT(FROM_DATE date, TO_DATE date) returns (FROM_ID integer, FROM_NAME varchar(180), TO_ID integer, TO_NAME varchar(180), FULL_SUM numeric(15,4)) as begin for select FROM_ID, TO_ID, sum(DOC_SUM) from DOC_TITLE where DOC_DATE >=:FROM_DATE and DOC_DATE <=:TO_DATE group by FROM_ID, TO_ID into:FROM_ID,:TO_ID,:FULL_SUM do begin FROM_NAME = NULL; TO_NAME = NULL; select NAME from client where CLIENT_ID =:FROM_ID into:FROM_NAME; select NAME from client where CLIENT_ID =:TO_ID into:TO_NAME; if (FULL_SUM is NULL) then FULL_SUM = 0; suspend; end end |
Процедура выдает то, что нужно для отчета, но, к сожалению, не в виде перекрестного отчета, а по строкам:
| От кого | Кому | На сумму |
| <Поставщик> | <Получатель> | Сумма... |
| ... |
Приводить к нормальному виду все это будет сервер приложений.
Все готово для написания сервера приложений. Приступим.
Сервер приложений
Создаваемый нами сервер приложений будет отдельным исполняемым модулем. Этот модуль затем можно будет расположить на отдельном компьютере, который сможет производить расчеты для нескольких клиентов и синхронизировать их работу.
Сервер приложений должен обеспечивать обработку документа как единого объекта, поэтому разумным будет выделить работу с ним в отдельный класс, в данном случае потомок TRemoteDataModule. Нам также понадобится модуль данных для работы со справочником поставщиков и получателей, и выдачи списка документов. Отчет я решил также выделить в отдельный модуль. В итоге на сервере необходимо создать три потомка TRemoteDataModule: rdmCommon (общий модуль со списками поставщиков/получателей и документов), rdmDoc и rdmReport – соответственно для документа и отчета.
Мастер создания удаленного модуля данных предлагает по умолчанию политику загрузки исполняемого модуля Multiple instance и модель потоков Apartment. Это именно то, что нам нужно! Действительно, Instancing = Internal приведет к созданию серверного компонента в клиентском процессе (это распространяется только на сервер, создаваемый в виде DLL). При Single instance каждая клиентская часть будет соединяться со своим собственным экземпляром сервера приложений, а синхронизацию проще сделать, если все клиенты подсоединяются к одному экземпляру сервера приложений. Выбор модели потоков Apartment позволит избежать ручной синхронизации доступа к данным компонента.
Теперь остается создать три (опять три, это тоже случайно) потомка TRemoteDataModule, расположить на них компоненты доступа к данным и написать код для обработки данных.
При этом необходимо учитывать, что при использовании модели потоков Apartment каждый модуль данных работает в своем потоке, и поэтому в каждом модуле должен находится отдельный компонент TIBDatabase.
При прямом доступе провайдера к базе (свойство ResolveToDataset = false) MIDAS также требует наличия отдельной копии объекта TIBTransaction для каждого компонента доступа к данным, то есть у каждого провайдера должна быть своя транзакция. Компонент TIBTransaction специфичен для компонентов прямого доступа к Interbase, обычно работа с транзакциями возложена на компонент соединения с базой данных.
| ПРИМЕЧАНИЕ При использовании сервера Interbase для доступа к данным по технологии MIDAS логично использовать IBX, провайдеры данных великолепно работают с этими компонентами. Единственное замечание – Borland сертифицировала на момент написания статьи версию IBX 4.52. Более поздние версии работают в составе MIDAS несколько иначе, чем раньше. В частности, транзакции теперь не закрываются автоматически после выборки данных. |
Рассмотрим удаленные модули данных по порядку, и начнем с модуля справочников (rdmCommon) (рисунок 2).
Рисунок 2. Общий модуль rdmCommon.
Компонент ibqDocs имеет тип TIBDatabase и обеспечивает соединение модуля с сервером БД. У меня БД находится в каталоге d:\projects\docmidas\data\ и называется doc.gdb. В прилагающемся к статье проекте сервер приложений позволяет указать произвольное местонахождение сервера БД и файла базы данных.
Для того, чтобы при каждом соединении сервер приложений не запрашивал имя пользователя и пароль, они просто указаны в параметрах соединения. Имя пользователя SYSDBA и пароль masterkey являются установками по умолчанию при инсталляции сервера Interbase.
Перечислим компоненты модуля. К компоненту транзакции ibtClient подсоединен запрос ibqClient (компонент TIBQuery), к которому, в свою очередь, присоединен провайдер dspClient. Соответственно, у транзакции и запроса указано соединение с БД ibdDocs. Остается только установить тип транзакции read committed (удобнее всего это сделать, дважды щелкнув на соответствующем компоненте, и выбрав его тип), и в свойстве SQL-запроса записать “select * from client”. Теперь провайдер может предоставлять клиентской части возможность работать со справочником клиентов. Но для повышения комфорта нужно добавить возможность нескольким пользователям изменять одновременно разные поля в одной и той же записи в таблице (их два: Name и Phone). Делается это довольно просто, в редакторе полей (Fields Editor) ibqClient нужно создать постоянный список всех полей запроса, и у поля CLIENT_ID в его свойство ProviderFlags добавить опцию pfInKey. Затем у провайдера dspClient установить свойство UpdateMode в upWhereChanged. В этом случае, если разные клиентские части изменят разные поля одной записи в таблице CLIENT, сервер приложений примет эти изменения. В случае, если будут изменены одни и те же поля одной записи, клиентской части будет выдано сообщение вида «Запись изменена другим пользователем».
| ПРИМЕЧАНИЕ Здесь мне хотелось бы остановиться на свойствах TField.ProviderFlags и TDataSetProvider.UpdateMode. Дело в том, что меня часто спрашивают, что зависит от значений этих свойств, а зависит от них довольно много. В справке по VCL эти свойства описаны, на мой взгляд, недостаточно подробно, а связь между ними достаточно тесная. Итак, пусть имеется компонент TQuery, TIBQuery или какой-то другой (запрос), соединенный с сервером БД, и к нему присоединен TDataSetProvider. В этом случае на логику работы оказывают влияние именно значения свойства ProviderFlags полей этого запроса, аналогичные свойства полей на клиентской стороне никакого влияния не оказывают. Комбинация значений этих свойств полностью определяет, как будут производиться операции обновления данных на сервере БД. Рассмотрим обновление данных в таблице. Добавление и удаление записи происходит аналогично. Провайдер с установленным свойством ResolveToDataset = false при обновлении записи формирует SQL-запрос вида UPDATE <Table> SET <Field1>=<NewValue1>,... WHERE <Field1>=<OldValue1> AND..., в полном соответствии со стандартом SQL (при ResolveToDataset=True производится поиск и обновление прямо в таблице). Имя таблицы <Table> берется из Dataset (провайдер великолепно понимает запросы SQL вида Select from...), либо задается в обработчике OnGetTableName. Значения NewValue и OldValue для каждого поля берутся из пакета обновления, посылаемого провайдеру. Имена полей в выражениях SET и FROM формируются автоматически, как раз на основе свойств ProviderFlags и UpdateMode того набора данных, через который провайдер работает с базой. Алгоритм следующий: В предложение SET входят только те поля, у которых установлен флаг pfUpdate в свойстве ProviderFlags (требуется обновлять в базе данных) и OldValue <> NewValue (значение поля было изменено). Предложение WHERE формируется следующим образом: Берутся все поля, у который установлены [pfInKey, pfInWhere], фактически это первичный ключ. При UpdateMode=upWhereKeyOnly больше никаких полей не берется. При UpdateMode=upWhereChanged к полям первичного ключа добавляются те поля, у которых OldValue <> NewValue и pfWhere in ProviderFlags, что позволяет делать проверку на изменение тех же полей другим пользователем. При UpdateMode=upWhereAll в список полей WHERE входят все поля записи, у которых pfWhere in ProviderFlags. В случае, если запись в таблице на сервере не найдена (нет записей, удовлетворяющих условию WHERE), пользователю выдается сообщение вида "Запись изменена другим пользователем", вне зависимости от причины. Остается одно значение флага, pfHidden. Поля с этим флагом не передаются клиентскому приложению, и не принимаются от него, флаг указывает, что эти поля - только для использования на стороне сервера. |
Если уж создан постоянный список полей, можно установить параметры их отображения на клиентской части, в частности, DisplayLabel, DisplayWidth и Visible, а у провайдера - флаги poIncFieldProps. При этом на клиентской части можно не заботиться о списке полей – значения, полученные с сервера приложений, переопределяют заданные на клиенте в любом случае. Заодно у провайдера надо установить опцию poMultiRecordUpdates, чтобы на клиентской части можно было изменять сразу несколько записей в справочнике до отправки изменений на сервер.
Поле CLIENT_ID в справочнике поставщиков и получателей является первичным ключем, а стало быть, в нем должны содержаться уникальные значения. Для получения уникальных значений удобно использовать автоинкрементальные поля (autoincrement field). В IB собственно автоинкрементных полей нет, нарастающие значения получают от генератора с помощью функции Gen_ID, и как правило, присваивают это значение полю в триггере. Мне нравится ситуация, когда новое уникальное значение появляется на клиентской части сразу после добавления записи. Поэтому вместо присвоения значения, полученного от генератора, в триггере, используется хранимая процедура, результатом работы которой и является это значение. Для этого в удаленном модуле данных расположен компонент spNewID: TIBStoredProc, присоединенный к компоненту транзакции ibtDefault, который предоставляет доступ к хранимой процедуре на сервере БД. Процедура описана в базе данных следующим образом:
| create procedure CLIENT_ID returns (ID integer) as begin ID = Gen_ID(CLIENT_ID_GEN,1); end |
Как видно, процедура просто выдает следующее значение генератора. Это гарантирует, что при последовательных запросах к ней это значение повторяться не будет. Получение значения на клиентской части обеспечивается методом сервера, об этом немного ниже.
Вторая хранимая процедура, spClientFullName, присоединена к компоненту транзакции ibtClient и предназначена для выдачи имени и телефона поставщика или получателя в виде единой строки «Имя (телефон)», возвращаемой процедурой сервера БД CLIENT_FULL_NAME. Эта строка также передается на клиентскую часть через метод сервера.
Группа компонентов ibtDocList, ibqDocList, dspDocList и ibqDelDoc предназначена для работы со списком документов. У IbtDocList, компонента транзакции, установлен режим read committed, а в компоненте ibqDocList содержится SQL-запрос «select * from List_doc(:FromDate,:ToDate)». Весь список документов сразу выводить довольно бессмысленно, их может быть много. Поэтому запрос выбирает список документов, даты которых лежат в промежутке от FromDate до ToDate. Провайдер dspDocList выдает этот список клиентской части.
Дополнительный компонент, ibqDelDoc, как, думаю, видно из его названия, предназначен для удаления документа, в его свойстве SQL стоит запрос «delete from DOC_TITLE where DOC_ID =:DOC_ID». Несмотря на то, что для создания и изменения документа планируется использовать отдельный модуль, rdmDoc, для удаления документа вовсе необязательно его открывать, и с точки зрения интерфейса пользователя удобно делать это прямо из списка документов. На первый взгляд, использование отдельного запроса для удаления кажется излишним, для этого обычно достаточно объявить в обработчике dspDocList.OnGetTableName имя таблицы (DOC_TITLE), и удаление будет автоматически обеспечено. Однако в постановке задачи стоит условие, что открытый в одной клиентской части документ должен быть недоступен для изменения (а значит, и удаления) из других клиентских частей. Поэтому приходится делать это в обработчике события dspDocList.OnBeforeUpdateRecord следующим образом:
| procedure TrdmCommon.dspDocListBeforeUpdateRecord(Sender: TObject; SourceDS: TDataSet; DeltaDS: TClientDataSet; UpdateKind: TUpdateKind; var Applied: Boolean); var DocID: Integer; begin if UpdateKind = ukDelete then //Только если запись удаляется begin DocID:= DeltaDS.FieldByName('DOC_ID').AsInteger; try if not RegisterDoc(DocID) then //Пытаемся зарегистрировать raise Exception.Create('Документ редактируется'); with ibqDelDoc do //Удаляем begin paramByName('DocID').AsInteger:= DocID; ExecSQL; end; Applied:= True; finally UnregisterDoc(DocID); //Изменение закончено, удалили end; end; end; |
Если удаляется документ, попытаемся его зарегистрировать в списке редактируемых функцией RegisterDoc, затем, если это получилось, удаляем его с помощью запроса ibqDelDoc и удаляем из списка редактирования (UnregisterDoc). Устанавливаем Applied:= true, чтобы сказать провайдеру, что все уже сделано.
Конечно, одновременно может редактироваться (удаляться, добавляться) довольно много документов, поэтому нужен единый список этих документов, к которому будут обращаться процедуры RegisterDoc и UnregisterDoc. Поскольку обращение к нему будет производиться из модулей данных, работающих в разных потоках, то наилучшим образом для этого подходит TThreadList (потокобезопасный класс списка). Список документов должен быть единым для всех клиентских частей, поэтому расположить его нужно в отдельном модуле, например, в модуле главной формы сервера. На ней потом можно вывести, например, список редактируемых на данный момент документов. Так и сделаем.
В модуле главной формы сервера в разделе implementation объявим переменную DocList: TThreadList; Этот список лучше инициализировать сразу при запуске сервера и уничтожать при выходе:
| initialization DocList:= TThreadList.Create; finalization if Assigned(DocList) then begin DocList.Free; DocList:= nil; end; end. |
С этим списком работают две функции: RegisterDoc и UnregisterDoc:
| function RegisterDoc(DocID: integer): boolean; begin Result:= False; if DocID = 0 then Exit; with DocList.LockList do try if IndexOf(Pointer(DocID)) < 0 then begin Add(Pointer(DocID)); Result:= True; end; finally DocList.UnlockList; end; end; function UnregisterDoc(DocID: integer): boolean; begin Result:= False; if DocID = 0 then Exit; with DocList.LockList do try if IndexOf(Pointer(DocID)) >= 0 then begin Remove(Pointer(DocID)); Result:= True; end; finally DocList.UnlockList; end; end; |
В списке хранятся идентификаторы документов. Но TThreadList предназначен для хранения указателей. Поэтому для хранения в этом списке идентификатора, имеющего тип Integer, придется привести его к типу pointer. Конечно, если потребуется хранить дополнительную информацию о документе, например, его номер, придется организовать в списке ссылки на записи, с выделением памяти под эту запись и уничтожением ненужных записей. При этом внешний вид функций не изменится, просто усложнится работа со списком, и может понадобиться обращение к БД для получения дополнительной информации.
Теперь все просто: все модули данных, которые работают с документами, используют эти две функции, и если RegisterDoc возвращает false (а это произойдет только в том случае, если номер уже есть в списке), то пользователю выдается сообщение, что с документом уже работают. Функция UnregisterDoc просто удаляет номер из списка.
На клиенте понадобится, кроме доступа к двум провайдерам, еще пара функций – получение нового значения CLIENT_ID для справочника клиентов и получение полного имени клиента. Для этого необходимо создать описание этих функций в библиотеке типов.
В зависимости от того, какой синтаксис используется в редакторе библиотеки типов (IDL или Pascal), объявление этих функций выглядит по-разному, ниже приведены их описания в protected-секции модуля данных:
| protected class procedure UpdateRegistry(Register: Boolean; const ClassID, ProgID: string); override; function NewClientID: Integer; safecall; function Get_ClientName(ClientID: Integer): WideString; safecall; |
На IDL это выглядит так:
| [id(0x00000001)] HRESULT _stdcall NewClientID([out, retval] long * Result); [propget, id(0x00000004)] HRESULT _stdcall ClientName([in] long ClientID, [out, retval] BSTR * Value); |
Реализация этих функций довольно проста. Надо вызвать хранимые процедуры, и выдать возвращаемое ими значение в качестве результата:
| function TrdmCommon.NewClientID: Integer; begin lock; with spNewID do try ExecProc; Result:= paramByName('ID').AsInteger; finally unlock; end; end; function TrdmCommon.Get_ClientName(ClientID: Integer): WideString; begin lock; try with spClientFullName do begin paramByName('ID').AsInteger:= ClientID; ExecProc; Result:= paramByName('FULL_NAME').AsString; end; finally unlock; end; end; |
Теперь основной модуль готов, и можно перейти к написанию следующего модуля данных, предназначенного для работы с документом.
Рисунок 3.
Здесь уже все немного сложнее. Разумеется, здесь тоже есть соединение с базой ibdDoc, настроенное на сервер БД. Хранимая процедура spNewID выдает на этот раз номер для нового документа, используя процедуру DOC_TITLE_ID, аналогичную процедуре CLIENT_ID.
На этот раз в модуле данных, помимо компонентов запросов к серверу, присутствуют два компонента TСlientDataSet и два провайдера данных. Эти дополнительные компоненты предназначены именно для организации расчетов на сервере. Поскольку, как мы договорились, на сервере приложений должна рассчитываться сумма документа, то на нем должно быть известно содержимое документа до того, как оно будет сохранено в БД. Разумеется, это можно осуществить, используя события провайдера для предварительной обработки пакета изменений, поступившего от клиентской части, но мне хотелось показать возможность организации работы с документом как с полноценным объектом.
Идея простая: пусть весь удаленный модуль данных работает с одним документом. В таком случае этот модуль будет выглядеть для клиентской части как полноценный объект, владеющий всеми данными документа и предоставляющий клиентской части все необходимые свойства. Разумеется, от пакетов данных никто не отказывается.
Таким образом, организуется следующий алгоритм работы: Клиентская часть создает на сервере либо новый документ, либо открывает существующий (удаление документов уже реализовано). Сервер приложений создает модуль данных и, если необходимо, закачивает в него содержимое документа с сервера БД. После этого клиентская часть и удаленный модуль данных совместно обрабатывают эти данные, занимаясь каждый своим делом: клиентская часть предоставляет средства для изменения этих данных пользователем, а удаленный модуль производит все необходимые расчеты.
К одному компоненту транзакции ibtDoc присоединено на этот раз два запроса ibqTitle и ibqBody, соответственно выбирающих одну строку заголовка документа (select * from DOC_TITLE where DOC_ID =:DocID) и все строки этого документа (select * from DOC_BODY where DOC_ID =:DocID).
| ПРИМЕЧАНИЕ Хотя MIDAS требует наличия своей IBTransaction для каждой пары компонентов "IBQuery-провайдер", в данном случае это необязательно. Провайдеры не будут начинать и завершать транзакции, открываться и закрываться транзакция будет явно, в соответствующих методах. |
К этим запросам присоединены провайдеры dspTitleInner и dspBodyInner, назначение которых – получить данные с сервера БД и передать их в соответствующие ClientDataSet. Свойство Exported у этих провайдеров установлено в false, они нужны только внутри сервера приложений, и видеть их на клиентской части незачем. Соответственно, клиентский набор данных cdsTitle (компонент TClientDataSet) получает одну строку заголовка из dspTitle и cdsBody, содержимое документа из dspBody.
Для того, чтобы клиентская часть могла получать и изменять данные документа, к клиентским наборам данных cdsTitle и cdsBody присоединены провайдеры данных, dspTitle и dspBody, соответственно. Свойству Exported этих провайдеров оставлено значение по умолчанию, True, зато свойство ResolveToDataSet установлено в True, для того, чтобы эти провайдеры не пытались работать с ClientDataSet с помощью запросов. Таким образом, клиентская часть может получать и изменять данные не из TIBQuery, но из TClientDataSet, причем совершенно об этом не догадываясь. По команде с клиентской части изменения, передаются серверу приложений, который и сохраняет их в БД.
Теперь посмотрим, что нам нужно для подобной реализации. Функции для синхронизации обработки документов RegisterDoc и UnregisterDoc уже есть, нужно их только использовать. С их помощью гарантируется, что одновременно один и тот же документ редактироваться не будет, поэтому у провайдеров данных dspTitleInner и dspTitleBody достаточно установить UpdateMode = upWhereKeyOnly, и указать ключевые поля у запросов. Содержимое документа может состоять из нескольких строк, поэтому у dspBodyInner и dspBody нужно установить флаг poAllowMultiRecordUpdates. Теперь нужно разобраться с полями клиентских наборов данных, установив у них соответствующие свойства. Я остановлюсь здесь только на свойстве ProviderFlags. Поскольку поле «Ссылка на документ» (DOC_ID) на клиентской части не нужно, ему можно задать флаг pfHidden. Разумеется, у всех ключевых полей (DOC_ID и LINE_NUM) и в наборе данных заголовка, и в содержимом документа надо указать флаг pfInKey. У провайдеров dspTitle и dspBody нужно установить политику обновления UpdateMode = upWhereKeyOnly, клиентская часть у модуля данных одна, и другие значения совершенно ни к чему.
Теперь компоненты для хранения и обработки данных подготовлены, осталось написать сами методы работы с ними.
Давайте разберемся, что именно требуется. Модуль rdmDoc предназначен как для создания нового документа, так и для редактирования существующего. Этот модуль можен находиться в одном из трех состояний, описанных в перечислении TObjState:
osInactive: данных нет, документ не редактируется,
osInsert: создан новый документ и
osUpdate – происходит изменение существующего документа.
Состояние хранится в переменной Fstate, находящейся внутри модуля. Сразу после создания и после окончания обработки документа модуль данных должен находиться в неактивном состоянии.
Переход из одного состояния в другое должен обеспечиваться соответствующими методами. Я назвал эти методы DoInactiveState (перевод в неактивное состояние), DoOpen (открыть существующий документ) и DoCreateNew (создание нового документа). При редактировании или добавлении документа нужно знать его уникальный номер, записываемый в поле DOC_ID. Для этого достаточно объявить в секции private переменную FDocID: integer, которая и будет его хранить.
В библиотеке типов нужно реализовать методы, которые будут создавать документ или открывать существующий, а также сохранять изменения. Кроме этого, понадобится свойство, позволяющее получить в любой момент сумму по документу. Сумма каждой строки содержимого пусть рассчитывается на клиентской части.
Итак, приступим. Сначала описываются методы перехода между состояниями, они предназначены для внутреннего использования, и поэтому их объявления содержатся в секции private:
| procedure DoInactiveState; procedure DoCreateNew; procedure DoOpen(DocID: integer); |
Рассмотрим их по порядку.
| procedure TrdmDoc.DoInactiveState; begin UnregisterDoc(FDocID); FDocID:= 0; cdsTitle.Active:= False; cdsBody.Active:= False; ibtDoc.Active:= False; FState:= osInactive; end; |
Процедура DoInactiveState удаляет документ из списка редактируемых, закрывает все клиентские наборы данных, а также производит откат транзакции (если она была активна).
| procedure TrdmDoc.DoOpen(DocID: Integer); begin if DocID = 0 then Exit; try if not RegisterDoc(DocID) then raise Exception.Create('Документ редактируется'); FDocID:= DocID; // и только здесь, иначе DoInactiveState удалит документ ibdDocs.Connected:= True; ibtDoc.StartTransaction; with cdsTitle do begin params.paramByName('DocID').AsInteger:= FDocID; Active:= True; if BOF and EOF then raise Exception.Create('Документ не найден'); end; with cdsBody do begin params.paramByName('DocID').AsInteger:= FDocID; Active:= True; end; FState:= osUpdate; ibtDoc.Commit; except DoInactiveState; raise; end; end; |
DoOpen предназначена для открытия существующего документа, идентификатор DOC_ID которого равен входному параметру DocID. Первым делом с помощью RegisterDoc производится проверка того, что документ в данный момент не редактируется. Затем идентификатор документа запоминается, и в клиентские наборы данных загружаются данные документа. В случае ошибки состояние документа переводится в osInactive.
| procedure TrdmDoc.DoCreateNew; var NewDocID: Integer; begin try NewDocID:= NewID; if not RegisterDoc(NewDocID) then raise Exception.Create('Документ редактируется'); FDocID:= NewDocID; ibdDocs.Connected:= True; ibtDoc.StartTransaction; with cdsTitle do begin params.paramByName('DocID').AsInteger:= FDocID; Active:= True; Append; Post; end; with cdsBody do begin params.paramByName('DocID').AsInteger:= FDocID; Active:= True; end; ibtDoc.Commit; FState:= osInsert; except DoInactiveState; raise; end; end; |
Процедура DoCreateNew предназначена для создания нового документа. Она практически аналогична предыдущей, за исключением того, что идентификатор документа получается от сервера БД с помощью процедуры NewID, которая обращается к хранимой процедуре на сервере. Реализация процедуры DoCreateNew очень похожа на аналогичную реализацию в rdmCommon.
Для того, чтобы вставка новой записи в документ происходила верно, достаточно написать обработчик cdsTitle.OnNewRecord, задающий начальное значение полей записи, и практически такой же обработчик для cdsBody:
| procedure TrdmDoc.cdsTitleNewRecord(DataSet: TDataSet); var Day, Month, Year: Word; begin DecodeDate(Date, Year, Month, Day); with cdsTitle do begin FieldByName('DOC_ID').AsInteger:= FDocID; FieldByName('DOC_NUM').AsString:= IntToStr(FDocID) + '/' + IntToStr(Year); FieldByName('DOC_DATE').asDateTime:= Date; FieldByName('DOC_SUM').asCurrency:= 0; FieldByName('FROM_ID').AsInteger:= 0; FieldByName('TO_ID').AsInteger:= 0; end; end; procedure TrdmDoc.cdsBodyNewRecord(DataSet: TDataSet); begin cdsBody.FieldByName('DOC_ID').AsInteger:= FDocID; end; |
В дополнение ко всему нужна еще одна процедура в секции private, для подсчета суммы документа:
| function TrdmDoc.CalcSum: Currency; begin Result:= 0; if not cdsBody.Active then Exit; with cdsBody do begin First; while not EOF do begin Result:= Result + FieldByName('COUNT_NUM').asCurrency * FieldByName('PRICE').asCurrency; Next; end; end; end; |
В функции CalcSum просматривается содержимое документа и рассчитывается общая сумма, которая возвращается в качестве результата.
Теперь надо позаботиться о клиентской части, то есть создать необходимые внешние методы сервера в библиотеке типов. Описание этих методов, созданное редактором библиотек типов, выглядит следующим образом:
| protected function ApplyChanges: WideString; safecall; function Get_DocID: Integer; safecall; procedure CreateNewDoc; safecall; procedure Set_DocID(Value: Integer); safecall; function Get_DocSum: Currency; safecall; |
Функциональность этих методов такова:
ApplyChanges – сохраняет текущий документ в БД.
DocID – свойство, доступное на запись и чтение При чтении выдается текущий ID документа (FDocID). При изменении значения свойства документ открывается для редактирования с ID, равным новому значению.