WWW.DISSERS.RU

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

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

Pages:     | 1 |   ...   | 11 | 12 || 14 | 15 |   ...   | 24 |

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

-- [ Страница 13 ] --

24 rows selected. Execution Plan 0 1 2 SELECT STATEMENT Optimizer=CHOOSE (Cost-2525 Card=24 Bytes=120) SORT (GROUP BY) grant query rewrite to tkyte;

Grant succeeded. tkyte@TKYTE816> alter session set query_rewrite_enabled=true;

Session altered. tkyte@TKYTE816> alter session set query_rewrite_integrity=enforced;

Session altered. tkyte@TKYTE816> create materialized view my_all_objects_aggs 2 build immediate 3 refresh on commit 4 enable query rewrite 5 as 6 select owner, count(*) 7 from my_all_objects 8 group by owner 9/ Materialized view created. tkyte@TKYTE816> analyze table my_all_objects_aggs compute statistics;

Table analyzed. По сути, мы заранее вычислили количество объектов и задали итоговую информацию в виде материализованного представления. Мы потребовали немедленно построить и наполнить данными это представление. Обратите внимание, что были также заданы конструкции REFRESH ON COMMIT и ENABLE QUERY REWRITE (вскоре они будут рассмотрены подробнее). Также обратите внимание, что, хотя создано материализованное представление, анализируется таблица. При создании материализованного представления создается настоящая таблица, и ее можно индексировать, анализировать и т.д. Давайте посмотрим представление в действии, выполнив еще раз запрос, использовавшийся при создании представления: tkyte@TKYTE816> set timing on tkyte@TKYTE816> select owner, count(*) 2 from my_all_objects 3 group by owner;

Материализованные представления OWNER A В TYPES 24 rows selected. Elapsed: 00:00:00.10 tkyte@TKYTE816> set timing off COUNT(*) 36 24 tkyte6TKYTE816> set autotrace traceonly tkyte@TKYTE816> select owner, count(*) 2 from my_all_objects 3 group by owner;

24 rows selected. Execution Plan 0 1 SELECT STATEMENT Optimizer=CHOOSE (Cost=l Card=24 Bytes=216) TABLE ACCESS (FULL) OF 'MY_ALL_OBJECTS_AGGS' (Cost=l Card=Valve) Statistics 0 12 7 0 0 1483 535 3 0 0 24 recursive calls db block gets consistent gets physical reads redo size bytes sent via SQL*Net to client bytes received via SQL*Net from client SQL*Net roundtrips to/from client sorts (memory) sorts (disk) rows processed tkyte@TKYTE816> set autotrace off Вместо более чем 3600 consistent gets (логических операций ввода-вывода) использовано всего 12. Физического ввода-вывода на этот раз вообще не было — данные взяты из кэша. Теперь буферный кэш будет значительно эффективнее, так как кэшировать надо намного меньше данных. Раньше кэширование рабочего множества даже не начиналось, но теперь все рабочее множество помещается в кэше. Обратите внимание, что план выполнения запроса предусматривает полный просмотр таблицы MY_ALL_OBJECTS_AGGS, хотя запрос выполнялся к исходной таблице MY_ALL_OBJECTS. При получении запроса SELECT OWNER, COUNT(*)... сервер автоматически направляет его к соответствующему материализованному представлению. Давайте пойдем дальше: добавим новую строку в таблицу MY_ALL_OBJECTS и зафиксируем изменение: tkyte@TKYTE816> insert into my_all_objects 2 (owner, object name, object type, object id) 3 Глава 13 values ('New Owner', 'New Name', 'New Type', 1111111);

1 row created. tkyte@TKYTE816> commit;

Commit complete. Теперь выполним аналогичный запрос, но обратимся только к вновь вставленной строке: tkyte@TKYTE816> set timing on tkyte@TKYTE816> select owner, count(*) 2 from my_all_objects 3 where owner = 'New Owner' 4 group by owner;

OWNER New Owner Elapsed: 00:00:00.01 tkyte@TKYTE816> set timing off tkyte@TKYTE816> set autotrace traceonly tkyte@TKYTE816> select owner, count(*) 2 from my_all_objects 3 where owner = 'New Owner' 4 group by owner;

Execution Plan 0 1 SELECT STATEMENT Optimizer=CHOOSE (Cost=l Card=l Bytes=9) TABLE ACCESS (FULL) OF 'MY_ALL_OBJECTS_AGGS' (Cost=l Card=Valve) COUNT(*) Statistics 0 12 6 0 0 430 424 2 0 0 1 recursive calls db block gets consistent gets physical reads redo size bytes sent via SQL*Net to client bytes received via SQL*Net from client SQL*Net roundtrips to/from client sorts (memory) sorts (disk) rows processed tkyte@TKYTE816> set autotrace off Анализ показывает, что новая строка была найдена при просмотре материализованного представления. Присутствие в исходном определении представления конструкции REFRESH ON COMMIT заставляет сервер Oracle обеспечивать синхронизацию между представлением и исходными данными — при изменении исходных данных изменяется Материализованные представления и представление. Такую синхронизацию нельзя обеспечить для всех материализованных представлений, но в случае однотабличного итогового представления (как наше) или только соединений, без агрегирования, это возможно. Теперь еще один, последний запрос: tkyte@TKYTE816> set timing on tkyte@TKYTE816> select count(*) 2 from my_all_objects 3 where owner = 'New Owner';

COUNT(*) 1 Elapsed: 00:00:00.00 tkyte@TKYTE816> set timing off tkyte@TKYTE816> set autotrace traceonly tkyte@TKYTE816> select count(*) 2 from my_all_objects 3 where owner = 'New Owner';

Execution Plan 0 SELECT STATEMENT Optimizer=CHOOSE (Cost=1 Card=1 Bytes=9) 1 0 SORT (AGGREGATE) 2 1 TABLE ACCESS (FULL) OF 'MX_ALL_OBJECTS_AGGS' (Cost=l -> Card=Valve) Statistics 0 12 5 0 0 367 424 2 0 0 1 recursive calls db block gets consistent gets physical reads redo size bytes sent via SQL*Net to client bytes received via SQL*Net from client SQL*Net roundtrips to/from client sorts (memory) sorts (disk) rows processed tkyte@TKYTE816> set autotrace off Как видите, сервер Oracle может использовать представление даже для запроса. Конструкции GROUP BY в нашем запросе не было, но сервер "понял", что материализованное представление все равно можно использовать. Это и является чудом использования материализованных представлений. Пользователи могут не знать о существовании итоговых таблиц, сервер сам разберется, что ответ уже существует, если включена воз 1098 Глава можность переписывания запроса, и автоматически перепишет запрос так, чтобы использовать соответствующее материализованное представление. Это позволяет непосредственно повлиять на работу приложений, не изменяя в них ни одного запроса.

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

Материализованные представления Как работать с материализованными представлениями Сначала работа с материализованными представлениями может показаться сложной. Иногда материализованное представление содержит ответ на определенный вопрос, но сервер Oracle почему-то его не использует. Если достаточно глубоко покопаться, можно понять, почему. Сервер Oracle — всего лишь программа, и она может работать только с явно предоставленной информацией. Чем больше метаданных предоставлено, чем больше сведений о базовых данных передано серверу Oracle, тем лучше. Эти фрагменты информации (требования NOT NULL, первичные ключи, внешние ключи и т.д.) — слишком тривиальные вещи, чтобы задумываться о них в среде хранилищ данных. Предоставляемые этими ключами и требованиями метаданные дают оптимизатору больше информации, а значит, — больше шансов. Ключи и требования, подобные представленным выше, не только обеспечивают целостность данных, но и добавляют в словарь данных информацию о данных, которую можно использовать при переписывании запросов (отсюда и название — метаданные). Подробнее об этом см. в разделе "Требования целостности". В следующих разделах мы рассмотрим, что необходимо сделать для использования материализованных представлений, представим ряд примеров и покажем, как после введения дополнительной информации, дополнительных метаданных в базу увеличивается частота использования материализованных представлений.

Подготовка Для использования материализованных представлений обязательно надо установить один параметр инициализации, COMPATIBLE. Параметр COMPATIBLE должен иметь значение 8.1.0 или больше, чтобы переписывание запросов вообще применялось. Если этот параметр не будет иметь соответствующего значения, модуль переписывания запросов не будет вызываться. Есть еще два связанных с использованием материализованных представлений параметра, которые можно устанавливать либо на уровне системы (в файле параметров инициализации, INIT.ORA), либо на уровне сеанса (с помощью оператора ALTER SESSION). • QUERY_REWRITE_ENABLED. Если этот параметр не имеет значения TRUE, запроса не переписывается. Стандартное значение — FALSE. • QUERY_REWRITE_INTEGRITY. Этот параметр управляет тем, как сервер Oracle переписывает запросы. Он может иметь одно из трех значений. • ENFORCED. Запросы будут переписываться с помощью требований и правил, применяемых и гарантируемых сервером Oracle. Имеются механизмы, с помощью которых можно сообщить серверу Oracle о других косвенных взаимосвязях, и это позволит переписать больше запросов;

но поскольку сервер Oracle не обеспечивает эти взаимосвязи, он не будет использовать подобные сведения на этом уровне целостности.

Глава • TRUSTED. Запросы будут переписываться на основе требований, обеспечиваемых сервером Oracle, а также всех взаимосвязей данных, о которых сообщили серверу, даже если их выполнение сервером не гарантируется. Например, в начальном примере можно вручную создать физическую таблицу MY_ALL_OBJECTS_AGGS с помощью распараллеливаемого и нерегистрируемого в журнале повторного выполнения оператора CREATE TABLE AS SELECT (для ускорения построения итоговой таблицы). Затем можно создать материализованное представление, использующее эту созданную заранее таблицу, а не создавать ее заново. Если необходимо, чтобы сервер Oracle использовал эту созданную заранее таблицу при последующем переписывании запросов, необходимо задать параметру QUERY_REWRITE_INTEGRITY значение TRUSTED. Надо, чтобы сервер Oracle "поверил", что мы предоставили корректные данные в заранее созданной таблице (сам сервер Oracle корректность этих данных не обеспечивает). • STALE_TOLERATED. Запросы будут переписываться для использования материализованных представлений, даже если серверу Oracle известно, что содержащиеся в представлении данные устарели (не синхронизированы с исходными). Это может пригодиться в среде, где итоговые таблицы обновляются периодически, а не при фиксации изменений, и где небольшая рассинхронизация приемлема. В представленном выше примере использовались операторы ALTER SESSION, обеспечивающие применение фокуса с переписыванием запроса. Поскольку в примере использовались только объекты и связи, поддерживаемые сервером Oracle, целостность запроса при перезаписи можно установить максимальной: ENFORCED. Также необходимо получить привилегию QUERY REWRITE. Но учетной записи, от имени которой я работаю, предоставлена роль DBA, среди привилегий которой есть и QUERY REWRITE, так зачем же явно предоставлять эту привилегию самому себе? Причина в том, что нельзя создать скомпилированные хранимые объекты, будь то материализованные представления, хранимые процедуры или триггеры, имея привилегии роли (роли DBA в данном случае). Полное описание особенностей использования ролей при работе со скомпилированными хранимыми объектами дано в главе 23. Если создается материализованное представление при включенном параметре QUERY_REWRITE_ENABLED, но системная привилегия QUERY REWRITE явно не предоставлена, будет получено следующее сообщение об ошибке: create materialized view my_all_objects_aggs ERROR at line 1:

ORA-01031: insufficient privileges Внутренняя реализация Итак, теперь, научившись создавать материализованные представления и убедившись, что они используются, разберемся, что будет предпринимать сервер Oracle для переписывания запросов? Обычно, когда параметр QUERY_REWRITE_ENABLED имеет значение FALSE, сервер Oracle анализирует полученный оператор SQL и оптимизирует его.

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

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

Полное совпадение текста Сервер ищет полное совпадение строк запроса с текстами определяющих запросов, хранящихся в словаре данных для материализованных представлений. В рассмотренном ранее примере именно этот метод использовал сервер Oracle для первого запроса, при выполнении которого использовалось материализованное представление. При этом используется более "дружественный" (гибкий) алгоритм, чем при поиске в разделяемом пуле (требующем побайтового совпадения), поскольку пробелы, регистр символов и другие особенности форматирования игнорируются.

Частичное совпадение текста Начиная с конструкции FROM, оптимизатор сравнивает оставшийся текст с текстом запроса, определяющего материализованное представление. В результате допускаются расхождения в списке выбора. Если необходимые данные можно получить из материализованного представления (т.е. по нему можно найти значения всех выражений, указанных в списке выбора), сервер Oracle перепишет запрос с использованием этого материализованного представления. Запрос SELECT LOWER(OWNER) FROM MY_ALL_OBJECTS GROUP BY OWNER;

— пример частичного совпадения текста.

Общие методы переписывания запроса Они обеспечивают использование материализованного представления, даже если оно содержит часть необходимых данных, больше данных или данные, которые могут быть преобразованы к нужному виду. Оптимизатор сравнивает определение материализованного представления с отдельными компонентами запроса (SELECT, FROM, WHERE, GROUP BY) в поисках соответствия. При этом сервер Oracle проверяет для этих компонентов следующее. • Достаточность данных. Можно ли получить нужные данные из этого материализованного представления? Если в списке выбора есть столбец X, отсутствующий в материализованном представлении, и его нельзя получить, выполняя соединение с этим представлением, то сервер Oracle не будет переписывать запрос так, чтобы он обращался к этому представлению. Например, запрос SELECT Глава DISTINCT OWNER FROM MY_ALL_OBJECTS при наличии созданного в примере материализованного представления может быть переписан, поскольку столбец OWNER доступен. Запрос же SELECT DISTINCT OBJECT_TYPE FROM MY_ALL_OBJECTS по материализованному представлению выполнить нельзя, поскольку в нем недостаточно данных. • Совместимость по соединениям. Можно ли получить результат соединения, требуемого исходным запросом, из материализованного представления. Совместимость по соединениям можно продемонстрировать с помощью таблицы MY_ALL_OBJECTS и следующих таблиц: tkyte@TKYTE816> create table tl (owner varchar2(30), flag chard));

Table created. tkyte@TKYTE816> create table t2 (object_type varchar2(30), flag char(l));

Table created. Следующий запрос совместим по соединению с материализованным представлением, поэтому он будет переписан так, чтобы обращаться к материализованному представлению: tkyte@TKYTE816> select a.owner, count(*), b.owner 2 from my_all_objects a, tl b 3 where a.owner = b.owner 4 and b.flag is not null 5 group by a.owner, b.owner 6/ Сервер может выяснить, что при использовании материализованного представления вместо исходной таблицы будет получен тот же ответ. Следующий запрос, однако, хотя и похож, но не совместим по соединению: tkyte@TKYTE816> select a.owner, count(*), b.object_type 2 from my_all_objects a, t2 b 3 where a.object_type = b.object_type 4 and b.flag is not null 5 group by a.owner, b.object_type 6/ Столбец OBJECT_TYPE в наше материализованное представление не входит, поэтому сервер Oracle не может переписать запрос так, чтобы он обращался к этому представлению.

Совместимость конструкций группировки Она требуется, если и материализованное представление, и запрос содержат конструкцию GROUP BY. Если материализованное представление сгруппировано на необходимом или более высоком уровне детализации, запрос будет переписан с использованием материализованного представления. Запрос SELECT COUNT(*) FROM MY_ALL_OBJECTS GROUP BY 1, если выполнять его после представленного выше примера, представляет тот самый случай, когда материализованное представление сгруп Материализованные представления пировано на более высоком уровне детализации, чем необходимо. Сервер может переписать этот запрос с использованием материализованного представления, хотя критерии группировки в запросе и материализованном представлении не совпадают.

