WWW.DISSERS.RU

БЕСПЛАТНАЯ ЭЛЕКТРОННАЯ БИБЛИОТЕКА

   Добро пожаловать!

Pages:     || 2 | 3 | 4 | 5 |   ...   | 24 |
-- [ Страница 1 ] --

Oracle для профессионалов Том Кайт DiaSoft 2003 торгово-издательский дом Москва • Санкт-Петербург • Киев УДК 681.3. 06(075) Б Б К 32.973.2 К 91 КАЙТ ТОМ К 91 Oracle для профессионалов. Пер. с

англ./ТомКайт- СПб.: ООО «ДиаСофтЮП», 2003. — 672 с. ISBN 5-93772-072-5 Выход в свет в конце прошлого года этой книги издательства Wrox стал эпохальным событием: впервые доходчиво и исчерпывающе раскрыты основные особенности архитектуры СУБД Oracle, принципиально отличающие ее от других популярных систем управления базами данных. Причем подробно описаны и проиллюстрированы множеством примеров именно те возможности, средства и особенности Oracle, которые обеспечивают разработку эффективных приложений для этой СУБД и ее успешную эксплуатацию. Автор книги, Том Кайт, давно работает с СУБД Oracle, создает приложения и администрирует базы данных. Многие годы он профессионально занимается решением проблем, возникающих при использовании СУБД Oracle у администраторов и разработчиков по всему миру. На специализированном сайте корпорации Oracle (Том Кайт отвечает на десятки вопросов в день. Он не только делится знаниями, но и умело подталкивает читателя к самостоятельным экспериментам. Следуя по указанному им пути, становишься Профессионалом. Если вы приступаете к изучению СУБД Oracle, — начните с этой книги. Если вы опытный разработчик приложений или администратор баз данных Oracle, — прочтите ее и проверьте, достаточно ли глубоко вы знаете эту СУБД и умеете ли использовать ее возможности. Вы найдете в книге десятки советов, описаний приемов и методов решения задач, о которых никогда не подозревали.

ББК 32.973. Authorized translation from the English language edition, entitled Expert One-on-One Oracle, 1st Edition by Kyte, Thomas, published by Pearson Education, Inc, publishing as Wrox Press Ltd, Copyright © 2002 All rights reserved. No part of this book may be reproduced or transmitted in any form or by any means, electronic or mechanical, including photocopying, recording or by any information storage retrieval system, without permission from Pearson Education, Inc. Russian language edition published by DiaSoft Publishing. Copyright © 2003 Лицензия предоставлена издательством Wrox Press Ltd. Все права зарезервированы, включая право на полное или частичное воспроизведение в какой бы то ни было форме. Материал, изложенный в данной книге, многократно проверен. Но, поскольку вероятность технических ошибок все равно существует, издательство не может гарантировать абсолютную точность и правильность приводимых сведений. В связи с этим издательство не несет ответственности за возможные ошибки, связанные с использованием книги. Все торговые знаки, упомянутые в настоящем издании, зарегистрированы. Случайное неправильное использование или пропуск торгового знака или названия его законного владельца не должно рассматриваться как нарушение прав собственности. ISBN 5-93772-072-5 (рус.) ISBN 1-861004-82-6 (англ.) © Перевод на русский язык. ООО «ДиаСофтЮП», 2003 © Wrox Press Ltd, 2002 © Оформление. ООО «ДиаСофтЮП», Гигиеническое заключение № 77.99.6.953.П.438.2.99 от 04.02. Предисловие научного редактора Уважаемые читатели!

О СУБД Oracle написано и издано как на английском, так и на русском языке, наверное, больше книг, чем обо всех остальных реляционных СУБД вместе взятых. Многие из этих книг полезны и интересны. Кроме того, в сети Internet доступны десятки тысяч страниц документации, которой могут воспользоваться разработчики, администраторы баз данных Oracle и пользователи. В журналах, на корпоративном сайте Oracle (http://www.oracle.com) и на десятках независимых сайтов печатаются статьи но всем аспектам администрирования и использования этой СУБД. Тем не менее появление в конце прошлого года именно этой книги издательства Wrox стало эпохальным событием: впервые доходчиво и исчерпывающе раскрыты основные особенности архитектуры СУБД Oracle, принципиально отличающие ее от других популярных систем управления базами данных. Причем подробно описаны и проиллюстрированы множеством примеров именно те возможности, средства и особенности Oracle, которые обеспечивают разработку эффективных приложений для этой СУБД и ее успешную эксплуатацию. В этом нет ничего удивительного. Автор книги, Том Кайт (Tom Kyte), давно работает с СУБД Oracle, создает приложения и администрирует несколько баз данных. Многие годы он, сотрудник корпорации Oracle, профессионально занимается решением проблем, возникающих при использовании СУБД Oracle у администраторов и разработчиков по всему миру. В дискуссионных группах соmp.databases.oracle.* и в журнале Oracle Magazine, а в последние годы — еще и на специализированном сайте корпорации Oracle (http://asktom.oracle.com) Том Кайт отвечает на десятки вопросов в день. Я набрел на этот сайт случайно, по ссылке в одном из документов, найденном славной поисковой системой Google. Потом стал его еженедельным, а со временем - ежедневным посетителем. Меня привлекло многообразие рассматриваемых проблем и изящество их решения. В изложении Тома Кайта все становится простым. При этом он не только делится знаниями, но и умело подталкивает читателя к самостоятельным экспериментам. Следуя по указанному им пути, становишься Профессионалом. Поэтому меня очень обрадовало сообщение о выходе книги Тома Кайта «Expert oneon-one: Oracle», и я сделал все от меня зависящее, чтобы издательство «ДиаСофт» опубликовало ее перевод. Этот перевод я не смог никому доверить и сделал его сам. Если текст на русском языке понятен и приятен для чтения, то только благодаря потрясающему литературному редактору Ж. Е. Прусаковой, помогавшей мне в работе над книгой. Я благодарен ей, а также сотрудникам издательства «ДиаСофт» за поддержку и усилия, которые они приложили для выхода этой книги в свет.. В оригинале книга — очень большая, более 1200 страниц. В русском переводе, с разрешения издательства Wrox, она разделена на две части. Мы хотели часть книги, наиболее принципиальную для успешного использования СУБД Oracle, выпустить как можно быстрее. Сейчас, когда вы читаете первую часть, посвященную архитектуре и основным возможностям СУБД Oracle, продолжается работа над второй частью;

она выйдет несколькими месяцами позже.

Предисловие научного редактора Мы старались сделать книгу максимально полезной и удобной для чтения: исправили выявленные читателями английской версии ошибки, которые приведены на сайте издательства Wrox, согласовали терминологию. Если вы приступаете к изучению СУБД Oracle, — начните с этой книги. Если вы опытный разработчик приложений или администратор баз данных Oracle, — прочтите ее и проверьте, достаточно ли глубоко вы знаете эту СУБД и умеете ли использовать ее возможности. Вы найдете в книге десятки советов, описаний приемов и методов решения задач, о которых никогда не подозревали. И, конечно же, рекомендую читать блестящие ответы и рекомендации Тома Кайта на его ежедневно обновляющемся сайте AskTom: http://asktom.oracle.com. Если корпорация Oracle станет общепризнанным и неоспоримым лидером на рынке производителей программного обеспечения, то в немалой степени благодаря тому, что и как делает для пользователей ее программных продуктов один человек — Том Кайт! В. Кравчук, OpenXS Initiative (http://openxs.net) 12 декабря 2002 года Оглавление Об авторе Введение О чем эта книга Для кого предназначена эта книга? Структура книги Основные понятия Структуры и утилиты базы данных Производительность Расширенные возможности SQL Расширяемость Защита Приложения Типографские особенности книги Контакты с читателями Исходный код и обновления Ошибки 14 18 18 20 20 22 23 23 24 25 26 26 27 27 Глава 1. Разработка успешных приложений для Oracle Мой подход Подход с использованием принципа черного ящика Как надо (и как не надо) разрабатывать приложения баз данных Понимание архитектуры СУБД Oracle Избегайте длительных транзакций в среде MTS Используйте связываемые переменные Особенности управления одновременным доступом Реализация блокирования Многовариантность Независимость от СУБД? Влияние стандартов Возможности и функции Решайте проблемы просто Открытость Как ускорить работу? Взаимоотношения АБД и разработчиков Резюме 38 40 44 44 45 47 51 51 54 59 62 66 68 70 72 75 Глава 2. Архитектура Сервер Файлы Файлы параметров Файлы данных Временные файлы Управляющие файлы 80 87 88 90 94 Оглавление Файлы журнала повторного выполнения Активный журнал повторного выполнения Архивный журнал повторного выполнения Структуры памяти Области PGA и UGA Область SGA Фиксированная область SGA Буфер журнала повторного выполнения Буферный кэш Разделяемый пул Большой пул Java-пул Процессы Серверные процессы Выделенный и разделяемый сервер Фоновые процессы Фоновые процессы, предназначенные для решения конкретных задач Служебные фоновые процессы Подчиненные процессы Подчиненные процессы ввода/вывода Подчиненные процессы параллельных запросов Резюме 95 96 99 100 100 105 108 108 109 112 114 115 117 117 120 123 123 131 132 132 133 Глава 3. Блокирование и одновременный доступ Что такое блокировки? Проблемы блокирования Потерянные изменения Пессимистическое блокирование Оптимистическое блокирование Блокирование Заблокированные вставки Заблокированные изменения и удаления Взаимные блокировки Эскалация блокирования Типы блокировок Блокировки ЯМД ТХ — блокировки транзакций ТМ — блокировки очередности ЯМД Блокировки ЯОД Защелки и внутренние блокировки Блокирование вручную. Блокировки, определяемые пользователем Блокирование вручную Создание собственных блокировок Что такое управление одновременным доступом? Уровни изолированности транзакции Уровень изолированности READ UNCOMMITTED Уровень изолированности READ COMMITTED Уровень изолированности REPEATABLE READ Получение согласованного ответа 138 140 140 142 143 144 145 145 146 150 151 152 152 158 159 163 163 164 164 165 165 167 169 170 Оглавление Предотвращение потери изменений Уровень изолированности SERIALIZABLE Транзакции только для чтения Резюме 172 173 175 Глава 4. Транзакции Операторы управления транзакцией Требования целостности и транзакции Плохие привычки при работе с транзакциями Распределенные транзакции Журналы повторного выполнения и сегменты отката Резюме 180 185 188 194 197 Глава 5. Повторное выполнение и откат Повторное выполнение Что происходит при фиксации? Что происходит при откате? Какой объем данных повторного выполнения генерируется? Можно ли отключить генерацию записей в журнал повторного выполнения? Не удается выделить новый журнал? Очистка блоков Конфликты при доступе к журналу Временные таблицы и данные повторного выполнения/отката Анализ данных повторного выполнения Откат Что генерирует основной/наименьший объем данных отмены? Оператор SET TRANSACTION 'ORA-01555: snapshot too old' Сегменты отката очень маленькие Данные извлекаются в нескольких транзакциях Отложенная очистка блоков Резюме 206 207 212 214 224 228 230 234 236 240 240 241 241 242 243 247 249 Глава 6. Таблицы Типы таблиц Терминология Отметка максимального уровня Списки свободных мест Параметры PCTFREE и PCTUSED Перенос строки Установка значений PCTFREE и PCTUSED Параметры INITIAL, NEXT и PCTINCREASE Параметры MINEXTENTS и MAXEXTENTS Параметры LOGGING и NOLOGGING Параметры INITRANS and MAXTRANS Таблицы, организованные в виде кучи Таблицы, организованные по индексу Таблицы в индексном кластере 257 259 259 260 263 264 266 270 271 271 271 271 276 Оглавление 298 308 309 318 321 330 Таблицы в хеш-кластере Вложенные таблицы Синтаксис вложенных таблиц Хранение вложенных таблиц Временные таблицы Объектные таблицы Резюме Глава 7. Индексы Обзор индексов в Oracle Индексы на основе В*-дерева Индексы совращенным ключом Индексы по убыванию Когда имеет смысл использовать индекс на основе В*-дерева? Индексы на основе битовых карт Когда имеет смысл использовать индекс на основе битовых карт? Индексы по функциям Важные детали реализации Пример использования индекса по функции Подводный камень Прикладные индексы Часто задаваемые вопросы об индексах Работают ли индексы с представлениями? Индексы и пустые значения Индексы по внешним ключам Почему мой индекс не используется? Случай 1 Случай 2 Случай 3 Случай 4 Случай 5 Случай 6 Использовались ли индексы? Миф: пространство в индексе никогда повторно не используется Миф: столбцы с максимальным количеством разных значений должны указываться первыми Резюме 342 343 348 349 351 359 361 363 363 364 372 373 375 375 375 378 380 380 380 380 380 382 384 385 386, 389 Глава 8. Импорт и экспорт Простой пример Когда могут пригодиться утилиты IMP и ЕХР? Выявление повреждений Извлечение операторов ЯОД Клонирование схем Перенос табличных пространств Пересоздание экземпляров Копирование данных с одной платформы на другую Особенности использования утилит 396 397 397 398 398 398 399 399 Оглавление 400 400 403 405 405 407 407 409 409 410 415 418 421 423 423 428 428 428 436 437 439 442 444 Опции Параметры утилиты ЕХР Параметры утилиты IMP Экспортирование больших объемов данных Использование параметра FILESIZE Экспортирование по частям Экспортирование в именованный канал Экспортирование на устройство, не поддерживающее абсолютную адресацию Выделение подмножеств данных Перенос данных Получение операторов ЯОД Преодоление ограничений с помощью сценариев Резервное копирование и восстановление Утилиты IMP/EXP (уже) не являются средствами реорганизации Импортирование в другие структуры Непосредственный экспорт Проблемы и ошибки Клонирование Использование различных версий утилит IMP/EXP Куда делись индексы? Явно и автоматически именуемые требования Поддержка национальных языков (NLS) Таблицы, расположенные в нескольких табличных пространствах Резюме Глава 9. Загрузка данных Введение в SQL*Loader 452 Как сделать 458 Загрузка данных с разделителями 458 Загрузка данных в фиксированном формате 462 Загрузка дат 464 Загрузка данных с использованием последовательностей и других функций 465 Изменение существующих строк и вставка новых 470 Загрузка данных из отчетов 473 Загрузка файла в поля типа LONG RAW или LONG 476 Загрузка данных, содержащих символы новой строки 477 Использование другого символа вместо символа новой строки 478 Использование атрибута FIX 479 Использование атрибута VAR 484 Использование атрибута STR 485 Как упростить обработку символов новой строки 486 Выгрузка данных 487 Загрузка больших объектов 498 Загрузка больших объектов с помощью PL/SQL 498 Загрузка данных больших объектов с помощью SQLLDR 501 Загрузка массивов переменной длины и вложенных таблиц с помощью SQLLDR. 508 Вызов утилиты SQLLDR из хранимой процедуры Оглавление Проблемы Нельзя выбрать сегмент отката TRUNCATE работает по-другому Стандартным типом поля в SQLLDR является CHAR(255) Опции командной строки переопределяют установки в командном файле Резюме 516 516 516 516 517 Глава 10. Стратегии и средства настройки Определение проблемы Мой подход Настройка — непрерывный процесс Проектирование с учетом производительности Пробуйте разные подходы Применяйте защитное программирование Проверяйте производительность Связываемые переменные и разбор (еще раз) Используются ли связываемые переменные? SQL_TRACE, TIMED_STATISTICS и TKPROF Организация трассировки Использование и интерпретация результатов работы утилиты TKPROF Использование и интерпретация исходных трассировочных файлов Пакет DBMS_PROFILER Средства контроля и отладки Набор утилит StatsPack Установка утилит StatsPack Представления V$ Представление V$EVENT_NAME Представления V$FILESTAT и V$TEMPSTAT Представление V$LOCK Представление V$MYSTAT Представление V$OPEN_CURSOR Представление V$PARAMETER Представление V$SESSION Представление V$SESSION_EVENT Представление V$SESSION_LONGOPS Представление V$SESSION_WAIT Представление V$SESSTAT Представление V$SESS_IO Представления V$SQL и V$SQLAREA Представление V$STATNAME Представление V$SYSSTAT Представление V$SYSTEM_EVENT Резюме 520 522 522 523 525 525 526 528 542 545 546 549 560 572 573 575 576 595 595 596 596 596 597 599 599 601 602 602 602 602 603 603 603 603 Глава 11. Стабилизация плана оптимизатора Обзор возможностей Использование стабилизации плана оптимизатора 608 Оглавление 611 616 618 618 619 619 619 620 622 622 623 624 625 625 626 629 629 629 631 632 633 633 633 635 635 637 637 637 639 639 639 640 644 645 Метод настройки Средство разработки Проверка использования индексов Получение списка SQL-операторов, выполненных приложением Как выполняется стабилизация плана оптимизатора Представления OUTLINES и OUTLINE_HINTS Представления _OUTLINES Представления _OUTLINE_HINTS Создание хранимых шаблонов Привилегии, необходимые для создания хранимых шаблонов Использование операторов ЯОД Использование оператора ALTER SESSION Пользователь OUTLN Перенос шаблонов из одной базы данных в другую Получение нужного шаблона Управление шаблонами Операторы ЯОД Оператор ALTER OUTLINE Оператор DROP OUTLINE Пакет OUTLN_PKG Процедура OUTLN_PKG.DROP_UNUSED Процедура OUTLN_PKG.DROP_BY_CAT Процедура OUTLN_PKG.UPDATE_BY_CAT Проблемы Имена шаблонов и регистр символов Проблема с оператором ALTER SESSION Оператор DROP USER не удаляет шаблоны Шаблоны и параметр 'CURSOR_SHARING = FORCE' В шаблонах используется простое сравнение текста Шаблоны по умолчанию хранятся в табличном пространстве SYSTEM Раскрытие условий OR Производительность Пространство имен шаблонов — глобально Ошибки, которые можно допустить Резюме Предметный указатель Глава 12. Аналитические функции Пример Как работают аналитические функции Синтаксис Функции Конструкция фрагментации Конструкция упорядочения Конструкция окна Окна диапазона Окна строк Задание окон Функции Примеры Запрос первых N Запрос с транспонированием Доступ к строкам вокруг текущей строки Проблемы Аналитические функции в PL/SQL Аналитические функции в конструкции WHERE Значения NULL и сортировка Производительность Резюме 1038 1041 1041 1043 1043 1044 1046 1048 1051 1053 1056 1059 1059 1070 1077 1081 1081 1083 1083 1085 Глава 13. Материализованные представления Предыстория Что необходимо для выполнения примеров Пример Назначение материализованных представлений Как работать с материализованными представлениями Подготовка Внутренняя реализация Переписывание запроса Как гарантировать использование представлений Требования целостности Измерения Пакет DBMS_OLAP Оценка размера Проверка достоверности измерений Рекомендация создания материализованных представлений Проблемы Материализованные представления не предназначены для систем ООТ Целостность запросов при переписывании Резюме 1090 1091 1092 1098 1099 1099 1100 1101 1103 1103 1108 1117 1117 1119 1121 1123 1123 1124 Оглавление Глава 14. Фрагментация Использование фрагментации Повышение доступности данных Упрощение администрирования Повышение производительности операторов ЯМД и запросов Как выполняется фрагментация Схемы фрагментации таблиц Фрагментация индексов Локально фрагментированные индексы Глобально фрагментированные индексы Резюме 1128 1128 1130 1131 1134 1134 1139 1140 1148 Глава 15. Автономные транзакции Пример Когда использовать автономные транзакции? Проверка, записи которой не могут быть отменены Метод, позволяющий избежать ошибки изменяющейся таблицы Выполнение операторов ЯОД в триггерах Запись в базу данных Строгая проверка Когда среда позволяет выполнять только операторы SELECT Разработка модульного кода Как работают автономные транзакции Выполнение транзакции Область действия Переменные пакетов Установки/параметры сеанса Изменения в базе данных Блокировки Завершение автономной транзакции Точки сохранения Проблемы Невозможность использования в распределенных транзакциях Только в среде PL/SQL Откатывается вся транзакция Временные таблицы уровня транзакции Изменяющиеся таблицы Ошибки, которые могут произойти Резюме 1162 1164 1164 1167 1168 1174 1174 1178 1182 1183 1183 1185 1185 1186 1187 1190 1191 1192 1194 1194 1194 1195 1196 1198 1200 Глава 16. Динамический SQL Сравнение динамического и статического SQL Когда использовать динамический SQL? Использование динамического SQL Пакет DBMS_SQL Встроенный динамический SQL Сравнение пакета DBMS_SQL и встроенного динамического SQL Связываемые переменные 1204 1206 1208 1208 1215 1220 Количество столбцов выходных данных на этапе компиляции не известно Многократное выполнение одного и того же оператора Проблемы Нарушение цепочки зависимостей "Хрупкость" кода Сложность настройки Резюме 1225 1233 1243 1243 1244 1244 Глава 17.

interMedia 1248 1249 1249 1252 1252 1255 1256 1258 1259 1262 1265 1266 1272 1272 1273 1274 1274 1275 1277 1277 1278 1279 Краткий исторический экскурс Использование компонента interMedia Text Поиск текста Управление разнородными документами Индексирование текста из различных источников данных Компонент interMedia Text — часть базы данных Oracle Смысловой анализ Поиск в приложениях XML Как работает компонент interMedia Text Индексирование с помощью interMedia Text, Оператор ABOUT Поиске разделах Проблемы Компонент interMedia Text —это НЕ система документооборота Синхронизация индекса Индексирование информации вне базы данных Службы обработки документов Индекс-каталог Возможные ошибки Устаревший индекс Ошибки внешней процедуры Дальнейшее развитие Резюме Глава 18. Внешние процедуры на языке С Когда используются внешние процедуры? Как реализована поддержка внешних процедур? Конфигурирование сервера Проверка программы extproc Проверка среды сервера Проверка процесса прослушивания Первая проверка Компиляция кода extproc.с Настройка учетной записи SCOTT/TIGER Создание библиотеки demolib Установка и запуск Наша первая внешняя процедура Оболочка Код на языке С 1282 1284 1285 1288 1288 1290 1290 1291 1292 1292 1293 1294 1295 Оглавление Создание внешней процедуры Установка и запуск Внешняя процедура для сброса большого объекта в файл (LOB_IO) Спецификация пакета LOB_IO Код Pro*С для пакета LOB_IO Создание внешней процедуры Установка и использование пакета LOB_IO Возможные ошибки Резюме 1330 1334 1335 1336 1338 1342 1344 1349 Глава 19. Хранимые процедуры на языке Java Когда используются хранимые процедуры на языке Java? Как работают внешние процедуры на языке Java Передача данных Полезные примеры Генерация списка файлов каталога Выполнение команды ОС Получение времени с точностью до миллисекунд Возможные ошибки ORA-29549 Java Session State Cleared Ошибки прав доступа ORA-29531 no method X in class Y Резюме 1360 1361 1366 1376 1376 1378 1381 1382 1382 1383 1383 Глава 20. Использование объектно-реляционных средств В каких случаях используются объектно-реляционные средства Как работают объектно-реляционные средства Добавление новых типов данных в систему Использование типов для расширения возможностей языка PL/SQL Создание нового типа данных PL/SQL Уникальные приемы использования наборов SELECT * из PL/SQL-функции Множественная выборка данных в записи Вставка записей Объектно-реляционные представления Необходимые типы Объектно-реляционное представление Резюме 1388 1389 1389 1403 1403 1414 1415 1418 1419 1420 1420 1421 Глава 2 1. Тщательный контроль доступа Пример Когда использовать это средство? Простота сопровождения Контроль доступа выполняется на сервере Упрощение разработки приложений Эволюционная разработка приложений Отказ от совместно используемых учетных записей Поддержка совместно используемых учетных записей Предоставление доступа к приложению как к службе 1438 1439 1439 1440 1441 1441 1441 1441 Оглавление Как реализованы средства тщательного контроля доступа Пример 1: Реализация правил защиты Пример 2: Использование контекстов приложений Проблемы Целостность ссылок Тайный канал Удаление строк Кэширование курсоров Экспортирование/Импортирование Проблемы экспорта Проблемы импорта Отладка Ошибки, которые могут произойти Резюме 1443 1445 1449 1467 1467 1468 1469 1472 1478 1479 1481 1482 1482 Глава 22. Многоуровневая аутентификация Когда использовать многоуровневую аутентификацию? Механизм многоуровневой аутентификации Предоставление привилегии Проверка промежуточных учетных записей Проблемы Резюме 1490 1493 1501 1502 1503 Глава 23. Права вызывающего и создателя Пример Когда использовать права вызывающего Разработка универсальных утилит Приложения, работающие со словарем данных Универсальные объектные типы Реализация собственных средств контроля доступа Когда использовать права создателя Производительность и масштабируемость Защита Как работают процедуры с правами вызывающего Права создателя Компиляция процедуры с правами создателя Права вызывающего Разрешение ссылок и передача привилегий Компиляция процедуры с правами вызывающего Использование объектов-шаблонов Проблемы Права вызывающего и использование разделяемого пула Производительность Более надежный код для обработки ошибок Побочные эффекты использования SELECT * Помните о "скрытых" столбцах Java и права вызывающего Возможные ошибки Резюме 1508 1511 1511 1515 1518 1518 1521 1521 1522 1523 1523 1525 1528 1529 1534 1535 1539 1539 1542 1544 1546 1547 1549 1554, Оглавление Приложение А. Основные стандартные пакеты Когда используются стандартные пакеты О стандартных пакетах 1558 Пакеты DBMS_ALERT и DBMS_PIPE Когда использовать сигналы и каналы Настройка Пакет DBMS_ALERT Одновременные сигналы нескольких сеансов Неоднократная передача сигнала в сеансе Передача многочисленных сигналов несколькими сеансами до вызова процедуры ожидания Пакет DBMS_PIPE Серверы каналов или внешние процедуры? Пример в сети Internet Резюме 1562 1562 1563 1565 1566 1567 1568 1571 1573 Пакет DBMS_APPLICATION_INFO Использование информации о клиенте Использование представления V$SESSION_LONGOPS Резюме 1576 1577 Пакет DBMS_JAVA Функции LONGNAME и SHORTNAME Установка опций компилятора Процедура SET_OUTPUT Процедуры loadjava и dropjava Процедуры управления правами Резюме 1584 1585 1589 1589 1590 Пакет DBMS_JOB Однократное выполнение задания Текущие задания Нетривиальное планирование Контроль заданий и обнаружение ошибок Резюме 1597 1601 1604 1606 Пакет DBMS_JOB 1610 1611 1611 1613 1614 1618 1620 1623 1626 1626 Как загружать большие объекты? Функция substr Оператор SELECT FOR UPDATE в языке Java Преобразования Преобразование типа BLOB в VARCHAR2 и обратно Преобразование данных типа LONG/LONG RAW в большой объект Пример множественного однократного преобразования типа Оперативное преобразование типа данных Запись значений объекта типа BLOB/CLOB на диск Выдача большого объекта на Web-странице с помощью PL/SQL Резюме Оглавление Пакет DBMS_LОСК Пакет Резюме 1629 DBMS_LOGMNR Обзор Этап 1: создание словаря данных Этап 2: использование средств LogMiner Опции и использование Определение с помощью LogMiner, когда Использование области PGA Ограничения пакетов LogMiner Объектные типы Oracle Перемещенные или фрагментированные строки Другие ограничения Представление V$LOGMNR_CONTENTS Резюме 1636 1637 1640 1646 1649 1651 1652 1652 1655 1658 1658 Пакет DBMS_OBFUSCATION_TOOLKIT Пакет-оболочка Проблемы Управление ключами Генерация и хранение ключей в клиентском приложении Хранение ключей в той же базе данных Хранение ключей в файловой системе сервера базы данных Резюме 1665 1680 1682 1682 1683 1684 Пакет DBMS_OUTPUT Как работает пакет DBMS_OUTPUT Пакет DBMS_OUTPUT в других средах Обход ограничений Использование небольшой функции-оболочки или другого пакета Создание аналога пакета DBMS_OUTPUT Резюме 1687 1692 1696 1696 1697 Пакет Проблемы Резюме DBMS_PROFILER 1714 Пакет DBMS_UTILITY Процедура COMPILE_SCHEMA Процедура ANALYZE_SCHEMA Применение процедуры ANALYZE_SCHEMA к изменяющейся схеме Процедура ANALYZE_SCHEMA анализирует не все Процедура ANALYZE_DATABASE Функция FORMAT_ERROR_STACK Функция FORMAT_CALL_STACK Функция GET_TIME Функция GET_PARAMETER_VALUE 1716 1721 1722 1723 1724 1724 1726 1729 Оглавление Процедура NAME_RESOLVE Процедура NAME_TOKENIZE Процедуры COMMA_TO_TABLE, TABLE_TO_COMMA Процедура DB_VERSION и функция PORT_STRING Функция GET_HASH_VALUE Резюме 1731 1734 1737 1739 1739 Пакет UTL_FILE Параметр инициализации UTL_FILE_DIR Обращение к сетевым дискам в Windows Обработка исключительных ситуаций Как сбросить Web-страницу на диск? Ограничение длины строки —1023 байт Чтение содержимого каталога Резюме 1746 1747 1749 1750 1751 1752 Пакет UTL_HTTP Возможности пакета UTL_HTTP Добавление поддержки протокола SSL в пакете UTL_HTTP Реальное использование пакета UTL_HTTP Улучшенная версия пакета UTL_HTTP Резюме 1756 1758 1765 1768 Пакет UTL_RAW Пакет UTL_SMTP и отправка электронной почты UTL_SMTP — расширенный пример использования Загрузка и использование интерфейса JavaMail Резюме 1779 1782 1787 Пакет UTL_TCP Тип SocketType Резюме Форумы на сайте p2p.wrox.com Как обратиться за поддержкой Почему эта система обеспечивает наилучшую поддержку Поиск информации об ошибках на сайте www.wrox.com Поиск информации об ошибках на Web-сайте Добавление информации об ошибке 1798 1811 1814 1814 1815 1815 1815 Приложение В. Поддержка, ошибки и сайт p2p.wrox.com Предметный указатель Об авторе Меня зовут Том Кайт. Я работаю в корпорации Oracle со времени версии 7.0.9 (для тех, кто не измеряет время версиями Oracle, уточню — с 1993 года). Однако я работал с СУБД Oracle, начиная с версии 5.1.5с (однопользовательская версия для DOS стоимостью 99 долларов на дискетах емкостью 360 Кбайт). До корпорации Oracle я более шести лет работал системным интегратором, занимаясь построением крупномасштабных гетерогенных баз данных и приложений (в основном для правительственных и оборонных учреждений). В этот период я много работал с СУБД Oracle, а точнее, помогал пользователям баз данных Oracle. Я работал непосредственно с клиентами на этапе создания спецификаций и построения систем, но чаще помогал перестраивать или настраивать системы ("настройка" обычно сводилась к переделке). Кроме того, я — именно тот Том, который ведет рубрику "AskTom" в журнале Oracle Magazine, отвечая на вопросы читателей о сервере и инструментальных средствах Oracle. Обычно на сайте http://asktom.oracle.com я получаю за день от 30 до 40 вопросов и отвечаю на них. Раз в два месяца я публикую подборку лучших вопросов с ответами в журнале (ответы на все вопросы доступны в Web и, естественно, хранятся в базе данных Oracle). В общем, я занимаюсь тем, что помогаю людям успешно эксплуатировать СУБД Oracle. Да, а в свободное время я разрабатываю приложения и программное обеспечение в самой корпорации Oracle. В этой книге описано то, чем я занимаюсь ежедневно. Предлагаемый в ней материал посвящен темам и вопросам, с которыми пользователи сталкиваются постоянно. Все проблемы рассматриваются с позиции "если я использую это, то делаю так...". Моя книга — итог многолетнего опыта использования СУБД Oracle в тысячах различных ситуаций.

Благодарности Благодарности Я хотел бы поблагодарить многих людей, помогавших мне создать эту книгу. В корпорации Oracle я работаю с лучшими и наиболее яркими людьми из тех, кого мне удалось узнать, и они все так или иначе помогли мне. В частности, я благодарю Джоэла Калмана (Joel Kallman) за помощь в создании раздела книги, посвященного технологии interMedia. В ходе работы над сайтом AskTom мне не раз пришлось обращаться к Джоэлу за помощью в этой области — он именно тот человек, к которому стоит обратиться, если речь идет об interMedia и соответствующих технологиях. Я также благодарен Дэвиду Ноксу (David Knox) за помощь в создании примеров работы с протоколом SSL в разделе, посвященном пакету UTL_HTTP. Если бы не его знания и желание поделиться ими со мной, этого раздела просто не было бы. Наконец, я хочу поблагодарить всех, с кем работаю, за поддержку в испытании писательским трудом. Мне понадобилось намного больше времени и энергии, чем я мог себе представить, и я благодарен им за понимание моих проблем. В особенности, хочу поблагодарить Тима Хёхста (Tim Hoechst) и Майка Хичва (Mike Hichwa), которых я знаю по совместной работе уже почти 10 лет. Их постоянные вопросы и требования помогли мне разобраться с вещами, которыми я лично никогда и не подумал бы заниматься. Хочу также поблагодарить пользователей программного обеспечения Oracle, задающих так много хороших вопросов. Если бы не они, мне и в голову не пришло бы написать эту книгу. Большая часть представленной здесь информации является прямым результатом чьего-нибудь вопроса "как" или "почему". Наконец, и это самое главное, я благодарен за неизменную поддержку моей семье. Когда в тысячный раз слышишь: "Папа, ну почему ты все еще пишешь эту книгу?", то понимаешь, что кому-то нужен. Я просто не представляю, как бы я закончил эту книгу без постоянной поддержки моей жены Лори, сына Алана и дочери Мэган.

Введение Представленный в этой книге материал сформирован на основе моего опыта разработки приложений Oracle и работы с коллегами-программистами, которым я помогал создавать надежные и устойчивые приложения для СУБД Oracle. Книга — лишь отражение того, чем я занимаюсь ежедневно, и тех проблем, с которыми постоянно сталкиваются люди. Я описал то, что мне показалось наиболее важным, — базу данных Oracle и ее архитектуру. Я мог бы написать книгу с аналогичным названием, объясняющую, как разрабатывать приложения с помощью конкретного языка и архитектуры, например, с помощью технологии динамических HTML-страниц Java Server Pages, обращающихся к компонентам Enterprise Java Beans, которые используют интерфейс JDBC для взаимодействия с сервером Oracle. Однако в конечном итоге для успешного создания подобного приложения действительно необходимо понимать темы, представленные в этой книге. Книга посвящена тому, что, по моему мнению, должно быть известно всем для успешной разработки приложений Oracle, независимо от того, программируются ли эти приложения на Visual Basic с использованием интерфейса ODBC, на языке Java с использованием технологии EJB и интерфейса JDBC или на языке Perl с помощью модуля DBI. Эта книга не навязывает определенную архитектуру приложений;

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

Введение О чем эта книга Одна из проблем при наличии множества вариантов разработки — выяснить, какой из них лучше всего подходит в конкретной ситуации. Все хотят получить максимальную гибкость (как можно больше вариантов), но при этом так, чтобы все было просто и понятно. Oracle дает разработчикам практически неограниченный выбор. Никто еще не говорил: "Этого нельзя сделать в Oracle";

говорят иначе: "Сколько способов сделать это в Oracle вам надо?". Я надеюсь, что книга поможет вам сделать правильный выбор. Эта книга для тех, кто приветствует свободу выбора, но хотел бы получить рекомендации и узнать особенности реализации тех или иных средств и функций Oracle. Например, СУБД Oracle предлагает замечательную возможность создания виртуальной приватной базы данных (virtual private database). В документации Oracle описано, как использовать эту возможность и что она дает. В документации, однако, не сказано, когда ее использовать и, что видимо еще важнее, когда ее не надо использовать. В документации не всегда представлены детали реализации той или иной возможности, а если они не известны, то могут неожиданно встать на вашем пути. (Речь идет не об ошибках, но о предполагавшихся способах работы и первоначальном назначении соответствующих средств.) Для кого предназначена эта книга?

Целевой аудиторией являются все разработчики приложений для Oracle как сервера баз данных. Книга написана для профессиональных разработчиков Oracle, интересующихся тем, как решить задачу средствами этой СУБД. Практическая ориентация книги означает, что многие разделы будут очень интересны администраторам баз данных (АБД). В большинстве примеров, приведенных в книге для демонстрации ключевых возможностей, используется утилита SQL*Plus, поэтому вы не сможете узнать из нее, как разрабатывать удобный и красивый графический пользовательский интерфейс, но зато узнаете, как работает СУБД Oracle, что позволяют сделать ее основные средства и когда их нужно (и не нужно) использовать. Книга предназначена для тех, кто хочет получить от СУБД Oracle большую отдачу при меньших усилиях. Она для каждого, кто хочет знать, как средства Oracle могут применяться в практической работе (при этом не только приводятся примеры использования того или иного средства, но и объясняется, почему это средство необходимо). Еще одна категория людей, которым эта книга покажется интересной, — технические руководители групп разработчиков, реализующих проекты на базе Oracle. В некотором отношении очень важно, чтобы они знали особенности СУБД, имеющие принципиальное значение для успешной разработки. Эта книга может дать дополнительные аргументы руководителю проекта, желающему обучить персонал необходимым технологиям или убедиться, что разработчики уже знают то, что им необходимо знать.

Введение Чтобы получить максимальную отдачу от этой книги, читатель должен: О Знать язык SQL. He обязательно быть лучшим специалистом по SQL в стране, но хорошее практическое знание существенно поможет. • Понимать программы на языке PL/SQL. Это не обязательное требование, но знание PL/SQL поможет "воспринять" примеры. Эта книга, например, не объясняет, как создавать циклы FOR или объявлять тип записи — об этом достаточно написано в документации Oracle и в многочисленных книгах. Однако это не значит, что вы не узнаете много нового о программировании на PL/SQL, прочтя эту книгу. Узнаете. Вы очень близко познакомитесь со многими возможностями PL/SQL и узнаете новые способы решения задач, изучите пакеты и средства, о существовании которых, возможно, даже и не подозревали.

• Иметь определенный опыт работы с процедурным языком программирования, на пример С или Java. Я уверен, что любой, кто способен понимать и писать код на каком-то процедурном языке программирования, сможет успешно разобраться в примерах, представленных в книге.

• Ознакомиться с руководством Oracle Server Concepts Manual.

Несколько слов об этом руководстве. Из-за большого объема многих пугает документация Oracle. Если вы только начинаете изучение руководства или ранее не читали подобной документации, я рекомендую начать именно с Oracle8i Concepts. Его объем — около 800 страниц, и в нем описаны многие из фундаментальных концепций Oracle, о которых вам надо знать. Это руководство не описывает все технические детали (именно этому посвящены остальные 10-20 тысяч страниц документации), но представляет все важнейшие концепции. В руководстве затронуты, в частности, следующие темы: • структура базы данных, организация и хранение данных;

• распределенная обработка;

• архитектура памяти Oracle;

• архитектура процессов Oracle;

• объекты пользовательской схемы (таблицы, индексы, кластеры и т.д.);

• встроенные и определяемые пользователем типы данных;

• хранимые процедуры;

• особенности организации транзакций;

• оптимизатор;

• целостность данных;

• управление одновременным доступом. Я и сам периодически перечитываю соответствующие главы. Это — фундаментальные концепции. Если вы их не понимаете, создаваемые вами приложения Oracle будут обречены на провал. Я рекомендую прочитать это руководство и разобраться хотя бы в важнейших вещах.

Введение Структура книги Чтобы облегчить восприятие, книга поделена на шесть отдельных частей (они описаны ниже). Это не просто структурные единицы — они помогут быстрее найти наиболее существенную информацию. Книга состоит из 23 глав, каждая из которых — "мини-книга", то есть практически отдельный компонент. Изредка я ссылаюсь на примеры или возможности, описанные в других главах (часть, посвященная защите, например, больше других зависит от примеров и понятий, представленных в других главах). Но, как правило, вполне можно читать главу отдельно от остальной книги. Например, вовсе не нужно прочитать главу 10, чтобы понять главу 14. Форматы и стили глав практически идентичны: • Введение в описываемые средства или возможности. • Почему это нужно (или не нужно) использовать. Я описываю ситуации, когда имеет смысл использовать данное средство и когда этого делать не стоит. • Как это использовать. Это не просто цитата из справочного руководства по языку SQL, а пошаговое описание: вот что требуется, что для этого надо сделать, а вот предварительные условия применения. В этом разделе рассматривается: Как применить то или иное средство или прием Примеры, примеры и еще примеры Отладка, поиск ошибок при реализации Подводные камни при использовании средства Устранение ошибок (превентивное) О Резюме, подводящее итог рассмотрения. В книге содержится множество примеров и большое количество кода, причем весь этот код доступен для загрузки на сайте http://www.wrox.com. Далее представлено подробное содержание каждой части.

Основные понятия • Глава 1. Разработка успешных приложений для Oracle. В этой главе описан мой принципиальный подход к программированию баз данных. Все СУБД устроены по-разному, и чтобы успешно и в срок разработать приложение, использующее базу данных, необходимо точно знать, что и как позволяет сделать ваша СУБД. Не зная возможностей СУБД, вы рискуете в очередной раз "изобрести велосипед", то есть создать средства, уже предоставляемые базой данных. Если вы не знаете, как работает СУБД, то с большой вероятностью будете создавать неэффективные и непредсказуемые приложения. В этой главе описывается ряд реальных приложений, при создании которых недостаток понимания базовых концепций СУБД привел к неудаче всего проекта. На основе такого практического подхода с контрпримерами в главе описываются базовые возможности и функции СУБД, которые необходимо понимать Введение разработчикам. Идея в том, что вы не можете себе позволить рассматривать СУБД как черный ящик, просто "отвечающий на запросы" и самостоятельно обеспечивающий требуемую масштабируемость и производительность. • Глава 2. Архитектура. СУБД Oracle — весьма сложная система. При каждом подключении к базе данных или выполнении команды UPDATE в фоновом режиме работает целый набор процессов, гарантирующих устойчивую работу приложений и поддержку целостности данных. Например, СУБД поддерживает достаточный объем информации для восстановления данных в исходное состояние при необходимости. Она кэширует данные и в случае необходимости повторно использует их. И так далее. В большинстве случаев все это происходит незаметно (по крайней мере, для разработчика), но при возникновении проблем половина успеха зависит от знания того, где искать их причину. В этой главе описаны три основных компонента архитектуры Oracle: структура памяти (в частности, глобальная системная область — System Global Area), физические процессы и набор файлов (фалы параметров, файлы журнала повторного выполнения...). Знание архитектуры Oracle принципиально важно для понимания уникального способа реализации ряда возможностей в Oracle и его влияния на приложения. • Глава 3. Блокирование и одновременный доступ. Различные СУБД выполняют одни и те же операции по-разному (то, что хорошо работает в SQL Server, может гораздо хуже работать в Oracle), и понимание реализации механизмов блокирования и управления одновременным доступом в Oracle жизненно важно для создания успешно работающих приложений. В этой главе описан базовый подход к этим механизмам, используемый в СУБД Oracle, типы применяемых блокировок (ЯМД, ЯОД, защелки...) и проблемы, возникающие при некорректной реализации блокирования (взаимные блокировки, блокирование-доступа и эскалация блокировок). В разделе, посвященном управлению одновременным доступом, описываются предоставляемые СУБД Oracle функции, которые позволяют контролировать доступ пользователей к базе данных и ее изменение. • Глава 4. Транзакции. Транзакции — фундаментальное свойство всех баз данных;

именно они отчасти отличают базу данных от файловой системы. И тем не менее их часто понимают неправильно, а многие разработчики даже не подозревают, что вовсе их не используют. В этой главе описано, как правильно использовать транзакции в СУБД Oracle. Кроме того, автор обращает внимание на ряд "плохих привычек", приобретаемых при разработке приложений для других СУБД. В частности, рассматривается понятие неделимости транзакции и ее влияние на выполнение операторов в Oracle. Затем описываются операторы управления транзакциями (COMMIT, SAVEPOINT, ROLLBACK), ограничения целостности и распределенные транзакции (протокол двухфазной фиксации). Наконец, рассматривается ряд реальных проблем использования транзакций: их регистрация и роль журнала повторного выполнения и сегментов отката.

Введение Структуры и утилиты базы данных • Глава 5. Повторное выполнение и откат. Можно сказать, что разработчику не требуется столь же детально, как АБД, понимать работу журнала повторного выполнения и сегментов отката, но разработчик должен представлять их значение для базы данных. Обсудив назначение журнала повторного выполнения, мы опишем, что конкретно делает оператор COMMIT. Мы также рассмотрим ряд проблем, в частности объем генерируемой информации в журнале повторного выполнения, отключение журнализации, а также проанализируем использование сегментов отката. В разделе главы, посвященном откату, мы сначала рассмотрим, какие операторы генерируют наибольший и наименьший объем данных для отката, а затем перейдем к SQL-оператору set transaction. Он обычно используется для задания большого сегмента отката для операции с большим объемом изменений. Затем мы займемся печально знаменитой ошибкой 'ORA-01555 snapshot too old', рассмотрим причины ее возникновения и способы предотвращения. • Глава 6. Таблицы. Oracle сейчас поддерживает несколько типов таблиц. В этой главе рассмотрены все типы таблиц — произвольно организованные (обычные, "нормальные" таблицы), организованные по индексу, входящие в индексный кластер, входящие в хеш-кластер, вложенные, временные и объектные — и описано, когда, как и почему имеет смысл использовать тот или иной тип. В большинстве случаев произвольно организованных таблиц вполне достаточно, но вы должны понимать, когда другие типы могут оказаться более подходящими. • Глава 7. Индексы. Индексы — критический компонент проекта приложения. Правильная реализация индексов требует глубокого знания данных, их распределения и способов их использования. Слишком часто индексы считают второстепенными структурами при разработке приложений, и от этого снижается их производительность. В этой главе мы детально рассмотрим различные типы индексов, включая индексы на основе В-дерева, битовые индексы, индексы по функциям и индексы прикладных доменов, а также опишем, когда надо и не надо использовать индексы определенного типа. В разделе "Часто задаваемые вопросы" мы дадим ответы на некоторые из типичных вопросов типа "Работают ли индексы с представлениями?" и "А почему мой индекс не используется?". • Глава 8. Импорт и экспорт. Средства импорта и экспорта — одни из самых старых инструментальных средств Oracle, используемые для извлечения таблиц, схем или всего определения базы данных из одного экземпляра Oracle и переноса их на другой экземпляр или в другую схему. Тем не менее, многие разработчики не знают, как правильно их использовать. Мы рассматриваем проблемы экспорта больших объемов информации, разделения и переноса данных, и использования этих средств при резервном копировании или реорганизации данных. Глава заканчивается описанием потенциальных ловушек и проблем при использовании средств экспорта и импорта данных.

Введение • Глава 9. Загрузка данных. Эта глава посвящена утилите SQLLDR и описывает различные способы использования этого средства для загрузки и изменения данных в базе данных. Среди рассмотренных тем — загрузка данных в формате записей с разделителями полей, обновление существующих строк и вставка новых, выгрузка данных и вызов утилиты SQLLDR из хранимой процедуры. Хотя SQLLDR тоже является давним и принципиально важным средством, но в отношении его практического использования возникает много вопросов.

Производительность • Глава 10. Стратегии и средства настройки. Это одна из моих любимых тем, и в данной главе я детально описываю свой подход к настройке производительности приложений Oracle, а затем предлагаю удобное практическое руководство по применяемым средствам и методам. Начальный раздел посвящен настройке приложений, включая такие темы, как связываемые переменные и синтаксический анализ, утилиты SQL_TRACE, TIMED_STATISTICS и TKPROF, пакет DBMS_PROFILER и важность наличия средств журнализации в приложениях. После полной настройки приложений можно переходить к базе данных, в частности к группе утилит StatsPack и представлениям V$, широко используемым при настройке. • Глава 11. Стабилизация плана оптимизатора. Разработчики, использующие Oracle 8i (и более новые версии), теперь могут сохранять набор "подсказок серверу", известный как план оптимизатора и детально описывающий, как лучше выполнять в базе данных определенный SQL-оператор. Это дает несомненные преимущества с точки зрения производительности, и мы детально описываем способ генерации таких "шаблонов" (outlines) и управление ими.

Расширенные возможности SQL • Глава 12. Аналитические функции. Некоторые вопросы об информации в базе данных задают часто, но реализующие их запросы сложно написать на обычном языке SQL (кроме того, такие запросы не всегда быстро работают). Сервер Oracle 8.1.6 впервые предоставил аналитические функции. Эти функции добавляют расширения языка SQL, упрощающие создание такого рода запросов и существенно повышающие производительность по сравнению с обычным SQL-запросом. В этой главе описан принцип работы аналитических функций, рассматривается полный синтаксис (включая конструкции функции, фрагмента и окна), а затем даются полные практические примеры использования этих функций. • Глава 13. Материализованные представления. Некоторые "агрегирующие" запросы должны для получения ответа обрабатывать терабайты данных. Последствия с точки зрения производительности очевидны, особенно если речь идет о часто выполняемом запросе — необходимость обработки огромного объема данных при каждом его выполнении. При использовании материализованных представлений мы просто делаем основную часть работы заранее — собираем Введение данные, необходимые для ответа на запрос в материализованном представлении, и дальнейшие запросы выполняются к этим заранее собранным данным. Более того, СУБД может распознавать аналогичные запросы, использующие эти подготовленные данные, и автоматически переписывать запрос так, чтобы он использовал материализованное представление. В этой главе описано, как все это работает и как поддерживать материализованные представления, включая использование ограничений, измерений и пакета DBMS_OLAP, • Глава 14. Фрагментация. Фрагментация создавалась как средство для упрощения управления очень большими таблицами и индексами за счет использования подхода "разделяй и властвуй" — деления таблицы или индекса на несколько меньших и более управляемых частей. Это как раз та область, где АБД и разработчик должны работать вместе с целью обеспечения максимальной доступности и производительности приложения. В данной главе рассмотрена фрагментация как таблиц, так и индексов. Мы рассмотрим фрагментацию с использованием локальных индексов (типична для хранилищ данных) и глобальных индексов (обычно используется в системах оперативной обработки транзакций — ООТ). • Глава 15. Автономные транзакции. Это средство позволяет создать подтранзакцию, изменения которой фиксируются или откатываются независимо от родительской транзакции. Мы рассмотрим ситуации, когда это может понадобиться, например отслеживание "нелегальных" попыток изменить защищенную информацию, попытки избежать ошибки "изменяющейся таблицы" или выполнение операторов ЯОД в триггерах. Затрагиваются также проблемы управления транзакциями, области действия, завершения автономных транзакций и точек сохранения. • Глава 16. Динамический SQL. В этой главе сравниваются два метода использования SQL-операторов в программах: "обычный" статический SQL и динамический SQL. Динамический SQL-код — это SQL-код, формируемый по ходу выполнения, не известный на этапе компиляции. Мы рассмотрим два метода использования динамического SQL в программах: на основе стандартного пакета DBMS_SQL и встроенного динамического SQL, декларативного метода для программ на языке PL/SQL. В каждом конкретном случае может быть несколько причин выбрать один из этих методов, например известность связываемых переменных на этапе компиляции, известность вида результатов на этапе компиляции, одно- или многократное выполнение динамически формируемого оператора в ходе сеанса. Мы детально рассмотрим все эти причины.

Расширяемость • Глава 17. interMedia. Эта глава посвящена компоненту interMedia Text. Вместо подробного описания того, "как использовать interMedia Text", мы рассмотрим, что это такое и что этот компонент может дать, а также средства СУБД, позволяющие достичь соответствующей функциональности. Мы рассмотрим поиск текста, возможности управлять разнообразными документами, индекси Введение ровать текст из различных источников данных и искать приложения XML. Глава завершается описанием ряда проблем interMedia, в том числе синхронизации индексов и индексирования информации, хранящейся вне базы данных. • Глава 18. Внешние процедуры на языке С. Начиная с Oracle 8.0, появилась возможность подключать к СУБД процедуры, реализованные на языках, отличных от PL/SQL, например, С или Java. Такие процедуры называют внешними. В этой главе мы рассмотрим процедуры на языке С с точки зрения архитектуры. Мы опишем, как сконфигурировать сервер для использования таких процедур, как протестировать конфигурацию, и создадим пример процедуры, передающей и обрабатывающей переменные различных типов. Мы также рассмотрим внешнюю процедуру для преобразования большого двоичного объекта в файл (LOB_IO), позволяющую записывать на диск большие двоичные объекты типа CLOB, BLOB и BF1LE. • Глава 19. Хранимые процедуры на языке Java. За счет разумного использования небольших фрагментов Java-кода можно получить широкие функциональные возможности, недоступные в языке PL/SQL. В этой главе рассматриваются практические примеры правильного использования этой возможности, например, для получения списка файлов в каталоге или выполнения команды операционной системы. Глава заканчивается описанием ряда проблем, с которыми может столкнуться разработчик при попытке использовать это средство, и возможных решений этих проблем. • Глава 20. Использование объектно-реляционных средств. Наличие объектнореляционных возможностей в СУБД (начиная с Oracle 8i) существенно расширяет набор доступных разработчику типов данных. Но когда их использовать (и, что не менее важно, стоит ли использовать)? В этой главе показано, как добавлять в систему новые типы данных (мы создадим новый тип данных PL/SQL), и рассмотрены уникальные возможности, предоставляемые наборами. Наконец, мы рассмотрим объектно-реляционные представления, предназначенные для тех, кто хочет воспользоваться объектно-реляционными возможностями, не теряя реляционного представления данных приложения.

Защита • Глава 21. Тщательный контроль доступа. Это средство позволяет добавить условие ко всем выполняемым запросам к базе данных. Реализация такой возможности на сервере означает, что ею может воспользоваться любое приложение, обращающееся к базе данных. Дополнительные аргументы в пользу применения этого средства — простота сопровождения и возможность устанавливать приложение на сервере приложений. Мы рассмотрим, как работает контроль доступа, путем тестирования пары примеров, реализующих на его основе правила защиты и использующих контексты приложений. Глава завершается разделом о потенциальных проблемах, в том числе при обеспечении целостности ссылок, экспорте и импорте данных, а также описанием возможных ошибок.

Введение • Глава 22. Многоуровневая аутентификация. В этой главе рассматривается влияние среды Web, существенно увеличивающей количество ситуаций, когда клиенты регистрируются на промежуточном сервере приложений, прежде чем получить доступ к базе данных. Мы рассмотрим, как реализовать такую возможность и что при этом происходит. Мы также рассмотрим, как предоставить привилегии и организовать проверку действий промежуточных учетных записей. • Глава 23. Права вызывающего и создателя. Начиная с Oracle 8i можно предоставлять различные наборы привилегий отдельным пользователям хранимой процедуры. При установке прав вызывающего можно создавать хранимые процедуры, выполняемые с набором привилегий вызывающего пользователя. Мы рассмотрим, для чего может пригодиться такая возможность, в частности, при создании утилит общего назначения и приложений словаря данных, и почему в большинстве случаев правильным остается выполнение с правами создателя. В разделе "как это работает" мы рассмотрим детально, что происходит при компиляции процедур с правами создателя и вызывающего.

Приложения • Приложение А. Основные стандартные пакеты. Многие из этих пакетов при разработке не используются, или их назначение неверно интерпретируется. В этом приложении я пытаюсь объяснить их назначение, показать, как их использовать и расширять.

Типографские особенности книги Мы используем различные стили оформления текста и типографские соглашения, помогающие выделить различные виды информации. Вот примеры используемых стилей с объяснением их назначения. Код выделяется по-разному. Если это слово, описываемое в тексте (например, если речь идет об операторе SELECT), фрагмент кода выделяется полужирным. Если это блок кода, набираемый и выполняемый, например, в SQL*Plus, он представлен специальным шрифтом:

tkyte@DEV816> create or replace procedure StaticEmpProc(p_job in varchar2) 2 as 3 begin 4 for x in (select ename from emp where job = p_job) 5 loop 6 dbms_output.put_line(x.ename);

7 end loop;

8 end;

9/ Procedure created.

Мы также показываем номера строк, выдаваемые при вводе в сеансе SQL*PIus, — это упрощает ссылки на них.

Введение Советы, подсказки и дополнительная информация представлены в таком стиле. Важная информация представлена в таких блоках. Термины выделены наклонным шрифтом. Маркированные списки представлены со сдвигом вправо. В этих списках: • важные слова выделены полужирным шрифтом;

• слова, которые можно увидеть в меню на экране, например File или Window, выделены полужирным шрифтом;

• клавиши, которые необходимо нажимать на клавиатуре, например Ctrl или Enter, выделены наклонным шрифтом.

Контакты с читателями Мы попытались сделать эту книгу максимально точной и удобной для изучения, но важно лишь, насколько она окажется полезной вам. Пожалуйста, поделитесь своим мнением о книге, либо послав нам карточку обратной связи, предлагаемую в конце книги, либо просто написав письмо по электронной почте по адресу feedback@wrox.com.

Исходный код и обновления При работе с представленными в книге примерами вы можете предпочесть набирать весь код вручную. Многие читатели предпочитают именно это способ, поскольку так проще привыкнуть к используемым приемам кодирования. Хотите вы набирать код или нет, мы предоставили все исходные коды для этой книги на сайте издательства по адресу:

http://www.wrox.com/ Если вы — один из тех, кто любит набирать код вручную, можете использовать эти файлы для сравнения с требуемыми результатами. Обратитесь к ним, если предполагаете, что при наборе сделали ошибку. Если же вы не любите набирать тексты, обязательно загрузите их с Web-сайта! В любом случае исходные коды помогут при отладке примеров.

Ошибки Мы сделали все возможное, чтобы избежать ошибок в тексте и исходных кодах. Однако людям свойственно ошибаться, и поэтому мы считаем своим долгом информировать читателей о любых обнаруженных и исправленных ошибках. Информацию об ошибках, обнаруженных во всех наших книгах, можно найти на сайте http:// www.wrox.cora. Если вы найдете ошибку, о которой еще не известно, пожалуйста, дайте нам знать. Наш сайт является центром накопления справочной и другой технической информации, включая код из всех изданных книг, примеры глав, обзоры готовящихся к выходу книг, а также статьи и мнения по соответствующим темам.

Настройка среды В этом разделе я опишу, как настроить среду для выполнения примеров из данной книги. Я опишу: • как установить демонстрационную схему SCOTT/TIGER;

• среду, которую необходимо создать и запустить;

• как сконфигурировать средство AUTOTRACE в SQL* Plus;

• как настроить компилятор языка С;

• соглашения по оформлению кода, принятые в этой книге.

Установка демонстрационной схемы SCOTT/TIGER Схема SCOTT/TIGER может уже существовать в базе данных в нескольких экземплярах. Она обычно создается при типичной установке, хотя и не является обязательным компонентом базы данных. Демонстрационную схему SCOTT можно установить в любую учетную запись пользователя — имя SCOTT не имеет никакого тайного смысла. Таблицы EMP/DEPT можно при желании создать в собственной схеме. Многие из примеров в этой книге зависят от таблиц в схеме SCOTT. Если вы хотите их проверить, эти таблицы необходимы. Если вы работаете в общей базе данных, имеет смысл установить собственную копию соответствующих таблиц в некоторой схеме, отличающейся от схемы SCOTT, чтобы избежать побочных эффектов, вызванных использованием и изменением тех же данных другими пользователями.

Настройка среды Чтобы создать демонстрационные таблицы схемы SCOTT, необходимо: • перейти в каталог [ORACLE_HOME]/sqlplus/demo;

• запустить сценарий demobld.sql от имени любого пользователя. Сценарий demobld.sql создаст и наполнит данными пять таблиц. При завершении он автоматически завершает работу утилиты SQL*Plus, так что не удивляйтесь, если окно после запуска этого сценария SQL*Plus исчезнет — так и должно быть. Стандартные демонстрационные таблицы включают стандартные требования целостности ссылок. Некоторые из моих примеров предполагают наличие этих требований. После выполнения сценария demobld.sql рекомендуется также выполнить следующие операторы:

alter table ешр add constraint emp_pk primary key(empno);

alter table dept add constraint dept_pk primary key(deptno);

alter table emp add constraint emp_fk_dept foreign key (deptno) references dept;

alter table emp add constraint emp_fk_emp foreign key(mgr) references emp;

Они завершат установку необходимой демонстрационной схемы. Если понадобится удалить эту схему, можно просто выполнить сценарий [ORACLE_HOME]/sqlplus/demo/ demodrop.sql. Он удалит все пять таблиц и завершит работу сеанса SQL*Plus.

Среда SQL*Plus Почти все примеры в этой книге предназначены для выполнения в среде SQL*Plus. Исключение представляют примеры на языке С, для которых, разумеется, необходим компилятор С, кроме сервера Oracle (см. раздел "Компиляторы языка С" далее). За исключением этого, SQL*Plus — единственная утилита, которую необходимо настроить и сконфигурировать. Утилита SQL*Plus имеет много полезных опций и команд, которые часто будут использоваться по ходу изложения. Например, почти все примеры в книге так или иначе используют пакет DBMS_OUTPUT. Чтобы этот пакет работал, необходимо выполнить следующую команду SQL*Plus:

SQL> s e t server output on Я думаю, вам быстро надоест постоянно ее набирать. К счастью, утилита SQL*Plus позволяет создать файл login.sql — сценарий, выполняемый при каждом запуске сеанса SQL*Plus. Более того, можно установить значение переменной среды SQLPATH, задающее местонахождение этого сценария начального запуска. Для всех примеров в этой книге я использую сценарий login.sql следующего вида:

define _editor=vi set serveroutput on size 1000000 set trimspool on set long 5000 set linesize 100 set pagesize 9999 column plan_plus_exp format a Настройка среды column global_name new_value gname set termout off select lower(user) || ' 8 ' || decode(global_name, 'ORACLE8.WORLD', '8.0', 'ORA8I.WORLD', '8i', global_name) global_name from global_name;

set sqlprompt '&gname> set termout on В этом сценарии: • DEFINE _EDITOR=vi устанавливается стандартный редактор для SQL*Plus. Можете задать свой любимый текстовый редактор (но не текстовый процессор), например Notepad или emacs. • SET SERVEROUTPUT ON SIZE 1000000 включает по умолчанию поддержку пакета DBMS_OUTPUT (чтобы не нужно было набирать эту команду каждый раз). Устанавливает также максимально возможный размер буфера. • SET TRIMSPOOL ON гарантирует, что в выдаваемом тексте хвостовые пробелы будут отсекаться. Если используется стандартное значение этой установки, OFF, выдаваемые строки будут иметь длину LINESIZE.

• SET LONG 5000 устанавливает стандартное количество байт, выдаваемых при выборе столбцов типа LONG и CLOB. • SET LINESIZE 100 устанавливает длину выдаваемой утилитой SQL*Plus строки равной 100 символам. • SET PAGESIZE 9999 задает значение PAGESIZE, определяющее, как часто утилита SQL*Plus выдает заголовки, настолько большим, чтобы на странице было не более одного заголовка. • COLUMN PLAN_PLUS_EXP FORMAT A80 устанавливает формат для результатов выполнения оператора EXPLAIN PLAN, получаемых при установке опции AUTOTRACE. Формат А80 (ширина — 80 символов) обычно достаточен для представления большинства планов. Следующая часть сценария login.sql задает приглашение SQL*Plus. Она начинается со строки:

column global_name new value gname Эта директива заставляет утилиту SQL*Plus помещать последнее значение, извлеченное из любого столбца с именем GLOBAL_NAME, в переменную подстановки GNAME. Затем выполняется следующий запрос:

select lower(user) || ' @ ' || decode(global_name, 'ORACLE8.WORLD', '8.0', 'ORA8I.WORLD', '8i', global_name) global_name from global_name;

Он выбирает из базы данных значение GLOBAL_NAME, используя функцию DECODE для присваивания требуемых имен одному или нескольким обычно используемым экземплярам, а затем конкатенирует его с именем текущего пользователя. Наконец, мы отображаем эту информацию в приглашении SQL*Plus:

s e t sqlprompt '&gname> ' Настройка среды Поэтому приглашение будет иметь вид:

tkyte@TKYTE816> Таким образом, я знаю, кто я и где я. Еще один очень полезный сценарий, который можно поместить в тот же каталог, что и login.sql, — это сценарий connect.sql:

set termout off connect &1 Slogan set termout on Утилита SQL*Plus будет выполнять сценарий login.sql при начальном запуске. В общем случае он должен выполняться при каждом подключении. Я просто завел себе привычку использовать команду:

tkyte@TKYTE816> @connect scott/tiger, а не просто CONNECT SCOTT/TIGER. В результате мое приглашение всегда устанавливается должным образом, как и другие установки, такие как SERVEROUTPUT.

Настройка AUTOTRACE в SQL*Plus По ходу всей книги эта установка пригодится нам для контроля производительности выполняемых запросов и получения информации о плане выполнения запроса, выбранном оптимизатором SQL, и другой полезной статистической информации о ходе выполнения. Oracle предлагает средство EXPLAIN PLAN, которое при использовании команды EXPLAIN PLAN позволяет генерировать план выполнения запроса. Подробнее об интерпретации результатов выполнения EXPLAIN PLAN см. в руководстве "Oracte8i Designing and Tuning for Performance". Однако утилита SQL*Plus предлагает средство AUTOTRACE, позволяющее получать планы выполнения обрабатываемых запросов, а также информацию об используемых ресурсах, без выполнения команды EXPLAIN PLAN. Соответствующий отчет генерируется после успешного выполнения операторов ЯМД (т.е. SELECT, DELETE, UPDATE и INSERT). В этой книге это средство широко используется. Средство AUTOTRACE можно настроить несколькими способами. Я практикую следующую последовательность действий: • перехожу в каталог [ORACLE_HOME]/rdbms/admin;

• регистрируюсь в SQL*Plus от имени SYSTEM;

• запускаю сценарий @utlxplan;

• выполняю оператор CREATE PUBLIC SYNONYM PLAN_TABLE FOR PLAN_TABLE;

• выполняю оператор GRANT ALL ON PLAN_TABLE TO PUBLIC. Если хотите, можете заменить GRANT... ТО PUBLIC оператором GRANT для конкретного пользователя. Предоставляя привилегию роли PUBLIC, вы фактически разрешаете трассировать операторы в SQL*Pius любому пользователю. По-моему это непло Настройка среды хо — пользователи могут не устанавливать собственные таблицы планов. Альтернатива этому — запуск сценария @UTLXPLAN в каждой схеме, где необходимо использовать средство AUTOTRACE. Следующий шаг — создание и предоставление всем роли PLUSTRACE: • переходим в каталог [ORACLE_HOME]/sqlplus/admin;

• регистрируемся в SQL*Plus от имени SYS;

• запускаем сценарий @plustrce;

• выполняем оператор GRANT PLUSTRACE TO PUBLIC. И в этом случае, если хотите, можете заменить PUBLIC в операторе GRANT именем конкретного пользователя.

Управление отчетом о плане выполнения Управлять информацией, выдаваемой в отчете о плане выполнения, можно с помощью установки системной переменной AUTOTRACE. SET AUTOTRACE OFF SET AUTOTRACE ON EXPLAIN SET AUTOTRACE ON STATISTICS Отчет AUTOTRACE не генерируется. Так происходит по умолчанию. В отчете AUTOTRACE показывается только выбранный оптимизатором план. В отчете AUTOTRACE показывается только статистическая информация о выполнении оператора SQL В отчет AUTOTRACE включается как выбранный оптимизатором план, так и статистическая информация о выполнении оператора SQL. Аналогично SET AUTOTRACE ON, но подавляет выдачу результатов выполнения запроса.

SET AUTOTRACE ON SET AUTOTRACE TRACEONLY Интерпретация плана выполнения запроса План выполнения отражает выбранный оптимизатором способ выполнения запроса. Каждая строка плана выполнения имеет порядковый номер. Утилита SQL*Plus также выдает номер строки родительской операции. План выполнения состоит из четырех столбцов, выдаваемых в следующем порядке: Имя столбца ID_PLUS_EXP PARENT_ID_PLUS_EXP PLAN_PLUS_EXP OBJECT_NODE_PLUS_EXP Описание Показывает порядковый номер шага выполнения Показывает для каждого шага родительский шаг. Этот столбец полезен в больших отчетах. Показывает описание шага выполнения. Показывает использованные базы данных или серверы для параллельного запроса.

2 Зак Настройка среды Формат столбцов можно изменять с помощью команды COLUMN. Например, чтобы отменить выдачу столбца PARENT_ID_PLUS_EXP, введите:

SQL> column parent_id_plus_exp noprint Компиляторы языка С Поддерживаемые сервером Oracle компиляторы языка С зависят от операционной системы. В Microsoft Windows я использую Microsoft Visual C/C++. Я использую только средства командной строки (nmake и cl). Ни в одном из примеров не использовалась графическая среда разработки. Однако их можно при желании проверять и в этой среде. Вам придется самостоятельно сконфигурировать и настроить соответствующие файлы include и подключить нужные библиотеки. Все файлы управления проектом makefile, содержащиеся в данной книге, — очень маленькие и простые, из них вполне очевидно, какие файлы include и библиотеки необходимы. В среде Sun Solaris поддерживается компилятор языка С, входящий в состав пакета Sun SparcsWorks. И в этом случае я использовал для компиляции программ только средства командной строки, make и cc.

Оформление кода Единственная особенность оформления кода, на которую я хочу обратить внимание читателей, — это именование переменных в коде PL/SQL. Например, рассмотрим следующее тело пакета:

create or replace package body my_pkg as g_variable varchar2(25);

procedure p(p_variable in varchar2) is l_variable varchar2(25) ;

begin null;

end;

end;

/ В этом примере используются три переменные: глобальная переменная пакета G_VARIABLE, формальный параметр процедуры, P_VARIABLE, и, наконец, локальная переменная, L_VARIABLE. Я именую переменные в соответствии с областями действия: все глобальные имеют префикс G_, параметры — префикс Р_, а локальные переменные — префикс L_. Главная причина этого — необходимость отличать переменные PL/SQL от столбцов таблицы базы данных. Например, рассмотрим следующую процедуру:

create procedure p(ENAME in varchar2) as begin for x in (select * from emp where ename = ENAME) loop dbms_output.put_line(x.empno);

end loop;

end;

Настройка среды Она всегда будет выдавать все строки в таблице ЕМР. В операторе SQL конструкция ename = ENAME интерпретируется, конечно же, как сравнение столбца с самим собой. Можно использовать сравнение ename = P.ENAME, то есть уточнить ссылку на переменную PL/SQL именем процедуры, но об этом легко забыть, что приведет к возникновению ошибок. Я всегда именую переменные в соответствии с областью действия. В этом случае я могу легко отличить параметры от локальных и глобальных переменных, а также не путать имена переменных и столбцов таблицы.

Другие особенности Каждая глава в этой книге самодостаточна. В начале каждой главы я удалял свою тестовую учетную запись и создавал ее заново. То есть, каждая глава начиналась с чистой схемы — без объектов. Если выполнять все примеры, с начала до конца главы, следует делать именно так. При запросах к словарю данных в поисках объектов, созданных в результате выполнения той или иной команды, вас могут сбить с толку объекты, оставшиеся от других примеров. Кроме того, я часто повторно использую имена таблиц (особенно таблицу Т), так что если не чистить схему при переходе к очередной главе, может возникнуть конфликт. Кроме того, если попытаться вручную удалять объекты, созданные в примере (а не просто удалять схему оператором drop user ИМЯ_ПОЛЬЗОВАТЕЛЯ cascade), нужно учитывать, что в именах Java-объектов используются символы разных регистров. Так что, если выполнить пример из главы 19:

tkyte@TKYTE816> create or replace and compile 2 Java source named "demo" 3 as 4 import java.sql.SQLException;

то окажется, что для удаления необходимо выполнять оператор вида:

tkyte@TKYTE816> drop Java source "demo";

Java dropped.

He забывайте использовать двойные кавычки вокруг идентификаторов Java-объектов, поскольку они создаются и хранятся с учетом регистра.

Разработка успешных приложений для Oracle Значительную часть времени я провожу, работая с программным обеспечением СУБД Oracle или, точнее, с людьми, которые это программное обеспечение используют. В течение последних двенадцати лет я работал над многими проектами, как успешными, так и закончившимися неудачно, и если бы потребовалось обобщить приобретенный при этом опыт несколькими фразами, я бы сказал следующее: • успех или неудача разработки приложения базы данных (приложения, зависящего от базы данных) определяется тем, как оно использует базу данных;

• в команде разработчиков должно быть ядро "программистов базы данных", обеспечивающих согласованность логики работы с базой данных и настройку производительности системы. Эти утверждения могут показаться очевидными, но опыт показывает, что слишком многие используют СУБД как "черный ящик", о деталях устройства которого знать необязательно. Они могут использовать генератор SQL, позволяющий не затруднять себя изучением языка SQL. Возможно, они решат использовать базу данных как обычный файл с возможностью чтения записей по ключу. Как бы то ни было, я могу вам сказать, что подобного рода соображения почти наверняка приводят к неправильным выводам — работать, не понимая устройства СУБД, просто нельзя. В этой главе описано, почему необходимо знать устройство СУБД, в частности, почему необходимо понимать: • архитектуру СУБД, ее компоненты и алгоритмы работы;

• что такое средства управления одновременным доступом и каково их значение для разработчиков;

Глава • как настраивать приложение с первого дня его создания;

• как реализованы определенные компоненты СУБД и чем эта реализация отличается от обычно предполагаемой;

• какие возможности реализованы в самой СУБД и почему, как правило, лучше использовать предоставляемые СУБД функции, а не реализовать их самостоятельно;

• зачем может понадобиться более глубокое знание языка SQL. Этот список тем для начального изучения может показаться слишком длинным, но давайте рассмотрим следующую аналогию: если бы вы разрабатывали масштабируемое, высокопроизводительное приложение для абсолютно новой операционной системы (ОС), с чего бы вы начали? Надеюсь, ваш ответ: "С изучения особенностей функционирования этой новой ОС, работы приложений в ней и т.п.". Если ответ принципиально другой, ваша разработка обречена на неудачу. Рассмотрим, например, одну из ранних версий Windows (скажем, Windows 3.x). Она, как и ОС UNIX, была "многозадачной" операционной системой. Однако эта многозадачность была не такой, как в ОС UNIX, — использовалась модель невытесняющей многозадачности (т.е., если работающее приложение не возвращает управление, ничто другое работать не может, включая операционную систему). Фактически, по сравнению с UNIX, Windows 3.x вообще не была многозадачной ОС. Для создания эффективных приложений разработчики должны были точно знать, как реализована возможность "многозадачности" Windows. Если необходимо разрабатывать приложение, работающее непосредственно в среде определенной ОС, понимание особенностей этой ОС очень важно. То, что верно в отношении приложений, непосредственно работающих в среде операционной системы, верно и для приложений, работающих в среде СУБД: понимание особенностей СУБД является определяющим фактором успеха. Если вы не понимаете, что делает используемая СУБД или как она это делает, создаваемое приложение не будет работать успешно. Предположение о том, что успешно работающее в среде SQL Server приложение так же успешно будет работать и в среде Oracle, скорей всего не оправдается.

Мой подход Прежде чем начать, хотелось бы объяснить вам мой подход к разработке. Я предпочитаю решать большинство проблем на уровне СУБД. Если что-то можно сделать в СУБД, я так и сделаю. Для этого есть две причины. Первая и главная состоит в том, что если встроить функциональность в СУБД, то ее можно будет применять где угодно. Я не знаю серверной операционной системы, для которой нет реализации СУБД Oracle. Одна и та же СУБД Oracle со всеми опциями работает везде — от Windows до десятков версий ОС UNIX и больших ЭВМ типа OS/390. Я часто разрабатываю и тестирую программы на моем портативном компьютере, где работает СУБД Огас1е8/для Windows NT. А применяются эти программы на различных серверах с ОС UNIX, на которых работает та же версия СУБД. Если приходится реализовать функциональность за пределами Разработка успешных приложений для Oracle СУБД, ее очень сложно переносить на любую другую платформу. Одна из основных особенностей, делающих язык Java привлекательным для многих разработчиков, состоит в том, что программы всегда компилируются в одной и той же виртуальной среде, виртуальной машине Java Virtual Machine (JVM), и поэтому максимально переносимы. Именно эта особенность привлекает меня в СУБД. СУБД Oracle — это моя виртуальная машина, моя "виртуальная операционная система". Мой подход состоит в том, чтобы делать в СУБД все, что возможно. Если требования выходят за пределы возможностей СУБД, я реализую соответствующие функции на языке Java вне СУБД. В этом случае особенности практически любой операционной системы скрываются. Мне все равно надо понимать, как работают мои "виртуальные машины" (Oracle или JVM) — надо знать используемые инструментальные средства, — но наиболее эффективная реализация соответствующих функций в конкретной ОС остается прерогативой создателей этих виртуальных машин. Таким образом, зная лишь особенности работы одной "виртуальной ОС", можно создавать приложения, демонстрирующие отличную производительность и масштабируемость во многих операционных системах. Я не утверждаю, что можно полностью игнорировать базовую ОС, — просто разработчик приложений баз данных достаточно хорошо от нее изолирован, и ему не придется учитывать многие ее нюансы. Ваш АБД, отвечающий за поддержку СУБД Oracle, должен знать намного больше об особенностях базовой ОС (если не знает — найдите нового АБД!). При разработке клиент-серверного программного обеспечения, если основная часть кода вынесена из СУБД и виртуальной машины (наиболее популярной виртуальной машиной, вероятно, является Java Virtual Machine), разработчику придется учитывать особенности ОС сервера. При разработке приложений баз данных я использую очень простую мантру: • если можно, сделай это с помощью одного оператора SQL;

• если это нельзя сделать с помощью одного оператора SQL, сделай это в PL/SQL;

• если это нельзя сделать в PL/SQL, попытайся использовать хранимую процедуру на языке Java;

• если это нельзя сделать в Java, сделай это в виде внешней процедуры на языке С;

• если это нельзя реализовать в виде внешней процедуры на языке С, надо серьезно подумать, зачем это вообще делать... В книге вы увидите применение этого подхода. Мы будем использовать язык PL/SQL и его объектные типы для реализации того, что нельзя сделать в SQL. Язык PL/SQL существует давно, за ним стоит более тринадцати лет настройки, и нет другого языка, настолько тесно интегрированного с языком SQL и настолько оптимизированного для взаимодействия с SQL. Когда возможностей PL/SQL оказывается недостаточно, например, при доступе к сети, отправке сообщений электронной почты и т.п., мы будем использовать язык Java. Иногда мы будем решать определенные задачи с помощью языка С, но обычно лишь в тех случаях, когда программирование на С — единственно возможный вариант или когда обеспечиваемая компилятором С скорость работы программы действительно необходима. Во многих случаях сейчас последняя причина отпадает при использовании компиляции в машинные коды программ на языке Java (возможности преобразовать байт-код Java в специфический объектный код операционной системы Глава для данной платформы). Это обеспечивает программам на Java такую же скорость работы, как и у программ на языке С.

Подход с использованием принципа черного ящика У меня есть предположение, основанное на личном опыте, почему так часто разработка приложений баз данных заканчивается неудачно. Позвольте уточнить, что к разряду неудавшихся разработок я отношу также проекты, официально не признанные неудавшимися, но потребовавшие на разработку и внедрение намного больше времени, чем планировалось первоначально, поскольку пришлось их существенно "переписывать", "перепроектировать" или "настраивать". Лично я такие не завершенные в строк проекты считаю неудавшимися: очень часто их вполне можно было завершить вовремя (и даже досрочно). Наиболее типичной причиной неудачи является нехватка практических знаний по используемой СУБД — элементарное непонимание основ работы используемого инструментального средства. Подход по принципу "черного ящика" требует осознанного решения: оградить разработчиков от СУБД. Их заставляют не вникать ни в какие особенности ее функционирования. Причины использования этого подхода связаны с опасениями, незнанием и неуверенностью. Разработчики слышали, что СУБД — это "сложно", язык SQL, транзакции и целостность данных — не менее "сложно". Решение: не заставлять никого делать что-либо "сложное". Будем относиться к СУБД, как к черному ящику, и найдем инструментальное средство, которое сгенерирует необходимый код. Изолируем себя несколькими промежуточными уровнями, чтобы не пришлось сталкиваться непосредственно с этой "сложной" СУБД. Такой подход к разработке приложений баз данных я не мог понять никогда. Одна из причин, почему мне трудно это понять, состоит в том, что для меня изучение языков Java и С оказалось намного сложнее, чем изучение основ работы СУБД. Я сейчас очень хорошо знаю языки Java и С, но для их освоения мне понадобилось намного больше практического опыта, чем для достижения соответствующего уровня компетентности при использовании СУБД. В случае СУБД необходимо знать, как она работает, но детали знать необязательно. При программировании на языке С или Java, необходимо, например, знать все особенности используемых компонентов;

кроме тою, это очень большие по объему языки. Еще одна причина — то, что при создании приложений базы данных самым важным компонентом программного обеспечения является СУБД. Для успешной разработки необходимо учитывать это и доводить до сведения разработчиков, постоянно обращая на это их внимание. Много раз я сталкивался с проектами, где придерживались прямо противоположных воззрений. Вот типичный сценарий такого рода разработки. • Разработчики были полностью обучены графической среде разработки или соответствующему языку программирования (например, Java), использованных для создания клиентской части приложения. Во многих случаях они обучались несколько недель, если не месяцев.

Разработка успешных приложений для Oracle • Команда разработчиков ни одного часа не изучала СУБД Oracle и не имела никакого опыта работы с ней. Многие разработчики вообще впервые сталкивались с СУБД. • В результате разработчики столкнулись с огромными проблемами, связанными с производительностью, обеспечением целостности данных, зависанием приложений и т.д. (но пользовательский интерфейс выглядел отлично). Не сумев обеспечить нужную производительность, разработчики обращались за помощью ко мне. Особенно показателен один случай. Я не мог вспомнить точный синтаксис новой команды, которую надо было использовать, и попросил руководство SQL Reference. Мне принесли экземпляр из документации по СУБД Oracle версии 6.0, хотя разработка велась на версии 7.3, через пять лет после выхода версии 6.0! Ничего другого для работы у них не было, но это вообще никого не беспокоило. Хотя необходимое им для трассировки и настройки инструментальное средство в то время вообще не существовало. Хотя за пять лет, прошедших после написания имевшейся у них документации, были добавлены такие средства, как триггеры, хранимые процедуры, и многие сотни других. Несложно понять, почему им потребовалась помощь, гораздо труднее было решить их проблемы. Странная идея о том, что разработчик приложения баз данных должен быть огражден от СУБД, чрезвычайно живуча. Многие почему-то считают, что разработчикам не следует тратить время на изучение СУБД. Неоднократно приходилось слышать: "СУБД Oracle — самая масштабируемая в мире, моим сотрудникам не нужно ее изучать, потому что СУБД со всеми проблемами справится сама". Действительно, СУБД Oracle — самая масштабируемая. Однако написать плохой код, который масштабироваться не будет, в Oracle намного проще, чем написать хороший, масштабируемый код. Можно заменить СУБД Oracle любой другой СУБД — это утверждение останется верным. Это факт: проще писать приложения с низкой производительностью, чем высокопроизводительные приложения. Иногда очень легко создать однопользовательскую систему на базе самой масштабируемой СУБД в мире, если не знать, что делаешь. СУБД — это инструмент, а неправильное применение любого инструмента может привести к катастрофе. Вы будете щипцами колоть орехи так же, как молотком? Можно, конечно, и так, но это неправильное использование инструмента, и результат вас не порадует. Аналогичные результаты будут и при игнорировании особенностей используемой СУБД. Я недавно работал над проектом, в котором проектировщики придумали очень элегантную архитектуру. Клиент с помощью Web-браузера взаимодействовал по протоколу HTTP с сервером приложений, обеспечивающим поддержку Java Server Pages (JSP). Алгоритмы работы приложения целиком генерировались инструментальными средствами и реализовывались в виде компонентов EJB (с использованием постоянного хранения на базе контейнеров), причем физически они выполнялись другим сервером приложений. В базе данных хранились только таблицы и индексы. Итак, мы начали с технически сложной архитектуры. Для решения задачи должны взаимодействовать друг с другом четыре компонента. Web-браузер получает страницы JSP от сервера приложений, который обращается к компонентам EJB, а те, в свою очередь, — к СУБД. Для разработки, тестирования, настройки и внедрения этого приложения необходимы были технически компетентные специалисты. После завершения раз Глава работки меня попросили оценить производительность приложения. Прежде всего я хотел узнать подход разработчиков к СУБД: • где, по их мнению, у приложения могут быть узкие места, точки потенциальных конфликтов? • каковы, по их мнению, основные препятствия для достижения требуемой производительности? Они не имели ни малейшего представления об этом. На вопрос о том, кто поможет мне переписать код компонента EJB для настройки сгенерированного запроса, ответ был следующий: "О, этот код нельзя изменять, все надо делать в базе данных". То есть, приложение должно оставаться неизменным. В этот момент я был готов отказаться от работы над проектом — ясно, что заставить это приложение нормально работать невозможно: • приложение было создано без учета масштабирования на уровне базы данных;

• приложение нельзя настраивать и вообще изменять;

• по моему опыту, от 80 до 90 процентов всей настройки выполняется на уровне приложения, а не на уровне базы данных;

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

select * from t for update;

Это приводило к строго последовательной работе всех клиентов. В базе данных была реализована такая модель, что перед выполнением любых существенных действий приходилось блокировать весьма большой ресурс. Это моментально превращало приложение в очень большую однопользовательскую систему. Разработчики не верили мне (в другой СУБД, использующей разделяемую блокировку чтения, наблюдалась другая ситуация). После десяти минут работы с инструментальным средством TKPROF (о нем подробно написано в главе 10) я смог продемонстрировать, что именно этот оператор SQL выполнялся приложением (они об этом не знали — просто никогда не видели генерируемых операторов SQL). Я не просто показал, какие операторы SQL выполняются приложением, но и с помощью пары сеансов SQL*Plus продемонстрировал, что второй сеанс не начинается до полного завершения работы первым сеансом. Итак, вместо того, чтобы неделю тестировать производительность приложения, я употребил это время на обучение разработчиков настройке, особенностям блокирования в базах данных, механизмам управления одновременным доступом, сравнение их реализаций в СУБД Oracle, Informix, SQL Server, DB2 и так далее (во всех этих СУБД они различны). Но сначала мне пришлось понять, однако, почему использовался оператор SELECT FOR UPDATE. Оказалось, что разработчики хотели добиться повторяемости при чтении.

Разработка успешных приложений для Oracle Повторяемость при чтении — это такой режим работы приложения, когда повторное чтение в транзакции строки, которая уже один раз прочитана в этой транзакции, дает тот же результат.

Зачем им это было нужно? Они слышали, что "это хорошо". Ладно, предположим, повторяемость при чтении действительно необходима. В СУБД Oracle это делается путем установки уровня изолированности транзакции SERIALIZABLE (что дает не только повторяемость при чтении строки, но и повторяемость при выполнении любого запроса — если два раза выполнить один и тот же запрос в пределах транзакции с таким уровнем изолированности, будут получены одинаковые результаты). Для обеспечения повторяемости при чтении в Oracle не нужно использовать SELECT FOR UPDATE — это делается только для обеспечения последовательного доступа к данным. К сожалению, использованное разработчиками инструментальное средство это не учитывало — оно было создано для использования с другой СУБД, где именно так повторяемость при чтении и достигалась. Итак, в данном случае для установки уровня изолированности транзакций SERIALIZABLE пришлось создать триггер на регистрацию в базе данных, изменяющий параметры сеанса (уровень изолированности транзакций) для данного приложения. Затем мы отключили все установки повторяемости при чтении в использовавшемся инструментальном средстве и повторно запустили приложение. Теперь, без конструкции FOR UPDATE, в базе данных определенные действия стали выполняться одновременно. Это была далеко не последняя проблема данного проекта. Нам пришлось разобраться: • как настраивать операторы SQL, не изменяя их кода (это сложно — некоторые методы мы рассмотрим в главе 11);

• как измерять производительность;

• как находить узкие места;

• что и как индексировать, и так далее. В конце недели разработчики, никогда ранее не работавшие с СУБД, были удивлены тем, что в действительности она дает возможность сделать, как легко получить указанную выше информацию и, что наиболее важно, как существенно все это может сказаться на производительности приложения. Тестированием производительности в течение этой недели мы не занимались (им кое-что пришлось переделывать!), но в конечном итоге проект завершился успешно — просто на пару недель позже запланированного срока. Это не критика инструментальных средств или современных технологий, таких как компоненты EJB и поддержка постоянного существования на базе контейнеров. Это — критика намеренного игнорирования особенностей СУБД, принципов ее работы и использования. Технологии, выбранные в этом проекте, работали отлично, но лишь после того, как разработчики немного разобрались в самой СУБД. Подводя итоги: СУБД — это краеугольный камень приложения. Если она не работает как следует, все остальное не имеет значения. Если плохо работает черный ящик, что Глава с ним делать? Его нельзя исправить, нельзя настроить (поскольку непонятно, как он устроен), и такую позицию вы выбрали сами. Но есть и другой подход, который я отстаиваю: разберитесь в используемой СУБД и принципах ее работы, поймите, что она может делать, и используйте весь ее потенциал.

Как надо (и как не надо) разрабатывать приложения баз данных Однако хватит теоретизировать, по крайней мере пока. В оставшейся части главы я использую более эмпирический подход, описывая, почему знание СУБД и особенностей ее работы существенно повышает шансы успешной реализации приложения (без необходимости переписывать его дважды!). Некоторые проблемы решить легко, если известно, как их найти. Для решения других потребуются существенные переделки. Одна из целей этой книги — помочь вам вообще избежать проблем.

В следующих разделах я опишу ряд важнейших особенностей СУБД Oracle, не вдаваясь в подробности их реализации и использования. Например, я опишу только одно из последствий использования архитектуры многопотокового сервера (Multi- Threaded Server — MTS) — режима, в котором можно (а иногда и нужно) конфигурировать сервер Oracle для поддержки множества пользовательских сеансов. Я, однако, не буду детально описывать архитектуру MTS, особенности ее работы и т.п. Все это подробно описано в руководстве Oracle Server Concepts Manual (дополнительную информацию можно найти также в руководстве Net8 Administrators Guide).

Понимание архитектуры СУБД Oracle Недавно я участвовал в проекте, создатели которого решили использовать только новейшие, самые совершенные технологии: все программное обеспечение было написано на Java в виде компонентов EJB. Клиентское приложение взаимодействовало с СУБД через эти компоненты — никакого протокола Net8. Между клиентом и сервером не предавались операторы SQL — только обращения к компонентам EJB с помощью вызовов удаленных методов (Remote Method Invocation — RMI) по протоколу Internet Inter-Orb Protocol (HOP). Об организации RMI no протоколу ПОР можно узнать на сайте http://java.sun.com/ products/rmi-nop/. Это вполне допустимый подход. Такой способ взаимодействия работает и может быть весьма масштабируемым. Те, кто разрабатывал архитектуру, хорошо понимали язык Java, технологию компонентов EJB, знали используемые протоколы, в общем — всю кухню. Им казалось, что имеются все основания для успешной реализации подобного проекта. Когда же выяснилось, что приложение может поддерживать лишь нескольких пользователей, они решили, что проблема — в СУБД, и усомнились в декларируемой корпорацией Oracle "рекордной масштабируемости СУБД".

Разработка успешных приложений для Oracle Проблема, однако, была не в СУБД, а в незнании особенностей ее работы, и некоторые решения, принятые на этапе проектирования, привели к краху приложения в целом. Чтобы использовать компоненты EJB в базе данных, сервер Oracle должен быть сконфигурирован для работы в режиме многопотокового (MTS), а не выделенного сервера. Чего не понимала команда разработчиков в принципе, так это последствий использования режима MTS в сочетании с компонентами EJB для их приложения. При отсутствии этого понимания, как и знания основ работы СУБД Oracle вообще, были приняты два ключевых решения. • В компонентах будут запускаться хранимые процедуры, работающие по 45 и более секунд (иногда — намного дольше). • Связываемые переменные использоваться не будут. В условиях всех запросов будут использоваться литеральные константы. Все входные данные для процедур будут передаваться в виде строк. Это "проще", чем использовать связываемые переменные. Эти, казалось бы, непринципиальные решения обусловили неизбежный провал проекта. Все было сделано так, что предельно масштабируемая СУБД не справлялась с нагрузкой даже при небольшом количестве пользователей. Нехватка знаний об особенностях работы СУБД свела на нет все глубокие знания разработчиков по созданию компонентов на Java и распределенной обработке. Если бы они нашли время на минимальное изучение особенностей работы СУБД Oracle и затем применили два представленных далее простых принципа, шансы на успех проекта уже в первой версии существенно бы повысились.

Избегайте длительных транзакций в среде MTS Решение использовать транзакции продолжительностью более 45 секунд в среде MTS выдало недостаточное понимание назначения режима MTS и особенностей его работы в Oracle. Если коротко, в режиме MTS используется общий пул серверных процессов, обслуживающий намного больший пул конечных пользователей. Это похоже на пул подключений. Поскольку создание и управление процессом — наиболее дорогостоящие операции, выполняемые операционной системой, режим MTS дает большие преимущества для крупномасштабной системы. Можно обслуживать 100 пользователей всего пятью или десятью разделяемыми серверными процессами. Когда разделяемый серверный процесс получает запрос на изменение данных или выполнение хранимой процедуры, он привязывается к этой задаче до ее завершения. Ни одна другая задача не будет использовать разделяемый серверный процесс, пока не будет закончено изменение или не завершится выполнение хранимой процедуры. Поэтому при использовании режима MTS надо применять как можно быстрее выполняющиеся операторы. Режим MTS создан для обеспечения масштабируемости систем оперативной обработки транзакций (ООТ), для которых характерны операторы, выполняющиеся за доли секунды. Речь идет об изменениях отдельных строк, вставке нескольких строк и запросах записей по первичному ключу. Не стоит в этом режиме выполнять пакетные процессы, для завершения которых требуются десятки секунд или минуты.

Глава Если все операторы выполняются быстро, архитектура MTS работает отлично. Можно эффективно обслуживать небольшим количеством процессов большое сообщество пользователей. Если же имеются сеансы, монополизирующие разделяемый сервер надолго, то кажется, что СУБД "зависает". Пусть сконфигурировано десять разделяемых серверов для поддержки 100 пользователей. Если в некоторый момент времени десять пользователей одновременно введут оператор, выполняющийся более 45 секунд, то всем остальным транзакциям (и новым подключениям) придется ждать. Если некоторым из ожидающих в очереди сеансов необходимо выполнять оператор такой же продолжительности, возникает большая проблема — "зависание" будет продолжаться не 45 секунд, а намного дольше. Даже если желающих выполнить подобный оператор одновременно будет не десять, а лишь несколько, все равно будет наблюдаться существенное падение производительности сервера. Мы отберем на длительное время совместно используемый ресурс, и это плохо. Вместо десяти серверных процессов, выполняющих быстрые запросы в очереди, остается пять или шесть (или еще меньше). Со временем система станет работать с производительностью, заметно меньше предполагаемой, исключительно из-за нехватки этого ресурса. Простое решение "в лоб" состоит в запуске большего количества разделяемых серверов, но в конечном итоге придется запускать разделяемый сервер для каждого пользователя, а это неприемлемо для системы с тысячами пользователей (как та, что создавалась в рассматриваемом проекте). Это не только создает узкие места в самой системе (чем большим количеством процессов приходится управлять, тем больше процессорного времени на это уходит), но и просто не соответствует целям создания режима MTS. Реальное решение этой проблемы оказалось простым: не выполнять продолжительные транзакции на сервере, работающем в режиме MTS. А вот реализация этого решения оказалась сложнее. Это можно было сделать несколькими способами, но все они требовали существенных изменений архитектуры. Самым подходящим способом, требующим минимальных изменений, оказалось использование средств расширенной поддержки очередей (Advanced Queues — AQ).

AQ — это промежуточное программное обеспечение для обмена сообщениями, реализованное на базе СУБД Oracle и позволяющее клиентскому сеансу добавлять сообщения в таблицу очереди базы данных. Это сообщение в дальнейшем (обычно сразу после фиксации транзакции) выбирается из очереди другим сеансом, проверяющим содержимое сообщения. Сообщение содержит информацию для обработки другим сеансом. Оно может использоваться для эмуляции мгновенного выполнения за счет вынесения продолжительного процесса за пределы интерактивного клиента.

Итак, вместо выполнения 45-секундного процесса, компонент должен помешать запрос со всеми необходимыми входными данными в очередь и выполнять его асинхронно, а не синхронно. В этом случае пользователю не придется ждать ответа 45 секунд, то есть система становится более динамичной. Хотя, судя по описанию, этот подход прост (подключение механизма AQ полностью решает проблему), потребовалось сделать намного больше. Этот 45-секундный процесс генерировал идентификатор транзакции, необходимый на следующем шаге в интерфейсе для соединения таблиц — по проекту интерфейс без этого не работал. Используя меха Разработка успешных приложений для Oracle низм AQ, мы не ждем генерации идентификатора транзакции, — мы обращаемся к системе с просьбой сделать это когда-нибудь. Поэтому приложение опять оказалось в тупике. С одной стороны, мы не можем ждать завершения процесса 45 секунд, но, с другой стороны, для перехода к следующему экрану необходим сгенерированный идентификатор, а получить его можно только спустя 45 секунд. Для того чтобы решить эту проблему, пришлось синтезировать собственный поддельный идентификатор транзакции, изменить продолжительный процесс так, чтобы он принимал этот сгенерированный поддельный идентификатор и обновлял таблицу, записывая его по завершении работы, благодаря чему реальный идентификатор транзакции связывался с поддельным. То есть, вместо получения реального идентификатора в результате длительного процесса, этот идентификатор становится для процесса входными данными. Во всех "подчиненных" таблицах использовался этот поддельный идентификатор транзакции, а не реальный (поскольку генерации реального надо ждать определенное время). Нам также пришлось пересмотреть использование этого идентификатора транзакции, чтобы понять, как это изменение повлияет на другие модули, и так далее. Еще одна проблема состояла в том, что при синхронной работе, если 45-секундный процесс завершался неудачно, пользователь узнавал об этом сразу. Он мог устранить причину ошибки (обычно путем изменения входных данных) и повторно выполнить запрос. Теперь, когда транзакции выполняются асинхронно с помощью механизма AQ, сделать это невозможно. Для поддержки отсроченного уведомления об ошибке пришлось добавить новые средства. В частности, понадобилось реализовать механизм потоков заданий для отправки информации о неудавшихся транзакциях соответствующему лицу. В результате пришлось существенно пересмотреть структуру базы данных. Пришлось добавить новое программное обеспечение (AQ). Пришлось также создать новые процессы (управление потоками заданий и другие служебные процессы). К положительным последствиям этих изменений можно отнести не только решение проблемы с архитектурой MTS, но и удобство для пользователя (создавалась видимость более быстрой реакции системы). С другой стороны, все эти изменения существенно задержали завершение проекта, поскольку проблемы были выявлены лишь непосредственно перед внедрением, на этапе тестирования масштабируемости. Очень жаль, что приложение сразу не был правильно спроектировано. Если бы разработчики знали, как физически реализован механизм MTS, было бы ясно, что исходный проект не обеспечивает требуемой масштабируемости.

Используйте связываемые переменные Если бы мне пришлось писать книгу о том, как создавать немасштабируемые приложения Oracle, первая и единственная ее глава называлась бы "Не используйте связываемые переменные". Это — основная причина проблем, связанных с производительностью, и основная помеха масштабируемости. Особенности использования разделяемого пула Oracle (очень важной структуры данных разделяемой памяти) требуют от разработчиков использовать связываемые переменные. Если надо замедлить работу приложения Oracle, вплоть до полного останова, — откажитесь от их использования. Связываемая переменная — это подставляемый параметр запроса. Например, для получения записи доя сотрудника с номером 123, можно выполнить запрос:

select * from emp where empno = 123;

Глава Но можно задать и другой запрос:

select * from emp where empno = :empno;

B обычной системе информацию о сотруднике с номером 123 могут запрашивать всего один раз. В дальнейшем будут запрашивать информацию о сотрудниках с номерами 456, 789 и т.д. При использовании в запросе литералов (констант) каждый запрос является для СУБД абсолютно новым, никогда ранее не выполнявшимся. Его надо разбирать, уточнять (определять объекты, соответствующие именам), проверять права доступа, оптимизировать и т.д. — короче, каждый выполняемый уникальный оператор придется компилировать при каждом выполнении. Во втором запросе используется связываемая переменная, :empno, значение которой подставляется в запрос при выполнении. Этот запрос компилируется один раз, а затем план его выполнения запоминается в разделяемом пуле (в библиотечном кэше), из которого его можно выбрать для повторного выполнения. Различие между этими двумя вариантами в плане производительности и масштабируемости — огромное, даже принципиальное. Из представленного выше описания вполне понятно, что разбор оператора с явными, жестко заданными константами (так называемый жесткий разбор) выполняется дольше и требует намного больше ресурсов, чем повторное использование уже сгенерированного плана запроса (его называют мягким разбором). Менее очевидным может оказаться, насколько постоянный жесткий разбор сокращает количество пользователей, поддерживаемых системой. Отчасти это связано с повышенным потреблением ресурсов, но в гораздо большей степени — с механизмом защелок, используемых в библиотечном кэше. При жестком разборе запроса СУБД будет дольше удерживать определенные низкоуровневые средства обеспечения последовательного доступа, которые называются защелками (подробнее о них см. в главе 3). Защелки защищают структуры данных в разделяемой памяти сервера Oracle от одновременного изменения двумя сеансами (иначе эти структуры данных Oracle в конечном итоге были бы повреждены) и от чтения этой структуры данных по ходу изменения другим сеансом. Чем чаще и на более продолжительное время на эти структуры данных устанавливаются защелки, тем длиннее становится очередь для установки этих защелок. Точно так же происходит при использовании длинных транзакций в среде MTS, — монополизируются критические ресурсы. Временами машина может казаться минимально загруженной, а СУБД работает очень медленно. Вполне вероятно, что один из сеансов удерживает защелку и формируется очередь в ожидании ее освобождения. В результате работа с максимальной скоростью невозможна. Достаточно одного неверно работающего приложения для существенного снижения производительности всех остальных приложений. Одно небольшое приложение, не использующее связываемые переменные, приводит со временем к удалению из разделяемого пула необходимых SQL-операторов других хорошо настроенных приложений. Достаточно ложки дегтя, чтобы испортить бочку меда. При использовании связываемых переменных любой сеанс, выдающий тот же самый запрос, будет использовать уже скомпилированный план выполнения из библиотечного кэша. Подпрограмма компилируется один раз, а используется многократно. Это очень эффективно, и именно такую работу пользователей предполагает СУБД. При этом не Разработка успешных приложений для Oracle только используется меньше ресурсов (мягкий разбор требует намного меньше ресурсов), но и защелки удерживаются значительно меньше времени, и нужны гораздо реже. Это повышает производительность и масштабируемость. Чтобы хоть примерно понять, насколько существенно это может сказаться на производительности, достаточно выполнить очень простой тест:

tkyte@TKYTE816> alter system flush shared_pool;

System altered.

Здесь я начинаю с "пустого" разделяемого пула. Если потребуется выполнять этот тест многократно, придется очищать разделяемый пул каждый раз, иначе представленный ниже оператор SQL, в котором не используются связываемые переменные, окажется в кэше и будет выполняться очень быстро.

tkyte@TKYTE816> set timing on tkyte@TKYTE816> declare 2 type rc is ref cursor;

3 l_rc rc;

4 l_dummy all_objects.object_name%type;

5 l_start number default dbms_utility.get_time;

6 begin 7 for i in 1.. 1000 8 loop 9 open l_rc for 10 'select object_name 11 from all_objects 12 where object_id - ' || i;

13 fetch l_rc into l_dummy;

14 close l_rc;

15 end loop;

16 dbms_output.put_line 17 (round((dbms_utility.get_time-l_start)/100, 2) || 18 ' seconds...');

19 end;

20 / 14.86 seconds... PL/SQL procedure successfully completed.

В этом коде используется динамический SQL для запроса одной строки из таблицы ALL_OBJECTS. Он генерирует 1000 уникальных запросов со значениями 1, 2, 3,... и так далее, жестко заданными в конструкции WHERE. На моем ноутбуке с процессором Pentium 300 Мгц для его выполнения потребовалось около 15 секунд (скорость выполнения на разных машинах может быть различной). Теперь сделаем то же самое с использованием связываемых переменных:

tkyte@TKYTE816> declare 2 type rc is ref cursor;

3 l_rc rc;

4 l_dummy all_objects.object_name%type;

5 l_start number default dbms_utility.get_time;

6 begin 7 for i in 1.. Глава 8 loop 9 open l_rc for 10 'select object_name 11 from all_objects 12 «here object_id = :x' 13 using i;

14 fetch l_rc into l_dummy;

15 close l_re;

16 end loop;

17 dbms_output.put_line 18 (round((dbms_utility.get_time-l_start)/100, 2) 19 ' seconds...');

20 end;

21 / 1.27 seconds... PL/SQL procedure successfully completed.

|| В этом коде использован точно такой же алгоритм. Единственное изменение — вместо жестко заданных значений 1, 2, 3... и так далее в запросе используется связываемая переменная. Результаты весьма впечатляющи. Код не только выполняется намного быстрее (разбор запросов требовал больше времени, чем их реальное выполнение!), но и позволяет большему количеству пользователей одновременно работать с системой. Выполнение операторов SQL без связываемых переменных во многом подобно перекомпиляции подпрограммы перед каждым вызовом. Представьте себе передачу клиентам такого исходного кода на языке Java, что перед любым вызовом метода класса им необходимо вызывать компилятор Java, компилировать класс и выбрасывать сгенерированный байт-код сразу после выполнения метода. При необходимости вызова того же метода в дальнейшем им пришлось бы делать то же самое — компилировать, запускать и выбрасывать байт-код. В своих приложениях никто так не поступает — не делайте этого и в СУБД.

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

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

Разработка успешных приложений для Oracle Особенности управления одновременным доступом Управление одновременным доступом — это то, чем отличаются различные СУБД. Именно это отличает СУБД от файловой системы и одну СУБД от другой. Для программиста важно, чтобы его приложение базы данных корректно работало в условиях одновременного доступа, и именно это постоянно забывают проверять. Приемы, прекрасно работающие в условиях последовательного доступа, работают гораздо хуже при одновременном их применении несколькими сеансами. Если не знать досконально, как в конкретной СУБД реализованы механизмы управления одновременным доступом, то: • будет нарушена целостность данных;

• приложение будет работать медленнее, чем предусмотрено, даже при небольшом количестве пользователей;

• будет потеряна возможность масштабирования до большого числа пользователей. Обратите внимание: я не пишу "возможно, будет..." или "вы рискуете..." — все эти проблемы точно будут. Все это вы получите, даже не представляя, что именно происходит. При неправильном управлении одновременным доступом будет нарушена целостность данных, поскольку то, что работает отдельно, будет работать не так, как предполагалось, в многопользовательской среде. Приложение будет работать медленнее, поскольку придется ждать доступа к данным. Возможность масштабирования будет потеряна из-за проблем с блокированием и конфликтов блокировок. По мере усложнения запросов к ресурсу ждать придется все дольше и дольше. Можно провести аналогию с таможенным переходом на границе. Если машины приезжают по одной, равномерно, с предсказуемой частотой, никаких очередей нет. Если же одновременно приедет много машин, начинают формироваться очереди. Причем время ожидания растет нелинейно по отношению к длине очереди. С определенного момента больше времени сотрудников уходит на "наведение порядка" в очереди, чем на таможенный досмотр машин (в случае СУБД мы говорим о планировании процессов и переключении контекста). Проблемы одновременного доступа выявлять сложнее всего — трудности сопоставимы с отладкой многопотоковой программы. Программа может отлично работать в управляемой, искусственной среде отладчика, но постоянно "слетать" в "реальном мире". Например, в условиях интенсивных обращений может оказаться, что два потока одновременно изменяют одну и ту же структуру данных. Такого рода ошибки очень сложно выявлять и исправлять. Если приложение тестировалось только в однопользовательском режиме, а затем внедряется в среде с десятками одновременно обращающихся пользователей, вполне вероятно проявление болезненных проблем с одновременным доступом. В следующих двух разделах будет представлено два небольших примера того, как непонимание.особенностей управления одновременным доступом может разрушить данные или снизить производительность и масштабируемость приложения.

Реализация блокирования СУБД использует блокировки, чтобы в каждый момент времени те или иные данные могли изменяться только одной транзакцией. Говоря проще, блокировки — это ме Глава ханизм обеспечения одновременного доступа. При отсутствии определенной модели блокирования, предотвращающей одновременное изменение, например, одной строки, многопользовательский доступ к базе данных попросту невозможен. Однако при избыточном или неправильном блокировании одновременный доступ тоже может оказаться невозможным. Если пользователь или сама СУБД блокирует данные без необходимости, то работать одновременно сможет меньшее количество пользователей. Поэтому понимание назначения блокирования и способов его реализации в используемой СУБД принципиально важно для создания корректных и масштабируемых приложений. Принципиально важно также понимать, что в различных СУБД блокирование реализовано по-своему. В одних — используется блокирование на уровне страниц, в других — на уровне строк;

в некоторых реализациях выполняется эскалация блокировок со строчного на страничный уровень, в других — не выполняется;

в некоторых СУБД используются блокировки чтения, в других — нет;

в одних СУБД уровень изолированности транзакций SERIALIZABLE реализуется с помощью блокирования, а в других — через согласованные по чтению представления данных (без установки блокировок). Эти небольшие отличия могут перерасти в огромные проблемы, связанные с производительностью, или даже привести к возникновению ошибок в приложениях, если не понимать их особенностей. Ниже приведены принципы блокирования в СУБД Oracle. • Oracle блокирует данные на уровне строк и только при изменении. Эскалация блокировок до уровня блока или таблицы никогда не выполняется. • Oracle никогда не блокирует данные с целью считывания. При обычном чтении блокировки на строки не устанавливаются. • Сеанс, записывающий данные, не блокирует сеансы, читающие данные. Повторю: операции чтения не блокируются операциями записи. Это принципиально отличается от практически всех остальных СУБД, в которых операции чтения блокируются операциями записи. • Сеанс записи данных блокируется, только если другой сеанс записи уже заблокировал строку, которую предполагается изменять. Сеанс считывания данных никогда не блокирует сеанс записи. Эти факты необходимо учитывать при разработке приложений, однако следует помнить, что эти принципы используются только в Oracle. Разработчик, не понимающий, как используемая СУБД обеспечивает одновременный доступ, неизбежно столкнется с проблемами целостности данных (особенно часто это происходит, когда разработчик переходит с другой СУБД на Oracle, или наоборот, и не учитывает в приложении различия механизмов обеспечения одновременного доступа). Один из побочных эффектов принятого в СУБД Oracle "неблокирующего" подхода состоит в том, что если действительно необходимо обеспечить доступ к строке не более чем одного пользователя в каждый момент времени, то именно разработчику необходимо предпринять для этого определенные усилия. Рассмотрим следующий пример. Один разработчик показывал мне только что завершенную им программу планирования ресурсов (учебных классов, проекторов и т.д.), находящуюся в стадии внедрения. Это приложение реализовало бизнес-правило, предотвращающее выделение ресурса более Разработка успешных приложений для Oracle чем одному лицу на любой период времени. То есть, приложение содержало специальный код, который проверял, что никто из пользователей не затребовал ресурс на тот же период времени (по крайней мере разработчик думал, что его код это проверяет). Код обращался к таблице планов и, если в ней не было строк с перекрывающимся временным интервалом, вставлял в нее новую строку. Итак, разработчик просто работал с парой таблиц:

create table resources(resource_name varchar2(25) primary key,... ) ;

create table schedules(resource_name varchar2(25) references resources, start_time date, end_time date);

И прежде чем зарезервировать на определенный период, скажем, учебный класс, приложение выполняло запрос вида:

select from where and count(*) schedules resource_name = :room_name (start_tiroe between :new_start_time and :new_end_time or end_time between :new_start_time and :new_end_time) Он казался разработчику простым и надежным: если возвращено значение 0, учебный класс можно занимать;

если возвращено ненулевое значение, значит, учебный класс на этот период уже кем-то занят. Ознакомившись с используемым алгоритмом, я подготовил простой тест, показывающий, какая ошибка будет возникать при реальной эксплуатации приложения. Эту ошибку будет крайне сложно обнаружить и тем более установить ее причину, — кому-то может даже показаться, что это ошибка СУБД. Я предложил его коллеге сесть за соседний компьютер, перейти на тот же экран и попросил на счет три обоих нажать на кнопку Go и попытаться зарезервировать класс на одно то же время. Оба смогли это сделать — то, что прекрасно работало в изолированной среде, не сработало в среде многопользовательской. Проблема в этом случае была вызвана неблокирующим чтением в Oracle. Ни один из сеансов не блокировал другой. Оба сеанса просто выполняли представленный выше запрос и применяли алгоритм резервирования ресурса. Они оба могли выполнять запрос, проверяющий занятость ресурса, даже если другой сеанс уже начал изменять таблицу планов (это изменение невидимо для других сеансов до фиксации, то есть до тех пор, когда уже слишком поздно). Поскольку сеансы никогда не пытались изменить одну и ту же строку в таблице планов, они никогда и не блокировали друг друга, вследствие чего бизнес-правило не срабатывало так, как ожидалось. Разработчику необходим метод реализации данного бизнес-правила в многопользовательской среде, способ, гарантирующий что в каждый момент времени только один сеанс резервирует данный ресурс. В данном случае решение состояло в программном упорядочении доступа — кроме представленного выше запроса count(*), необходимо было сначала выполнить:

select * from resources where resource_name = :room_name FOR UPDATE;

Ранее в этой главе рассматривался пример, когда использование конструкции FOR UPDATE приводило к проблемам, но в этом случае она обеспечивает корректную ра Глава боту бизнес-правила. Мы просто блокируем ресурс (учебный класс), использование которого планируется непосредственно перед его резервированием, до выполнения запроса к таблице планов, выбирающего строки для данного ресурса. Блокируя ресурс, который мы пытаемся зарезервировать, мы гарантируем, что никакой другой сеанс в это же время не изменяет план использования ресурса. Ему придется ждать, пока наша транзакция не будет зафиксирована — после этого он сможет увидеть сделанное в ней резервирование. Возможность перекрытия планов, таким образом, устранена. Разработчик должен понимать, что в многопользовательской среде иногда необходимо использовать те же приемы, что и при многопотоковом программировании. В данном случае конструкция FOR UPDATE работает как семафор. Она обеспечивает последовательный доступ к конкретной строке в таблице ресурсов, гарантируя, что два сеанса одновременно не резервируют ресурс. Этот подход обеспечивает высокую степень параллелизма, поскольку резервируемых ресурсов могут быть тысячи, а мы всего лишь гарантируем, что сеансы изменяют конкретный ресурс поочередно. Это один из немногих случаев, когда необходимо блокирование вручную данных, которые не должны изменяться. Требуется уметь распознавать ситуации, когда это необходимо, и, что не менее важно, когда этого делать не нужно (пример, когда не нужно, приведен далее). Кроме того, такой прием не блокирует чтение ресурса другими сеансами, как это могло бы произойти в других СУБД, благодаря чему обеспечивается высокая масштабируемость. Подобные проблемы приводят к масштабным последствиям при переносе приложения с одной СУБД на другую (к этой теме я вернусь чуть позже), которых разработчикам сложно избежать. Например, при наличии опыта разработки для другой СУБД, в которой пишущие сеансы блокируют читающих, и наоборот, разработчик может полагаться на это блокирование как защищающее от подобного рода проблем — именно так все и работает во многих СУБД, отличных от Oracle. В Oracle приоритет отдан одновременности доступа, и необходимо учитывать, что в результате все может работать подругому. В 99 процентах случаев блокирование выполняется незаметно, и о нем можно не заботиться. Но оставшийся 1 процент надо научиться распознавать. Для решения этой проблемы нет простого списка критериев типа "в таком-то случае надо сделать то-то". Нужно понимать, как приложение будет работать в многопользовательской среде и что оно будет делать в базе данных.

Многовариантность Эта тема очень тесно связана с управлением одновременным доступом, поскольку создает основу для механизмов управления одновременным доступом в СУБД Oracle — Oracle использует модель многовариантной согласованности по чтению при одновременном доступе. В главе 3 мы более детально рассмотрим технические аспекты многовариантности, но по сути это механизм, с помощью которого СУБД Oracle обеспечивает: • согласованность по чтению для запросов: запросы выдают согласованные результаты на момент начала их выполнения;

• неблокируемые запросы: запросы не блокируются сеансами, в которых изменяются данные, как это бывает в других СУБД.

Разработка успешных приложений для Oracle Это две очень важные концепции СУБД Oracle. Термин многовариантность произошел от того, что фактически СУБД Oracle может одновременно поддерживать множество версий данных в базе данных. Понимая сущность многовариантности, всегда можно понять результаты, получаемые из базы данных. Наиболее простой из известных мне способов продемонстрировать многовариантность в Oracle:

txyte@TKYTE816> c r e a t e table t 2 as 3 select * from all_users;

Table created. tkyte@TKYTE816> variable x refcursor tkyte@TKYTE816> begin 2 open :x for select * from t;

3 end;

4 / PL/SQL procedure successfully completed. tkyte@TKYTE816> delete from t;

18 rows deleted. txyte@TKYTE816> commit;

Commit complete. tkyte@TKYTE816> print x USERNAME USER ID 0 5 16 24 25 26 27 30 57 CREATED 04-NOV-00 04-KOV-00 04-HOV-00 04-NOV-00 04-NOV-00 04-NOV-00 04-NOV-00 04-NOV-OO 07-PEB- SYS SYSTEM DBSNMP AURORA$ORB$UNAUTHENTICATED ORDSYS ORDPLUGIMS MDSYS CTXSYS DEMO 18 rows selected.

В этом примере мы создали тестовую таблицу Т и заполнили ее данными из представления ALL_USERS. Мы открыли курсор для этой таблицы. Мы не выбирали данные с помощью этого курсора, просто открыли его.

Помните, что при открытии курсора сервер Oracle не "отвечает " на запрос;

он никуда не копирует данные при открытии курсора (представьте, сколько времени потребовало бы открытие курсора для таблицы с миллиардом строк в противном случае). Курсор просто открывается и дает результаты запроса по ходу обращения к данным. Другими словами, он будет читать данные из таблицы при извлечении их через курсор.

Глава В том же (или в другом) сеансе мы затем удаляем все данные из таблицы. Более того, мы даже фиксируем (COMMIT) это удаление. Строк больше нет — не так ли? На самом деле их можно извлечь с помощью курсора Фактически, результирующее множество, возвращаемое командой OPEN, было предопределено в момент открытия курсора. Мы не прочитали при открытии курсора ни одного блока данных таблицы, но результат оказался жестко зафиксированным. Мы не сможем узнать этот результат, пока не извлечем данные, но с точки зрения нашего курсора результат этот неизменен. Дело не в том, что СУБД Oracle скопировала все эти данные в другое место при открытии курсора;

данные сохранил оператор delete, поместив их в область данных под названием сегмент отката. Именно в этом и состоит согласованность по чтению, и если не понимать, как работает схема многовариантности в Oracle и каковы ее последствия, вы не только не сможете воспользоваться всеми преимуществами СУБД Oracle, но и не создадите корректных приложений для Oracle, гарантирующих целостность данных. Давайте рассмотрим последствия использования многовариантной согласованности запросов по чтению и неблокируемых чтений. Для тех, кто не знаком с многовариантностью, представленные ниже результаты могут показаться удивительными. Для простоты предположим, что в каждом блоке данных (это минимальная единица хранения в СУБД) считываемой таблицы хранится всего одна строка и что выполняется полный просмотр таблицы. В запрашиваемой таблице хранятся балансы банковских счетов. Она имеет очень простую структуру:

create table accounts ( account_number number primary key, account_balance number );

В реальной таблице счетов будут сотни тысяч строк, но для простоты мы будем рассматривать таблицу всего с четырьмя строками (более детально мы рассмотрим этот пример в главе 3): Строка 1 2 3 4 Номер счета 123 234 345 456 Баланс счета 500.00 $ 250,00 $ 400,00 $ 100,00 $ Требуется создать отчет, который в конце банковского дня позволяет определить количество денег в банке. Это делается с помощью предельно простого запроса:

select sum(account balance) from accounts;

Pages:     || 2 | 3 | 4 | 5 |   ...   | 24 |



© 2011 www.dissers.ru - «Бесплатная электронная библиотека»

Материалы этого сайта размещены для ознакомления, все права принадлежат их авторам.
Если Вы не согласны с тем, что Ваш материал размещён на этом сайте, пожалуйста, напишите нам, мы в течении 1-2 рабочих дней удалим его.