|
Фильтрация
Фильтрация TTable и TQuery происходит с учетом живого или
мертвого кэша. Для TTable при наложении фильтра конструируется
соответствующий SQL-запрос, а TQuery производит фильтрацию буквально
при помощи Locate (т.е. сначала выбираются все записи в кэш, а затем
идет фильтрация уже в кэше).
О вреде UNIQUE constraint
В Interbase уникальность поля можно обеспечить тремя способами:
создать первичный ключ, создать unique constraint, и создать
уникальный индекс. Но при чем здесь Interbase? А при том, что BDE
открывает TTable по умолчанию с использованием уникального индекса.
Если таблица одновременно содержит как первичный ключ, так и unique
constraint, то в результате у таблицы 2 уникальных индекса. При
обращении к списку индексов TTable берет для сортировки по умолчанию
первый попавшийся. Если уникальность поля обеспечивается обычным
уникальным индексом, то проблем нет. А вот если та же уникальность
обеспечивается через UNIQUE constraint, то при backup/restore базы
данных есть шанс что порядковые номера индексов поменяются
(поскольку для IB это constraint целостности), и BDE будет брать в
качестве первого попавшегося индекс от unique constraint вместо
индекса от primary key. Вреда от этого, в общем, никакого нет, но в
результате это вызывает нежелательный порядок сортировки по
умолчанию в приложениях.
"Живые" запросы
Если способность TTable редактировать и удалять записи ни у кого
не вызывает удивления, то TQuery требует, чтобы свойство RequestLive
было установлено в True. Если при False запрос отправлялся
непосредственно на сервер, то при True запрос предварительно
обрабатывается локальным SQL (модуль IDSQL32.DLL). Это необходимо
для того, чтобы TQuery смог сформировать запросы
INSERT/UPDATE/DELETE на основании заданного SELECT. Для TTable
построение таких запросов не представляет сложности, т.к. задано
только имя таблицы, имена полей считаны и т.п. А существующий
SQL-запрос нужно синтаксически разобрать, чтобы понять, сколько в
нем используется таблиц, какие выбираются поля и из каких таблиц, и
можно ли вообще сформировать запросы на вставку, обновление и
удаление данных.
Именно таким разбором SQL и занимается Local SQL. Разумеется, он
поддерживает весьма ограниченный синтаксис SQL, что не позволяет
делать "живыми" запросы, использующие расширенные конструкции SQL,
пользовательские функции или специфические для конкретного сервера
особенности. Например, для организации живого запроса вместо
SELECT * FROM TABLE
WHERE FIELD STARTING WITH 'A'
|
придется писать
SELECT * FROM TABLE
WHERE FIELD LIKE 'A%'
|
Подобную замену еще можно пережить, но не всегда возможно найти
замену конструкции, которую не понимает Local SQL, и прекрасно
понимает сервер.
примечание:
вы сами можете убедиться в изложенном, поместив первый
запрос в TQuery, переключив RequestLive в True. Попытайтесь
установить Active компонента в True и посмотрите что
получится.
Собственно, как вы поняли, на самом деле никаких "живых" запросов
не существует. В SQL оператор SELECT выполняет только чтение, а
вставить, обновить или удалить записи можно только операторами
INSERT, UPDATE и DELETE, и никак иначе.
При переключении TQuery.RequestLive:=True TQuery начинает вести
себя как TTable - т.е. он сначала разбирает запрос, извлекает оттуда
имя таблицы, и потом выбирает информацию из системных таблиц о полях
таблицы, индексах и т.п. Вы можете все это увидеть в SQL Monitor.
Кроме RequestLive можно еще воспользоваться и компонентом
UpdateSQL. Об этом см. дальше в разделе CachedUpdates.
SQLQUERYMODE
Кроме RequestLive на выполнение запросов влияет и параметр алиаса
или драйвера IB SQLQUERYMODE. Когда этот параметр установлен в
LOCAL, BDE всегда производит разбор SQL-конструкций при помощи Local
SQL. Если параметр установлен в "пусто", то BDE сначала пытается
отправить SQL на сервер, а при получении ошибки пытается выполнить
его Local SQL. При установленном параметре SERVER запросы всегда
отправляются только на сервер (за исключением "живых").
Таким образом, при установке LOCAL запросы будут всегда
выполняться локальным ядром SQL BDE, и функциональность SQL IB будет
недоступна (не будут выполняться запросы с containing и др.
синтаксисом, который не поддерживает Local SQL). Избавиться от
такого поведения лучше всего установив раз и навсегда значение
SERVER.
Refresh и атомарность запросов
Читатель уже после информации о живом и мертвом кэше, наверное,
давно хочет спросить - а как же BDE видит новые записи, добавляемые
другими приложениями? Да никак. С TTable все понятно - в любой
момент можно вызвать refrech, что приведет к удалению "живого" кэша
и переоткрытию TTable как мы уже видели в разделе о кэшах записей.
TTable перед своим закрытием запоминает запись, на которой стоял
курсор грида, и поэтому после открытия может спозиционироваться на
эту же запись.
TQuery работает с "мертвым" кэшем, поэтому обновлять его
невозможно. BDE не знает о том, какое из полей в запросе является
первичным ключом, да и вообще по скольким таблицам построен запрос.
Поэтому единственным вариантом для refresh является переоткрытие
TQuery (Close/Open). Текущая запись при этом будет потеряна. Можно,
правда, попытаться использовать TBookmark чтобы запомнить запись и
вернуться к ней после открытия TQuery, но как и Locate это вызовет
выборку всех записей с сервера в кэш TQuery и при большом количестве
выбираемых записей может занять длительное время.
примечание:
Даже если компонент IBX IBTable и поддерживает
Refresh, то он его выполняют точно таким же образом, что и BDE. А
компонент IBDataSet выполняет Refresh только для одной, текущей,
записи.
В чтение актуальных данных вмешивается еще и атомарность
операторов SQL. Применительно к SELECT это означает, что он будет
выбирать только те записи, которые существовали на момент выполнения
этого SELECT. Это означает, что если открыть TQuery, а затем через 5
минут подсоединить его к гриду, то в нем будут видны только те
записи, которые были в базе данных 5 минут назад. Даже если за это
время это же самое приложение в этой же транзакции успело добавить,
изменить или удалить 1 или сколь угодно большее количество записей,
попадающих под условия выборки данного SELECT.
В буквальном смысле это означает, что если вставить запись в
открытый select, то увидеть новую запись нельзя. Для этого придется
переоткрыть запрос. По отношению к TQuery это справедливо, а вот
TTable "обманывает" пользователя, помещая данные успешно вставленной
записи прямо в свой собственный кэш. Таким образом, вставка в TTable
как бы помещает данные прямо в открытую выборку. Чего, собственно,
на самом деле на сервере не происходит.
Вообще перечитывание данных почти всегда вызывает проблемы.
Сервер не уведомляет клиентов, что определенные записи изменились,
появились или были удалены. EventAlerter может сообщить только
информацию что некое событие (например, была изменена таблица)
произошло, но не "номер записи". В многопользовательской среде
перечитывание данных по таймеру может вызвать большой сетевой
трафик. Да и кроме того, клиент обычно видит в гриде только какую-то
часть данных, и идеальным вариантом было бы не только узнать, что в
именно этой части данных произошли изменения, но и перечитать только
эту часть. В итоге, самым разумным вариантом является помещение в
приложение на нужную форму кнопки Refresh (Перечитать). Пусть
пользователь решает, когда ему нужно это сделать.
примечание:
в отличие от атомарного SELECT, оператор FOR SELECT
внутри процедур IB не является атомарным. Т.е. если в цикле FOR
SELECT добавлять записи, то они могут попасть в область видимости
FOR SELECT, и может произойти "бесконечный цикл". Также в IB
неатомарной является конструкция INSERT INTO ... SELECT
FROM.
Завершение транзакций
BDE устроен так, что компонент TDatabase может работать только с
одной транзакцией одновременно. При этом может быть два режима -
неявная работа с транзакциями (AUTOCOMMIT, NOAUTOCOMMIT), и явная
работа с транзакциями (методы StartTransaction, Commit и Rollback).
В режиме AUTOCOMMIT BDE самостоятельно завершает транзакцию и
стартует новую при любых модификациях данных (insert/update/delete)
или при вызове TStoredProc.ExecProc. Таким образом изменения
автоматически сохраняются в базе данных. Однако чтение данных и
вообще работа с ними может быть выполнена только в контексте
транзакции. Т.е. вне транзакции с данными работать нельзя, т.к. не
будет обеспечиваться целостность данных. При этом данные,
прочитанные в одной транзакции, неактуальны для другой транзакции.
Если посмотреть справку BDE32.HLP по функции dbiEndTran, то можно
обнаружить, что BDE при завершении явной или неявной транзакции
ведет себя следующим образом:
открытый query довыбирает данные.
открытый table закрывается
другие случаи я не упомянул, потому что IB SQL Link их не
поддерживает. То есть при любом завершении транзакции (и открытии
новой) данные будут перечитываться. Для TTable это не смертельно,
т.к. он знает первичный ключ записи, на которой стоял курсор грида,
и может перечитать немного данных, чтобы заново отобразить их. А вот
для TQuery, который не знает никаких первичных ключей, происходит
полная выборка всех данных, что эквивалентно вызову Locate, FetchAll
или Last. Так что если ваше приложение при обновлении данных
почему-то сильно тормозит, или возникают паузы, то нужно срочно
смотреть в SQL Monitor, какие именно запросы перечитываются.
примечание:
иногда по неизвестным причинам BDE перечитывает
запросы, которые совершенно этого не требуют. Например мне
встречалась ситуация с неявным перевыполнением запроса при
перемещении по grid-у detail-таблицы, причем запрос никак не был
связан ни с master ни с detail-таблицами. Избавиться от проблемы
не удалось.
Соответственно, чтобы предотвратить плохую производительность,
нужно или держать минимум данных открытыми в TQuery, или стремиться
к минимизации количества записей, выбираемых TQuery. Также можно
открыть второй TDatabase, и работать например со справочными
таблицами только в нем. Таким образом изменения будут идти в одном
коннекте, и не будут вызывать завершение транзакции и перечитывание
данных в другом. В компонентах прямого доступа это решается более
простым способом, т.к. там поддерживается произвольное количество
транзакций для одного коннекта. Есть, кстати, и оригинальное
решение, которое позволяет использовать коннект TDatabase совместно
с компонентами FreeIBComponents или IBX:
var
h: tisc_db_handle;
DB := TIBDatabase.Create(nil);
try
Dbtables.Check(DbiGetProp(HDBIOBJ(DMCommBilling.Database.Handle), dbNATIVEHNDL, @h, sizeof(tisc_db_handle), l));
DB.DBName := 'Cloned';
DB.Handle := h;
TR := TIBTransaction.Create(nil);
try
|
и так далее. Таким образом, в приложении BDE можно дополнительно
обрабатывать данные в транзакциях IBX. Приложение получается
комбинированным, поскольку для доступа к данным в новой транзакции
придется использовать компоненты IBX.
Record/Key deleted
Надо сказать, что BDE облегчает жизнь программисту хотя бы тем,
что перечитывает запись, которую собирается редактировать
пользователь. Т.е. как только BDE переводит TTable или "живой"
TQuery в режим Edit, он производит выборку текущей записи (по
первичному ключу) и показывает для редактирования самые последние,
актуальные, данные. Правда, пока пользователь редактирует запись, ее
могут изменить или даже удалить другие пользователи - BDE никоим
образом не "блокирует" запись, которая редактируется, т.к. в SQL
вообще нет команды вроде "заблокировать запись". Поэтому после Post
клиент может обнаружить, что его изменения не попадут в базу данных,
т.к. запись уже изменилась или удалена. И обнаружит он это или нет,
зависит от режима TDataSet.UpdateMode.
UpdateMode имеет 3 режима:
- upWhereAll
- По умолчанию - BDE пытается сделать UPDATE с внесением в
условие WHERE всех значений полей, которые были ДО момента
редактирования. Если при этом произошла ошибка, значит хотя бы
одно поле у редактируемой записи уже было кем-то изменено (с
момента входа в режим редактирования до момента Post).
- upWhereChanged
- BDE пытается сделать UPDATE с условием WHERE, проверяющим
старые значения только измененных полей. Т.е. чтобы убедиться, что
пользователь поменял именно те значения полей, которые видел, на
новые. Если произошла ошибка, то это значит что одно из изменяемых
полей было уже кем-то изменено.
- upWhereKeyOnly
- BDE обновляет запись, устанавливая в WHERE поиск записи только
по ее первичному ключу.
Соответственно, если запись не найдена, то выдается упомянутое в
заголовке сообщение Record/Key deleted. Обратите внимание, что
успешное обновление записи в режимах upWhereChanged или
upWhereKeyOnly может вызвать проблемы с конкурентным обновлением.
Например, существует таблица TABLE, у которой три поля: ID, NAME и
PRICE.
Два пользователя открывают таблицу. Один видит, что для данного
имени товара неверно указана цена. Другой счел, что цена правильная,
только имя товара указано с ошибкой. У обоих UpdateMode установлен в
upWhereKeyOnly или upWhereChanged.
После изменения пользователи по очереди нажимают Post
(вероятность одновременного нажатия достаточно низка, а кто из них
нажал на кнопку первым не имеет значения). В результате оказалось
изменено и название товара и его цена, и комбинация этих полей опять
содержит неправильную информацию!
В данном частном случае избавиться от проблемы можно установкой
UpdateMode только upWhereAll, чтобы запрос при обновлении проверял
все зависимые поля. Или, можно подключить компонент TUpdateSQL и
прописать для обновления данных запрос, который будет проверять на
"старые" значения и имя товара и его цену. Однако работать с
TUpdateSQL без CachedUpdates невозможно.
Другая причина, по которой может происходить сообщение Record/Key
deleted - перечитывание данных после их обновления. BDE таким
образом (по крайней мере для TTable) пытается вставить запись в
нужное место (в порядке сортировки) кэша. Но если после вставки или
обновления запись на сервере изменилась - другим пользователем,
default-условием или триггером (с генератором) - то BDE не сможет ее
найти и выдаст упомянутое сообщение.
Если запись от момента редактирования до момента перечитывания
была изменена другим пользователем, то тут ничего нельзя сделать.
Если это был default или триггер, то вполне возможно, что лучше
отказаться от считывания таких полей в DBGrid (вызовите
FieldEditor). Если же это поле первичного ключа, которому в триггере
присваивается значение генератора, то вам явно стоит прочитать
статью, которая за 4 года существования не потеряла своей
актуальности.
Cached Updates
При работе без CachedUpdates изменения, производимые над данными,
отправляются на сервер немедленно. Это достаточно удобно, т.к.
позволяет немедленно обнаруживать конфликты изменений, но не всегда
хорошо для сетевого трафика если нет явного управления транзакциями
или приводит к накоплению версий записей при длительных явных
транзакциях. В первую очередь режим CachedUpdates подходит для
"блокировочных" серверов, в которых чтение данных блокирует их от
изменения (например MS SQL, Sybase).
CachedUpdates позволяет накопить изменения, и затем "выстрелить"
их на сервер одним пакетом. При этом время блокировок минимально,
минимален также сетевой трафик, но существует высокая вероятность
что данные уже успели измениться. Поэтому при использовании CU
необходимо тщательно планировать именно процесс обращения к таблицам
и режимы UpdateMode.
За более подробной информацией по CachedUpdates обращайтесь к
документации или к книге Шумакова ("Delphi 3 и создание приложений
баз данных", в том числе последующие издания для Delphi 4 и 5 в
соавторстве с Фароновым), где все это очень хорошо описано. Нас
сейчас CU больше интересует как замена RequestLive.
Действительно, "оживление" запроса выполняется следующим образом
- к компоненту TQuery подключается компонент TUpdateSQL, в котором
прописываются вручную или автоматически запросы на вставку, удаление
или изменение записи. Заметьте, только одной записи. После включения
CachedUpdates:=True при модификации данных именно эти запросы, а не
конструируемые Local SQL при RequestLive=True, будут отправляться на
сервер (отправляются они только в момент ApplyUpdates, а не в момент
реального обновления записи).
Самым непонятным является то, почему связка TQuery и TUpdateSQL
не может работать без CachedUpdates. Например компоненты IBX без
проблем обеспечивают такой режим, да и вообще там у TIBQuery нет
свойства RequestLive (т.к. нет парсера SQL на клиентской стороне).
Т.е. в IBX, конечно, можно использовать CachedUpdates, но разве что
при действительной в нем необходимости.
Гетерогенные запросы
BDE обладает уникальной способностью выполнять запросы, которые
обращаются к таблицам, находящимся на разных серверах баз данных
(или к таблицам разных форматов). Это так называемые "гетерогенные"
запросы. Иногда их называют "распределенными", т.к. данные
"распределены" по разным базам данных возможно одного и того же
SQL-сервера.
Выполнить гетерогенный запрос можно следующим образом:
- Открыть 2 или более TDatabase, каждый для соответствующей базы
данных. Например, один компонент подсоединен как A к алиасу TEST,
а другой, как
- Открыть TDatabase, который подсоединен к драйверу типа
STANDARD(т.е. к локальным таблицам. Существование оных
необязательно). См. окно свойств TDatabase.
- Выполнить запрос в компоненте TQuery, подсоединенном к
"стандартному" TDatabase. В результате должна получиться такая
"конструкция"
а запрос иметь вид
SELECT C.CLIENT_NAME
FROM ":A:CLIENTS" C, ":B:EMPLOYEE" E
WHERE E.EMP_NO = C.CLIENT_ID
|
Конечно, по смыслу это полная чушь, но зато показывает пример
указания таблиц из разных базах данных. Еще один пример запроса
можно найти по ключевой фразе 'heterogeneous joins' в BDE32.HLP.
Пока я готовил и проверял этот пример, установка Query1.Active в
true вызывала страшные содрогания винчестера. Дело в том, что
подобные запросы выполняются следующим образом:
- Ядро Local SQL "разбирает" запрос, и выясняет, какие таблицы
из каких баз данных используются в запросе
- Данные из каждой таблицы вытаскиваются в локальный кэш (т.е.
на клиента), в память или временные таблицы.
- Извлеченные данные обрабатываются локальным SQL (join, where,
order by и т.п.).
Однако происходит так не всегда. По крайней мере в моем тестовом
случае Local SQL начал выполнять просто чудовищные операции:
Сначала для одной, а затем для другой таблицы был выполнен SELECT
COUNT(*). Т.е. Local SQL сначала пытается понять, во что ему
обойдется скачивание данных на клиентскую часть. Очевидно, записей в
CLIENTS ему показалось мало, и он вытащил все записи из EMPLOYEE, а
потом начал последовательно выбирать соответствующие записи из
CLIENTS отдельными запросами для каждой записи (проверяя
соответствие условия WHERE). Буквально SELECT ... FROM CLIENTS WHERE
CLIENT_ID = ? ORDER BY CLIENT_ID ASC.
(зачем здесь нужен order by - неизвестно). Почему произошло не
наоборот, т.е. меньшая таблица не была выбрана в память, неясно.
Можно даже не упоминать, что select count(*) на реальных данных
может выполняться долго (даже без учета возможной сборки мусора). Не
говоря о том, что в EMPLOYEE было 42 записи, и отдельных запросов к
таблице CLIENTS получилось тоже 42.
Вот такая веселая арифметика. Зато получены четкие объяснения,
почему "трещал" винчестер.
Однако, пусть даже и таким жутким способом, но BDE умеет
выполнять гетерогенные запросы. Благодаря Local SQL и тому, что BDE
умеет работать с локальными таблицами (которые он использует для
хранения промежуточных данных таких запросов). Ни IBObjects, ни
FIBC/IBX, ни IB API не имеют таких возможностей, и соответственно,
не могут выполнять гетерогенные запросы.
Итог
После прочтения этой статьи может сложиться впечатление, что BDE
вообще не пригоден для работы с SQL-серверами. На самом деле это не
так. Если знать его архитектуру (надеюсь, статья вам в этом
помогла), то можно снизить неэффективность BDE в приложениях до
минимума.
Другой важный момент - скорость разработки. Она до сих пор
остается самой высокой по сравнению с другими наборами компонент
(даже с IBObjects). А скорость разработки - это в первую очередь
более низкая стоимость разработки системы.
Кстати, может оказаться, что вся эта "неэффективность" в смысле
большого объема передаваемых данных на вашей 100мбит сети и не
проявится. А если сеть гигабитная, то вы вообще никакого лишнего
трафика не заметите. И наоборот - для модемных соединений BDE,
конечно, никуда не годится. Или если вам нужно тщательное
планирование и управление транзакциями IB, то BDE здесь тоже делать
нечего.
Есть и более жесткие критерии выбора - если вы собираетесь
переходить на Kylix или IB6 (диалект 3), то c BDE придется
расстаться. Если же в течение ближайшего года или полутора вы не
собираетесь этого делать - забудьте об альтернативах, и продолжайте
работать привычным способом.
|
Архитектура BDE и его особенности
при работе с SQL-серверами 2