Совместимость конструкций агрегирования Такая совместимость требуется, если и запрос, и материализованное представление содержат функции агрегирования. Она гарантирует, что материализованное представление обеспечит данные для необходимых агрегатов. В некоторых случаях возможны очень интересные варианты переписывания. Например, сервер распознает, что AVG(X) — то же самое, что и SUM(X)/COUNT(X), так что запрос, требующий выбора AVG(X), может быть выполнен по материализованному представлению, содержащему значения SUM и COUNT. Во многих случаях простое применение описанных выше правил позволит серверу Oracle переписать запрос так, чтобы он обращался к материализованному представлению. В других случаях (как будет показано далее) серверу потребуется помощь администратора. Надо предоставить серверу дополнительную информацию, чтобы он смог использовать для ответа на запрос материализованное представление.

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

Требования целостности Меня часто спрашивали: "Почему надо использовать первичный ключ? Почему просто не создать уникальный индекс?". Можно, конечно, создать и просто индекс, но ведь факт использования первичного ключа говорит намного больше, чем просто создание уникального индекса. То же самое можно сказать об использовании внешних ключей, требований NOT NULL и других. Они не только защищают данные от нежелательных изменений, но и добавляют информацию о данных в словарь данных. На основе этой дополнительной информации сервер Oracle сможет чаще и в более сложных случаях переписывать запрос. Рассмотрим следующий небольшой пример. Скопируем таблицы ЕМР и DEPT из схемы пользователя SCOTT и создадим материализованное представление, соединяющее эти две таблицы. Это материализованное представление отличается от использованного в первом примере тем, что для него задана конструкция REFRESH ON DEMAND. Это означает, что для учета изменений в исходных данных это представление надо обновлять вручную: tkyte@TKYTE816> create table emp as select * from scott.emp;

Table created. tkyte@TKYTE816> create table dept as select * from scott.dept;

Глава Table created. tkyte@TKYTE816> alter session set query_rewrite_enabled=true;

Session altered. tkyte@TKYTE816> alter session set query_rewrite_integrity=enforced;

Session altered. tkyte@TKYTE816> create materialized view emp_dept 2 build immediate 3 refresh on demand 4 enable query rewrite 5 as 6 select dept.deptno, dept.dname, count {*) 7 from emp, dept 8 where emp.deptno = dept.deptno 9 group by dept.deptno, dept.dname 10 / Materialized view created. tkyte@TKYTE816> alter session set optimizer_goal=all_rows;

Session altered. Поскольку базовые таблицы и полученное материализованное представление — очень небольшие, мы с помощью оператора ALTER SESSION принудительно потребуем использовать оптимизатор, основанный на стоимости, а не проанализируем таблицы, как обычно. Если сервер Oracle "узнает", насколько малы эти таблицы, он не будет выполнять некоторые из желательных для нас оптимизаций. При использовании стандартной статистической информации, оптимизатор будет работать так, будто таблицы достаточно большие. В данном случае мы предоставили серверу Oracle мало информации. Ему не известно, как соотносятся таблицы ЕМР и DEPT, какие столбцы являются первичными ключами и т.д. Теперь выполним запрос и посмотрим, что произойдет: tkyte@TKYTE816> set autotrace on tkyte@TKYTE816> select count(*) from emp;

COUNT(*) 14 Execution Plan 0 SELECT STATEMENT Optimizer=ALL_ROWS (Cost=l Card=l) 1 0 SORT (AGGREGATE) 2 1 TABLE ACCESS (FULL) OF 'EMP' (Cost=l Card=82) Запрос был выполнен к базовой таблице ЕМР. Теперь мы с вами знаем, что значение COUNT(*) намного эффективнее (особенно при большом количестве отделов и сотрудников в них) может быть получено из материализованного представления. В нем есть вся необходимая информация для подсчета количества сотрудников. Мы знаем об этом потому, что учитываем сведения о данных, неизвестные серверу Oracle:

Материализованные представления • Столбец DEPTNO — первичный ключ таблицы DEPT. Это означает, что каждая строка в таблице ЕМР соответствует не более чем одной строке в таблице DEPT. • Столбец DEPTNO в таблице ЕМР — внешний ключ по столбцу DEPTNO таблицы DEPT. Если значение столбца DEPTNO в строке таблицы ЕМР непустое, она будет соединена со строкой в таблице DEPT (ни одна строка таблицы ЕМР с непустым значением при соединении потеряна не будет). • Для столбца DEPTNO в таблице ЕМР задано требование NOT NULL. В сочетании с требованием внешнего ключа это означает, что ни одна строка таблицы ЕМР не будет потеряна. Эти три факта в совокупности означают, что при соединении таблиц ЕМР и DEPT каждая строка таблицы ЕМР будет входить в результирующее множество только один раз. Поскольку серверу Oracle об этом не сообщалось, он не смог использовать материализованное представление. Давайте же сообщим серверу все это: tkyte@TKYTE816> alter table dept 2 add constraint dept_pk primary key(deptno);

Table altered. tkyte@TKYTE816> alter table emp 2 add constraint emp_fk_dept 3 foreign key(deptno) references dept(deptno);

Table altered. tkyte@TKYTE816> alter table emp modify deptno not null;

Table altered. tkyte@TKYTE816> set autotrace on tkyte@TKYTE816> select count(*) from emp;

COUNT(*) 14 Execution Plan 0 1 2 SELECT STATEMENT Optimizer=ALL_ROWS (Cost=l Card=l Bytes=13) 0 SORT (AGGREGATE) 1 TABLE ACCESS (FULL) OF 'EMP DEPT' (Cost=l Card=82 Bytes=1066) Теперь сервер Oracle может переписать запрос с использованием материализованного представления EMP_DEPT. Каждый раз, когда известно, что сервер мог бы использовать материализованное представление, но не использует (и проверено, что вообще использование материализованных представлений в сеансе возможно), более детально изучите данные и спросите себя: "Какую информацию я не предоставил серверу Oracle?". В девяти случаях из десяти обнаружится фрагмент метаданных, при добавлении которого сервер Oracle будет переписывать запрос. Итак, что же произойдет в реальном хранилище данных, где в представленных таблицах будут десятки миллионов записей? Дополнительные затраты ресурсов на проверку выполнения требования целостности нежелательны — в программе первичной обра Глава ботки данных это уже сделано, не так ли? В данном случае можно создать непроверяемое требование, которое используется для информирования сервера о взаимосвязи, но сервером не проверяется. Давайте рассмотрим предыдущий пример еще раз, но теперь сымитируем загрузку данных в существующее хранилище (хранилище представлено предыдущим примером). Удалим требования, загрузим данные, обновим материализованные представления и снова добавим требования. Начнем с удаления требований: tkyte@TKYTE816> alter table emp drop constraint emp_fk_dept;

Table altered. tkyte@TKYTE816> alter table dept drop constraint dept_pk;

Table altered. tkyte@TKYTE816> alter table emp modify deptno null;

Table altered. Теперь, чтобы сымитировать загрузку, я вставлю новую строку (для демонстрационных целей этого вполне достаточно) в таблицу ЕМР. Затем мы обновим материализованное представление и сообщим серверу Oracle, что его можно считать актуальным (FRESH): tkyte@TKYTE816> insert into emp (empno,deptno) values (1, 1 ) ;

1 row created. tkyte@TKYTE816> exec dbms_mview.ref resh ('EMP_DEPT');

PL/SQL procedure successfully completed. tkyte@TKYTE816> alter materialized view emp_dept consider fresh;

Materialized view altered. Теперь сообщаем серверу о взаимосвязи таблиц ЕМР и DEPT: tkyte@TKYTE816> alter table dept 2 add constraint dept_pk primary key(deptno) 3 rely enable NOVALIDATE 4/ Table altered. tkyte@TKYTE816> alter table emp 2 add constraint emp_fk_dept 3 foreign key(deptno) references dept(deptno) 4 rely enable NOVALIDATE 5/ Table altered. tkyte@TKYTE816> alter table emp modify deptno not null NOVALIDATE;

Table altered. Итак, мы сообщили серверу Oracle, что имеется, как и прежде, внешний ключ в таблице ЕМР, ссылающийся на таблицу DEPT. Однако, поскольку перед загрузкой в хранилище данные уже обрабатывались, мы сообщаем серверу, что проверять выполнение требований не надо. Опция NOVALIDATE позволяет избежать проверки загруженных Материализованные представления данных, а опция RELY требует, чтобы сервер рассматривал данные как целостные. По сути, мы сообщили серверу о необходимости считать, что при соединении таблиц ЕМР и DEPT по столбцу DEPTNO каждая строка в таблице ЕМР обязательно попадет в результат, причем не более одного раза. Фактически мы "обманули" сервер, вставив в таблицу ЕМР строку, для которой нет соответствующей строки в таблице DEPT. Теперь все готово для выполнения запроса: tkyte@TKYTE816> alter session set query_rewrite_integrity=enforced;

Session altered. tkyte@TKYTE816> select count(*) from emp;

COUNT(*) 15 Execution Plan 0 1 2 SELECT STATEMENT Optimizer=ALL_ROWS (Cost=l Card=l) 0 SORT (AGGREGATE) 1 TABLE ACCESS (FULL) OF 'EMP' (Cost=l Card=164) Поскольку установлено значение параметра QUERY_REWRITE_INTEGRITY=ENFORCED, сервер Oracle не переписал запрос с использованием материализованного представления. Необходимо понизить уровень целостности запроса. Надо, чтобы сервер Oracle нам "поверил": tkyte@TKYTE816> a l t e r s e s s i o n s e t q u e r y _ r e w r i t e _ i n t e g r i t y = t r u s t e d ;

Session a l t e r e d. tkyte@TKYTE816> s e l e c t c o u n t ( * ) from emp;

COUNT(*) 14 Execution Plan 0 1 2 0 1 SELECT STATEMENT Optimizer=ALL_ROWS (Cost=1 Card=l Bytes=13) SORT (AGGREGATE) TABLE ACCESS (FULL) OF 'EMP_DEPT' (Cost=l Card=82 Bytes=1066) В этом случае сервер Oracle переписал запрос, но побочным эффектом оказалось то, что вновь вставленные строки не учтены. Возвращается "ошибочный" ответ, поскольку "факт" сохранения каждой строки таблицы ЕМР в результатах соединения с таблицей DEPT при загруженных в таблицу данных — уже не факт. При обновлении материализованного представления вновь добавленная строка ЕМР в него не попала. Данные, которым сервер Oracle по нашему требованию доверял, оказались ненадежными. В результате мы приходим к двум важным умозаключениям: • можно очень эффективно использовать материализованные представления в больших хранилищах данных, без необходимости выполнять множество дополнительных и зачастую избыточных проверок данных;

Глава • но, лучше лишний раз перепроверить согласованность данных, если вы требуете от сервера Oracle им доверять.

Измерения Использование измерений — еще один метод предоставления дополнительной информации серверу Oracle. Предположим, имеется таблица исходных данных с датами транзакций и идентификаторами клиентов. По дате транзакции в другой таблице можно найти детальную информацию о том, к какому месяцу относится транзакция, к какому кварталу финансового года и т.д. Теперь предположим, что создано материализованное представление для хранения агрегированной информации о продажах по месяцам. Может ли сервер Oracle использовать это представление, выполняя запрос о продажах за квартал или год? Да, мы знаем, что по дате транзакции можно получить месяц, по месяцу — квартал, по кварталу — год, так что — да, может. Серверу Oracle (пока) об этой взаимосвязи не известно, поэтому использовать представление он не будет. С помощью объекта базы данных DIMENSION (измерение) можно сообщить серверу Oracle эти сведения о данных, чтобы он использовал для переписывания большего количества запросов. Измерение декларирует отношение главный/подчиненный между парами столбцов. С его помощью можно указать серверу Oracle что, в строке таблицы значение столбца MONTH определяет значение, которое окажется в столбце QTR, столбец QTR определяет значение, которое окажется в столбце YEAR и т.д. Используя измерение, можно создать материализованное представление, содержащее менее подробные сведения, чем исходные записи (например, итоговые данные по месяцам). Этот уровень агрегирования может оказаться более детальным, чем требуется в запросе (в запросе, скажем, требуются данные по кварталам), но сервер Oracle разберется, что для получения ответа можно использовать материализованное представление. Вот простой пример. Создадим таблицу SALES для хранения даты транзакции, идентификатора клиента и общей суммы продаж. В этой таблице будет около 350000 строк. Другая таблица, TIME_HIERARCHY, будет содержать соответствие даты транзакции месяцу, кварталу и году. При соединении этих двух таблиц можно получить агрегированные данные по месяцам, кварталам, годам и т.д. Аналогично, если имеется таблица, сопоставляющая идентификатор клиента с почтовым индексом, а почтовые индексы — с регионом, можно легко соединить эту таблицу с таблицей SALES для агрегирования данных по почтовому индексу или региону. В обычной базе данных (без материализованных представлений и других специфических структур) эти действия можно выполнить, но это потребует много времени. Для каждой строки данных продаж придется выполнять чтение по индексу справочной таблицы (соединение вложенным циклом NESTED LOOP JOIN) для преобразования даты транзакции или идентификатора клиента в другое значение и последующего группирования результатов по этому значению. Вот тут и пригодится материализованное представление. Можно хранить итоговые данные по продажам, агрегированные, скажем, помесячно по датам транзакции и по почтовым индексам клиентов. Теперь обобщение данных поквартально или по регионам может выполняться очень быстро. Начнем с создания таблицы SALES и загрузки в нее случайных тестовых данных, сгенерированных на основе представления ALL_OBJECTS.

Материализованные представления tkyte@TKYTE816> create table sales 2 (trans_date date, cust_id int, sales_amount number);

Table created. tkyte@TKYTE816> insert /*+ APPEND */ into sales 2 select trunc(sysdate,'year')+mod(rownum,366) TRANS_DATE, 3 mod(rownum,100) CUST_ID, 4 abs(dbms_random.random)/100 SALES_AMOUNT 5 from a l l _ o b j e c t s 6 / 21921 rows created. tkyte@TKYTE816> commit;

Commit complete. Эта исходная информация будет представлять данные за год. Я задаю столбец TRANS_DATE как первый день года плюс число от 1 до 365. Значение CUST_ID — число от 0 до 99. Общая сумма продаж — некоторое сравнительно большое число (год выдался хороший). В моем представлении ALL_OBJECTS содержится около 22000 строк, так что после четырех вставок, каждая из которых удваивает размер таблицы, мы получим около 350000 записей. Я использую подсказку / * + APPEND */. чтобы избежать генерации большого объема данных в журнал повторного выполнения: tkyte@TKYTE816> begin 2 for i in 1.. 4 3 loop 4 insert /*+ APPEND */ into sales 5 select trans_date, cust_id, abs(dbms_random.random)/100 6 from sales;

7 commit;

8 end loop;

9 end;

10 / PL/SQL procedure successfully completed. tkyte@TKYTE816> select count(*) from sales;

COUNT(*) 350736 Теперь необходимо создать таблицу TIME_HIERARCHY, "округляющую" дату до месяца, года, квартала и т.д.: tkyte@TKYTE816> create table time_hierarchy 2 (day primary key, mmyyyy, mon_yyyy, qtr_yyyy, yyyy) 3 organization index 4 as 5 select distinct 6 trans_date DAY, 7 cast (to_char(trans_date,'mmyyyy') as number) MMYYYY, Глава 8 to_char(trans_date,'mon-yyyy') MON_YYYY, 9 'Q' || ceil( to_char(trans_date,'mm')/3) || 'FY' 10 || to_char(trans_date,'yyyy') QTR_YYYY, 11 cast( to_char( trans_date, 'yyyy') as number ) YYYY 12 from sales 13 / Table created. В данном случае все просто. Мы сгенерировали столбцы: • MMYYYY — месяц и год;

• MON_YYYY — то же, но с сокращенным названием месяца;

• QTR_YYYY — квартал и год;

• YYYY - год. Однако вычисления, необходимые для создания подобной таблицы, могут быть намного сложнее. Например, кварталы финансового года вычислить не так легко, как и границы финансового года. Как правило, его границы не соответствуют календарному году. Теперь создадим материализованное представление SALES_MV. Оно суммирует исходные продажи за месяц. Можно ожидать, что в полученном материализованном представлении будет примерно 1/30 общего количества строк таблицы SALES, если данные были равномерно распределены: tkyte@TKYTE816> analyze table sales compute statistics;

Table analyzed. tkyte@TKYTE816> analyze table time_hierarchy confute statistics;

Table analyzed. tkyte@TKYTE816> create materialized view sales_mv 2 build immediate 3 refresh on demand 4 enable query rewrite 5 as 6 select sales.cust_id, sum(sales.sales_amount) sales_amount, 7 time_hierarchy.mmyyyy 8 from sales, time_hierarchy 9 where sales.trans_date = time_hierarchy.day 10 group by sales.cust_id, time_hierarchy.mmyyyy 11 / Materialized view created. tkyte@TKYTE816> set autotrace on tkyte@TKYTE816> select time_hierarchy.mmyyyy, sum(sales_amount) 2 from sales, time_hierarchy 3 where sales.trans_date = time_hierarchy.day 4 group by time_hierarchy.mmyyyy 5/ Материализованные представления M Y Y SUM(SALES_AMOUNT) MYY 1ll 12001 12002 22001 32001 42001 52001 62001 72001 82001 92001 102001 112001 122001 13 rows selected. Execution Plan 0 1 3.2177Е+11 1.0200Е+10 2.8848Е+11 3.1944Е+11 3.1012Е+11 3.2066Е+11 3.0794Е+11 3.1796Е+11 3.2176Е+11 3.0859Е+11 3.1868Е+11 3.0763Е+11 3.1305Е+ 0 SELECT STATEMENT Optimizer=CHOOSE (Cost=4 Card=327 Bytes=850VALVE) SORT (GROUP BY) (Cost=4 Card=327 Bytes=8502) TABLE ACCESS (FULL) OF 'SALES_MV' (Cost=l Card=327 Bytes Пока все отлично: сервер Oracle переписал запрос так, что используется представление SALES_MV. Однако посмотрим, что произойдет при выполнении запроса, требующего более высокого уровня агрегирования: tkyte@TKYTE816> set timing on tkyte@TKYTE816> set autotrace on tkyte@TKYTE816> select time_hierarchy.qtr_yyyy, sum(sales_amount) 2 from sales, time_hierarchy 3 where sales.trans_date = time_hierarchy.day 4 group by time_hierarchy.qtr_yyyy 5/ QTR_YYYY Ql Q1 Q2 Q3 FY2001 FY2002 FY2001 FY2001 SUM(SALES_AMOUNT) 9.2969E+11 1.0200E+10 9.3872E+11 9.4832E+11 9.3936E+ Q4 FY2001 Elapsed: 00:00:05.58 Execution Plan 0 1 2 3 4 0 1 2 SELECT STATEMENT Optimizer=CHOOSE (Cost=8289 Card=5 Bytes=14) SORT (GROUP BY) (Cost=8289 Card=5 Bytes=145) NESTED LOOPS (Cost=169 Card=350736 Bytes=10171344) TABLE ACCESS (FULL) OF 'SALES' (Cost=169 Card=350736 В INDEX (UNIQUE SCAN) OF 'SYS IOT TOP 30180' (UNIQUE) Глава Statistics 0 recursive calls 15 db block gets 351853 consistent gets Как видите, сервер Oracle не знает того, что знаем мы. Он еще не знает, что мог бы использовать материализованное представление для ответа на данный запрос, поэтому использует исходную таблицу SALES, проделывая огромный объем работы для получения ответа. То же самое получится и при запросе обобщенных данных за финансовый год. С помощью объекта DIMENSION проинформируем сервер Oracle о том, что материализованное представление позволяет получить ответ и на эти запросы. Сначала создадим объект DIMENSION: tkyte@TKYTE816> create dimension time_hierarchy_dim 2 level day is time_hierarchy.day 3 level mmyyyy is time_hierarchy.mmyyyy 4 level qtr_yyyy is time_hierarchy.qtr_yyyy 5 level yyyy is time_hierarchy.yyyy 6 hierarchy time_rollup 7{ 8 day child of 9 mmyyyy child of 10 qtr_yyyy child of 11 yyyy 12 ) 13 attribute mmyyyy 14 determines mon_yyyy;

Dimension created. Этот оператор сообщает серверу Oracle, что столбец DAY таблицы TIME_HIERARCHY определяет значение столбца MMYYYY, который, в свою очередь, определяет значение столбца QTR_YYYY. Наконец, значение столбца QTR_YYYY определяет значение столбца YYYY. Также утверждается, что столбцы MMYYYY и MON_YYYY — синонимы, между ними есть однозначное соответствие. Так что, когда сервер Oracle обнаруживает в запросе столбец MON_YYYY, он обрабатывает запрос так же, как при использовании столбца MMYYYY. Теперь, когда серверу Oracle известна взаимосвязь данных, выполнение запроса существенно ускоряется: tkyte@TKYTE816> set autotrace on tkyte@TKYTE816> select time_hierarchy.qtr_yyyy, sum(sales_amount) 2 from sales, time_hierarchy 3 where sales.trans_date = time_hierarchy.day 4 group by time_hierarchy.qtr_yyyy 5/ QTR_YYYY Q1 FY2001 Q1 FY2002 SUM(SALES_AMOUNT) 9.2969E+11 1.0200E+ Материализованные представления Q2 FY2001 Q3 FY2001 Q4 FY2001 Elapsed: 00:00:00.20 Execution Plan 0 1 2 3 4 5 6 0 1 2 3 4 9.3872E+11 9.4832E+11 9.3936E+ SELECT STATEMENT Optimizer=CHOOSE (Cost=7 Card=5 Bytes=195) SORT (GROUP BY) (Cost=7 Card=5 Bytes=195) HASH JOIN (Cost=6 Card=150 Bytes=5850) VIEW (Cost=4 Card=46 Bytes=598) SORT (UNIQUE) (Cost=4 Card=46 Bytes=598) INDEX (FAST FULL SCAN) OF 'SYS_IOT_TOP_30180' (UNI TABLE ACCESS (FOIL) OF 'SALES_MV (Cost=1 Card=327 Byt Statistics 0 recursive calls 16 db block gets 12 consistent gets Мы сократили количество логических чтений с 350000 до 12 — не так уж плохо. Если выполнить этот пример, различие будет заметно. Для выполнения первого запроса потребовалось некоторое время (около шести секунд), а вот ответ на второй оказался на экране раньше, чем я отпустил клавишу Enter (через две сотых доли секунды). Для одной базовой исходной таблицы можно задавать сколько угодно иерархий с помощью DIMENSION. Давайте свяжем с каждым клиентом в таблице продаж атрибуты ZIP_CODE (почтовый индекс) и REGION (регион): tkyte@TKYTE816> create table customer_hierarchy 2 (cust_id primary key, zip_code, region) 3 organization index 4 as 5 select cust_id, 6 mod(rownum, 6) || to_char(mod( rownum, 1000 ), 'fm0000') zip_code, 7 mod(rownum, 6) region 8 from (select distinct cust_id from sales) 9/ Table created. tkyte@TKYTE816> analyze table customer_hierarchy compute statistics;

Table analyzed. Теперь пересоздадим материализованное представление так, чтобы значения SALES_AMOUNT группировались по столбцам ZIP_CODE и MMYYYY: tkyte@TKYTE816> drop materialized view sales_mv;

Materialized view dropped. tkyte@TKYTE816> create materialized view sales_mv 2 build immediate 3 refresh on demand 4 5 6 7 8 9 10 11 12 Глава enable query rewrite as select customer_hierarchy.zip_code, time_hierarchy.mnyyyy, sum(sales.sales_amount) sales_amount from sales, time_hierarchy, customer_hierarchy where sales.trans_date = time_hierarchy.day and sales.cust_id = customer_hierarchy.cust_id group by customer_hierarchy.zip_code, time_hierarchy.mmyyyy / Materialized view created. Выполнив запрос, который выдает данные по продажам, сгруппированные по столбцам ZIP_CODE и MMYYYY, можно убедиться, что для их выполнения используется это материализованное представление: tkyte@TKYTE816> set autotrace tkyte@TKYTE816> select customer_hierarchy.zip_code, 2 time_hierarchy.mmyyyy, 3 sum(sales.sales_amount) sales_amount 4 from sales, time_hierarchy, customer_hierarchy 5 where sales.trans_date = tiroe_hierarchy.day 6 and sales.cust_id = customer_hierarchy.cust_id 7 group by customer_hierarchy.zip_code, time_hierarchy.mmyyyy 8 / 1250 rows selected. Execution Plan 0 1 0 SELECT STATEMENT Optimizer=CHOOSE (Cost=l Card=409 Bytes=204 TABLE ACCESS (FULL) OF 'SALES_MV' (Cost=1 Card=409 Bytes= Statistics 28 12 120 recursive calls db block gets consistent gets Однако если запросить информацию на другом уровне агрегирования (обобщая MMYYYY до YYYY и ZIP_CODE до REGION), окажется, что сервер не счел возможным использовать материализованное представление: tkyte@TKYTE816> select customer_hierarchy.region, 2 time_hierarchy.yyyy, 3 sum(sales.sales_amount) sales_amount 4 from sales, time_hierarchy, customer_hierarchy 5 where sales.trans_date = time_hierarchy.day 6 and sales.cust_id = customer_hierarchy.cust_id 7 group by customer_hierarchy.region, time_hierarchy.yyyy 8/ 9 rows selected.

Материализованные представления Execution Plan 0 1 2 3 4 5 6 0 1 2 3 3 2 SELECT STATEMENT Optimizer=CHOOSE (Cost=8289 Card=9 Bytes=26 SORT (GROUP BY) (Cost=8289 Card=9 Bytes=261) NESTED LOOPS (Cost=169 Card=350736 Bytes=10171344) NESTED LOOPS (Cost=169 Card=350736 Bytes=6663984) TABLE ACCESS (FULL) OF 'SALES' (Cost=169 Card=350736 INDEX (UNIQUE SCAN) OF 'SYS_IOT_TOP_30185' (UNIQUE) INDEX (UNIQUE SCAN) OF 'SYS_IOT_TOP_30180' (UNIQUE) Statistics 0 15 702589 recursive calls db block gets consistent gets Сервер учел имеющееся измерение по времени, но у него отсутствует информация о том, как соотносятся столбцы CUST_ID, ZIP_CODE и REGION в таблице CUSTOMER_HIERARCHY. Чтобы исправить это, пересоздадим измерение так, чтобы оно включало две иерархии: одну для таблицы TIME_HIERARCHY, а другую — для CUSTOMER_HIERARCHY: tkyte@TKYTE816> drop dimension time_hierarchy_dim 2/ Dimension dropped. tkyte@TKYTE816> create dimension sales_dimension 2 level cust_id is customer_hierarchy.cust_id 3 level zip_code is customer_hierarchy.zip_code 4 level region is customer_hierarchy.region 5 level day is time_hierarchy.day 6 level mmyyyy is time_hierarchy.mmyyyy 7 level qtr_yyyy is time_hierarchy.qtr_yyyy 8 level yyyy is time_hierarchy.yyyy 9 hierarchy cust_rollup 10 ( 11 cust_id child of 12 zip_code child of 13 region 14 ) 15 hierarchy time_rollup 16 ( 17 day child of 18 mmyyyy child of 19 qtr_yyyy child of 20 yyyy 21 ) 22 attribute mmyyyy 23 determines mon_yyyy;

Dimension created.

Глава Мы удалили исходную иерархию по времени и создали новое, более информативное измерение, описывающее все существенные взаимосвязи. Теперь сервер Oracle "поймет", что по созданному представлению SALES_MV можно ответить на многие другие запросы. Например, если еще раз запросить "регионы по годам": tkyte@TKYTE816> select customer_hierarchy.region, 2 time_hierarchy.yyyy, 3 sum(sales.sales_amount) sales_amount 4 from sales, time_hierarchy, customer_hierarchy 5 where sales.trans_date = time_hierarchy.day 6 and sales.cust_id = customer_hierarchy.cust_id 7 group by customer_hierarchy.region, time_hierarchy.yyyy 8/ REGION 0 0 1 2 2 3 4 4 5 9 rows selected. Execution Plan 0 1 2 3 4 5 6 7 8 9 10 0 1 2 3 4 5 3 2 8 9 SELECT STATEMENT Optimizer=CHOOSE (Cost=ll Card=9 Bytes=576) SORT (GROUP BY) (Cost=11 Card=9 Bytes=576) HASH JOIN (Cost=9 Card=78 Bytes=4992) HASH JOIN (Cost=6 Card=78 Bytes=4446) VIEW (Cost=3 Card=19 Bytes=133) SORT (UNIQUE) (Cost=3 Card=19 Bytes=133) INDEX (FAST FULL SCAN) OF 'SYS_IOT_TOP_30180' (U TABLE ACCESS (FULL) OF 'SALES_MV (Cost=1 Card=409 В VIEW (Cost=3 Card=100 Bytes=700) SORT (UNIQUE) (Cost=3 Card=100 Bytes=700) INDEX (FULL SCAN) OF 'SYS_IOT_TOP_30185' (UNIQUE) YYYY SALES_AMOUNT 2001 2002 2001 2001 2002 2001 2001 2002 2001 5.9598E+11 3123737106 6.3789E+11 6.3903E+11 3538489159 6.4069E+11 6.3885E+11 3537548948 6.0365E+ Statistics 0 16 14 recursive calls db block gets consistent gets Оказывается, что сервер Oracle смог использовать обе иерархии измерения и выполнил запрос к материализованному представлению. Благодаря созданным измерениям он выполнил простой поиск для преобразования значения столбца CUST_ID в REGION (поскольку значение CUST_ID определяет значение ZIP_CODE, а оно, в свою очередь, Материализованные представления определяет REGION), значения столбца MMYYYY — в QTR_YYYY и ответил на запрос почти моментально. Здесь нам удалось сократить количество операций логического ввода-вывода с более чем 700000 до 16. Если учесть, что таблица SALES со временем будет расти, а размер представления SALES_MV будет увеличиваться намного медленнее (примерно 180 записей в месяц), запрос будет очень хорошо масштабироваться.

Пакет DBMS_OLAP Последним фрагментом головоломки, которую представляют собой материализованные представления, является пакет DBMS_OLAP. Этот пакет используется для: • оценки размера материализованного представления в строках и байтах;

• проверки корректности объектов-измерений, с учетом заданных отношений первичного/внешнего ключа;

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

• оценки использования материализованного представления с помощью предоставляемых процедур, которые информируют о фактической полезности имеющихся материализованных представлений независимо от того, использовались они или нет. К сожалению, процедуры оценки полезности выходят за рамки тем, которые я могу раскрыть в одной главе. Для использования этих процедур необходимо настроить утилиту Oracle Trace и средства Enterprise Manager Performance Pack, но остальные три процедуры мы рассмотрим. Чтобы использовать пакет DBMS_OLAP, необходимо настроить использование внешних процедур, поскольку большая часть кода пакета DBMS_OLAP хранится в библиотеке, написанной на языке С. Если выдается сообщение об ошибке следующего вида, выполните инструкции по настройке, представленные в главе 18: ERROR at line 1: ORA-28575: unable to open RPC connection to external procedure agent ORA-06512: at "SYS.DBMS_SUMADV", line 6 ORA-06512: at "SYS.DBMS_SUMMARY", line 559 ORA-06512: at line Оценка размера Процедура ESTIMATE_SUMMARY_SIZE информирует о предположительном количестве строк и размере в байтах материализованного представления. Поскольку ретроспективный анализ дает наилучшие результаты, можно оценить эти значения с помощью пакета DBMS_OLAP, а затем сравнить с реальными значениями. Для запуска процедуры необходимо убедиться, что в схеме установлена таблица PLAN_TABLE. Соответствующий оператор CREATE TABLE можно найти в файле [ORACLE_HOME]/rdbms/admin/utlxplan.sql на сервере. При выполнении этого сцена Глава рия автоматически будет создана таблица PLAN_TABLE. Эта таблица используется при выполнении оператора EXPLAIN PLAN, результаты работы которого, в свою очередь, используются пакетом DBMS_OLAP для оценки размера материализованного представления. При наличии этой таблицы можно использовать встроенную процедуру ESTIMATE_SUMMARY_SIZE для оценки количества строк/байтов в материализованном представлении, которое предполагается создать. Я начну с удаления статистической информации (DELETE STATISTICS) о материализованном представлении SALES_MV. Обычно пакету DBMS_OLAP недоступно материализованное представление, размер которого оценивается, поэтому нам придется этот размер скрыть (в противном случае пакет DBMS_OLAP получит точный ответ по словарю данных): tkyte@TKYTE816> analyze table sales_mv DELETE statistics;

Table analyzed. tkyte@TKYTE816> declare 2 num_rows number;

3 num_bytes number;

4 begin 5 dbms_olap.estimate_summary_size 6 ('SALES_MV_ESTIMATE', 7 'select customer_hierarchy.zip_code, 8 time_hierarchy.mmyyyy, 9 sum(sales.sales_amount) sales_amount 10 from sales, time_hierarchy, customer_hierarchy 11 where sales.trans_date = time_hierarchy.day 12 and sales.cust_id = customer_hierarchy.cust_id 13 group by customer_hierarchy.zip_code, time_hierarchy.mmyyyy', 14 num_rows, 15 num_bytes);

16 17 dbms_output.put_line(num_rows || ' rows');

18 dbms_output.put_line(num_bytes || ' bytes');

19 end;

20 / 409 rows 36401 bytes PL/SQL procedure successfully completed. Первый параметр процедуры — имя плана, под которым его надо запомнить в таблице планов. Это имя не имеет особого значения, но его надо задать в операторе DELETE FROM PLAN_TABLE WHERE STATEMENT_ID = 'SALES_MV_ESTIMATE' no завершении эксперимента. Второй параметр — запрос, который будет использоваться для создания материализованного представления. Пакет DBMS_OLAP проанализирует этот запрос на основе статистической информации о базовых таблицах, чтобы оценить размер этого объекта. Остальные два параметра предназначены для передачи результатов работы процедуры пакета DBMS_OLAP — предполагаемого количества строк и байтов. Они получили значения 409 и 36401, соответственно. Теперь давайте подсчитаем реальные значения:

Материализованные представления tkyte@TKYTE816> analyze table sales_mv COMPUTE statistics;

Table analyzed. tkyte@TKYTE816> select count(*) from sales_mv;

COUNT(*) 1250 tkyte@TKYTE816> s e l e c t blocks * 8 * 1024 2 from user_tables 3 where table_name = 'SALES_MV' 4/ BLOCKS*8*1024 40960 Итак, процедура ESTIMATE_SUMMARY_SIZE дала хороший результат при оценке размера таблицы, но недооценила количество строк. Обычно с оценками так и происходит: какие-то параметры оцениваются верно, а какие-то — нет. Я бы использовал эту процедуру для грубой оценки предполагаемого размера объекта.

Проверка достоверности измерений Эта процедура проверяет достоверность иерархий, входящих в указанное измерение. Так, в рассмотренном ранее примере она проверит, действительно ли значение CUST_ID определяет значение ZIP_CODE, а то, в свою очередь, определяет значение столбца REGION. Чтобы увидеть соответствующую процедуру в действии, создадим пример недостоверного измерения. Начнем с таблицы, содержащей строку для каждого дня года с атрибутами день, месяц и год: tkyte@TKYTE816> create table time_rollup 2 (day date, 3 mon number, 4 year number 5) 6/ Table created. tkyte@TKYTE816> insert into time_rollup 2 select dt, to_char(dt,'mm'), to_char(dt,'yyyy') 3 from (select trunc(sysdate,'year')+rovmum-l dt 4 from all_objects where rownum < 366) 5/ 365 rows created. Итак, мы создали развернутую информацию по дате, аналогично предыдущему примеру. На этот раз, однако, я не включил год в атрибут, представляющий месяц, — только две цифры, представляющие порядковый номер месяца в году. Если добавить в эту таблицу еще одну строку:

Глава tkyte@TKYTE816> insert into time_rollup values 2 (add_months(sysdate,12), 3 to_char(add_months(sysdate,12),'mm'), 4 to_char(add_months(sysdate, 12), 'yyyy'));

1 row created. проблема станет очевидной. Мы будем утверждать, что значение DAY определяет значение MON, а MON, в свою очередь, определяет значение YEAR, но в данном случае это неверно. Одно и то же значение месяца будет в таблице для двух разных годов. Пакет DBMS_OLAP позволяет проверить достоверность;

при этом ошибка будет выявлена. Сначала создаем измерение: tkyte@TKYTE816> create dimension time_rollup_dim 2 level day is time_rollup.day 3 level mon is time_rollup.mon 4 level year is time_rollup.year 5 hierarchy time_rollup 6( 7 day child of mon child of year 8) 9/ Dimension created. А затем проверяем его достоверность: tkyte@TKYTE816> exec dbms_olap.validate_dimension('time_rollup_dim', user, false, false);

PL/SQL procedure successfully completed. Кажется, что все в порядке, но надо проверить таблицу, автоматически созданную и заполненную в процессе работы с данными: tkyte@TKYTE816> select * from mviewS_exceptions;

OWNER TABLE_NAME DIMENSION_NAME RELATIONSHI BAD_ROWID AAAGkxAAGAAAAcKAA7 AAAGkxAAGAAAAcKAA8 AAAGkxAAGAAAAcKAA TKYTE TIME_ROLLUP TIME_ROLLUP_DIM CHILD OF TKYTE TIME_ROLLUP TIME_ROLLUP_DIM CHILD OF TKYTE TIME_ROLLUP TIME_ROLLUP_DIM CHILD OF 32 rows selected. Если просмотреть строки, на которые указывает представление MVIEW$_EXCEPTIONS, окажется, что это строки за март (я выполнял этот пример в марте). А именно: tkyte@TKYTE816> select * from time_rollup 2 where rowid in (select bad_rowid from mview$_exceptions);

DAY 01-MAR-01 02-MAR-01 MON 3 3 YEAR 2001 Материализованные представления 03-MAR-01 04-MAR-01 30-MAR-01 31-MAR-01 26-MAR-02 32 rows selected.

3 3 3 3 2001 2001 2001 2001 Теперь проблема ясна: значение MON не определяет однозначно YEAR — измерение недостоверно. Его использование небезопасно, поскольку будет получен неверный ответ. Рекомендуется проверять достоверность измерений после их изменения, чтобы гарантировать целостность результатов, получаемых из материализованных представлений благодаря наличию этих измерений.

Рекомендация создания материализованных представлений Один из наиболее интересных вариантов использования пакета DBMS_OLAP — определение того, какие материализованные представления имеет смысл создавать. Процедура RECOMMEND делает именно это. Имеется две версии этой процедуры. • Процедура RECOMMEND_MV анализирует структуру таблицы, внешние ключи, материализованные представления, всю соответствующую статистическую информацию, а затем выдает список рекомендаций в порядке убывания приоритетов. • Процедура RECOMMEND_MV_W идет еще дальше. Если используется утилита Oracle Trace и Enterprise Manager Performance Packs, процедура анализирует запросы, обрабатываемые системой, и рекомендует создание материализованных представлений на основе информации о реальной работе. В качестве простого примера, оценим с помощью пакета DBMS_OLAP существующую "таблицу фактов" SALES. Таблица фактов (таблица основной информации) — это таблица в схеме "звезда", содержащая фактические данные. Использованная ранее таблица SALES — это таблица фактов. В таблице фактов обычно есть два типа столбцов: столбцы, содержащие факты (например, столбец SALES_AMOUNT в нашей таблице SALES), и столбцы, являющиеся внешними ключами к таблицам измерений (например, к таблице TRANS_DATE для нашей таблицы SALES). Давайте посмотрим, что порекомендует пакет DBMS_OLAP. Сначала необходимо создать внешние ключи. Процедуры RECOMMEND не будут анализировать объекты DIMENSION при выработке рекомендаций — для определения связей между таблицами им необходимы внешние ключи:

Глава tkyte@TKYTE816> alter table sales add constraint t_fk_time 2 foreign key( trans_date) references time_hierarchy 3/ Table altered. tkyte@TKYTE816> alter table sales add constraint t_fk_cust 2 foreign key( cust_id) references customer_hierarchy 3/ Table altered. После этого можно анализировать нашу таблицу фактов, SALES: tkyte@TKYTE816> exec dbms_olap.recommend_mv('SALES', 10000000000, '' );

PL/SQL procedure successfully completed. Мы попросили процедуру RECOMMEND_MV: • проанализировать таблицу SALES;

• учесть, что для материализованных представлений места предостаточно (мы просто передали очень большое значение в качестве ограничения);

• не оставлять без необходимости существующих материализованных представлений (мы передали " в качестве списка имен сохраняемых представлений). Теперь можно либо непосредственно обращаться к заполненным этой процедурой таблицам, либо, что удобнее, использовать простую процедуру для выдачи их содержимого. Для установки этой процедуры и построения отчета надо выполнить: tkyte@TKYTE816> @C:\oracle\RDBMS\demo\saclvdemo Package created. Package body created. Package created. Package body created. tkyte@TKYTE816> exec demo_sumadv.prettyprint_recornmendations Recommendation Number = 1 Recommended Action is CREATE new summary: SELECT CUSTOMER_HIERARCHY.CUST_ID, CUSTOMER_HIERARCHY.ZIP_CODE, CUSTOMER_HIERARCHY.REGION, COUNT(*), SUM(SALES.SALES_AMOUNT), COUNT(SALES.SALES_AMOUNT) FROM TKYTE.SALES, TKYTE.CUSTOMER_HIERARCHY WHERE SALES.CUST_ID = CUSTOMER_HIERARCHY.CUST_ID GROUP BY CUSTOMER_HIERARCHY.CUST_ID, CUSTOMER_HIERARCHY.ZIP_CODE, CUSTOMER_HIERARCHY.REGION Storage in bytes is 2100 Percent performance gain is 43.2371266138567 Benefit-to-cost ratio is.0205891079113603 Recommendation Number = 2 PL/SQL procedure successfully completed.

Материализованные представления Процедура пакета DBMS_OLAP учла существующие измерения и материализованные представления и выдала рекомендации по созданию дополнительных материализованных представлений, которые могут оказаться полезными с учетом имеющихся у сервера метаданных (первичных ключей, внешних ключей и измерений). При использовании утилиты Oracle Trace можно пойти в процессе выработки рекомендаций чуть дальше. Утилита Oracle Trace позволяет перехватывать фактические запросы к данным, принимаемые сервером, и записывать подробную информацию о них. Эта информация будет использоваться пакетом DBMS_OLAP для выработки еще более точных рекомендаций, основанных не только на потенциальных возможностях, но и на реальных запросах, выполняемых к данным. При этом не рекомендуется создание материализованных представлений, которые теоретически могли бы, но не будут использоваться при таком потоке запросов. Рекомендоваться будут только те материализованные представления, которые будут использованы для выполнения запросов, реально поступающих в систему.

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

Материализованные представления не предназначены для систем ООТ Как уже упоминалось, поддержка материализованных представлений требует дополнительных затрат ресурсов при выполнении отдельных транзакций и, если представления созданы с опцией REFRESH ON COMMIT, приводит к конфликтам. Дополнительные затраты ресурсов связаны с необходимостью учета изменений, выполненных транзакцией, — эти изменения будут либо сохраняться в качестве данных состояния сеанса, либо регистрироваться в таблицах. В системах, интенсивно обрабатывающих транзакции, такие дополнительные затраты ресурсов нежелательны. Проблема одновременного доступа возникает для материализованных представлений с опцией REFRESH ON COMMIT из-за того, что многие записи в исходной таблице фактов ссылаются на одну строку в итоговой таблице. Изменение любой из многих тысяч записей, которые могут существовать, приводит к необходимости изменить одну строку в итоговой таблице. Это, естественно, мешает одновременному доступу при интенсивных изменениях. Это не исключает использования материализованных представлений, в частности представлений, обновляемых по требованию (REFRESH ON DEMAND), в среде ООТ при полном обновлении. Полное обновление не требует дополнительных затрат ресурсов на отслеживание изменений на уровне транзакций. Вместо этого в определенный момент времени выполняется запрос, определяющий материализованное представление, и его результаты просто заменяют существующее материализованное представление. Поскольку делается это по требованию (или периодически), такое обновление можно выполнять в периоды низкой загруженности сервера. Полученное материализованное Глава представление особенно пригодится для создания отчетов: данные ООТ можно каждую ночь преобразовывать с помощью SQL-операторов в форму, упрощающую и ускоряющую выполнение запросов. На следующий день оперативные отчеты по результатам вчерашней работы выполняются максимально быстро, не мешая при этом обработке транзакций.

Целостность запросов при переписывании Как было описано ранее, есть три режима обеспечения целостности. • ENFORCED. Будет использовать материализованное представление, только если при этом невозможно получение некорректных или устаревших данных. • TRUSTED. Сервер Oracle будет использовать материализованное представление, даже если некоторые требования, на которые он при этом полагается, им не проверяются и не обеспечиваются. Эта ситуация типична в среде хранилища данных, где многие требования целостности соблюдены, но не поддерживаются сервером Oracle. • STALE_TOLERATED. Сервер Oracle будет использовать материализованное представление, даже если "знает", что данные, по которым оно построено, изменились. Эта ситуация типична для среды создания отчетов, вроде описанной выше. Надо понимать последствия использования каждого из этих режимов. Режим ENFORCED дает правильные ответы всегда — за счет отказа от использования некоторых материализованных представлений, которые могли бы ускорить выполнение запроса. В режиме TRUSTED, если окажется, что условие, которому сервер Oracle попросили доверять, в действительности не выполняется, могут выдаваться результаты, отличные от получаемых по исходным данным. Такая ситуация была рассмотрена в примере с материализованным представлением EMP_DEPT. Режим STALE_TOLERATED следует использовать в системах создания отчетов, где вполне допустимо получить устаревшее значение. Если требуется актуальная информация с точностью до минуты, режим STALE_TOLERATED использовать нельзя.

Резюме Материализованные представления — мощное средство повышения производительности хранилищ данных и систем поддержки принятия решений. Одно материализованное представление может использоваться многими взаимосвязанными запросами. Самое главное, что его использование полностью прозрачно для приложения и пользователя. Не нужно сообщать пользователям, какие итоговые таблицы поддерживаются, об этом информируется сервер Oracle с помощью требований целостности ссылок и измерений. Все остальное сервер сделает автоматически. Материализованные представления — естественное развитие и объединение различных возможностей сервера и средств поддержки принятия решений. Средства поддержки итоговых таблиц Oracle Discoverer (и других подобных программ) уже не ограничены только этой средой. Теперь любой клиент, от замечательного SQL*Plus до разработан Материализованные представления ного вами приложения и готовых средств создания отчетов, может использовать уже гдето хранящийся ответ на его запрос. Добавьте к этому возможности пакета DBMS_OLAP. Он не только позволяет оценить, сколько дополнительно места на диске понадобится для поддержки материализованного представления, но и может следить за использованием существующих представлений. На основе этой информации пакет рекомендует удалить одни и создать другие представления — вплоть до выдачи текста запроса, который имеет смысл для этого использовать. В конечном итоге, материализованные представления в среде, где данные только читаются или интенсивно читаются, несомненно, оправдают выделенное для них дополнительное место на диске, сократив время выполнения и экономя ресурсы, необходимые для фактического выполнения запросов.

Фрагментация Возможность фрагментации, то есть разбиения таблицы или индекса на несколько меньших, проще управляемых частей, впервые появилась в сервере Oracle версии 8.0. Логически для обращающегося к базе данных приложения есть только одна таблица или индекс. Физически же эта таблица или индекс могут состоять из многих десятков фрагментов. Каждый фрагмент — самостоятельный объект, с которым можно работать отдельно или как с частью большего объекта. Фрагментация разрабатывалась для упрощения управления очень большими таблицами и индексами за счет применения подхода "разделяй и властвуй". Предположим, в базе данных имеется индекс размером 10 Гбайт. Если необходимо перестроить этот нефрагментированный индекс, придется перестраивать весь индекс в один прием. Хотя сервер способен перестраивать такие индексы динамически, объем ресурсов, необходимых для полного пересоздания всего индекса размером 10 Гбайт, огромен. Потребуется еще не менее 10 Гбайт свободного пространства для хранения обоих экземпляров индекса, необходима временная таблица журнала транзакций для записи изменений, сделанных в базовой таблице за время пересоздания индекса, и т.д. С другой стороны, если индекс разбит на десять фрагментов размером 1 Гбайт, можно пересоздавать каждый фрагмент индекса отдельно, по одному. При этом потребуется только 10 процентов свободного пространства, которое понадобилось бы при пересоздании нефрагментированного индекса. Пересоздание индекса пройдет намного быстрее (возможно, раз в десять), намного уменьшится объем выполненных транзакциями изменений, которые придется учесть в новом индексе, и т.д.

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

Использование фрагментации Для использования фрагментации имеются три причины: • повышение доступности данных;

• упрощение администрирования;

• повышение производительности запросов и операторов ЯМД.

Повышение доступности данных Повышение доступности данных достигается за счет того, что фрагменты являются независимыми сущностями. Доступность (или недоступность) одного фрагмента объекта не означает, что весь объект доступен (или недоступен). Оптимизатор учтет реализованную схему фрагментации и удалит из плана выполнения запроса фрагменты, данные из которых не запрашиваются. Если недоступен один фрагмент большого объекта и запрос не обращается к данным в этом фрагменте, сервер Oracle успешно выполнит этот запрос. Давайте создадим фрагментированную по хеш-функции таблицу из двух фрагментов, хранящихся в разных табличных пространствах, и вставим в нее данные. Для каждой вставляемой в таблицу строки значение в столбце EMPNO хешируется с целью определения фрагмента (а значит, и табличного пространства, в данном случае), в который следует помещать данные. Затем, дополнив имя таблицы именем фрагмента, просмотрим содержимое каждого фрагмента: tkyte@TKYTE816> CREATE TABLE emp 2 (empno int, 3 ename varchar2(20) 4) 5 PARTITION BY HASH (empno) 6 (partition part_l tablespace p1, 7 partition part_2 tablespace p2 8) 9/ Table created. tkyte@TKYTE816> insert into emp select empno, ename from scott.emp 2/ 14 rows created. tkyteeTKYTE816> select * from emp partition(part_l);

EMPNO ENAME 7369 7499 7654 7698 SMITH ALLEN MARTIN BLAKE Фрагментация 7782 CLARK 7839 KING 7876 ADAMS 7934 MILLER 8 rows selected. tkyte@TKYTE816> select * from emp partition (part_2);

EMPNO ENAME 7521 WARD 7566 JONES 7788 SCOTT 7844 TURNER 7900 JAMES 7902 FORD 6 rows selected. Теперь сделаем часть данных недоступными, отключив одно из используемых табличных пространств, и выполним запрос, затрагивающий оба фрагмента, чтобы показать невозможность его выполнения. Вы увидите, что запрос, не обращающийся к отключенному табличному пространству, работает как обычно — сервер Oracle не обращается к отключенному табличному пространству. В этом примере я использовал связываемую переменную, чтобы продемонстрировать, что, даже если в момент оптимизации запроса сервер не знает, к какому фрагменту будут обращаться, он все равно пропустит ненужный фрагмент: tkyteeTKYTE816> alter tablespace p1 offline;

Tablespace altered. tkyte@TKYTE816> select * from emp 2/ select * from emp ERROR at line 1: ORA-00376: file 4 cannot be read at this time ORA-01110: data file 4: 'C:\ORACLE\ORADATA\TKYTE816\P1.DBF' tkyteeTKYTE816> variable n number tkyte@TKYTE816> exec :n := 7844 PL/SQL procedure successfully completed. tkyte@TKYTE816> select * from emp where empno = :n 2/ EMPNO ENAME 7844 TURNER Как видите, мы отключили одно из табличных пространств, сымитировав сбой диска. В результате, если потребуется обратиться ко всей таблице, естественно, ничего не получится. Однако обратиться к данным, находящимся в доступном фрагменте, можно. Когда оптимизатор может удалить фрагменты из плана выполнения запроса, он это де Глава лает. Этот факт увеличивает доступность данных для приложений, использующих в запросах ключ, по которому выполнена фрагментация. Фрагменты повышают доступность также благодаря сокращению времени простоя. Например, если таблица размером 100 Гбайт разбита на 50 фрагментов размером 2 Гбайт, восстановление в случае ошибок выполняется в 50 раз быстрее. Если один из фрагментов размером 2 Гбайта поврежден, для его восстановления нужно намного меньше времени, чем для восстановления таблицы размером 100 Гбайт. Таким образом, доступность повышается по двум направлениям: многие пользователи могут вообще не заметить, что данные были недоступны, благодаря тому, что сбойный фрагмент пропускается, а время простоя при сбое сокращается вследствие существенно меньшего объема работы, необходимой для восстановления.

Упрощение администрирования Упрощение администрирования связано с тем, что операции с маленькими объектами выполнять гораздо проще, быстрее и при этом требуется меньше ресурсов, чем в случае больших объектов. Например, если оказалось, что 50 процентов строк в таблице фрагментированы (подробнее о фрагментации и переносе строк см. в главе 6, посвященной таблицам), и необходимо это исправить, фрагментация таблицы очень пригодится. Чтобы исключить фрагментацию строк, как правило, пересоздается объект, в данном случае — таблица. Если таблица размером 100 Гбайт, придется выполнять эту операцию одним большим "куском", последовательно, с помощью оператора ALTER TABLE MOVE. Если же эта таблица разбита на 25 фрагментов размером 4 Гбайта, можно перестраивать фрагменты по одному. Более того, если это делается в период минимальной загруженности сервера, можно даже выполнять операторы ALTER TABLE MOVE параллельно в отдельных сеансах, что позволяет сократить время пересоздания. Практически все, что делается с нефрагментированным объектом, можно сделать и с частью фрагментированного объекта. Еще один фактор, который необходимо учитывать при оценке влияния фрагментации на администрирование, — использование смещающегося окна данных в хранилищах данных и при архивировании. Во многих случаях необходимо сохранять доступными последние (по времени создания) N групп данных. Например, необходимо предоставлять данные за последние 12 месяцев или пять лет. При отсутствии фрагментации это обычно связано с множественной вставкой новых данных, а затем — множественным удалением устаревших. Для этого необходимо выполнить множество операторов ЯМД, сгенерировать множество данных повторного выполнения и отката. При использовании фрагментации можно: • загрузить в отдельную таблицу данные за новый месяц (или год, или любой другой период);

• полностью проиндексировать таблицу (эти шаги можно сделать вообще в другом экземпляре, а результаты перенести в текущую базу данных);

• добавить ее в конец фрагментированной таблицы;

• удалить самый старый фрагмент с другого конца фрагментированной таблицы.

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

Повышение производительности операторов ЯМД и запросов Еще одним преимуществом фрагментации является повышение производительности запросов и операторов ЯМД. Мы рассмотрим преимущества фрагментации для этих двух категорий операторов отдельно. Повышение производительности операторов ЯМД связано с потенциальной возможностью распараллеливания. При распараллеливании операторов ЯМД сервер Oracle использует несколько потоков или процессов для выполнения операторов INSERT, UPDATE или DELETE. На многопроцессорной машине с большой пропускной способностью ввода-вывода потенциальное ускорение для операторов ЯМД, выполняющих множественные изменения, может быть весьма большим. В отличие от параллельных запросов (обработки несколькими процессами/потоками оператора SELECT), для распараллеливания операторов ЯМД требуется фрагментация (есть специальный случай параллельной непосредственной вставки, задаваемой с помощью подсказки / * + APPEND */> когда фрагментация не требуется). Если таблицы не фрагментированы, распараллелить операторы ЯМД не удастся. Сервер Oracle присваивает каждому объекту максимальную степень распараллеливания в зависимости от количества составляющих его фрагментов. Не стоит ожидать от распараллеливания операторов ЯМД ускорения работы приложений оперативной обработки транзакций (ООТ). В этом отношении есть много заблуждений. Я много раз слышал: "Параллельно выполняемые операции должны давать результаты быстрее, чем при последовательном выполнении". Это не всегда верно. При параллельном выполнении некоторых операций требуется во много раз больше времени, чем при последовательном. На организацию параллельного выполнения расходуются определенные ресурсы, необходима дополнительная координация. Более того, распараллеливание вообще не стоит использовать в среде интенсивной оперативной обработки транзакций — в этом просто нет смысла. Распараллеливание операций предназначено исключительно для максимального использования ресурсов системы. При параллельном выполнении один пользователь может единолично использовать все диски, процессоры и всю свободную память машины. В среде хранилища данных, где данных много, а пользователей мало, именно это и требуется. В системе ООТ (большое количество пользователей, выполняющих короткие, быстрые транзакции) предоставление пользователю возможности полностью использовать ресурсы машины отрицательно скажется на масштабируемости. В этом есть кажущееся противоречие: мы используем распараллеливание запроса для ускорения работы с большими объемами данных, как же это решение может быть немасштабируемым? Применительно к системе ООТ, однако, это утверждение абсолютно Глава верно. Параллельные запросы плохо масштабируются при увеличении количества пользователей, одновременно их выполняющих. Параллельные запросы позволяют в одном пользовательском сеансе выполнять столько же действий, как в ста одновременных сеансах. Однако в системе ООТ нежелательно, чтобы один пользователь выполнял столько же действий, как сто. Распараллеливание операторов ЯМД полезно в среде больших хранилищ данных как средство множественного изменения больших объемов данных. Распараллеленный оператор ЯМД выполняется сервером во многом аналогично параллельному запросу: каждый фрагмент используется как отдельный экземпляр базы данных. Каждый фрагмент изменяется отдельным потоком в отдельной транзакции (поэтому при изменении возможно использование отдельного сегмента отката), а когда все изменения закончатся, происходит нечто подобное быстрой двухфазной фиксации отдельных, независимых транзакций. В связи с такой архитектурой при распараллеливании операторов ЯМД возникает ряд ограничений. Например, в ходе параллельного выполнения оператора ЯМД не поддерживаются триггеры. Это, по-моему, разумное ограничение, поскольку выполнение триггеров при изменении обычно существенно увеличивает использование ресурсов, а распараллеливание выполняется для максимального ускорения — это несовместимые действия. Кроме того, при распараллеливании операторов ЯМД не поддерживается ряд декларативных требований целостности ссылок, поскольку каждый фрагмент обрабатывается в отдельной транзакции, по сути — в отдельном сеансе. Не поддерживается, например, целостность ссылок объекта на самого себя. Представьте себе проблемы блокирования и взаимные блокировки, которые могли бы возникнуть при выполнении таких требований. С точки зрения производительности фрагментация обеспечивает две специализированные операции. • Игнорирование фрагмента. Некоторые фрагменты данных не просматриваются при обработке запроса. Пример игнорирования фрагмента был представлен ранее, когда мы отключили одно из табличных пространств и смогли, тем не менее, выполнить запрос. Отключенное табличное пространство при выполнении запроса было пропущено. • Параллельное выполнение операций. Распараллеливать можно соединения по фрагментам, если объекты фрагментированы по ключам соединения, или просмотр индексов. Как и в случае распараллеливания операторов ЯМД, не стоит ожидать от фрагментации существенного повышения производительности в среде ООТ. Игнорирование фрагмента эффективно при полном просмотре больших объектов. Пропуская фрагмент, можно избежать просмотра больших частей объекта. Именно за счет этого может повышаться производительность. В среде ООТ, однако, большие объекты полностью не просматриваются (если просматриваются — это серьезная ошибка проектирования). Даже если фрагментировать индексы, ускорение при просмотре меньшей части индекса будет незначительным (или его вообще не будет). Если часть запросов использует индекс и при поиске можно пропустить только один фрагмент индекса запросы после такой фрагментации могут выполняться медленнее, поскольку вместо одного большого индекса Фрагментация теперь надо просматривать 5, 10 или 20 маленьких. Более детально мы изучим это позже, при рассмотрении типов фрагментации индексов. Имеется возможность повысить эффективность работы системы ООТ с помощью фрагментации, например, повышая степень параллелизма за счет уменьшения количества конфликтов. Фрагментацию можно использовать для распределения изменений одной таблицы по нескольким физическим фрагментам. Вместо использования одного сегмента таблицы и одного сегмента индекса можно создать 20 фрагментов таблицы и 20 фрагментов индекса. Результат будет таким же, как при наличии 20 таблиц вместо одной, — конфликтов при изменениях этого разделяемого ресурса станет меньше. Что касается распараллеливания запросов, то оно, как я уже подчеркивал ранее, в среде ООТ нежелательно. Распараллеливание операций имеет смысл оставить администратору базы данных для пересоздания и создания индексов, анализа таблиц и т.п. Для запросов в системе ООТ обычно характерен очень быстрый доступом к данным по индексу, так что фрагментация не слишком ускорит этот доступ. Это не означает, что следует вообще отказаться от использования фрагментации в среде ООТ, просто не стоит ожидать существенного повышения производительности только за счет фрагментации объектов. Приложения в данном случае не могут использовать преимущества, которые могла бы дать фрагментация. В среде же хранилища данных/систем поддержки принятия решений (СППР) фрагментация не только существенно упрощает администрирование, но и позволяет ускорить работу. Предположим, имеется большая таблица, к которой надо выполнить запрос, анализирующий продажи по кварталам. Для каждого квартала имеются сотни тысяч записей, а общее количество записей измеряется миллионами. Итак, необходимо запросить сравнительно небольшой срез общего набора данных, но индексировать данные по кварталам нет смысла. Такой индекс будет ссылаться на сотни тысяч записей для каждого квартала, и просмотр индекса по диапазону при этом будет выполняться чрезвычайно медленно (подробнее об этом см. в главе 7, посвященной индексам). Итак, для выполнения большого количества запросов приходится полностью просматривать таблицу, но при этом просматриваются миллионы записей, большинство из которых не связаны с выполняемым запросом. Используя соответствующую схему фрагментации, можно разделить данные по кварталам таким образом, что при запросе данных за конкретный квартал полностью просматривать придется только один фрагмент. Это лучшее из всех возможных решений. Кроме того, в среде хранилищ данных/систем поддержки принятия решений часто используется распараллеливание запросов. Здесь операции типа параллельного просмотра индексов по диапазону или параллельный, быстрый полный просмотр индекса не только имеют смысл, но и дают преимущества. Мы хотим максимально использовать все имеющиеся ресурсы, и распараллеливание запросов позволяет этого добиться. Так что, в подобной среде фрагментация с большой долей вероятности ускорит выполнение запросов. Упорядочив преимущества фрагментации по степени важности, получим: 1. Увеличение доступности данных — хорошо для всех типов систем. 2. Упрощение администрирования больших объектов базы данных за счет замены их несколькими меньшими — хорошо для всех типов систем.

Глава 3. Повышение производительности некоторых операторов ЯМД и запросов — достигается, в основном, в среде больших хранилищ данных. 4. Уменьшение количества конфликтов в системах ООТ с большим количеством вставок (например, в таблицу записей аудита) за счет их распределения по нескольким отдельным фрагментам (распределение "горячей точки" по нескольким дискам).

Как выполняется фрагментация В этом разделе будут рассмотрены схемы фрагментации, предлагаемые сервером Oracle 8i. Имеется три схемы фрагментации для таблиц и две — для индексов. В рамках двух схем фрагментации индексов можно выделить несколько классов фрагментированных индексов. Мы рассмотрим преимущества и отличительные особенности каждого класса, а также разберемся, какие схемы фрагментации следует применять для различных типов приложений.

Схемы фрагментации таблиц В настоящее время сервер Oracle поддерживает три способа фрагментации таблиц. • Фрагментация по диапазону. Можно указать диапазоны значений данных, строки для которых должны храниться вместе. Например, все данные за январь 2001 года будут храниться в фрагменте 1, все данные за февраль 2001 года — в фрагменте 2 и т.д. Это, вероятно, самый популярный способ фрагментации в Oracle 8i.

• Фрагментация по хеш-функции. Такая схема уже использовалась в первом примере этой главы. К значению одного или нескольких столбцов применяется хешфункция, определяющая фрагмент, в который помещается строка. • Составная фрагментация. Это сочетание фрагментации по диапазону и по хешфункции. Можно сначала применить разбиение по диапазону значений данных, а затем выбрать в пределах диапазона фрагмент на основе значения хеш-функции. Следующий код и схемы наглядно демонстрируют применение этих способов фрагментации. Кроме того, операторы CREATE TABLE структурированы так, чтобы можно было понять синтаксис создания фрагментированной таблицы. Сначала рассмотрим таблицу, фрагментированную по диапазону: tkyte@TKYTE816> CREATE TABLE range_example 2 (range_key_column date, 3 data varchar2(20) 4) 5 PARTITION BY RANGE (range_key_column) 6 (PARTITION part_l VALUES LESS THAN 7 (to_date('01-jan-1995','dd-mon-yyyy')), 8 PARTITION part_2 VALUES LESS THAN 9 (to_date('01-jan-1996', 'dd-mon-yyyy')) Фрагментация 10 ) 11 / Table created.

Следующая схема показывает, что сервер Oracle проверяет столбец RANGE_KEY_COLUMN и в зависимости от его значения вставляет строку в один из фрагментов:

Интересно, что произойдет, если изменится значение столбца, определяющего, в какой фрагмент попадает строка. При этом надо учитывать два случая. • Изменение не перемещает строку в другой фрагмент;

строка принадлежит тому же фрагменту. Такое изменение возможно всегда. • Изменение вызывает перемещение строки в другой фрагмент. Такое изменение поддерживается, только если для таблицы включен перенос строк, иначе выдается сообщение об ошибке. Эту особенность легко продемонстрировать. Вставим строку во фрагмент PART_1 созданной ранее таблицы. Затем изменим значение столбца RANGE_KEY_COLUMN так, что строка останется во фрагменте PART_1, — это изменение будет успешно выполнено. Далее изменим значение столбца RANGE_KEY_COLUMN так, чтобы переместить строку во фрагмент PART_2. При этом будет выдано сообщение об ошибке, поскольку перенос строк явно включен не был. Наконец, изменим таблицу, разрешив перемещение строк, и продемонстрируем последствия этого изменения: tkyte@TKYTE816> i n s e r t i n t o range_exanple 2 values (to_date('01-jan-1994', 'dd-mon-yyyy'), 1 row c r e a t e d. tkyte@TKYTE816> update range_example 2 s e t range_key_column = range_key_column+l 3/ 1 row updated. Как и ожидалось, изменение успешно выполнено, ведь строка осталась во фрагменте PART_1. Затем посмотрим, что произойдет, если изменение вызывает перемещение строки: 'application data'), Глава tkyte@TKYTE816> update range_example 2 set range_key_column = range_key_column+366 3/ update range_example * ERROR at line 1: OBA-14402: updating partition key column would cause a partition change Сразу же выдается сообщение об ошибке. В Oracle 8.1.5 и более новых версиях можно включить поддержку переноса строк для таблицы, что позволит перемещать строку из одного фрагмента в другой. В версиях Oracle 8.0 это было невозможно;

приходилось удалять строку и повторно вставлять ее с измененными значениями. Следует, однако, помнить о побочном эффекте перемещения строк. Это — один из двух случаев, когда идентификатор строки (ROWID) изменяется при изменении данных (другой — изменение первичного ключа таблицы, организованной по индексу;

универсальный идентификатор для этой строки тоже изменится): tkyte@TKYTE816> select rowid from range_example 2/ ROWID AAAHeRAAGAAAAAKAAA tkyte@TKYTE816> alter table range_example enable row movement 2/ Table altered. tkyte@TKYTE816> update range_example 2 set range_key_column = range_key_column+366 3/ 1 row updated. tkyte@TKYTE816> select rowid from range_example 2/ ROWID AAAHeSAAGAAAABKAAA Итак, если учитывать изменение идентификатора строки при изменении значения ключа фрагментации, включение перемещения строк позволит изменять эти ключи. Следующий пример демонстрирует фрагментацию таблицы по хеш-функции. В этом случае сервер Oracle будет применять хеш-функцию к ключу фрагментации для определения того, в какой из N фрагментов надо поместить данные. Для наиболее равномерного распределения рекомендуется в качестве значения N использовать степени двойки (2, 4, 8, 16 и т.д.). Фрагментация по хеш-функции предназначена для равномерного распределения данных по нескольким устройствам (дискам). В качестве хеш-ключа для таблицы необходимо выбирать столбец или набор столбцов с как можно большим количеством уникальных значений — это обеспечивает равномерное распределение значений. Если выбрать столбец, имеющий всего четыре значения, и использовать два Фрагментация фрагмента, в результате хеширования все строки могут оказаться в одном фрагменте, что делает фрагментацию бессмысленной. Создадим таблицу, распределенную по хеш-функции на два фрагмента: tkyte@TKYTE816> CREATE 2 (hash_key_column 3 data 4) 5 PARTITION BY HASH 6 (partition part_l 7 partition part_2 8) 9/ Table created. Следующая схема показывает, что сервер Oracle применит хеш-функцию к столбцу HASH_KEY_COLUMN и, в зависимости от ее значения, вставит строку в один из двух фрагментов: TABLE hash_example date, varchar2(20) (hash_key_column) tablespace p1, tablespace p Теперь рассмотрим пример смешанной фрагментации, когда строки фрагментируются и по диапазону, и по хеш-функции. Здесь фрагментация по диапазону будет выполняться для одного набора столбцов, а фрагментация по хеш-функции — для другого. Вполне допустимо использовать одни и те же столбцы в обоих условиях фрагментации: tkyte@TKYTE816> CREATE TABLE composite_example 2 (range_key_column d a t e, 3 hash_key_column int, 4 data varchar2(20) 5) 6 PARTITION BY RANGE (range_key_column) 7 subpartition by hash(hash_key_column) subpartitions 2 8( 9 PARTITION part_l 10 VALUES LESS THAN(to_date('01-jan-1995','dd-mon-yyyy')) 11 (subpartition part_l_sub_1, 12 subpartition part_l_sub_ Глава 13 ), 14 PARTITION part_2 15 VALUES LESS THAN(to_date('01-jan-1996','dd-mon-yyyy')) 16 (subpartition part_2_sub_1, 17 subpartition part_2_sub_2 18 ) 19 ) 20 / Table created. При смешанной фрагментации сервер Oracle сначала применяет правила фрагментации по диапазону, чтобы понять, к какому диапазону относятся данные, а затем хеш-функцию, которая и определяет, в какой физический фрагмент попадет строка:

Фрагментация по диапазону используется, когда данные логически разделяются по значениям. Классический пример — данные, привязанные к периоду времени. Фрагментация по кварталам, по финансовым годам, по месяцам. Фрагментация по диапазону во многих случаях позволяет пропускать фрагменты, в том числе для условий строгого равенства и условий, задающих диапазоны: меньше, больше, в указанных пределах и т.д. Фрагментация по хеш-функции подходит для данных, в которых не удается выделить естественные диапазоны значений, подходящие для фрагментации. Предположим, необходимо загрузить в таблицу данные переписи населения — в них может и не быть атрибута, по которому имеет смысл разделять данные на диапазоны. Однако хотелось бы воспользоваться преимуществами, которые предоставляет фрагментация с точки зрения администрирования, производительности и доступности данных. Можно выбрать набор столбцов с уникальными значениями, по которым выполнять хеширование. Это позволит равномерно распределить данные по любому количеству фрагментов. Игнорирование фрагмента для объектов, разделенных по хеш-функции, возможно только для условий строгого равенства или IN (значение 1, значение2,...), но не для условий, задающих диапазоны значений. Составная фрагментация подходит, когда данные логически поделены на диапазоны, но получающиеся в результате фрагменты — слишком большие, чтобы ими можно Фрагментация было эффективно управлять. Можно разделить данные по диапазону, а затем разбить каждый фрагмент на несколько подфрагментов по хеш-функции. Это позволит распределить операции ввода-вывода по нескольким дискам для каждого большого фрагмента. Кроме того, теперь можно пропускать фрагменты на трех уровнях. Если запрос выполняется по ключу, использованному при фрагментации по диапазону, сервер может пропустить все фрагменты, не отвечающие критериям запроса. Если в запросе будет указан еще и ключ хеширования, сервер сможет пропустить другие подфрагменты в соответствующем диапазоне. Если в запросе используется только ключ хеш-функции (а ключ, по которому выполнена фрагментация по диапазону, не используется), сервер будет обращаться только к соответствующим подфрагментам в каждом диапазоне. Рекомендуется преимущественно использовать фрагментацию по диапазону, если данные вообще имеет смысл разбивать на диапазоны по каким-то атрибутам. Фрагментация по хеш-функции имеет множество преимуществ, но она не так эффективна с точки зрения возможностей игнорирования фрагментов. Использовать хеш-фрагментацию в пределах фрагментов по диапазону рекомендуется, когда соответствующие диапазонам фрагменты слишком велики для эффективного управления, или в тех случаях, когда желательно распараллеливать операторы ЯМД или иметь возможность параллельного просмотра индексов для отдельного фрагмента.

Фрагментация индексов Индексы, как и таблицы, можно фрагментировать. Существует два способа фрагментации индексов. • Можно фрагментировать индекс по тем же критериям, что и базовую таблицу. Такие индексы называют локально фрагментированными. Для каждого фрагмента таблицы будет создан соответствующий фрагмент индекса, индексирующий только этот фрагмент таблицы. Все записи в данном фрагменте индекса ссылаются на один фрагмент таблицы, а все строки фрагмента таблицы представлены в одном фрагменте индекса. • Можно фрагментировать индекс по диапазону. Такие индексы называют глобально фрагментированными. Индекс фрагментируется по диапазону, и один фрагмент индекса может ссылаться на любые (хоть все) фрагменты базовой таблицы. Следующие схемы показывают различие между локально и глобально фрагментированными индексами.

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

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

Фрагментация Оба типа индексов обеспечивают игнорирование фрагмента, оба могут поддерживать уникальность (если индекс без префикса включает ключ фрагментации) и т.д. Запрос, использующий локально фрагментированный индекс с префиксом, всегда позволяет пропускать фрагмент, а запрос, использующий локально фрагментированный индекс без префикса, может и не позволить это сделать. Вот почему утверждается, что локально фрагментированные индексы без префикса "медленнее";

они не гарантируют игнорирование фрагментов (хотя его и поддерживают). Кроме того, как будет продемонстрировано ниже, при выполнении некоторых операций оптимизатор будет обрабатывать локально фрагментированные индексы без префикса не так, как индексы с префиксом. В документации Oracle подчеркивается, что: локально фрагментированные индексы с префиксом обеспечивают более высокую производительность, чем индексы без префикса, потому что уменьшают количество проверяемых оптимизатором индексов Понимать это надо так: локально фрагментированные индексы обеспечивают более высокую производительность для. ЗАПРОСОВ, ссылающихся на весь входящий в них ключ фрагментации, по сравнению с ЗАПРОСАМИ, не ссылающимися на ключ фрагментации Локально фрагментированные индексы с префиксом, использующиеся для начального доступа к таблице в запросе, не имеют существенных преимуществ по сравнению с индексами без префикса. Я имею в виду, что, если выполнение запроса может начаться с просмотра индекса (SCAN AN INDEX), особой разницы между индексами с префиксом и без префикса нет. Позже, когда будет рассматриваться использование фрагментированных индексов в соединениях, вы увидите разницу между индексами с префиксом и без префикса. Для запроса, выполнение которого начинается с доступа по индексу, все зависит от условия, использованного в запросе. Продемонстрирую это на маленьком примере. Создадим таблицу PARTITIONED_TABLE и локально фрагментированный индекс с префиксом LOCAL_PREFIXED по ней. Кроме того, добавим локально фрагментированный индекс без префикса LOCAL_NONPREFIXED: tkyte@TKYTE816> CREATE TABLE partitioned_table 2 (a int, 3 b int 4) 5 PARTITION BY RANGE (a) 6( 7 PARTITION part_l VALUES LESS THAN(2), 8 PARTITION part_2 VALUES LESS THAN(3) 9) 10 / Table created. tkyte@TKYTE816> create index local_prefixed on partitioned_table (a,b) local;

Index created.

Глава tkyte@TKYTE816> create index local_nonprefixed on partitioned_table (b) local;

Index created. Теперь вставим данные в один фрагмент и пометим фрагменты индексов как не используемые (UNUSABLE): tkyte@TKYTE816> insert into partitioned_table values (1, 1);

1 row created. tkyte@TKYTE816> Index altered. tkyte@TKYTE816> a l t e r index local_nonprefixed modify partition part_2 unusable;

Index altered. Пометка этих фрагментов индекса как UNUSABLE предотвращает доступ к ним сервера Oracle. Все будет точно так же, как если бы произошел сбой носителя, — фрагменты недоступны. Теперь выполним запросы к таблице, чтобы разобраться, какие фрагменты индексов потребуются для разных запросов: tkyte@TKYTE816> set autotrace on explain tkyte@TKYTE816> select * from partitioned_table where a = 1 and b = 1;

А 1 Execution Plan 0 SELECT STATEMENT Qptimizer=CHOOSE (Cost=l Card=l Bytes=26) 1 0 INDEX (RANGE SCAN) OF 'LOCAL_PREFIXED' (NON-UNIQUE) (Cost=l Итак, запрос, использующий индекс LOCAL_PREFIX, успешно выполнен. Оптимизатор смог исключить фрагмент PART_2 индекса LOCAL_PREFIX из рассмотрения, поскольку в запросе задано условие А=1. Нам помогло игнорирование фрагмента. Для второго запроса: tkyte@TKYTE816> select * from partitioned_table where b = 1;

ERROR: ORA-01502: index 'TKYTE.LOCAL_NONPREFIXED' or partition of such index is in unusable state no rows selected Execution Plan 0 1 2 3 0 1 2 SELECT STATEMENT Optimizer=CHOOSE (Cost=l Card=2 Bytes=52) PARTITION RANGE (ALL) TABLE ACCESS (BY LOCAL INDEX ROWID) OF 'PARTITIONED_TABLE' INDEX (RANGE SCAN) OF 'LOCAL_NONPREFIXED' (NON-UNIQUE) В 1 alter index local_prefixed modify partition part_2 unusable;

Оптимизатор не смог исключить из рассмотрения фрагмент PART_2 индекса LOCAL_NONPREFIXED. С этим и связана проблема производительности при исполь Фрагментация зовании локально фрагментированных индексов без префикса. Они используются и для запросов, не включающих ключ фрагментации, в отличие от индексов с префиксом. Дело не в том, что индексы с префиксом лучше, просто они используются запросами, обеспечивающими возможность игнорирования фрагментов. Если удалить индекс LOCAL_PREFIXED и еще раз выполнить исходный, успешно выполненный запрос: tkyte@TKYTE816> s e l e c t * from p a r t i t i o n e d _ t a b l e where a = 1 and b = 1;

А 1 Execution Plan 0 1 2 SELECT STATEMENT Optimizer=CHOOSE (Cost=l Card=l Bytes=26) TABLE ACCESS (BY LOCAL INDEX ROWID) OF 'PARTITIONED_TABLE' INDEX (RANGE SCAN) OF 'LOCAL NONPREFIXED' (NON-UNIQUE) (Cost=l В 0 Этот результат может показаться удивительным. Почти такой же план выполнения, как и в случае неудавшегося запроса, но на этот раз все работает. Причина в том, что оптимизатор может пропускать фрагменты даже для локально фрагментированных индексов без префикса (в этом плане нет шага PARTITION RANGE(ALL)). Если к представленной выше таблице часто выполняются запросы вида: select... from partitioned_table where a = :a and b = :b;

select... from partitioned_table where b = :b;

имеет смысл создать локально фрагментированный индекс без префикса по столбцам (b,а);

он пригодится для обоих представленных выше запросов. Локально фрагментированный индекс с префиксом по столбцам (а,b) пригодится только для первого запроса. Однако при использовании фрагментированных индексов в соединениях результаты могут быть другими. В представленных выше примерах сервер Oracle по условию запроса мог во время оптимизации определить, можно или нельзя пропустить фрагменты. Это было понятно по условию в конструкции WHERE (даже если в нем использовались связываемые переменные). Когда доступ по индексу используется в качестве начального, основного метода доступа, особой разницы между локально фрагментированными индексами с префиксом и без префикса нет. При соединении с локально фрагментированным индексом, однако, все меняется. Рассмотрим следующую таблицу, фрагментированную по диапазону: tkyte@TKYTE816> CREATE TABLE range_example 2 (range_key_column date, 3 x int, 4 data varchar2(20) 5) 6 PARTITION BY RANGE (range_key_column) 7 (PARTITION part_l VALUES LESS THAN 8 (to_date('01-jan-1995', 'dd-mon-yyyy')), 9 PARTITION part_2 VALUES LESS THAN 10 (to_date('01-jan-1996','dd-mon-yyyy')) 11 ) Глава / Table created. tkyte@TKYTE816> alter table range_example 2 add constraint range_example_pk 3 primary key (range_key_column,x) 4 using index local 5/ Table altered. tkyte@TKYTE816> insert into range_example values (to_date('01-jan-1994'), 1, 'xxx');

1 row created. tkyte@TKYTE816> i n s e r t i n t o range_example values (to_date('01-jan-1995'), 2, 'xxx');

1 row c r e a t e d. Сначала по таблице создан локально фрагментированный индекс с префиксом для первичного ключа. Чтобы увидеть разницу между индексами с префиксом и без префикса, необходимо создать еще одну таблицу. Используем эту таблицу в качестве ведущей в запросе к таблице RANGE_EXAMPLE. Таблица TEST просто используется в качестве ведущей в запросе, который будет выполнять соединение вложенными циклами с таблицей RANGE_EXAMPLE: tkyte@TKYTE816> create table test (pk, range_key_column, x, 2 constraint test_pk primary key(pk)) 3 as 4 select rownum, range_key_column, x from range_example 5/ Table created. tkyte@TKYTE816> set autotrace on explain tkyte@TKYTE816> select * from test, range_example 2 where test.pk - 1 3 and test.range_key_column = range_example.range_key_column 4 and test.x = range_example.x 5/ PK 1 RANGE_KEY 01-JAN-94 X RANGE_KEY 1 01-JAN-94 X DATA 1 xxx Execution Plan 0 1 2 3 4 5 6 SELECT STATEMENT Optimizer=CHOOSE (Cost=2 Card=l Bytes=69) NESTED LOOPS (Cost=2 Card=l Bytes=69) TABLE ACCESS (BY INDEX ROWID) OF 'TEST' (Cost=l Card=l INDEX (RANGE SCAN) OF 'TEST_PK' (UNIQUE) (Cost=l Card=l) PARTITION RANGE (ITERATOR) TABLE ACCESS (BY LOCAL INDEX ROWID) OF 'RANGE_EXAMPLE' INDEX (UNIQUE SCAN) OF 'RANGE_EXAMPLE_PK' (UNIQUE) 0 1 2 1 4 Фрагментация Представленный выше план будет обрабатываться следующим образом. 1. С помощью индекса TEST_PK находим строки в таблице TEST, соответствующие условию test.pk = 1. 2. Обращаемся к таблице TEST для выборки значений остальных столбцов TEST — range_key_column и х. 3. По выбранным на предыдущем шаге значениям с помощью RANGE_EXAMPLE_PK находим единственный соответствующий фрагмент со строками таблицы RANGE_EXAMPLE. 4. Обращаемся к одному фрагменту таблицы RANGE_EXAMPLE для выбора значений столбца данных. Это кажется достаточно очевидным, но давайте посмотрим, что произойдет при изменении порядка следования столбцов range_key_column и х и превращении индекса в индекс без префикса: tkyte@TKYTE816> a l t e r t a b l e range_example 2 drop c o n s t r a i n t range_example_pk 3/ Table a l t e r e d. tkyte@TKYTE816> a l t e r t a b l e range_example 2 add constraint range_example_pk 3 primary key (x,range_key_column) 4 using index local 5/ Table altered. tkyte@TKYTE816> select * from test, range_example 2 where test.pk - 1 3 and test.range_key_column = range_example.range_key_column 4 and test.x = range_example.x 5/ PK RANGE_KEY 1 01-JAN-94 Execution Plan 0 1 2 3 4 5 SELECT STATEMENT Qptimizer=CHOOSE (Cost=2 Card=l Bytes=69) NESTED LOOPS (Cost=2 Card=l Bytes=69) TABLE ACCESS (BY INDEX ROWID) OF 'TEST' (Cost=l Card=l INDEX (RANGE SCAN) OF 'TEST_PK' (UNIQUE) (Cost=l Card=l) PARTITION RANGE (ITERATOR) TABLE ACCESS (FULL) OF 'RANGE_EXAMPLE' (Cost=l Card=164 X 1 RANGE_KEY 01-JAN-94 X DATA 1 xxx 0 1 2 1 Неожиданно оказывается, что с точки зрения сервера Oracle этот новый индекс слишком неэффективен. Это один из случаев, когда использование индекса с префиксом гораздо предпочтительнее.

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

Локально фрагментированные индексы и уникальность Для поддержки уникальности, задаваемой требованиями целостности UNIQUE или PRIMARY KEY, ключ фрагментации индекса должен входить в соответствующее требование. По-моему, это самая главная особенность локально фрагментированных индексов. Сервер Oracle обеспечивает уникальность только в пределах фрагмента индекса, но не среди нескольких фрагментов. Это означает, например, что нельзя фрагментировать данные по диапазону значений столбца TIMESTAMP и обеспечить поддержку первичного ключа по столбцу ID с помощью локально фрагментированного индекса. Сервер Oracle для обеспечения уникальности создаст один глобальный индекс. Например, если выполнить следующий оператор CREATE TABLE в схеме, где нет объектов (чтобы можно было легко понять, какие объекты созданы, просто запросив все сегменты данного пользователя), окажется: tkyte@TKYTE816> CREATE TABLE partitioned 2 (timestamp date, 3 id int primary key 4) 5 PARTITION BY RANGE (timestamp) 6( 7 PARTITION part_l VALUES LESS THAN 8 (to_date('Ol-jan-2000','dd-mon-yyyy')), 9 PARTITION part_2 VALUES LESS THAN 10 (to_date('01-jan-2001','dd-mon-yyyy')) 11 ) 12 / Table created. tkyte@TKYTE816> select segment_name, partition_name, segment_type 2 from user_segments;

SEGMENT_NAME PARTITIONED PARTITIONED SYS_C003582 PARTITION_NAME PART_2 PART_1 SEGMENT_TYPE TABLE PARTITION TABLE PARTITION INDEX Индекс SYS_C003582 — нефрагментированный, он и не мог таким оказаться. Это означает, что вы теряете ценные для хранилищ данных свойства фрагментации. Обыч Фрагментация ные действия с фрагментами в хранилищах данных больше нельзя будет выполнять независимо. Так, при добавлении нового фрагмента данных, придется пересоздавать весь глобальный индекс, а также изменять все действия с фрагментами. Сравните с таблицей, имеющей только локально фрагментированные индексы — их не нужно пересоздавать, если только не затрагивается соответствующий фрагмент. Если попытаться обмануть сервер Oracle, воспользовавшись тем, что требование первичного ключа может обеспечиваться и неуникальным индексом, окажется, что это тоже не помогает: tkyte@TKYTE816> CREATE TABLE p a r t i t i o n e d 2 (timestamp date, 3 id int 4) 5 PARTITION BY RANGE (timestamp) 6( 7 PARTITION part_l VALUES LESS THAN 8 (to_date('Ol-jan-2000','dd-mon-yyyy')), 9 PARTITION part_2 VALUES LESS THAN 10 (to_date('01-jan-2001','dd-mon-yyyy')) 11 ) 12 / Table c r e a t e d. tkyte@TKYTE816> c r e a t e index partitioned_index 2 on partitioned(id) 3 LOCAL 4/ Index created. tkyte@TKYTE816> s e l e c t segment_name, partition_name, 2 from user_segments;

SEGMENT_NAME PARTITIONED PARTITIONED PARTITIONED_INDEX PARTITIONED_INDEX PARTITION_NAME PART_2 PART_1 PART_2 PART_1 SEGMENT_TYPE TABLE TABLE INDEX INDEX PARTITION PARTITION PARTITION PARTITION segment_type tkyte@TKYTE816> a l t e r t a b l e p a r t i t i o n e d 2 add constraint partitioned_pk. 3 primary key(id) 4/ alter table partitioned E R R at line 1: RO ORA-01408: such column list already indexed Здесь сервер Oracle попытался создать глобальный индекс по столбцу ID, но обнаружил, что не может этого сделать, потому что индекс уже существует. Представленные выше операторы сработали бы, если бы был создан нефрагментированный индекс (сервер Oracle просто использовал бы его для выполнения требования).

Глава Если ключ фрагментации не входит в условие, обеспечить уникальность нельзя по двум причинам. Во-первых, если бы сервер Oracle это разрешал, то были бы сведены на нет преимущества фрагментации. Доступность и масштабируемость были бы потеряны, поскольку требовался бы просмотр всех фрагментов и доступ к ним при любой вставке или изменении данных. Чем больше фрагментов, тем менее доступны данные. Чем больше фрагментов в таблице, тем больше фрагментов индекса приходится просматривать и тем менее масштабируемой становится схема фрагментации. То есть фрагментация ухудшит оба показателя. Кроме того, серверу Oracle пришлось бы последовательно выполнять вставки и изменения этой таблицы на уровне транзакций. Дело в том, что при добавлении строки со значением ID=1 во фрагмент PART_1, серверу пришлось бы предотвращать вставку строки со значением ID=1 другими сеансами во фрагмент PART_2. Единственный способ добиться этого — запретить изменять фрагмент PART_2, поскольку другого метода заблокировать этот фрагмент просто нет. В системе ООТ для обеспечения целостности данных требования уникальности должны обеспечиваться системой (сервером Oracle). Это означает, что логическая модель данных будет влиять на физическую. Необходимость поддерживать уникальность либо будет определять схему фрагментации, диктуя выбор ключей фрагментации, либо наличие этих требований приведет к необходимости использования глобально фрагментированных индексов. Рассмотрим глобально фрагментированные индексы более подробно.

Глобально фрагментированные индексы Глобально фрагментированные индексы разбиваются на фрагменты не так, как базовая таблица. Таблица может быть разбита по значению столбца TIMESTAMP на десять фрагментов, а глобально фрагментированный индекс по этой таблице может быть разбит на пять фрагментов по значению столбца REGION. В отличие от локально фрагментированных, есть только один класс глобально фрагментированных индексов — с префиксом. Глобально фрагментированные индексы, ключ которых не начинается с ключа фрагментации, не поддерживаются. Продолжая предыдущий пример, ниже я представлю простой вариант использования глобально фрагментированного индекса. Вы убедитесь, что глобально фрагментированный индекс обеспечивает уникальность первичного ключа, так что можно использовать фрагментированные индексы, обеспечивающие уникальность, но не включающие ключ фрагментации базовой таблицы. В следующем примере создается таблица, фрагментированная по столбцу TIMESTAMP, индекс которой фрагментирован по столбцу ID: tkyte@TKYTE816> CREATE TABLE partitioned 2 (timestamp date, 3 id int 4) 5 PARTITION BY RANGE (timestamp) 6( 7 PARTITION part_l VALUES LESS THAN 8 (to_date('01-jan-2000','dd-mon-yyyy')), Фрагментация 9 PARTITION part_2 VALUES LESS THAN 10 (to_date('01-jan-2001','dd-mon-yyyy')) 11 ) 12 / Table created. tkyte@TKYTE816> create index partitioned_index 2 on partitioned(id) 3 GLOBAL 4 partition by range(id) 5( 6 partition part_l values less than(lOOO), 7 partition part_2 values less than (MAXVALUE) 8) 9/ Index created. Обратите внимание на использование в этом индексе значения MAXVALUE. Значение MAXVALUE можно использовать в таблицах или индексах, фрагментированных по диапазону. Оно представляет максимально возможное значение. До сих пор в примерах использовались жесткие верхние границы диапазонов (значения, меньшие чем Определенное значение>). Однако для глобально фрагментированного индекса требуется, чтобы фрагмент с наибольшими значениями (последний фрагмент) имел верхний предел MAXVALUE. Это гарантирует, что все строки базовой таблицы можно будет проиндексировать. Добавим для таблицы первичный ключ: tkyte@TKYTE816> alter table partitioned add constraint 2 partitioned_pk 3 primary key(id) 4/ Table altered. Пока еще не очевидно, что сервер Oracle использует для поддержки первичного ключа созданный индекс. Доказать это можно с помощью "волшебного" запроса к словарю данных. Этот запрос необходимо выполнять от имени учетной записи, имеющей привилегию SELECT на базовые таблицы словаря данных или привилегию SELECT ANY TABLE: tkyte@TKYTE816> select t.name table_name 2, u.name owner 3, c.name constraint_name 4, i.name index_name 5, decode(bitand(i.flags, 4), 4, 'Yes', 6 decode(i.name, c.name, 'Possibly', 'No')) generated 7 from sys.cdef$ cd 8, sys.con$ с 9, sys.obj$ t 10, sys.obj$ i 11, sys.user$ u 12 where cd.type# between 2 and 3 13 and cd.con# = c.con# Глава 14 15 16 17 18 / and and and and cd.obj# = t.obj# cd.enabled = i.obj# c.owner# = u.user# c.owner# = uid OWNER CONSTRAINT_NAME INDEX_NAME GENERATE TABLE_NAME PARTITIONED TKYTE PARTITIONED_PK PARTITIONED_INDEX No Запрос показывает, какой индекс использовался для поддержки данного требования, и пытается "угадать", сгенерировано ли имя индекса автоматически или задано явно. В данном случае он показывает, что для поддержки первичного ключа используется только что созданный индекс PARTITIONED_INDEX (имя которого не было сгенерировано автоматически). Чтобы показать, что сервер Oracle не позволит создать глобальный индекс без префикса, достаточно попробовать: tkyte@TKYTE816> create index partitioned_index2 2 on partitioned(timestamp,id) 3 GLOBAL 4 partition by range(id) 5( 6 partition part_l values less than(1000), 7 partition part_2 values less than(MAXVALUE) 8) 9/ partition by range(id) * ERROR at line 4: ORA-14038: GLOBAL partitioned index must be prefixed Сообщение об ошибке весьма красноречиво. Глобально фрагментированный индекс должен быть с префиксом. Итак, когда же надо использовать глобально фрагментированный индекс? Рассмотрим два типа систем — хранилища данных и системы ООТ — и выясним, когда эти индексы могут пригодиться.

Хранилища данных и глобально фрагментированные индексы Я считаю, что эти две вещи несовместимы. Хранилища данных предполагают определенные особенности;

добавляются и удаляются большие объемы данных, высока вероятность сбоя на каком-нибудь из дисков и т.д. В любом хранилище данных, использующем перемещающееся окно, лучше избегать использования глобально фрагментированных индексов. Вот пример того, что я имею в виду под перемещающимся окном, и как на его использование влияет глобально фрагментированный индекс: tkyte@TKYTE816> CREATE TABLE partitioned 2 (timestamp date, 3 id int 4) 5 PARTITION BY RANGE (timestamp) 6( Фрагментация 7 8 9 10 11 12 13 PARTITION fy_1999 VALUES LESS THAN (to_date('01-jan-2000','dd-mon-yyyy')), PARTITION fy_2000 VALUES LESS THAN (to_date('Ol-jan-2001','dd-mon-yyyy')), PARTITION the_rest VALUES LESS THAN (maxvalue) ) / Table created. tkyte@TKYTE816> insert into partitioned partition(fy_1999) 2 select to_date('31-dec-1999')-mod(rownum,360), object_id 3 from all_objects 4/ 21914 rows created. tkyte@TKYTE816> insert into partitioned partition(fy_2000) 2 select to_date('31-dec-2000')-mod(rownum,360), object_id 3 from all_objects 4/ 21914 rows created. tkyte@TKYTE816> create index partitioned_idx_local 2 on partitioned(id) 3 LOCAL 4/ Index created. tkyte@TKYTE816> create index partitioned_idx_global 2 on partitioned (timestamp) 3 GLOBAL 4/ Index created. Итак, мы создали таблицу "хранилища данных". Данные фрагментированы по финансовому году;

оперативно доступны данные за последние два года. По этой таблице создано два фрагментированных индекса;

один — как LOCAL, а другой — как GLOBAL. Обратите внимание, что я оставил пустой фрагмент, THE_REST, в конце таблицы. Это поможет быстро добавлять новые данные. Предположим, очередной финансовый год закончился, и необходимо сделать следующее. 1. Удалить данные за самый давний финансовый год. Эти данные не теряются, они просто считаются устаревшими и архивируются. 2. Добавить данные за последний финансовый год. Для их загрузки, преобразования, индексирования и т.д. потребуется определенное время. Хотелось бы, чтобы эти действия не влияли на доступность остальных данных. Итак, можно выполнить следующее: tkyte@TKYTE816> create table fy_1999 (timestamp date, id int);

Table created.

Глава tkyte@TKYTE816> create index fy_1999_idx on fy_1999(id) 2/ Index created. tkyte@TKYTE816> create table fy_2001 (timestamp date, id int);

Table created. tkyte@TKYTE816> insert into fy_2001 2 select to_date('31-dec-2001')-mod( rownum,360), object_id 3 from all_objects 4/ 21922 rows created. tkyte@TKYTE816> create index fy_2001_idx on fy_2001(id) nologging 2/ Index created. Здесь я создал новую пустую таблицу-"оболочку" и индекс для самых старых данных. Преобразуем текущий полный фрагмент в пустой и создадим "полную" таблицу с данными фрагмента FY_1999. Кроме того, я заранее выполнил все необходимые действия по подготовке данных для фрагмента FY_2001. Речь идет о проверке достоверности данных, преобразовании и любых других сложных действиях по их подготовке. Теперь все готово для изменения "актуальных" данных: tkyte@TKYTE816> alter table partitioned 2 exchange partition fy_1999 3 with table fy_1999 4 including indexes 5 without validation 6/ Table altered. tkyte@TKYTE816> alter table partitioned 2 drop partition fy_1999 3/ Table altered. Вот и все, что необходимо сделать для удаления "устаревших" данных. Мы превратили фрагмент в отдельную целую таблицу, а пустую таблицу — во фрагмент. Это было просто изменение словаря данных, никаких больших объемов ввода-вывода. Теперь можно экспортировать эту таблицу (возможно, с помощью перемещаемого табличного пространства) из базы данных с целью архивирования. При необходимости ее очень легко присоединить снова. Теперь добавим новые данные: tkyte@TKYTE816> alter table partitioned 2 split partition the_rest 3 at (to_date('01-jan-2002','dd-mon-yyyy')) 4 into (partition fy_2001, partition the_rest) 5/ Table altered.

Фрагментация tkyte@TKYTE816> a l t e r t a b l e p a r t i t i o n e d 2 exchange partition fy_2001 3 with table fy_2001 4 including indexes 5 without validation 6/ Table altered. Изменение словаря данных было выполнено моментально. Отделение пустого фрагмента требует очень мало времени, поскольку данных там никогда не было и не будет. Вот зачем я поместил пустой фрагмент в конец таблицы, — чтобы упросить отделение. Затем вновь созданный пустой фрагмент заменяется всей таблицей, а таблица — пустым фрагментом. Новые данные оперативно доступны. Однако, если посмотреть на индексы, оказывается: tkyte@TKYTE816> s e l e c t index_name, INDEX_NAME STATUS s t a t u s from user_indexes;

FY_1999_IDX VALID FY_2001_IDX VALID PARTITIONED_IDX_GLOBAL UNUSABLE PARTITIONED_IDX_LOCAL N/A Глобально фрагментированный индекс после этих действий, несомненно, недоступен. Поскольку каждый фрагмент индекса может указывать на фрагмент таблицы, и мы удалили один фрагмент, и добавили другой, индекс некорректен. В нем есть записи, ссылающиеся на удаленный фрагмент. В нем нет записей, ссылающихся на добавленный фрагмент. Запрос, использующий этот индекс, не будет выполнен: tkyte@TKYTE816> select count(*) 2 from partitioned 3 where timestamp between sysdate-50 and sysdate;

select count(*) * ERROR at line 1: ORA-01502: index 'TKYTE.PARTITIONED_IDX_GLOBAL' or p a r t i t i o n of such index is in unusable s t a t e Можно установить параметр SKIP_UNUSABLE_INDEXES=TRUE, но тогда мы теряем повышение производительности, которое обеспечивал индекс (это работает в Oracle 8.1.5 и более поздних версиях;

до этого оператор SELECT все равно пытался бы использовать индекс, помеченный как UNUSABLE). Этот индекс надо пересоздать, чтобы снова обеспечить возможность использования данных. Процесс перемещения окна, который до сих пор происходил без задержек, теперь будет выполняться очень долго, пока не будет пересоздан глобальный индекс. Придется просмотреть все данные и полностью пересоздать индекс по данным таблицы. Если таблица имеет размер в сотни гигабайт, для этого потребуются существенные ресурсы. Любая операция с фрагментом таблицы сделает невозможным использование глобально фрагментированного индекса. Если необходимо перенести фрагмент на другой диск, все глобально фрагментированные индексы надо пересоздавать (для локально фрагмен Глава тированных индексов достаточно пересоздать только соответствующие фрагменты). Если окажется, что необходимо разделить фрагмент на два меньших, все глобально фрагментированные индексы придется пересоздавать (для локально фрагментированных индексов достаточно пересоздать только соответствующие пары фрагментов). И так далее. Поэтому надо избегать использования глобально фрагментированных индексов в среде хранилища данных. Их использование может негативно повлиять на многие действия.

Системы ООТ и глобально фрагментированные индексы Система ООТ характеризуется частым выполнением множества небольших транзакций, читающих и изменяющих данные. Обычно беспокоиться о поддержке перемещающихся окон данных не приходится. Прежде всего необходимо обеспечить быстрый доступ к строкам. Целостность данных — жизненно важна. Доступность данных также имеет большое значение. Глобально фрагментированные индексы имеет смысл использовать в системах ООТ. Данные таблицы могут быть фрагментированы только по одному ключу, по одному набору столбцов. Однако могут понадобиться различные способы доступа к данным. Можно фрагментировать данные в таблице EMPLOYEE по местонахождению офиса. Однако при этом необходимо также обеспечить быстрый доступ к данным по следующим столбцам. • DEPARTMENT. Отделы географически разнесены, и однозначного соответствия между отделом и его местонахождением нет. • EMPLOYEE_ID. Хотя идентификатор сотрудника определяет его местонахождение, не хотелось бы искать данные по EMPLOYEE_ID и LOCATION, поскольку при этом не удастся обеспечить игнорирование фрагментов индекса. Кроме того, значения столбца EMPLOYEE_ID сами по себе должны быть уникальны.

• JOB_TITLE. Необходимо обращаться к данным таблицы EMPLOYEE по многим различным ключам, из разных частей приложения, причем, скорость доступа является основным требованием. В хранилище данных мы просто использовали бы локально фрагментированные индексы по перечисленным выше ключам и параллельный просмотр диапазонов по индексам для быстрого доступа к данным. Там не нужно было бы использовать игнорирование фрагментов, но в системе ООТ, однако, это необходимо. Распараллеливание запроса в таких системах неприемлемо — надо предоставить соответствующие индексы. Поэтому необходимо использовать глобально фрагментированные индексы по некоторым полям. Итак, необходимо достичь следующих целей: • быстрый доступ;

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

• доступность данных. В системе ООТ этого позволяют добиться глобально фрагментированные индексы, поскольку характеристики этой системы существенно отличаются от хранилища данных. Не будут использоваться перемещающиеся окна, не придется делить фрагменты (разве Фрагментация что в период запланированного простоя), не нужно переносить данные из одного табличного пространства в другое и т.д. Действия, типичные для хранилищ данных, обычно не выполняются в системе оперативной обработки транзакций. Вот небольшой пример, показывающий, как добиться трех перечисленных выше целей с помощью глобально фрагментированных индексов. Я собираюсь использовать простые глобальные индексы из одного фрагмента, но результаты будут такими же и для глобально фрагментированных индексов (разве что возрастет доступность и управляемость при добавлении фрагментов): tkyte@TKYTE816> create table emp 2 (EMPNO NUMBER(4) NOT NOLL, 3 ENAME VARCHAR2(10), 4 JOB VARCHAR2(9), 5 MGR NUMBER(4), 6 HIREDATE DATE, 7 SAL NUMBER(7,2), 8 COMM NUMBER(7,2), 9 DEPTNO NUMBER(2) NOT NULL, 10 LOC VARCHAR2 (13) NOT NULL 11 ) 12 partition by range(loc) 13 ( 14 partition p1 values less than('C') tablespace p1, 15 partition p2 values less than('D') tablespace p2, 16 partition p3 values less than('N') tablespace p3, 17 partition p4 values less than('Z') tablespace p4 18 ) 19 / Table created. tkyte@TKYTE816> alter table emp add constraint emp_pk 2 primary key(empno) 3/ Table altered. tkyte@TKYTE816> create index emp_job_idx on emp(job) 2 GLOBAL 3/ Index created. tkyte@TKYTE816> create index emp_dept_idx on emp(deptno) 2 GLOBAL 3/ Index created. tkyte@TKYTE816> insert into emp 2 select e.*, d.loc 3 from scott.emp e, scott.dept d 4 where e.deptno = d.deptno 5/ 14 rows created.

Глава Итак, мы начинаем с таблицы, фрагментированной по местонахождению, LOC, в соответствии с нашими правилами. Существует глобальный уникальный индекс по столбцу EMPNO как побочный эффект выполнения оператора ALTER TABLE ADD CONSTRAINT. Это показывает, что можно обеспечить целостность данных. Кроме того, мы добавили еще два глобальных индекса по столбцам DEPTNO и JOB для ускорения доступа к строкам по этим атрибутам. Теперь добавим в таблицу немного данных и посмотрим, что оказалось в каждом из фрагментов: tkyte@TKYTE816> select empno,job,loc from emp partition(p1);

no rows selected tkyte@TKYTE816> select empno,job,loc from emp partition(p2);

EMPNO JOB 7900 CLERK 7844 SALESMAN 7698 MANAGER 7654 SALESMAN 7521 SALESMAN 7499 SALESMAN 6 rows selected. EMPNO 7902 7876 7788 7566 JOB ANALYST CLERK ANALYST MANAGER LOC CHICAGO CHICAGO CHICAGO CHICAGO CHICAGO CHICAGO tkyte@TKYTE816> select empno,job,loc from emp partition(p3);

LOC DALLAS DALLAS DALLAS DALLAS DALLAS LOC 7369 CLERK EMPNO JOB tkyte@TKYTE816> select empno,job,loc from emp partition(p4);

7934 CLERK NEW YORK 7839 PRESIDENT NEW YORK 7782 MANAGER NEW YORK Этот пример показывает распределение данных по фрагментам в соответствии с местонахождением сотрудника. Теперь можно выполнить несколько запросов для оценки производительности: tkyte@TKYTE816> select empno,job,loc from emp where empno = 7782;

EMPNO JOB 7782 MANAGER Execution Plan 0 1 2 SELECT STATEMENT Optimizer=CHOOSE (Cost=1 Card=4 Bytes=108) TABLE ACCESS (BY GLOBAL INDEX ROWID) OF 'EMP' (Cost=l Card INDEX (RANGE SCAN) OF 'EMP_PK' (UNIQUE) (Cost=l Card=4) LOC NEW YORK 0 Фрагментация tkyte@TKYTE816> select empno,job,loc from emp where job = 'CLERK';

EMPNO JOB 7900 7876 7369 7934 CLERK CLERK CLERK CLERK LOC CHICAGO DALLAS DALLAS NEW YORK Execution Plan 0 1 2 SELECT STATEMENT Optimizer=CHOOSE (Cost=l Card=4 Bytes=108) TABLE ACCESS (BY GLOBAL INDEX ROWID) OF 'EMP' (Cost=l Card INDEX (RANGE SCAN) OF 'EMP_JOB_IDX' (NON-UNIQUE) (Cost=l 0 Созданные индексы используются для обеспечения высокоскоростного доступа к данным в системе ООТ. Если бы они были фрагментированы, то должны были бы включать префикс, что позволило бы игнорировать фрагменты индекса;

Pages:     | 1 |   ...   | 11 | 12 || 14 | 15 |   ...   | 24 |



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

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