WWW.DISSERS.RU

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

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

Pages:     | 1 |   ...   | 8 | 9 || 11 | 12 |   ...   | 24 |

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

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

16 / PL/SQL procedure successfully completed tkyte@TKYTE816> select a.event, 2 (a.total_waits-nvl(b.total_waits,0)) total_waits, 3 (a.time_waited-nvl(b.time_waited,O)) time_waited 4 from (select * 5 from v$session_event 6 where sid = (select sid from v$mystat where rownum = 1)) a, 7 sess_event b 8 where a.event = b.event(+) 9 and (a.total waits-nvl(b.total_waits,0)) > 0 10 / EVENT SQL*Net message from client SQL*Net message to client log file sync TOTAL_WAITS 4 5 5 TIME_WAITED 14 0 В этом небольшом тесте мы создаем уникальный оператор INSERT, который будет выглядеть примерно так:

insert into t values (12323, 12323, 12323, 12323);

insert into t values (632425, 632425, 632425, 632425);

Представленные выше результаты получены в однопользовательском режиме. Если выполнить это одновременно в двух сеансах, увидим примерно такой отчет о времени ожидания:

EVENT SQL*Net message from client SQL*Net message to client enqueue latch free log file sync TOTAL_WAITS 4 5 2 142 2 TIME_WAITED 18 0 0 235 Стратегии и средства настройки Как видите, сеанс много раз ждал освобождения защелки (причем суммарное время ожидания — достаточно большое). Кроме того, наблюдалось ожидание следующих событий: • SQL*Net message from client. Сервер ждал, пока клиент пошлет ему сообщение. В данном случае клиент — SQL*Plus. В большинстве случаев ожидание этого события можно игнорировать, но если при выполнении приложения предполагаются длительные раздумья пользователя, это число неизбежно будет большим. В нашем случае сеанс SQL*Plus постоянно выдавал операторы на сервер, поэтому время ожидания должно быть небольшим. Если бы оно было большим, проблема была бы связана с клиентом (узким местом был бы клиент, неспособный достаточно часто обращаться к базе данных). • SQL*Net message to client. Сколько времени потребовалось на передачу сообщений с сервера клиенту (SQL*Plus).

• Enqueue. Ожидание той или иной блокировки. • Log file sync. Время ожидания сброса буфера журнала повторного выполнения на диск процессом LGWR при фиксации. Все события, которых может ожидать сервер, описаны в руководстве "Oracle8i Reference Manual" в приложении "Oracle Wait Events". В этом руководстве содержатся подробные описания всех событий, которые можно увидеть в представлении V$SESSION_EVENT. На ожидание события освобождения защелки в данном случае надо обратить внимание. Эта защелка предотвращала одновременный доступ к разделяемой области SQL. Я предполагал это ожидание с учетом характеристик выполнявшейся транзакции. Другие запросы к представлениям V$ могут подтвердить это (далее мы рассмотрим представления V$ более детально). Поскольку теперь два сеанса выполняют "жесткий разбор" (анализируют запрос, никогда ранее не обрабатывавшийся), появляются конфликты доступа к разделяемой области SQL. Двум сеансам надо изменить общую структуру данных, и делать это они могут только поочередно. В следующей таблице показано количество ожиданий освобождения защелки для 1, 2, 3, 4 и 5 сеансов, одновременно выполняющих представленную выше транзакцию: 1 пользователь Количество ожиданий Время (секунд) 0 0 2 пользователя 102 1.56 3 пользователя 267 5.92 4 пользователя 385 10.72 5 пользователей 542 16. Учтите, что в таблице представлена информация для одного сеанса: каждому сеансу пришлось ждать столько раз и такое суммарное количество времени. В случае двух пользователей ждать пришлось три секунды, трех — около 18, четырех — около 40 и т.д. В какой-то момент при добавлении дополнительных пользователей ожидать мы будем Глава дольше, чем работать. Чем больше добавляется пользователей, тем дольше приходится ждать, и эти ожидания могут оказаться настолько продолжительными, что добавление пользователей не только замедлит ответы на запросы, но и снизит общую пропускную способность сервера в целом. Как это исправить? Просто переписать блок кода с использованием связываемых переменных, например, так:

tkyte@TKYTE816> declare 2 l_number number;

3 begin 4 for i in 1.. 10000 5 loop 6 l_number := dbms_random.random;

7 8 execute immediate 9 'insert into t values (:xl, :x2, :x3, :x4)' 10 using l_number, l_number, l_number, l_number;

11 end loop;

12 commit;

13 end;

14 / PL/SQL procedure successfully completed.

Если собираетесь выполнять этот пример в Oracle 8.1.5, см. информацию об ошибках на Web-сайте издательства Wrox, http://www.wrox.com. Там можно узнать, что нужно сначала вызвать процедуру dbms_random.initialize. Кроме того, для установки пакета dbms_random в Oracle 8i вплоть до версии 8.1.6, необходимо от имени пользователя SYS выполнить сценарий catoctk.sql, который находится в каталоге $ORACLE_HOME/rdbms/admin. В этом случае мы видим заметное улучшение: 1 пользователь Количество ожиданий Время (секунд) 0 0 2 пользователя 47 (46%) 0.74 (47%) 3 пользователя 65 (25%) 1.29 (21%) 4 пользователя 89 (23%) 2.12 (19%) 5 пользователей 113 (20%) 3.0 (17%) Это существенное улучшение, но можно сделать еще лучше. При двух пользователях общее количество ожиданий освобождения защелок в обшей области SQL сократилось до 46 процентов исходного значения, как и время ожидания. При добавлении пользователей ситуация еще улучшается. В случае пяти пользователей количество ожиданий сократилось на 80 процентов, и суммарное время ожиданий составило лишь 17 процентов исходного времени. Однако я утверждаю, что можно пойти еще дальше. В представленном выше примере мы избегали жесткого разбора, но постоянно выполняли "мягкий разбор". На каждой итерации цикла необходимо искать оператор INSERT в разделяемом пуле и прове Стратегии и средства настройки рять, можно ли его использовать. Представленный выше подход на базе оператора EXECUTE IMMEDIATE можно описать так:

loop разобрать связать выполнить закрыть end;

А лучше было бы так:

разобрать loop связать выполнить end;

закрыть;

В нашем случае для этого можно использовать статический SQL в PL/SQL-блоке либо пакет DBMS_SQL, позволяющий процедурно формировать и выполнять SQL-операторы (примеры и особенности использования пакета DBMS_SQL представлены в главе 16). Я буду использовать статический SQL со связываемыми переменными следующим образом:

tkyte@TKYTE816> declare 2 l_number number;

3 begin 4 for i in 1.. 10000 5 loop 6 l_number := dbms_random.random;

7 8 insert into t 9 values(l_number, l_number, l_number, l_number);

10 end loop;

11 commit;

12 end;

13 / PL/SQL procedure successfully completed.

PL/SQL будет автоматически кэшировать курсор — это одно из основных преимуществ PL/SQL. Оператор вставки обычно будет разобран только один раз на сеанс, если он помещен в хранимую процедуру. Он будет разобран один раз при выполнении блока, если помещен в анонимный блок. Теперь можно снова выполнить тестирование: 1 пользователь Количество ожиданий Время (секунд) 0 0 2 пользователя 1 0 3 пользователя 1 0.01 4 пользователя 0. 5 пользователей 7 0. Глава Время ожидания освобождения защелок крайне мало — им просто можно пренебречь. Рассмотренный пример показывает, почему: • использование связываемых переменных определяет производительность;

• важно избегать лишних мягких разборов запроса. Сокращение количества мягких разборов оператора SQL в некоторых случаях, как показано выше, дает даже больше, чем использование связываемых переменных. Не торопитесь закрывать курсор: если его можно будет использовать повторно, расходы ресурсов на поддержку курсора в открытом состоянии в ходе выполнения программы с лихвой покрываются повышением производительности. В Oracle 8.1.6 добавлена новая возможность: совместное использование курсора — CURSOR_SHARING. Совместное использование курсора — это своего рода автоматическая подстановка связываемых переменных. Сервер вынужден переформулировать поступающий запрос так, чтобы в нем использовались связываемые переменные, прежде чем разбирать его. В результате, запрос вида:

scott@TKYTE816> select * from emp where ename = 'KING';

будет автоматически преобразован в вид:

select * from агор where ename =:SYS_B_ или, в версиях 8.1.6 и 8.1. select * from emp where ename =:"SYS_B_0" Это шаг в правильном направлении, но нельзя использовать этот параметр как окончательное и долговременное решение проблемы. Использование CURSOR_SHARING имеет побочные эффекты, о которых надо помнить. Производительность плохо написанной программы может существенно увеличиться при установке CURSOR_SHARING= FORCE, но работать она все равно будет медленнее, чем могла бы, да и масштабируемость будет ограничена. Как было показано выше, количество и время ожиданий можно значительно сократить за счет использования связываемых переменных. Того же результата можно добиться с помощью установки CURSOR_SHARING=FORCE. Однако пока не предотвращены избыточные мягкие разборы операторов, от всех ожиданий избавиться нельзя. Совместное использование курсоров не избавляет от лишних мягких разборов. Если установка параметра CURSOR_SHARING дает существенный результат, значит, вы требуете от сервера Oracle слишком часто разбирать большое количество запросов. Если требуется частый разбор большого количества запросов, то установка CURSOR_SHARING решит проблему связываемых переменных, но не устранит дополнительный расход ресурсов на повторный мягкий разбор. Хотя и не так очевидно, как отсутствие связываемых переменных, большое количество мягких разборов тоже ограничивает производительность и масштабируемость. Единственное решение — использовать связываемые переменные и по возможности использовать курсоры повторно. Например, если бы я создавал программу на Java, я никогда не написал такой фрагмент:

Стратегии и средства настройки String getWordb(int ID, int IDLang, Connection conn) throws SQLException { CallableStatement stmt = null;

stmt = conn.prepareCall("{ call get.wordb (?,?,?)}");

stmt.setInt(l,ID);

stmt.setlnt(2,IDLang);

stmt.registerOutParameter (3, Java.sql.Types.VARCHAR);

stmt.execute();

String word = stmt.getstring (3) ;

stmt.close() ;

return word;

} Я бы написал так:

CallableStatement stmt = null;

String getWordbfint ID, int IDLang, Connection conn) throws SQLException { if (stmt — null) { stmt = conn.prepareCall("{call get.wordb (?,?,?))");

stmt.registerOutParameter (3, Java.sql.Types.VARCHAR);

} stmt.setlnt(1,ID);

stmt.setlnt(2,IDLang);

s tmt.execute();

return stmt.getstring (3);

} Здесь я гарантирую использование связываемых переменных, подставляя символызаместители в оператор. Кроме того, я разбираю оператор не более одного раза при каждом выполнении программы. Это дает огромный выигрыш в производительности. В ходе одного тестирования я вызвал "плохую" и "хорошую" реализацию по 1000 раз. Плохая реализация, в которой мягкий разбор выполнялся при каждом обращении, работала две с половиной секунды. Хорошая реализация работала одну секунду. Это в однопользовательском режиме. Как вы уже знаете, при добавлении дополнительных пользователей, каждый из которых выполняет тысячи мягких разборов, работа существенно замедлится за счет ожидания снятия защелок в ходе мягкого разбора. Этих дополнительных расходов можно и нужно избегать в создаваемых приложениях. Теперь ненадолго вернемся к параметру CURSOR_SHARING. Я уже говорил, что имеются побочные эффекты использования параметра CURSOR_SHARING, о которых надо знать. Их можно разбить на следующие категории: • Проблемы оптимизатора. При установке CURSOR_SHARING из запроса удаляются все символьные строки и числовые константы;

у оптимизатора остается меньше информации для работы. Это может привести к совершенно другим планам выполнения запросов.

Глава • Проблемы с результатами выполнения запросов. Длина извлекаемых столбцов может неожиданно измениться. Запросы, обычно возвращавшие данные типа VARCHAR2(5) и NUMBER(2), могут теперь возвращать VARCHAR2(30) и NUMBER(5). Фактический размер возвращаемых данных не изменится, но приложение будет получать информацию о том, что столбец может содержать строки длиной до 30 байт, а это может повлиять на отчеты и создающие их приложения. • Сложности в оценке планов выполнения запросов. Они возникнут из-за того, что EXPLAIN PLAN будет "видеть" не такой запрос, как поступает в базу данных. Это усложняет настройку производительности запросов. Средства типа AUTOTRACE в SQL*Plus становятся ненадежными источниками информации при установке параметра CURSOR_SHARING. Мы подробно рассмотрим каждую из этих проблем, но сначала давайте поговорим о проблемах оптимизатора. Они непосредственно влияют на производительность приложения. Рассмотрим следующий простой пример, в котором выполняется запрос, содержащий как связываемые переменные, так и строковые константы. Производительность этого запроса до установки параметра CURSOR_SHARING — отличная. Производительность после включения параметра CURSOR_SHARING — ужасная. Причина падения производительности в том, что оптимизатор теперь имеет намного меньше информации, необходимой ему для работы. По строковым константам оптимизатор мог определить, что один индекс будет более избирателен по сравнению с другим. При удалении всех констант оптимизатор не может прийти к такому выводу. Подобная проблема — не редкость для многих приложений. В большинстве приложений в операторах SQL используются и связываемые переменные, и константы. Не использовать связываемые переменные — это ужасно, но использовать связываемые переменные всегда — немногим лучше. Вот какую таблицу надо создать для данного примера: tkyte@TKYTE816> create table t as 2 s e l e c t * from all_objects;

Table created. tkyte@TKYTE816> create index t_idx1 on t(OBJECT_NAME) ;

Index created. tkyte@TKYTE816> create index t_idx2 on t(OBJECT_TYPE);

Index created. tkyte@TKYTE816> analyze table t compute s t a t i s t i c s 2 for all indexed columns 3 for table;

Table analyzed. По таблице имеется два индекса. Индекс по столбцу OBJECT_TYPE используется для выполнения представленного ниже запроса. Индекс по столбцу OBJECT_NAME интенсивно используется другим приложением. Оба эти индекса необходимы. Мы будем выполнять к таблице следующий запрос:

Стратегии и средства настройки select from where and * t object_name like :search_str object_type i n ('FUNCTION', 'PROCEDURE', 'TRIGGER');

Этот запрос создавался для заполнения выпадающего списка в приложении. Пользователь выбирает из списка процедуру, функцию или триггер для редактирования. Запрос выполняется тысячи раз в день. Если посмотреть на реальные данные в таблице:

tkyte@TKYTE816> compute sum of cnt on report tkyte@TKYTE816> break on report tkyte@TKYTE816> select object_type, count(*) cnt from t group by 2 object_type;

OBJECT_TYPE CONSUMER GROUP CONTEXT DIRECTORY FUNCTION INDEX INDEXTYPE JAVA CLASS JAVA DATA JAVA RESOURCE JAVA SOURCE LIBRARY CNT 2 4 1 27 301 LOB OPERATOR PACKAGE PACKAGE BODY PROCEDURE SEQUENCE SYNONYM TABLE TRIGGER TYPE TYPE BODY UNDEFINED VIEW 288 69 4 33 3 15 229 212 24 292 7 137 12 1340 24 rows selected.

то окажется, что конструкция IN вернет 58 строк, а количество строк, возвращаемых конструкцией LIKE, определить заранее нельзя (их может быть сколько угодно — от О до 21782). Если выполнить в SQL*Plus запрос следующего вида:

tkyte@TKYTE816> variable search_str varchar2(25) tkyte@TKYTE816> exec :search_str := '%';

PL/SQL procedure successfully completed.

Глава tkyte@TKYTE816> set autotrace traceonly tkyte@TKYTE816> select * from t tl where object_name like :search_str 2 and object_type in('FUNCTION', 'PROCEDURE', 'TRIGGER');

58 rows selected. Execution Plan 0 1 2 3 SELECT STATEMENT Optimizer=CHOOSE (Cost=5 Card=3 Bytes=291) INLIST ITERATOR TABLE ACCESS (BY INDEX ROWID) OF 'T' (Cost=5 Card=3 Bytes=291) INDEX (RANGE SCAN) OF 'T_IDX2' (NON-UNIQUE) (Cost=2 Card=3) 0 1 Statistics 222 0 45 3 0 6930 762 5 1 0 58 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 то с учетом того, что мы знаем о распределении данных, кажется очевидным, что оптимизатор должен использовать индекс по столбцу OBJECT_TYPE для выборки 58 строк из 21000, а затем применять к этим строкам конструкцию LIKE. Это показывает, что иногда использование констант оправдано. В данном случае использовать связываемую переменную не стоит — лучше указать константу. При этом оптимизатор сможет определить, что запрос будет выполняться быстрее при использовании конкретного индекса. Если же сделать так:

tkyte@TKYTE816> alter session set cursor_sharing = force;

Session altered. tkyte@TKYTE816> select * from t t2 where object_name like :search_str 2 and object_type in('FUNCTION', 'PROCEDURE', 'TRIGGER');

58 rows selected. Execution Plan 0 1 2 3 SELECT STATEMENT Optimizer=CHOOSE (Cost=5 Card=3 Bytes=291) INLIST ITERATOR TABLE ACCESS (BY INDEX ROWID) OF 'T' (Cost=5 Card=3 Bytes=291) INDEX (RANGE SCAN) OF 'T_IDX2' (NON-UNIQUE) (Cost=2 Card=3) 0 1 Стратегии и средства настройки statistics О О 19256 169 0 7480 762 5 2 0 58 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 то, хотя выдаваемый план выполнения запроса якобы не изменился (AUTOTRACE показывает точно такой же план), различие в количестве consistent gets (логических чтений) получается существенное, так что явно что-то изменилось. Сервер фактически выполняет запрос:

select * from t t2 where object_name like :search_str and object_type in( :SYS_B_0,:SYS_B_l, :SYS_B_2 ) и уже не может определить, сколько строк он будет выбирать через индекс по столбцу OBJECT_TYPE. Этот пример также показывает, как установка параметра CURSOR_SHARING затрудняет настройку. Выдаваемый утилитой SQL*Plus план запроса заставляет думать, что считывается индекс T_IDX2, но если посмотреть на количество consistent gets (логических чтений), окажется, что их выполнено 19256. Первый запрос, действительно использующий индекс T_IDX2, обработал 45 блоков. В данном случае установка autotrace выдает нам некорректный план. Утилита SQL*Plus не знает, какой запрос в действительности выполняется. Я включил трассировку SQL_TRACE (подробнее об этом — в следующем разделе), и теперь для двух запросов можно четко увидеть различие:

select * from t tl where object_name like :search_str and object_type in('FUNCTION', 'PROCEDURE', 'TRIGGER') call Parse Execute Fetch total Rows 58 58 61 count cpu 0.00 0.00 0.01 0.01 elapsed 0.00 0.00 0.09 0.09 disk query current rows 1 1 5 0 0 14 0 0 34 0 0 0 0 0 58 Row Source Operation INLIST ITERATOR TABLE ACCESS BY INDEX ROWID T INDEX RANGE SCAN (object id 25244) call Глава select * from t t2 where object_name like :search_str and object_type in(:SYS_B_O,:SYS_B_1, :SYS_B_2) count cpu elapsed 0.00 0.00 0.15 0.15 0.00 0.00 1.77 1.77 disk query current rows Parse Execute Fetch total Rows 58 1 1 5 0 0 255 0 19256 0 0 0 0 0 58 Row Source Operation TABLE ACCESS BY INDEX ROWID T INDEX RANGE SCAN (object id 25243) Средства SQL_TRACE и TKPROF могут показать, что происходит на самом деле. Второй запрос был выполнен с использованием другого индекса (идентификатор объекта — другой), что в данном случае не оптимально. Наш запрос выполняется в 15-20 раз дольше и обрабатывает огромный объем данных. Эта проблема ненужных связываемых переменных будет проявляться во многих приложениях, намеренно использующих как связываемые переменные, так и константы. Без дополнительной информации, обеспечиваемой константами в запросе, оптимизатор может принять неверное решение. Только при корректном использовании связываемых переменных, где только возможно, и констант — там, где это обязательно, можно достичь сбалансированности. Установка CURSOR_SHARING — временное решение, с которого можно начать, но по изложенным выше причинам оно не может быть долговременным. Параметр CURSOR_SHARING на только сбивает с толку оптимизатор, как было показано выше, он может повлиять и на другие средства Oracle. Например, в главе 7 описывалось такое средство как индексы по функции. По сути, в Oracle можно создать индекс по функции. Используя пример из той главы, где индекс создавался следующим образом:

tkyte@TKYTE816> create index test_soundex_idx on 2 test_soundex(substr(my_soundex(name),1,6)) 3/ Index created.

можно выяснить, что установка параметра CURSOR_SHARING не позволит для выполнения запроса tkyte@TKYTE816> s e l e c t name 2 from test_soundex С 3 where substr(my_soundex(name),1,6) = ray_soundex('FILE$') 4/ использовать этот индекс, поскольку литералы 1 и 6 будут заменены связываемыми переменными. В данном случае можно решить эту проблему, "спрятав" константы в представлении, но ее все равно надо учитывать. Не будет ли других "неожиданных" отличий?

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

tkyte@TKYTE816> declare 2 l_theCursor integer default dbms_sql.open_cursor;

3 l_descTbl dbms_sql.desc_tab;

4 l_colCnt number;

5 begin 6 execute immediate 'alter session set cursor_sharing=exact';

7 dbms_output.put_line('Without Cursor Sharing:');

8 f or i in 1.. 2 9 loop 10 dbms_sql.parse( l_theCursor, 11 'select substr(object_name, 1, 5) cl, 12 55 c2, 13 ''Hello" c3 14 from all_objects t'||i, 15 dbms_sql.native);

16 17 dbms_sql.describe_columns(l_theCursor, 18 l_colCnt, l_descTbl);

19 20 for i in 1.. l_colCnt loop 21 dbms_output.put_line('Column ' || 22 l_descTbl(i).col_name || 23 ' has a length of ' || 24 l_descTbl(i).col_max_len);

25 end loop;

26 execute immediate 'alter session set cursor_sharing=force';

27 dbms_output.put_line('With Cursor Sharing:');

28 end loop;

29 30 dbms_sql.close_cursor(l_theCursor);

31 execute immediate 'alter session set cursor_sharing=exact';

32 end;

33 / Without Cursor Sharing: Column Cl has a length of 5 Column C2 has a length of 2 Column C3 has a length of 5 With Cursor Sharing: Column Cl has a length of 30 Column C2 has a length of 22 Column C3 has a length of 32 PL/SQL procedure successfully completed.

Глава Размер первого столбца с 5 байт вырос до 30, потому что функция SUBSTR(OBJECT_ NAME, 1, 5) была переписана как SUBSTR(OBJECT_NAME, :SYS_B_0, :SYS_B_l) Сервер "не знает", что функция может вернуть максимум 5 байт, поэтому теперь возвращается значение 30 (длина поля OBJECT_NAME). Длина второго столбца выросла с 2 до 22 байт, потому что сервер больше "не знает", что будет возвращено значение 55 — известно только, что будет возвращаться число, а длина числа может составлять до 22 байт. Для последнего столбца выдано стандартное значение — если бы строка HELLO была больше, то и стандартное значение оказалось бы больше (например, если бы использовалась 35-байтовая строка, стандартное значение составляло бы 128 байт). Можно возразить: "Ну, длина возвращаемых данных не изменится, изменится только значение длины, выдаваемое сервером по запросу описания результирующего множества...". Проблемы возникнут во всех сценариях SQL*Plus, во всех отчетах, создаваемых с помощью различных инструментальных средств, и вообще во всех приложениях, запрашивающих у сервера характеристики результирующего множества для соответствующего форматирования столбцов. Результаты, выдаваемые этими приложениями, при установке параметра CURSOR_SHARING изменятся;

форматирование тщательно подготовленных отчетов во многих случаях окажется неадекватным. Только подумайте, как это может повлиять на множество уже существующих приложений! Этот побочный эффект очень легко продемонстрировать:

tkyte@TKYTE816> select substr(object_name,1,2) 2 from all_objects tl 3 where rownum = 1 4 / SU /1 tkyte@TKYTE816> alter session set cursor_sharing = force;

Session altered. tkyte@TKYTE816> select substr(object_name,1,2) 2 from all_objects t2 3 where rownum = 1 4 / SUBSTR(OBJECT_NAME,1,2) / Утилита SQL*Plus перешла от столбца из 2 символов к столбцу из 30. Это, несомненно, повлияет на ранее успешно работавшие отчеты.

Используются ли связываемые переменные?

Когда я спрашиваю: "Используете ли вы связываемые переменные?", в ответ получаю вопрос: "А как узнать, используются ли связываемые переменные?". К счастью, выяснить это весьма просто;

вся необходимая информация находится в разделяемом пуле.

Стратегии и средства настройки Я создал сценарий, который часто использую (и распространяю), для выявления операторов, которые совпадали бы при использовании связываемых переменных. Чтобы показать, как работает этот сценарий, я искусственно заполнил разделяемый пул операторами SQL, не использующими связываемых переменных:

tkyte@TKYTE816> create table t (x int) ;

Table created. tkyte@TKYTE816> begin 2 for i in 1.. 100 3 loop 4 execute immediate 'insert into t values (' || i || ' ) ' ;

5 end loop;

6 end;

7/ PL/SQL procedure successfully completed.

Теперь можно демонстрировать сценарий. Он начинается с создания функции, удаляющей константы из строк. Она будет преобразовывать SQL-операторы вида:

insert into t values ('hello', 55);

insert into t values ('world', 66);

в такой вид:

insert into t values ('#', @) ;

Все операторы, которые могли бы совпасть при использовании связываемых переменных, теперь легко выявить: оба представленных выше уникальных оператора INSERT после подстановки станут одинаковыми. Такое преобразование позволяет выполнить следующая функция:

tkyte@TKYTE816> create or replace 2 function remove_constants(p_query in varchar2) 3 return varchar2 4 as 5 l_query long;

6 l_char varchar2 (1) ;

7 l_in_quotes boolean default FALSE;

8 begin 9 for i in 1.. length(p_query) 10 loop 11 l_char := substr(p_query,i,l);

12 if (l_char = '''' and l_in_quotes) 13 then 14 l_in_quotes := FALSE;

15 elsif (l_char = " " and NOT l_in_quotes) 16 then 17 l_in_quotes := TRUE;

18 l_query := l_query || '''#';

19 end if;

20 if ( NOT l_in_quotes ) then 21 l_query := l_query || l_char;

22 23 24 25 26 27 28 29 30 Глава 10 end if;

end loop;

l_query := translate(l_query, '0123456789', '@@@@@@@@@@');

for i in 0.. 8 loop l_query := replace(l_query, lpad('@',10-i,'@'), '@');

l_query := replace (l_query, lpad(' ',10-i, ' ' ) / ' ' ) ;

end loop;

return upper(l_query);

end;

/ Function created.

Для основного кода сценария мы сделаем копию представления V$SQLAREA — запросы к этому представлению выполняются долго, поэтому хотелось бы обращаться к нему только один раз. Мы копируем его во временную таблицу, чтобы можно было работать с соответствующими данными:

tkyte@TKYTE816> create global temporary table sql_area_tmp 2 on commit preserve rows 3 as 4 select sql_text, sql_text sql_text_wo_constants 5 from v$sqlarea 6 where 1=0 7/ Table created. tkyte@TKYTE816> insert into sql_area_tmp (sql_text) 2 select sql_text from v$sqlarea 3/ 436 rows created. Пройдем по всем строкам этой таблицы и определим преобразованный SQL_TEXT, из которого удалены все константы:

tkyte@TKYTE816> update sql_area_tmp 2 set sql_text_wo_constants = remove constants(sql_text);

3/ 436 rows updated.

Теперь все готово для выявления "плохих" операторов SQL:

tkyte@TKYTE816> select sql_text_wo_constants, count(*) 2 from sql_area_tmp 3 group by sql_text_wo_constants 4 having count(*) > 10 5 order by 2 6/ SQL_TEXT_WO_CONSTANTS INSERT INTO T VALUES ( 6 ) COUNT(*) Стратегии и средства настройки Итак, в разделяемом пуле имеется 100 операторов INSERT, отличающихся только одним числовым полем в конструкции VALUES. Это почти наверняка означает, что ктото забыл использовать связываемые переменные. Бывают вполне оправданные случаи наличия нескольких экземпляров SQL-оператора в разделяемом пуле (например, в базе данных может быть пять разных таблиц с именем Т). Выяснив, что разумной причины, объясняющей наличие нескольких экземпляров одного и того же оператора, нет, необходимо найти соответствующего разработчика, научить его, как делать правильно, и заставить исправить операторы. Я считаю это ошибкой в программе, а не вполне допустимым приемом, а ошибка должна быть исправлена. Итак, в этом разделе мы обсуждали важность использования связываемых переменных в приложении, а также необходимость свести к минимуму количество разборов запросов. Было описано новое средство — параметр инициализации CURSOR_SHARING, который мог показаться панацеей при решении этих проблем, но оказалось, что все не так просто. Установка параметра CURSOR_SHARING может использоваться как временное, промежуточное решение определенных проблем производительности приложения, но достичь максимальной производительности и масштабируемости можно только за счет правильной реализации приложений. Я не знаю, как еще подчеркнуть этот момент. Приходилось видеть множество систем, потерпевших неудачу из-за того, что их создатели не учитывали представленных выше фактов. Как я уже писал в самом начале книги, если бы мне пришлось писать книгу о том, как создавать немасштабируемые и медленно работающие приложения для СУБД Oracle, она содержала бы всего одну главу, где было бы сказано: "не используйте связываемые переменные". Использование связываемых переменных и правильных приемов разбора операторов еще не гарантирует масштабируемость, но если их не использовать, то ее точно не будет.

SQL_TRACE, TIMED_STATISTICS и TKPROF SQL_TRACE, TIMED_STATISTICS и TKPROF- мои самые любимые инструментальные средства. Я использовал их множество раз для выявления причин неудовлетворительной производительности системы. Во всех этих случаях приходилось настраивать системы, которые я не создавал, поэтому и не знал, где искать. Эти установки и средства дают необходимую информацию для начала работы. Если коротко, параметр SQL_TRACE включает регистрацию всех операторов SQL, выполняемых приложением, информации о производительности, полученной в ходе выполнения этих операторов SQL, и фактически использованных планов выполнения операторов. Как было показано в предыдущем разделе, посвященном параметру CURSOR_SHARING, AUTOTRACE показывает неверный план, а вот параметр SQL_TRACE и утилита TKPROF показывают именно тот план, который реально использован. TIMED_STATISTICS — это параметр, при установке которого сервер регистрирует продолжительность выполнения каждого шага. Наконец, TKPROF — это простая программа, используемая для преобразования файла трассировки в более удобочитаемый вид. В этом разделе я продемонстрирую, как использовать установку SQL_TRACE и утилиту TKPROF, и попытаюсь разъяснить значение содержимого ис Глава пользуемых ими файлов. Я не столько буду описывать, как настроить конкретный запрос, сколько покажу, как с помощью этих средств найти запросы, требующие настройки. Более подробную информацию о настройке отдельных запросов можно найти в руководстве Oracle8i Designing and Tuning for Performance Manual. Там описаны различные способы доступа к данным, использование подсказок оптимизатору для настройки запросов и т.д. Параметр TIMED_STATISTICS управляет тем, будет ли сервер Oracle собирать информацию о времени выполнения различных действий в базе данных. Он может иметь одно из двух значений: TRUE или FALSE. Эта возможность настолько полезна, что я часто оставляю значение TRUE, даже когда не занимаюсь настройкой — влияние этого значения на производительность СУБД, как правило, незначительно (была проблема в Oracle 8.1.5, где совместное использование операторов SQL не всегда обеспечивалось, если параметр TIMED_STATISTICS имел значение TRUE). Значение этого параметра можно устанавливать как на уровне системы, так и на уровне сеанса, а также глобально, в файле параметров инициализации экземпляра. Достаточно просто добавить в файл INIT.ORA для экземпляра строку:

timed_statistics=true и при следующем перезапуске СУБД этот параметр будет включен. Для установки его на уровне сеанса выполните следующую команду:

tkyte@TKYTE816> Session altered. alter session set timed_statistics=true;

А для включения учета времени во всей системе:

tkyte@TKYTE816> System altered. alter system set timed_statistics=true;

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

Организация трассировки Параметр SQL_TRACE также можно устанавливать на уровне системы или сеанса. При его установке генерируется так много данных и работа системы так замедляется, что включать ею лучше избирательно (редко или вообще никогда его не устанавливают для системы в файле init.ora). Параметр SQL_TRACE тоже может иметь одно из двух значений, TRUE или FALSE. Если установлено значение TRUE, в каталоге, задаваемом параметром USER_DUMP_DEST файла init.ora при подключении к выделенному серверу или BACKGROUND_DUMP_DEST — при подключении к многопотоковому (MTS) серверу, будут генерироваться трассировочные файлы. Я, однако, не рекомендую использовать SQL_TRACE при подключении в режиме MTS, поскольку результаты запросов сеанса будут записываться в различные трассировочные файлы при пере Стратегии и средства настройки ходе сеанса с одного разделяемого сервера на другой. При подключении в режиме MTS интерпретация результатов SQL_TRACE практически невозможна. Еще один важный параметр в файле init.ora — MAX_DUMP_FILE_SIZE. Он ограничивает максимальный размер генерируемого сервером трассировочного файла. Если обнаружится, что трассировочные файлы — усеченные, увеличьте значение этого параметра. Это можно сделать с помощью оператора ALTER SYSTEM или ALTER SESSION. Параметр MAX_DUMP_FILE_SIZE можно задать тремя способами. • Числовое значение параметра MAX_DUMP_FILE_SIZE задает максимальный размер в блоках файловой системы. • Число, за которым следует суффикс К или М, задает размер в килобайтах или мегабайтах, соответственно. • Строка UNLIMITED означает, что ограничения на размер трассировочных файлов нет — они могут иметь любой размер, допускаемый операционной системой. Я не рекомендую устанавливать значение UNLIMITED — так можно заполнить всю файловую систему;

значения в диапазоне от 50 до 100 Мбайт обычно более чем достаточно. Как включить параметр SQL_TRACE? Чаще всего я использую следующие способы. • ALTER SESSION SET SQL_TRACE=TRUE|FALSE. Выполнение этого оператора SQL позволит включить стандартный режим трассировки SQL_TRACE в текущем сеансе. Этот оператор наиболее полезен в интерактивной среде типа SQL*Plus или при встраивании в приложение, так чтобы из приложения можно было при необходимости включать и отключать трассировку. Возможность просто включать и отключать SQL_TRACE средствами приложения — будь-то опция командной строки, пункт меню или параметр конфигурации — полезна в любом приложении.

• SYS.DBMS_SYSTEM.SET_SQL_TRACE_IN_SESSION. Эта процедура позволяет устанавливать и сбрасывать трассировку для любого существующего сеанса. Для этого необходимо указать лишь параметры SID и SERIAL# соответствующего сеанса — их можно получить из представления динамической производительности V$SESSION. • ALTER SESSION SET EVENTS. Можно установить событие, обеспечивающее трассировку с большим объемом регистрируемой информации, чем обычно получается при установке ALTER SESSION SET SQL_TRACE=TRUE. Прием с использованием SET EVENTS не описан в документации и не поддерживается Oracle Corporation, но его существование общеизвестно (обратитесь на сайт http:// www.google.com/ и поищите по запросу alter session set events 10046: вы увидите, на скольких сайтах эта возможность описана). С помощью этого события можно не только получить всю информацию, выдаваемую при установке SQL_TRACE, но и значения связываемых переменных в SQL-операторах, а также информацию о том, какие события ожидаются (что замедляет работу) при выполнении этих SQL-операторов.

Глава Есть и другие методы, но именно эти три чаще всего я встречаю и использую сам. Методы установки SQL_TRACE оператором ALTER SESSION SET SQL_TRACE и вызовом SYS.DBMS_SYSTEM — очень просты и очевидны. Использование события несколько менее тривиально. При этом используется внутренний (и не отраженный в документации) механизм событий сервера Oracle. Если коротко, используются следующие команды:

alter session set events '10046 trace name context forever, level ';

alter session set events '10046 trace name context o f f ;

где N может иметь одно из следующих значений: N=1. Включает стандартные средства SQL_TRACE. Результат не отличается от установки SQL_TRACE=true. N=4. Включает стандартные средства SQL_TRACE и добавляет в трассировочный файл значения связываемых переменных. N=8. Включает стандартные средства SQL_TRACE и добавляет в трассировочный файл информацию об ожидании событий на уровне запросов. N=12. Включает стандартные средства SQL_TRACE и добавляет как значения связываемых переменных, так и информацию об ожидании событий. Использование средств пакета DBMS_SUPPORT — еще один метод установки трассировки с отображением значений связываемых переменных и информации об ожиданиях событий. Для получения пакета DBMS_SUPPORT надо связаться со службой поддержки Oracle Support, поскольку он не входит в обычно поставляемый набор инструментальных средств. Так как это всего лишь интерфейс к представленной выше команде ALTER SYSTEM SET EVENTS, ее использование может оказаться проще. Теперь, когда известно, как включить SQL_TRACE, возникает вопрос, как это средство лучше использовать? Лично я предпочитаю добавлять в свои приложения опцию, которую можно задать в командной строке или в адресе URL (если это Web-приложение), для включения трассировки. Это позволяет получать информацию SQL_TRACE для одного сеанса. Многие средства разработки Oracle тоже позволяют это сделать. Например, при использовании Oracle Forms, можно вызывать форму с параметром:

С:\> ifrun60 module=myform userid=scott/tiger statistics=yes STATISTICS=YES - это флаг, требующий выполнить команду ALTER SESSION SET SQL_TRACE=TRUE. Если бы подобные средства предоставляли все приложения, их настройка упростилась бы. Можно было бы попросить пользователя, столкнувшегося с проблемой производительности, включить трассировку и затем воспроизвести проблему. В результате можно получить всю информацию, необходимую для выяснения причин медленной работы. Не придется спрашивать, что именно делается, чтобы воспроизвести проблему самостоятельно, — достаточно будет попросить ее воспроизвести и затем проанализировать результаты трассировки. Если в трассировочном файле имеются значения связываемых переменных и информация об ожидавшихся событиях, то данных более чем достаточно для выяснения того, что же работает не так.

Стратегии и средства настройки Как обеспечить трассировку, если приходится работать с приложением стороннего производителя или с существующим приложением, не поддерживающим включение SQL_TRACE? Я использую два подхода. Один из них подходит для клиент-серверного приложения, постоянно подключенного к базе данных. Достаточно запустить приложение и подключиться к базе данных. Затем, выполнив запрос к представлению V$SESSION, можно определить параметры SID и SERIAL# соответствующего сеанса. Теперь можно вызвать SYS.DBMS_SYSTEM.SET_SQL_TRACE_IN_SESSION для включения трассировки указанного сеанса. Сегодня, однако, популярны Web-приложения, для которых этот метод не подходит. Сеансы при этом очень короткие, и они часто начинаются и завершаются. Необходимо установить средство SQL_TRACE для пользователя — при каждом подключении этого пользователя необходимо устанавливать SQL_TRACE для соответствующего сеанса. К счастью, это можно сделать с помощью триггера базы данных на событие LOGON. Например, в Oracle 8i я часто использую следующий триггер (триггеры на события базы данных, такие как AFTER LOGON, — новое средство, поддерживаемое в Oracle 8.1.5 и последующих версиях):

create or replace trigger logon_trigger after logon on database begin if (user = 'TKYTE') then execute immediate 'ALTER SESSION SET EVENTS ''10046 TRACE NAME CONTEXT FOREVER, LEVEL 4' ";

end if;

end;

/ Он обеспечивает включение трассировки при каждом подключении к базе данных. Приложение не надо менять для установки SQL_TRACE — мы это сделаем сами.

Использование и интерпретация результатов работы утилиты TKPROF TKPROF — это средство командной строки для преобразования трассировочного файла в более удобочитаемый вид. Это прекрасная утилита, к сожалению, недостаточно часто используемая. Я считаю, что это связано с тем, что о ее существовании просто не знают. Теперь, когда вы о ней знаете, я думаю, вы будете использовать ее постоянно. В этом разделе я выполню запрос с включенной трассировкой. Затем мы детально рассмотрим соответствующий отчет TKPROF и выясним, на что надо обращать внимание в подобных отчетах:

tkyte@TKYTE816> show parameter timed_statistics;

NAME timed_statistics TYPE boolean VALUE TRUE tkyte@TKYTE816> alter session set sql_trace=true;

Глава Session altered. tkyte@TKYTE816> select owner, count(*) 2 from all_objects 3 group by owner;

OWNER COUNT(*) CTXSYS DBSNMP DEMO DEMO11 MDSYS MV_USER ORDPLUGINS ORDSYS PUBLIC SCOTT SEAPARK SYS SYSTEM TKYTE TYPES 15 rows selected. tkyte@TKYTE816> select 2 from v$process 3 where a.addr = 4 and b.audsid 5 / SPID 1124 a.spid a, v$session b b.paddr = userenv('sessionid') 185 4 5 3 176 5 26 206 9796 18 3 11279 51 32 Здесь я проверил, что установлен параметр TIMED_STATISTICS (без этого устанавливать SQL_TRACE практически бесполезно), а затем включил SQL_TRACE. Затем я выполнил запрос, который необходимо проанализировать. Наконец, я выполнил запрос для получения идентификатора серверного процесса (SPID — server process ID) — он потребуется для идентификации соответствующего трассировочного файла. После выполнения этого запроса я завершил сеанс SQL*Plus и перешел в каталог на сервере, заданный в качестве значения параметра USER_DUMP_DEST в файле init.ora. Значение этого параметра можно получить по ходу сеанса с помощью запроса к представлению V$PARAMETER или утилиты DBMS_UTILITY (для этого не нужен доступ к представлению V$PARAMETER):

tkyte@TKYTE816> declare 2 l_intval number;

3 l_strval varchar2(2000) ;

4 l_type number;

5 begin 6 l_type := dbms_utility.get_parameter_value 7 ('user_dump_dest', l_intval, l_strval);

Стратегии и средства настройки 8 dbms_output.put_line(l_strval);

9 end;

10 / С:\oracle\admin\tkyte816\udump PL/SQL procedure successfully completed.

В этом каталоге я обнаружил следующее:

С:\oracle\ADMIN\tkyte816\udump>dir Volume in drive C has no label. Volume Serial Number is F4S5-B3C3 Directory 03/16/2001 03/16/2001 03/16/2001 03/16/2001 03/16/2001 of C:\oracle\ADMIN\tkyte816\udump

5,114 ORA00860.TRC 3,630 ORA01112.TRC 6,183 ORA01124.TRC 14,927 bytes File(s) Dir(s) 13,383,999,488 bytes free 02:55р 02:55р 08:45а 02:52р 02:53р 3 Несколько трассировочных файлов — вот теперь и пригодится значение SPID. Трассировочный файл моего сеанса — ORA01124.TRC. Я знаю это, потому что значение SPID — часть имени файла. В ОС UNIX используется похожий принцип именования, т.е. в имя файла тоже входит значение SPID. Одна из проблем, связанных с трассировочными файлами, состоит в том, что они могут быть недоступны для чтения пользователям, не входящим в группу администраторов Oracle (например, в группу dba в ОС UNIX). Если они недоступны, попросите администратора базы данных установить параметр _trace_files_public = true в файле init.ora на тестовых серверах и серверах разработчиков. Это позволит читать трассировочные файлы на сервере всем пользователям. Эту установку нельзя делать на производственном сервере, поскольку трассировочные файлы могут содержать секретную информацию. В тестовой среде или среде разработки она вполне безопасна. Обратите внимание, что имя параметра начинается с символа подчеркивания. Этот параметр не описан в документации и не поддерживается корпорацией Oracle. Как и в случае с командой EVENTS, которую мы будем использовать чуть позже, этот параметр широко известен и повсеместно используется: поищите с помощью запроса _trace_files_public в Google или любой другой поисковой системе и вы получите много интересной информации об этом параметре. Теперь, определив свой трассировочный файл, необходимо его сформатировать. Можно читать его и непосредственно. Но около 90 процентов нужной информации легко получить из хорошо сформатированного отчета. Остальные 10 процентов информации обычно не нужны, но если она потребуется, придется получать эту информацию непосредственно из трассировочного файла. Для форматирования трассировочного файла ис Глава пользуется утилита командной строки TKPROF. В простейшем случае достаточно выполнить:

C:\oracle\ADMIN\tkyte816\udump>tkprof ora01124.trc report.txt TKPROF: Release 8.1.6.0.0 - Production on Fri Mar 16 15:04:33 2001 (c) Copyright 1999 Oracle Corporation. All rights reserved.

Параметрами команды TKPROF являются имена файла исходных данных и файла результатов обработки. Теперь достаточно открыть файл REPORT.TXT в текстовом редакторе, и мы увидим следующее:

select owner, count(*) from all_objects group by owner call Parse Execute Fetch total count 1 1 2 cpu 0.00 0.00 1.20 1.20 elapsed 0.00 0.00 1.21 1.21 disk 0 0 0 query 0 0 86091 86091 current 0 0 4 rows 0 0 15 Misses in library cache during parse: 0 Optimizer goal: CHOOSE Parsing user id: 69 Rows 15 21792 21932 46 21976 21976 1 1 0 0 1 1 1 1 1 1 1 1 1 1 11777 30159 28971 Row Source Operation SORT GROUP BY FILTER NESTED LOOPS TABLE ACCESS FULL USER$ TABLE ACCESS BY INDEX ROWID OBJ$ INDEX RANGE SCAN (object id 34) FIXED TABLE FULL X$KZSPR FIXED TABLE FULL X$KZSPR FIXED TABLE FULL X$KZSPR FIXED TABLE FULL X$KZSPR FIXED TABLE FULL X$KZSPR FIXED TABLE FULL X$KZSPR FIXED TABLE FULL X$KZSPR FIXED TABLE FULL X$KZSPR FIXED TABLE FULL X$KZSPR FIXED TABLE FULL X$KZSPR FIXED TABLE FULL X$KZSPR FIXED TABLE FULL X$KZSPR FIXED TABLE FULL X$KZSPR FIXED TABLE FULL X$KZSPR NESTED LOOPS FIXED TABLE FULL X$KZSRO TABLE ACCESS BY INDEX ROWID OBJAUTH$ Стратегии и средства настройки 28973 631 654 INDEX RANGE SCAN (object id 101) TABLE ACCESS BY INDEX ROWID IND$ INDEX UNIQUE SCAN (object id 36) Утилита TKPROF выдает массу информации. Давайте рассмотрим ее по частям:

select owner, count(*) from all_objects group by owner Сначала показан исходный запрос в том виде, как он был получен сервером. Так легко можно узнать искомые запросы. В данном случае именно такой запрос я и ввел. Затем идет общая информация о выполнении запроса:

call Parse Execute Fetch total count cpu 0.00 0.00 1.20 1.20 elapsed 0.00 0.00 1.21 1.21 disk query current rows 1 1 0 0 0 86091 0 0 0 0 Здесь можно увидеть три основные стадии выполнения запроса. • Стадия PARSE. На этом этапе сервер Oracle находит запрос в разделяемом пуле (мягкий разбор) или создает новый план его выполнения (жесткий разбор). • Стадия EXECUTE. Это действия, выполняемые сервером Oracle при открытии курсора или выполнении запроса. Для операторов SELECT соответствуюшие.столбцы часто будут "пустыми", тогда как для операторов UPDATE именно на этой стадии все и делается. • Стадия FETCH. Для оператора SELECT именно на этом этапе выполняется основная работа, что и будет отражено в отчете, но для операторов типа UPDATE ничего делаться не будет (при выполнении этого оператора данные не извлекаются). Заголовки столбцов в этом разделе отчета имеют следующие значения: • CALL. Может иметь одно из значений: PARSE, EXECUTE, FETCH или TOTAL. Показывает, о какой стадии обработки запроса идет речь. • COUNT. Показывает, сколько раз произошло событие. Это число может оказаться крайне важным. Ниже мы рассмотрим, как интерпретировать значения столбцов. • CPU. Показывает, сколько секунд процессорного времени заняла эта стадия выполнения запроса. Этот столбец заполняется, только если установлен параметр TIMED_STATISTICS. • ELAPSED. Показывает, сколько реального времени потребовала эта стадия выполнения запроса. Этот столбец заполняется, только если установлен параметр TIMED STATISTICS.

Глава • DISK. Показывает, сколько физических операций ввода/вывода с диска потребовалось для выполнения запроса. • QUERY. Показывает, сколько блоков обработал запрос в режиме согласованного чтения. Сюда входят блоки, прочитанные из сегмента отката для получения предыдущего состояния блока. • CURRENT. Показывает, сколько блоков было прочитано в режиме 'CURRENT'. Блоки в режиме CURRENT читаются в том виде, как они есть на момент чтения, а не в режиме согласованного чтения. Обычно блоки для запроса получаются в том виде, как они были на момент начала запроса. В текущем режиме блоки извлекаются в том виде, как они существуют на момент их чтения, а не какими они были ранее. В ходе выполнения оператора SELECT можно увидеть извлечения в режиме CURRENT, связанные с чтением словаря данных в поисках следующего экстента таблицы при полном просмотре (необходима текущая информация об этом, а не согласованное чтение). В ходе изменения мы будем также обращаться к блокам в режиме CURRENT. • ROWS. Показывает, сколько строк было затронуто на данной стадии обработки. При выполнении оператора SELECT строки будут обрабатываться на стадии FETCH. При выполнении оператора UPDATE количество обработанных строк будет показано на стадии EXECUTE. В этом разделе отчета надо обратить внимание на следующие особенности. Значительный процент (около 100) разборов по отношению к выполнениям, если количество выполнений — более одного. Берем количество разборов оператора и делим на количество выполнений. Если получаем в результате 1, значит, запрос разбирался при каждом выполнении, и это надо исправить. Желательно, чтобы это отношение стремилось к нулю. В идеале разбор должен быть один, а выполнений — более одного. Если наблюдается значительное количество разборов, значит, выполняется многократный мягкий разбор запроса. Как было показано в предыдущем разделе, это может существенно снизить масштабируемость и производительность даже единственного пользовательского сеанса. Необходимо обеспечить однократный разбор и многократное выполнение запроса в сеансе;

от разбора SQL-оператора при каждом выполнении надо избавляться. Одно выполнение для всех или почти всех операторов SQL. Если в отчете TKPROF указано, что все операторы SQL выполняются только один раз, скорее всего, не используются связываемые переменные (выполняются похожие запросы, которые отличаются лишь используемыми константами). В трассировочных файлах реальных приложений уникальных операторов SQL обычно немного;

одни и те же SQL-операторы выполняются многократно. Слишком большое количество уникальных SQL-операторов обычно означает, что недостаточно используются связываемые переменные. Существенное отличие процессорного и реального времени выполнения запроса. Это означает, что приходится долго чего-то ждать. Если для выполнения необходима одна секунда процессорного времени, но реально запрос выполнялся 10 секунд, это означает, что 90 процентов времени ушло на ожидание освобождения ресурса. Далее в этом разделе мы увидим, как по исходному файлу трассировки определить причину ожида Стратегии и средства настройки ния. Это ожидание может быть вызвано несколькими причинами. Например, на выполнение изменения, заблокированного другим сеансом, уйдет намного больше реального времени, чем процессорного. SQL-запрос, выполняющий большой объем физического ввода/вывода с диска, может долго ждать завершения ввода/вывода. Длительное процессорное или реальное время выполнения. Сокращение продолжительности длительно выполняющихся запросов — ваша ближайшая.цель. Если удастся ускорить их выполнение, программа заработает быстрее. Зачастую, один запрос-монстр тормозит всю работу;

настройте его, и приложение будет отлично работать. Большая величина отношения (FETCH СОUNT)/(количество извлеченных строк). Для ее вычисления берем количество действий типа FETCH (в нашем примере — два) и делим на количество извлеченных строк (в нашем примере — 15). Если полученный результат близок к одному и извлечено более одной строки, приложение не выполняет множественные извлечения. Любой язык или функциональный интерфейс позволяет это делать — извлекать несколько строк одним вызовом. Если возможность множественного извлечения не используется, на пересылки информации с клиента на сервер и обратно уйдет намного больше времени. Этот постоянный обмен информацией, помимо того, что чрезвычайно загружает сеть, выполняется намного медленнее, чем получение нескольких строк одним вызовом. Как организовать множественное извлечение данных в приложении, зависит от используемого языка и/или функционального интерфейса. Например, при использовании Рго*С необходимо выполнять перекомпиляцию с параметром prefetch=NN, в Java/JDBC необходимо вызвать метод SETROWPREFETCH, в PL/ SQL необходимо использовать конструкцию BULK COLLECT в операторах SELECT INTO и т.д. Представленный ранее пример показывает, что утилита SQL*Plus (использованный нами клиент) вызвала FETCH дважды для извлечения 15 строк. Это показывает, что утилита SQL*Plus использовала при выборке массив не менее чем из восьми строк. На самом деле стандартным для SQL*Plus является использование массивов из 15 строк;

вторая операция извлечения вернула ноль строк — она получила признак конца результирующего множества. Слишком большое количество физических обращений к диску. Простое правило для этого параметра придумать сложнее, но если DISK COUNT = QUERY + CURRENT MODE BLOCK COUNT, значит, все блоки читались с диска. Будем надеяться, что при следующем выполнении этого запроса часть блока будет найдена в области SGA. Большое количество обращений к диску — предупреждающий сигнал о том, что необходимо провести дополнительное исследование. Возможно, надо увеличить размер буферного кэша в SGA или придумать другой запрос, требующий чтения меньшего количества блоков. Слишком большое количество обработанных блоков (QUERY или CURRENT). Это показывает, что запрос обрабатывает большой объем информации. Проблема это или нет — судить вам. Некоторым запросам действительно необходимо обработать много данных, как в представленном ранее примере. Часто выполняемый запрос, однако, должен обрабатывать сравнительно немного блоков. Если сложить значения QUERY и CURRENT количества обработанных блоков и поделить на значение столбца count в строке EXECUTE, должно получаться небольшое число.

Глава Давайте перейдем к следующей части отчета:

Misses in library cache during parse: 0 Optimizer goal: CHOOSE Parsing user id: Из этого можно сделать вывод, что выполненный запрос был найден в разделяемом пуле (количество не найденных в библиотечном кэше запросов равно 0). То есть, выполнялся мягкий разбор запроса. При самом первом выполнении запроса в этой строке будет значение 1. Если практически у всех выполнявшихся запросов будет значение 1, значит, не используются связываемые переменные (это надо исправить). Операторы SQL не используются повторно. Вторая строка показывает режим работы оптимизатора при выполнении запроса. Эта информация — для справки;

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

tkyte@TKYTE816> select * from all_users where user_id = 69;

USERNAME TKYTE USER ID CREATED 69 10-MAR-Ol Как видите, запрос разбирал я. Последний раздел отчета TKPROF для данного запроса — план выполнения. Стандартный план выполнения показан ниже:

Rows 15 21792 21932 46 21976 21976 1 1 0 0 1 1 1 1 1 1 1 1 1 1 11777 30159 28971 Row Source Operation SORT GROUP BY FILTER NESTED LOOPS TABLE ACCESS FULL USER$ TABLE ACCESS BY INDEX ROWID OBJ$ INDEX RANGE SCAN (object id 34) FIXED TABLE FULL X$KZSPR FIXED TABLE FULL X$KZSPR FIXED TABLE FULL X$KZSPR FIXED TABLE FULL X$KZSPR FIXED TABLE FULL X$KZSPR FIXED TABLE FULL X$KZSPR FIXED TABLE FULL X$KZSPR FIXED TABLE FULL X$KZSPR FIXED TABLE FULL X$KZSPR FIXED TABLE FULL X$KZSPR FIXED TABLE FULL XSKZSPR FIXED TABLE FULL X$KZSPR FIXED TABLE FULL X$KZSPR FIXED TABLE FULL X$KZSPR NESTED LOOPS FIXED TABLE FULL X$KZSRO TABLE ACCESS BY INDEX ROWID OBJAUTH$ Стратегии и средства настройки 28973 631 654 INDEX RANGE SCAN (object id 101) TABLE ACCESS BY INDEX ROWID IND$ INDEX UNIQUE SCAN (object id 36) Это реальный план запроса, использованный сервером Oracle при выполнении. Интересно, что показано количество обработанных на каждом шаге строк. Можно увидеть, например, что 28971 строка была извлечена из OBJAUTH$. Речь идет о строках, полученных в результате выполнения данного шага плана (после применения всех возможных условий, которым должны соответствовать строки таблицы OBJAUTH$, на следующий шаг плана передана 28971 строка). В Oracle 8.0 и более ранних версиях выдавалось количество строк, просмотренных на данном шаге плана выполнения (количество строк, поступивших на вход этого шага). Например, если рассматривалось 50000 строк в таблице OBJAUTH$, но часть из них была исключена конструкцией WHERE, в отчете TKPROF версии Oracle 8.0 выдано было бы в соответствующей строке плана 50000. По этой информации можно понять, от каких шагов выполнения запроса имеет смысл отказаться либо путем изменения запроса, либо с помощью подсказок оптимизатору, выбирающих более удачный план. Обратите внимание, что вперемешку используются как имена объектов (например, TABLE ACCESS BY INDEX ROWID INDS), так и идентификаторы (например, INDEX UNIQUE SCAN (object id 36)). Причина в том, что в исходном трассировочном файле для некоторых объектов не записаны имена, а только идентификаторы. Кроме того, по умолчанию утилита TKPROF не подключается к базе данных для преобразования идентификаторов объектов в имена. Получить имя объекта по идентификатору можно с помощью запроса:

tkyte@TKYTE816> select owner, object_type, object_name 2 from all_objects 3 where object_id = 36;

OWNER SYS OBJECT_TYPE INDEX OBJECT_NAME I_IND Но можно и добавить параметр EXPLAIN= при вызове утилиты TKPROF следующим образом:

С: \oracle\ADMIN\tkyte816\uduinp>tkprof ora01124.trc х. t x t explain=tkyte/tkyte В результирующем файле мы получим следующее сообщение об ошибке:

error during parse of EXPLAIN PLAN statement ORA-01039: insufficient privileges on underlying objects of the view Хотя мы и можем выполнить запрос, базовые таблицы, по которым построено представление, недоступны. Чтобы получить план выполнения запроса, необходимо подключиться от имени учетной записи SYS или другой учетной записи, имеющей доступ к базовым объектам.

Я предпочитаю не использовать параметр EXPLAIN= и вам не советую.

Глава Запрос, передаваемый оператору EXPLAIN PLAN, может принципиально отличаться от используемого при реальном выполнении. Единственный план, которому можно доверять, — это план, сохраненный в самом трассировочном файле. Вот простой пример использования утилиты TKPROF с параметром explain=имя/пароль, демонстрирующий это:

select count(object_type) from t where object_id > 0 call Parse Execute Fetch total count cpu 0.00 0.00 0.19 0.19 elapsed 0.00 0.00 2.07 2.07 disk query current 1 1 0 0 0 20498 0 0 0 0 Misses in library cache during parse: 1 Optimizer goal: CHOOSE Parsing user id: 69 (TKYTE) Rows Row Source Operation 1 21790 21791 Rows SORT AGGREGATE TABLE ACCESS BY INDEX ROWID T INDEX RANGE SCAN (object id 25291) Execution Plan 0 1 SELECT STATEMENT GOAL: CHOOSE SORT (AGGREGATE) TABLE ACCESS GOAL: ANALYZED (FULL) OF 'T' Очевидно, один из планов — неправильный;

в одном указано сканирование диапазона по индексу и доступ к таблице по идентификатору строки, а в другом —полный просмотр. Если не знать, что я проанализировал таблицу после выполнения запроса, но до запуска утилиты TKPROF, это расхождение объяснить нельзя. После анализа таблицы стандартный план выполнения этого запроса изменился. Утилита TKPROF использует предоставляемый Oracle стандартный оператор explain plan. В результате выдается план, который использовался бы при выполнении оператора сейчас, а не использованный фактически. Различие планов в трассировочном файле и в результатах выполнения оператора explain plan может обуславливаться многими факторами. Например, приложение могло использовать хранимые шаблоны запросов (подробнее об этой возможности см. в главе 11). В ходе выполнения план мог базироваться на хранящейся схеме, а план, возвращенный оператором explain plan, может оказаться другим. В общем случае, если при вызове утилиты TKPROF все же используется параметр EXPLAIN=, необходимо пошагово сравнить согласованность двух полученных планов. Утилита TKPROF имеет много опций командной строки, и если ввести команду tkprof, все они будут выданы:

Стратегии и средства настройки C:\Documents and Settings\Thomas Kyte\Desktop>tkprof Usage: tkprof tracefile outputfile [explains ] [tables ] [prints ] [insert= ] [sys= ] [sorts ] table=имя_схемы.имя таблицы Используйте "имя_схемы.имя_таблицы" внесте с опцией "explains". explain=пользователь/пароль Подключиться к ORACLE и выполнить EXPLAIN PLAIN. print=количество Выдать только указанное "количество" операторов SQL. aggregate=yes|no iпsеrt=имя_файла Выдать в этот файл операторы SQL и данные в операторах INSERT. sys=no He выдавать информацию об операторах SQL, выполненных от имени пользователя SYS. record=имя_файла Выдать сюда нерекурсивные операторы, имеющиеся в трассировочном файле. sort=опции Набор из куля или более следующих опций: prscnt сколько раз выполнялся разбор prscpu процессорное время раэбора prsela реальное время раэбора prsdsk количество чтений с диска в ходе разбора prsqry количество буферов, прочитанных в режиме согласованного чтения в ходе разбора prscu количество буферов, непосредственно прочитанных в ходе раэбора prsmis количество непопаданий в библиотечный кэше в ходе разбора execnt сколько раз выполнялся оператор ехесри процессорное время выполнения exeela реальное время выполнения exedsk количество чтений с диска при выполнении exeqry количество буферов, прочитанных в режиме согласованного чтения в ходе выполнения execu количество буферов, непосредственно прочитанных при выполнении exerow количество обработанных при выполнении строк exemis количество непопаданий в библиотечный кэш в ходе выполнения fchcnt сколько раз выполнялось извлечение данных fchcpu процессорное время извлечения данных fchela реальное время извлечения данных fchdsk количество обращений к диску при извлечении данных fchqry количество буферов, прочитанных в режиме согласованного чтения при извлечении данных fchcu количество буферов, непосредственно прочитанных при извлечении данных fchrow количество извлеченных строк userid идентификатор пользователя, разобравшего оператор Наиболее полезной, по моему мнению, является опция sort=. Я люблю сортировать результаты по разным показателям процессорного и реального времени выполнения, чтобы "наихудшие" запросы оказывались в начале трассировочного файла. Сортировку можно также использовать для поиска запросов, выполняющих слишком много физическоОписания параметров переведены на русский язык. Для получения исходных описаний на английском выполните команду tkprof. Прим. научн. ред.

Глава го ввода/вывода и т.д. Назначение остальных опций очевидно. В 99,9 процентах случаев я использую tkprof имя_трассировочного_файла имя_файла_отчета, и ничего более. При этом операторы SQL выдаются примерно в том порядке, как они посылались серверу в ходе выполнения. Я могу использовать утилиту типа grep в ОС UNIX или find в Windows для извлечения суммарных (total) строк, что позволяет легко определить, на какие запросы надо обратить внимание. Например, обработав полученный ранее файл report.txt:

С:\oracle\ADMIN\tkyte816\udump>find total total total total total total total 2 4 4 6 4 14 6 REPORT.TXT 0.00 0.01 1.20 0.01 0.00 1.21 0.01 0.00 0.02 1.21 0.01 0.00 1.23 0.01 0 1 0 0 0 1 0 "total" 0 1 86091 4 0 86092 4 report.txt 0 4 4 0 0 8 0 0 1 15 2 1 17 можно понять, что для ускорения процесса надо в текстовом редакторе искать строку 1.21. Есть и другие операторы, но, очевидно, именно на этом надо сконцентрировать усилия для ускорения работы приложения.

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

UPDATE BMP SET ENAME=LOWER (ENAME) WHERE EMPNO = :b call Parse Execute Fetch total count 1 1 0 cpu 0.00 0.00 0.00 0. elapsed 0.00 54.25 0.00 54. disk query 0 17 0 current 0 8 rows 0 1 0 0 Стратегии и средства настройки Проблема, очевидно, есть: на изменение одной строки уходит почти минута, хотя процессорного времени требуется менее сотой доли секунды. Итак, слишком долго пришлось ожидать какого-то события, но какого именно, утилита TKPROF не показывает. Кроме того, не мешало бы знать, при изменении какой строки это произошло (а именно: какое значение EMPNO было указано в переменной :b1). Эта информация поможет понять, как мы попали в подобную ситуацию. К счастью, трассировка приложения обеспечивалась следующей командой:

alter session set events '10046 trace name context forever, level 12';

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

scott@TKYTE816> alter session set events 2 '10046 trace name context forever, level 12';

Session altered. scott@TKYTE816> declare 2 l_empno number default 7698;

3 begin 4 update emp set ename = lower(ename) where empno = l_empno;

5 end;

6 / PL/SQL procedure s u c c e s s f u l l y completed. scott@TKYTE816> e x i t В этом случае мы точно знаем, какое значение EMPNO использовалось, но обычно это не известно. Ниже представлено содержимое трассировочного файла и соответствующие комментарии:

Dump file C:\oracle\admin\tkyte816\udump\ORA01156.TRC Sat Mar 17 12:16:38 2001 ORACLE V8.1.6.0.0 - Production vsnsta=0 vsnsql=e vsnxtr=3 Windows 2000 Version 5.0, CPU type 586 0racle8i Enterprise Edition Release 8.1.6.0.0 - Production With the Partitioning option JServer Release 8.1.6.0.0 - Production Windows 2000 Version 5.0, CPU type 586 Instance name: tkyte816 Redo thread mounted by this instance: 1 Oracle process number: 11 Windows thread id: 1156, image: ORACLE.EXE Это стандартный заголовок трассировочного файла. Он пригодится для определения точной версии системы и СУБД, с которой работает приложение. В заголовке также имеется идентификатор Oracle SID (имя экземпляра), который позволяет понять, с тем ли трассировочным файлом мы работаем.

Глава *** 2001-03-17 12:16:38.407 *** SESSION ID:(7.74) 2001-03-17 12:16:38.407 APPNAME mod='SQL*PLUS' mh=3669949024 act='' ah= Запись APPNAME была сделана при вызове подпрограммы пакета DBMS_ APPLICATION_INFO (подробнее об этом пакете см. в Приложении А). Этот пакет используется для регистрации действий приложений в базе данных, чтобы по результатам запросов к представлению V$SESSION можно было понять, какое именно приложение открыло сеанс. Утилита SQL*Plus, в частности, этот пакет использует. В вашем трассировочном файле записи APPNAME может и не быть: все зависит от среды. Было бы замечательно, если бы все приложения регистрировались с помощью этого пакета, так что, надеюсь, вы обнаружили эту запись, в которой указано имя работающего модуля. Эта запись имеет следующий формат:

APPNAME mod='%s' mh=%lu act='%s' ah=%lu Поле mod mh act ah Значение Имя модуля, переданное DBMS_APPLICATION_INFO Хэш-значение для модуля Действие модуля, переданное DBMS_APPLICATION_INFO Хэш-значение для действия Если вы программируете на языке С, то узнаете строку формата для функции printf стандартной библиотеки С. По ней можно определить, какого типа данные будут в записи APPNAME;

%s — это строка, %lu — длинное целое без знака (число). Далее в моем трассировочном файле идут строки:

PARSING IN CURSOR #3 len=70 dep=0 uid=54 oct=42 lid=54 tim=6184206 hv=347037164 ad='31883a4' alter session set events '10046 trace name context forever, level 12' END OF STMT EXEC #3:c=0,e=0,p=0,cr=0,cu=0,mis=l,r=0,dep=0,og=4,tim=6184206 WAIT #3: nam='SQL*Net message to client' ela= 0 pl=1111838976 p2=l p3=0 WAIT #3: nam='SQL*Net message from client' ela= 818 pl-1111838976 p2=l p3= Здесь можно увидеть, каким именно оператором включена трассировка. Перед этим идет запись CURSOR, которая будет в трассировочном файле всегда (все SQL-операторы в трассировочном файле предваряются записью CURSOR). Эта запись имеет следующий формат:

Parsing in ad='%s' Cursor #%d len=%d dep=%d uid=%ld oct=%d lid=%ld tim=%ld hv=%ld Стратегии и средства настройки Поле Cursor # Значение Номер курсора. Его м о ж н о использовать, в частности, для определения максимального количества открытых курсоров в приложении, поскольку это значение увеличивается и уменьшается на единицу при каждом открытии нового и закрытии существующего курсора, соответственно. соответствующего SQL-оператора.

len dep Длина Рекурсивная глубина SQL-оператора. Рекурсивный SQL-оператор - это SQL-оператор, инициированный д р у г и м SQL-оператором. Обычно рекурсивные SQL-операторы выполняются сервером Oracle для разбора запроса или управления пространством. Это могут быть также SQLоператоры, вызванные в программных единицах PL/SQL (программная единица или блок PL/SQL - это тоже SQL). Так что операторы приложения тоже могут оказаться "рекурсивными". Идентификатор пользователя - владельца текущей схемы. Обратите внимание, что значение может отличаться от представленного ниже идентификатора lid, в частности, если использовался оператор alter session set current_schema для изменения схемы, в которой выполняется разбор. Oracle Command Type. Числовой код, показывающий тип выполняемого оператора SQL. Идентификатор пользователя, от имени которого выполнялась проверка привилегий доступа. Таймер с точностью до сотых долей секунды. Сравнивая время регистрации событий, м о ж н о определить, насколько отдалены о н и друг от друга по времени. Хэш-идентификатор SQL-оператора. Значение в столбце ADDR строки представления V$SQLAREA, описывающей SQL-оператор.

uid oct lid tim hv ad Затем в трассировочном файле можно увидеть, что оператор выполнялся сразу же после разбора. Запись EXEC имеет следующий формат: EXEC Cursor#: c=%d, e=%d,p=%d, cr=%d, cu=%d,mi.s=%d, r=%d, dep=%d, og=%d, tim=%d Поле Cursor # с е р Значение Номер курсора, Процессорное время выполнения в сотых долях секунды, Реальное время выполнения в сотых долях секунды, Количество выполненных физических чтений. в согласованном режиме (логический cr Количество чтений блоков ввод/вывод). сu Количество непосредственных чтений блоков (логический ввод/вывод).

Поле mis Глава 10 Значение Количество непопаданий в библиотечный кэш, по которому можно судить, что пришлось разбирать оператор, поскольку он был удален из разделяемого пула как устаревший, никогда не был в разделяемом пуле или версию в кэше вообще нельзя использовать. Количество обработанных строк. Рекурсивная глубина SQL-оператора. Цель оптимизации, 1= все строки, 2 = первые строки, 3 = оптимизация на основе правил, 4 = выбор режима оптимизации Таймер.

r dep og tim Есть и другие разновидности записи EXEC, с другими ключевыми словами вместо EXEC: Поле PARSE FETCH UNMAP SORT UNMAP Значение Разбор оператора. Извлечение строк из результирующего множества курсора. Освобождение временных сегментов с промежуточными результатами, когда эти результаты уже не нужны. То же, что и UNMAP, но для сегментов сортировки.

Записи PARSE, FETCH, UNMAP и SORT UNMAP содержат ту же информацию, что и запись EXEC, причем, в том же порядке. Последняя часть этого раздела содержит первые упоминания об ожидании событий. В данном случае это: WAIT #3: nam='SQL*Net message to client' ela= 0 pl=1111838976 p2=l p3=0 WAIT #3: nam='SQL*Net message from client' ela= 818 pl=1111838976 p2=l p3=0 Это типичные ожидания данных при пересылке с клиента на сервер, которые уже описывались ранее в этой главе. Строка, содержащая message to client, означает, что сервер послал клиенту сообщение и ждет ответа. Строка, содержащая message from client, означает, что сервер ждет запроса от клиента. В данном случае реальное время ожидания (ela) этого события составило 8,18 секунды. Это означает, что я подождал 8,18 секунды после выполнения оператора ALTER SESSION, прежде чем послать следующую команду данного примера. Если только не обрабатывается постоянный и непрерывный поток обращений к серверу, ожидание "message from client" неизбежно и вполне нормально. Запись WAIT имеет следующий формат: WAIT Cursor#: nam='%s' ela=%d pl=%ul p2=%ul p3=%ul Поле Cursor # nam Значение Номер курсора. Имя ожидаемого события. В руководстве Oracle Server Reference содержится полный список событий, которые может ожидать сервер, с подробным описанием каждого события.

Стратегии и средства настройки Поле ela Значение Реальное время ожидания события в сотых долях секунды.

р1, р2, рЗ Параметры ожидаемого события. Каждое событие имеет определенный набор параметров. Значение параметров р1, р2 и рЗ для конкретного события см. в руководстве Oracle Server Reference Теперь можно переходить к первому реальному оператору в трассировочном файле:

PARSING IN CURSOR #3 len=110 dep=0 uid=54 oct=47 lid-54 tim=6185026 hv=2018962105 ad='31991c8' declare l_empno number default 7698;

begin update emp set ename = lower(ename) where empno = l_empno;

end;

END OF STMT PARSE #3:c=0,e=0,p=0,cr=0,cu=O,mis=l,r=0,dep=O,og=4,tim=6185026 BINDS #3:

Мы видим блок кода PL/SQL в том виде, в каком мы его передали. По записи PARSE можно понять, что разобран он был очень быстро, хотя и не был найден в библиотечном кэше (MIS=1). Далее идет запись BINDS без детальной информации, поскольку в переданном блоке кода не использовались связываемые переменные. В дальнейшем мы еще вернемся к этой записи. Переходим к следующему оператору в трассировочном файле, где уже можно обнаружить кое-что интересное:

PARSING IN CURSOR #4 l e n - 5 1 dep=l uid=54 oct=6 l i d = 5 4 tim=6185026 hv=2518517322 ad='318e29c'UPDATE E P SET ENAME=LOWER(ENAME) W E E E P O = :b1 M HR MN END OF STMT PARSE #4:c=0,e=0,p=0,cr=0,cu=O,mis=l,r=0,dep=l,og=0,tim=6185026 BINDS #4: bind 0: dty=2 mxl=22(21) mal=00 s c l = 0 0 pre=00 oacflg=03 o a c f l 2 = l s i z e = 2 4 offset=0 bfp=07425360 bln=22 avl=03 flg=05 value=7698 WAIT #4: nam='enqueue' ela= 308 pl=1415053318 p2-393290 p3=2947 WAIT #4: nam='enqueue' ela= 307 pl=1415053318 p2=393290 p3=2947 WAIT #4: nam='enqueue' ela= 307 pl=1415053318 p2=393290 p3=2947 WAIT #4: nam='enqueue' ela= 308 pl=1415053318 p2=393290 p3=2947 WAIT #4: nam='enqueue' ela= 307 pl=1415053318 p2=393290 p3=2947 WAIT #4: nam='enqueue' ela= 308 pl=1415053318 p2=393290 p3=2947 WAIT #4: nam='enqueue' ela= 307 pl=1415053318 p2=393290 p3=2947 WAIT #4: nam='enqueue' ela= 308 pl=1415053318 p2=393290 p3=2947 WAIT #4: nam='enqueue' ela= 307 pl=1415053318 p2=393290 p3=2947 WAIT #4: nam='enqueue' ela= 308 pl=1415053318 p2=393290 p3=2947 WAIT #4: nam='enqueue' ela= 307 pl=1415053318 p2=393290 p3=2947 WAIT #4: nam='enqueue' ela= 307 pl=1415053318 p2=393290 p3= WAIT WAIT WAIT WAIT WAIT WAIT EXEC EXEC WAIT WAIT Глава 10 #4: nam='enqueue' ela= 308 pl=1415053318 p2=393290 p3=2947 #4: nam='enqueue' ela= 307 р1=1415053318 р2=393290 p3=2947 #4: nam='enqueue' ela= 308 pl=1415053318 p2=393290 p3=2947 #4: nam='enqueue' ela= 307 pl=1415053318 p2=393290 p3=2947 #4: nam='enqueue' ela= 308 pl=1415053318 p2=393290 p3=2947 #4: nam='enqueue' ela= 198 pl-1415053318 p2=393290 p3=2947 #4:c=0,e=5425,p=0,cr=17,cu=8,mis=0,r=l,dep=l,og=4,tim=6190451 #3:c=0,e=5425,p=0,cr=17,cu=8,mis=0,r=l,dep=0,og=4,tim=6190451 #3: nam='SQL*Net message to client' ela= 0 pl=1111838976 p2=l p3=0 #3: nam='SQL*Net message from client' ela= 0 pl=1111838976 p2=l p3= Представлен оператор UPDATE в том виде, как его получил сервер Oracle. Он отличается от того, который использовался в PL/SQL-блоке, а именно: ссылка на l_empno (переменная) заменена связываемой переменной. Перед выполнением SQL-оператора PL/SQL-машина заменяет в нем все вхождения локальных переменных связываемыми переменными. Кроме того, по записи PARSING IN CURSOR можно понять, что рекурсивная глубина (dep) теперь — 1, а не 0, как у исходного блока PL/SQL. Понятно, что это SQL-оператор, выполненный каким-то другим SQL- или PL/SQL-оператором;

он не передавался клиентским приложением на сервер. Этот флаг можно использовать для поиска соответствующего SQL-оператора. Если поле dep имеет ненулевое значение, значит, выполнение SQL-оператора инициировано сервером, а не клиентским приложением. Это можно учесть при настройке. SQL-оператор, выполнение которого инициировано сервером, легко изменить без изменения приложения. Для изменения SQLоператора, посылаемого клиентским приложением, необходимо найти соответствующее приложение, изменить код, перекомпилировать и снова установить его. Чем больше SQLоператоров находится на сервере, тем лучше — их можно изменить, не изменяя само приложение. Для этого оператора тоже выдана запись BINDS, причем с детальной информацией. Наш оператор изменения содержит связываемую переменную, и можно явно узнать ее значение — первая связываемая переменная имела значение 7698. Теперь, если бы этот запрос был проблемным (выполнялся бы медленно), то имеется вся необходимая для его настройки информация. Есть точный текст запроса. Известны значения связываемых переменных (так что можно повторно выполнить его с теми же данными). Известно даже, ожидание каких событий замедлило выполнение. Не хватает только плана выполнения запроса, но это лишь потому, что мы до него еще не дошли. Запись BIND в трассировочном файле содержит следующую информацию: Поле cursor # bind N dty mxl mal Значение Номер курсора. Позиция связываемой переменной (0 - первая связываемая переменная). Тип данных (см. ниже). Максимальная длина связываемой переменной. Максимальная длина массива (при связывании массивов или множественных операциях).

Стратегии и средства настройки Поле scl рге oacflg oacfl2 size offset bfp bin avl flag value Значение Масштаб. Точность.

Внутренние флаги. Если это число - нечетное, связываемая переменная может иметь пустое значение (допускается значение NULL). Продолжение внутренних флагов. Размер буфера. Используется при частичных связываниях. Адрес связывания. Длина буфера связывания. Длина фактического значения. Внутренние флаги. Представление связываемого значения в виде строки (может быть шестнадцатиричным представлением двоичных данных) - именно это нам и надо!

Значение dty (тип данных) можно декодировать с помощью информации из представления USER_TAB_COLUMNS. Если выбрать из представления all_views текст представления, для которого view_name = 'USER_VIEWS', можно увидеть функцию декодирования, сопоставляющую значениям dty строковые названия типов. Интересующая нас информация — информация об ожиданиях — найдена. Можно четко увидеть, почему выполнение изменения потребовало почти минуту реального времени, хотя процессорное время, необходимое для этого, пренебрежимо мало. Мы ожидали снятия блокировки: в главах 3 и 4 было описано, что enqueue — один из двух внутренних механизмов, используемых сервером Oracle для поочередного доступа к разделяемым ресурсам. Трассировочный файл показывает, что мы ждали снятия блокировки, т.е. мы не ждали завершения ввода/вывода, синхронизации журнального файла или освобождения буфера, — мы стояли в очереди в ожидании освобождения некоторого ресурса. Если пойти дальше, можно взять значение параметра p1 и получить по нему тип блокировки, снятия которой пришлось ждать. Вот как это можно сделать: tkyte@TKYTE816> create or replace 2 function enqueue_decode(l_pl in number) return varchar2 3 as 4 l_str varchar2(25);

5 begin 6 select chr(bitand(l_pl,-16777216)/16777215) || 7 chr(bitand(l_pl, 16711680)/65535) || ' ' || 8 decode (bitand(l_pl, 65535), 9 0, 'No lock', 10 1, 'No lock', 11 2, 'Row-Share', 12 3, 'Row-Exclusive', 13 4, 'Share', 14 15 16 17 18 19 20 Глава 5, 'Share Row-Excl', 6, 'Exclusive' ) into l_str from dual;

return l_str;

end;

/ Function created. tkyte@TKYTE816> tkyte@TKYTE816> select enqueue_decode(1415053318) from dual;

ENQUEUE_DECODE(1415053318) TX Exclusive Этот результат показывает, что мы ждем снятия исключительной блокировки строки. Теперь понятно, почему для изменения строки потребовалась минута. Другой сеанс целую минуту блокировал соответствующую строку, пока мы ждали снятия блокировки. Что делать в этом случае — зависит от приложения. Например, в рассмотренном выше случае я делал изменение "вслепую". Если не хочется, чтобы приложение блокировалось при изменении, можно выполнять его так:

select ename from emp where empno = :bv for update NOWAIT;

update emp set ename = lower(ename) where empno = :bv;

Это решает проблему блокирования. По крайней мере теперь точно известно, почему изменение выполнялось так долго. Мы можем постфактум это определить. Больше не нужно заниматься диагностикой "на месте" — достаточно получить соответствующую трассировочную информацию. Ближе к концу трассировочного файла мы видим:

PARSING IN CURSOR #5 len=52 dep=0 uid=54 oct=47 lid=54 tim=6190451 hv=1697159799 ad='3532750' BEGIN DBMS_OUTPUT.GET_LINES(:LINES, :NUMLINES) ;

END;

END OF STMT PARSE #5:c=0,e=0,p=0,cr=0,cu=0,mis=0,r=0, dep=0,og=4,tim=6190451 BINDS #5: bind 0: dty=l mxl=2000(255) mal=25 scl=00 pre=00 oacflg=43 oacf12=10 size*2000 offset=0 bfp=07448dd4 Ып=255 avl-00 flg=05 bind 1: dty=2 mxl=22(02) mal=00 scl=00 pre=00 oacflg=01 oacf12=0 size=24 offset=0 bfp=0741c7e8 bln=22 avl=02 flg=05 value=25 WAIT #5: nam='SQL*Net message to client' ela= 0 pl=1111838976 p2=l p3=0 EXEC #5:c=0,e=0,p=0,cr=0,cu=0,mis=0,r=l,dep=0,og=4,tim=6190451 WAIT #5: nam='SQL*Net message from client' ela= 273 pl=1111838976 p2=l p3= Стратегии и средства настройки А вот этот оператор — неожиданность. Мы сами его не выполняли, и это не рекурсивный SQL-оператор (dep=O). Он поступил от клиентского приложения. Все это показывает детали работы утилиты SQL*Plus и пакета DBMS_OUTPUT. В файле начального запуска login.sql я задал команду set serveroutput on, чтобы при запуске утилиты SQL*Plus выдача результатов с помощью пакета DBMS_OUTPUT была включена. После каждого выполненного оператора, который мог сгенерировать данные для пакета DBMS_OUTPUT, утилита SQL*Plus должна вызвать процедуру GET_LINES для получения данных и их выдачи на экран (подробнее о пакете DBMS_OUTPUT см. в Приложении А). Мы видим, как утилита SQL*Plus делает этот вызов. Более того, мы видим, что первый параметр, :LINES, фактически является массивом из 25 элементов (mal=25). Теперь понятно, что утилита SQL*Plus извлекает из буфера DBMS_OUTPUT по 25 строк за раз и выдает их на экран. Тот факт, что можно трассировать действия утилиты SQL*Plus, показателен: значит, мы можем трассировать действия любого программного обеспечения, работающего с СУБД Oracle, и понять, что оно делает. Наконец, вот последние записи трассировочного файла:

XCTEND rlbk=0, rd_only=0 WAIT #0: nam='log file sync' ela= 0 pl=968 p2=0 p3=0 STAT #4 id=l cnt=l pid=0 pos=0 obj=0 op='UPDATE ЕМР ' STAT #4 id=2 cnt=2 pid=l pos=l obj=24767 op='TABLE ACCESS FULL EMP ' Запись XCTEND (граница транзакции) связана с фиксацией изменений, но мы явно ничего не фиксировали. Утилита SQL*Plus без предупреждений зафиксировала изменения при выходе. В записи XCTEND имеются следующие значения: Поле rlbk rd_Only Значение Флаг отката. Если указано значение 0, значит, транзакция зафиксирована. Значение 1 обозначает откат транзакции. Флаг только для чтения. Если указано значение 1, транзакция выполнялась в режиме только для чтения. Значение 0 показывает, что изменения были и они зафиксированы (или отменены).

Сразу после записи XCTEND зафиксированы еще какие-то ожидания событий, в данном случае — синхронизации журнального файла. Если обратиться к руководству Oracle Server Reference и найти это событие, можно узнать, что значение 988 для параметра pi означает, что необходимо записать буфер 988 журнала повторного выполнения, и именно сброса этого буфера на диск мы ждали. Ждать пришлось менее сотой доли секунды, о чем свидетельствует значение ela=0. Последние записи в трассировочном файле — записи STAT. Это фактический план выполнения SQL-оператора. Этому плану можно доверять. Более того, для каждого шага плана указано точное количество обработанных строк. Эти записи создаются после закрытия соответствующего курсора. В общем случае это означает, что клиентское приложение должно завершить работу, чтобы эти записи появились в файле — выполнения оператора ALTER SESSION SET SQL_TRACE=FALSE может оказаться недостаточно. Поля этой записи имеют следующие значения:

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

cursor # id cnt pid pos obj ор В трассировочных файлах можно обнаружить еще два типа записей. Они описывают ошибки, выявленные при выполнении запроса. Выделяют: • ошибки разбора (PARSE) — выполнялся недопустимый SQL-оператор;

• ошибки времени выполнения, например дублирование значения ключа индекса, нехватка места и т.д. Решая различные проблемы, я постоянно обращаюсь к трассировочным файлам, в которых записываются ошибки. Если при использовании готового приложения, средства сторонних производителей и даже команд Oracle выдается невразумительное сообщение об ошибке, имеет смысл выполнить команду с включенной трассировкой SQL_TRACE и посмотреть в трассировочном файле, что на самом деле происходит. Во многих случаях причина проблемы может быть установлена по трассировочному файлу, поскольку все выполненные от имени сеанса SQL-операторы в нем записаны. Чтобы продемонстрировать эти записи, я выполнил следующий SQL-оператор: tkyte@TKYTE816> create table t (x int primary key);

Table created. tkyte@TKYTE816> alter session set sql_trace=true;

Session altered. tkyte@TKYTE816> select * from;

select * from ERROR at line 1: ORA-00903: invalid table name tkyte@TKYTE816> insert into t values (1);

1 row created. tkyte@TKYTE816> insert into t values (1);

insert into t values (1) * ERROR at line 1:

Стратегии и средства настройки ORA-00001: unique c o n s t r a i n t tkyte@TKYTE816> e x i t (TKYTE.SYS_C002207) violated В трассировочном файле я обнаружил:

PARSE ERROR #3:len=15 dep=0 uid=69 oct=3 lid=69 tim=7160573 err=903 select * from PARSING IN CURSOR #3 len=27 dep=0 uid=69 oct=2 lid=69 tim=7161010 hv=1601248092 ad='32306c0' insert into t values ( 1 ) END OF STMT PARSE #3:c=0 / e=0,p=0,cr=0,cu=0,mis=0,r=0,dep=0,og=4,tim= EXEC #3:c=l,e=9,p=0,cr=9,cu=7,mis=0,r=0,dep=O,og=4,tim=7161019 E R R #3:err=l tine=71610l9 RO Как видите, поиск проблемного SQL-оператора, ставшего причиной ошибки, с помощью этого метода — тривиальная задача. При этом сразу видно, что не так. Это крайне полезно при поиске ошибки, возникающей, например, глубоко в коде большой хранимой процедуры. Неоднократно я сталкивался с ситуацией, когда ошибка возникала в глубоко вложенном вызове хранимой процедуры, а в приложении использовался обработчик исключительных ситуаций WHEN OTHERS, который все исключительные ситуации перехватывал и игнорировал. По моему убеждению, обработчик исключительных ситуаций WHEN OTHERS использовать вообще нельзя, а все приложения, в которых он используется и при этом не возбуждает исключительную ситуацию повторно, необходимо немедленно удалять — это бомбы замедленного действия. Рано или поздно ошибка произойдет, но она будет перехвачена и проигнорирована, и никто об этом не узнает. Будет казаться, что процедура работает, но на самом деле это не так. В этом случае установка SQL_TRACE покажет, что действительно делает процедура, и ошибка будет обнаружена. Останется только разобраться, почему эта ошибка игнорируется. Я также использую трассировку, когда при выполнении операторов выдаются неинформативные сообщения об ошибках. Например, если при обновлении моментального снимка (материализованного представления) выдается сообщение об ошибке ORA-00942: table or view does not exist, установка параметра SQL_TRACE поможет выяснить истинную причину. Вы можете и не знать всех SQL-операторов, выполняемых от вашего имени при обновлении материализованного представления, и то, какие таблицы они "затрагивают". С помощью SQL_TRACE можно легко установить, какая именно таблица или представление не существует, и изменить соответствующие права доступа. Запись PARSE ERROR имеет следующий формат: Поле len dep Значение Длина SQL-оператора Рекурсивная глубина SQL-оператора Поле uid oct Jid tim err Глава Значение Схема, от имени которой выполнялся разбор (может отличаться от схемы, для которой определялись права доступа) Тип команды Таймер Код ошибки. Если выполнить следующую команду:

tkyte@TKYTE816> EXEC DBMS_OUTPUT.PUT_LINE (SQLERRM(-903) ) ;

ORA-00903: invalid table name Oracle Схема, с привилегиями которой фактически выполняется оператор то можно получить текст сообщения об ошибке. Формат записи ERROR еще проще: Поле cursor # err tim Значение Номер курсора Код ошибки Таймер Итак, в этом разделе достаточно глубоко рассмотрен набор ценнейших средств, работающих во всех средах и всегда доступных. Трассировка при установке SQL_TRACE и результирующие отчеты, выдаваемые утилитой TKPROF — мощнейшие средства настройки и отладки. Я успешно использовал их для отладки и настройки огромного количества приложений. Их повсеместная доступность (нет ни одной СУБД Oracle, в которой эти средства отсутствуют) в сочетании с возможностями, делает их незаменимыми при настройке. Зная, как трассировать приложение и интерпретировать результаты трассировки, можно считать, что настройка приложения наполовину завершена. Вторая половина — разобраться, например, почему запрос требует доступа к миллиону блоков или почему он пять минут ждет в очереди. Установка SQL_TRACE позволит понять, что именно надо исправлять, а поиск причины проблем обычно сложнее, чем их устранение, особенно если детали реализации приложения неизвестны.

Пакет DBMS PROFILER Те, кто интенсивно использует язык PL/SQL, с энтузиазмом отнесутся к добавлению в СУБД профилировщика исходного кода. В Oracle 8i полнофункциональный профилировщик исходного кода на языке PL/SQL интегрирован в базу данных. Этот пакет, именуемый DBMS_PROFILER, позволяет определить, на какие подпрограммы и пакеты приходится наибольшая доля в общем времени выполнения. Более того, он позволяет анализировать охват кода, т.е. понять, сколько процентов кода приложения проверено в тесте.

Стратегии и средства настройки В Приложении А я детально описываю использование пакета DBMS_PROFILER и интерпретацию получающихся в результате отчетов и данных. Пакет очень легко использовать, и он отлично интегрирован в среду PL/SQL. По ходу работы хранимой процедуры на PL/SQL можно включать и отключать профилирование, сужая фрагмент настраиваемого кода. При поэтапной настройке приложения я сначала с помощью SQL_TRACE и утилиты TKPROF выявляю и исправляю плохо настроенные SQL-операторы. Если все SQLоператоры работают максимально быстро, но необходима дальнейшая настройка, я перехожу к профилированию исходного кода. За исключением действительно неудачных алгоритмов, основное повышение производительности достигается за счет настройки SQL-операторов. Настройка исходного кода PL/SQL дает обычно средние результаты: достаточные, чтобы этим стоило заниматься, но намного меньшие, чем исправление неудачных запросов. Конечно, если использован крайне неэффективный алгоритм, все обстоит иначе. Еще одно назначение профилировщика — создание отчета об охвате кода в тестовом примере. Это необходимо на этапе тестирования приложения. С помощью этого средства можно составить набор тестов, покрывающих весь код в ходе тестирования. Хотя это и не гарантирует отсутствие ошибок в коде, но позволяет избежать очевидных упущений.

Средства контроля и отладки Обеспечение средств для контроля и отладки — жизненно важная задача, особенно в большом приложении с множеством компонентов. Чем сложнее приложение и чем больше компонентов оно включает, тем сложнее найти компонент, снижающий производительность. Средства контроля и отладки (instrumentation) — это части кода, обеспечивающие возможность журнализации, которую можно избирательно включать для определения того: а) что делает программа и б) как долго она это делает. Все, от простейшего процесса до самого хитроумного алгоритма, должно быть снабжено полноценными средствами контроля и отладки. Да, эти средства требуют дополнительных расходов ресурсов, даже если сообщения в журнал не записываются, но невозможность определить, где возникает проблема, намного хуже, чем небольшое падение производительности при наличии этих средств. В начале главы я рассказывал о недавно выполненной мною настройке. Архитектура приложения была, мягко говоря, сложной. Пользовательский интерфейс в Web-браузере взаимодействовал с группой Web-серверов через весьма строгий брандмауэр. Webсерверы поддерживали страницы Java Server Pages (JSP). Эти страницы через пул подключений на сервере приложений взаимодействовали с базой данных, где выполнялся код SQL и PL/SQL. Кроме того, они с помощью CORBA обращались к еше одному серверу приложений для взаимодействия с существующей системой. Они были лишь составной частью большего приложения. В системе были еще пакетные задания, фоновые процессы, обработка очередей и другие готовые компоненты. Мне пришлось начинать, абсолютно ничего не зная о приложении, но что еще хуже, мало кто там вообще знал Глава хоть что-нибудь о системе в целом: все знали только свои задачи и компоненты. Представить себе ситуацию в целом всегда сложно. Поскольку ни один из компонентов не был снабжен средствами контроля и отладки, для выявления проблемы пришлось использовать представленные ранее средства СУБД. Трассировка с помощью SQL_TRACE не показала ничего подозрительного (фактически, она показала, что SQL-операторы выполняются отлично). Профилировщик тоже не дал ничего, кроме подтверждения, что PL/SQL-код тоже работает отлично. Представления динамической производительности V$ в базе данных подтвердили, что все в порядке. С помощью этих средств мы просто доказали, что замедление не связано с работой СУБД. Но выявить проблему они не помогли. Она была вне базы данных, где-то между браузером и базой данных. К сожалению, этот промежуток представлял собой жуткую смесь страниц JSP, компонентов EJB, пулов подключений и CORBA-вызовов. Нам оставалось только снабдить код средствами контроля и отладки, чтобы выявить медленно работающий компонент. Нельзя было просто запустить программу под отладчиком, как "в старые добрые времена". Приходилось работать с десятками компонентов и фрагментов кода, связанными по сети — именно эти компоненты и должны были нам указать, какой именно из них работает медленно. В конце концов мы этот компонент обнаружили. Это был CORBA-вызов существующей системы, который выполнялся для генерации практически каждой страницы. Только создав журнальные файлы с временными метками, мы смогли это обнаружить. Оказалось, что это не проблема базы данных и даже не проблема приложения, но пользователям от этого легче не стало;

для них не важно, чей код работает медленно. Жаль было потраченных на обнаружение причин проблемы недель. Способ включения средств контроля и отладки зависит от используемого языка программирования. Например, в языке PL/SQL я использую специально разработанный для этого пакет DEBUG. Он реализует стандартный механизм журнализации для создания журнальных файлов в любой подпрограмме PL/SQL. Достаточно включить вызовы debug.f в код приложения следующим образом: create function foo... as begin debug.f('Enter procedure f00');

if (some_condition) then l_predicate := 'x=l';

end if;

debug.f("Going to return the predicate "%s"', l_predicate) ;

return l_predicate;

end;

и автоматически в журнал вносятся записи вида:

011101 145055 ( FOO, 6) Enter procedure foo 011101 145056 ( FOO, 11) Going to return the predicate "x=l" При этом в журнал автоматически добавляется дата (01/11/2001) и время (14:50:55), а также информация о том, в какой процедуре/пакете и в какой строке был вызов. Можно Стратегии и средства настройки включать и отключать трассировку в любом модуле или наборе модулей. Это не только полезное средство отладки — по трассировочным файлам легко понять, что именно работало долго. Утилиту DEBUG мы еще рассмотрим в главе 21, где она многократно упоминается. Если бы все приложения и их компоненты имели подобные средства, искать причины снижения производительности стало бы намного проще. В системе без таких средств искать их — все равно, что иголку в стоге сена. Даже хуже, поскольку при поисках иголки вряд ли вокруг будут крутиться советчики, пытающиеся высказать свое мнение о причине проблем и направить поиски по этому пути. Еще раз повторю: все компоненты приложения, даже не связанные с базой данных, должны быть снабжены средствами контроля и отладки, особенно в современных средах, где редко встретишь приложение, взаимодействующее с единственным сервером. С учетом роста популярности Web-приложений, в особенности, использующих сложные распределенные архитектуры, определение источников проблем намного сложнее их устранения. Снабдив с самого начала код средствами контроля и отладки, мы реализуем защитный подход к программированию, который положительно скажется в дальнейшем. Я гарантирую, что вы никогда не пожалеете о включении в приложение средств контроля и отладки, жалеть придется, если вы этого не сделаете. Я настоятельно рекомендую оставить средства отладки в коде готового приложения. Не удаляйте средства отладки в реально работающем приложении. Именно там они наиболее полезны! Я обычно подставляю пустую реализацию тела пакета DEBUG (где все функции сразу делают возврат). При этом если необходим трассировочный файл, я подставляю реальное тело пакета DEBUG, трассирую все, что нужно, а затем подставляю снова пустую реализацию. Удаление кода из производственного приложения "из соображений производительности" существенно снижает его полезность. Посмотрите на саму СУБД: путем установки огромного количества событий служба технической поддержки Oracle может получить огромный объем диагностических данных из производственной базы данных клиента. Разработчики ядра СУБД поняли, что отсутствие трассировочного кода в производственной системе значительно хуже, чем возможные дополнительные расходы ресурсов.

Набор утилит StatsPack Мы уже рассмотрели средства настройки приложений. Трассировка с помощью SQL_TRACE, пакет DBMS_PROFILER, добавление средств контроля и отладки — все это обеспечивает настройку на уровне приложения. Если есть уверенность, что приложение работает максимально хорошо, имеет смысл разобраться с работой всего экземпляра базы данных, оценить его производительность в целом. Именно здесь перекрываются служебные обязанности и размывается грань между функциями администратора базы данных и разработчика приложений. Администратор базы данных должен найти причину замедления, но устранять ее зачастую приходится разработчику. Совместная работа в данном случае обязательна. Раньше для оценки работы экземпляра использовались средства UTLBSTAT и UTLESTAT (начать сбор статистики и закончить сбор статистики). Сценарий UTLBSTAT Глава делал моментальный снимок многих представлений динамической производительности V$. Затем с помощью сценария UTLESTAT создавался отчет по "начальным" и "конечным" значениям в таблицах V$. Полученная статистическая информация обрабатывалась и выдавалась для изучения в виде простого текстового отчета. Начиная с Oracle8i, сценарии BSTAT/ESTAT формально были заменены набором утилит StatsPack. Этот набор инструментальных средств намного превосходит прежние возможности BSTAT/ ESTAT. Наиболее существенным добавлением стала возможность сохранять значения представлений V$ в хронологическом порядке. Т.е. вместо удаления статистической информации после формирования отчета утилиты StatsPack позволяют сохранить данные и генерировать отчеты позже, при необходимости. При использовании средств BSTAT/ ESTAT, например, невозможно было генерировать ежедневные отчеты и почасовой отчет для каждого дня недели. С помощью средств StatsPack можно установить почасовой сбор статистической информации (что мало влияет на работу системы) и генерировать отчеты, сравнивающие два "моментальных снимка". Таким образом, можно создать отчет и за любой час, и за любой день недели. Кроме гибкости при создании отчетов, средства StatsPack обеспечивают более полный набор регистрируемых данных. В этом разделе я собираюсь описать установку утилит StatsPack, сбор данных и, самое главное, анализ получаемых отчетов.

Установка утилит StatsPack Пакет утилит StatsPack должен устанавливаться при подключении как INTERNAL или, еще лучше, как SYSDBA (CONNECT SYS/CHANGE_ON_INSTALL AS SYSDBA), хотя в сценариях все равно будет выполняться CONNECT INTERNAL. Для успешной установки необходимо выполнить эту операцию. Очевидно, придется попросить сделать это администратора базы данных или администраторов сервера. Если можно подключиться как INTERNAL, установка StatsPack — тривиальна. Необходимо просто выполнить сценарий statscre.sql в версии 8.1.6 или spcreate.sql в версии 8.1.7. Они находятся в каталоге [ORACLE_HOME]\rdbms\admin после подключения как INTERNAL с помощью SQL*Plus. Процесс установки выглядит примерно так:

C:\oracle\RDBMS\ADMIN>sqlplus internal SQL*PLUS: Release 8.1.6.0.0 - Production on Sun Mar 18 11:52:32 2001 (c) Copyright 1999 Oracle Corporation. All rights reserved.

Connected to: Oracle8i Enterprise Edition Release 8.1.6.0.0 - Production With the Partitioning option JServer Release 8.1.6.0.0 - Production sys@TKYTE816> @statscre... Installing Required Packages Перед запуском сценария statscre.sql надо знать следующее.

Стратегии и средства настройки • Имя стандартного табличного пространства для пользователя PERFSTAT, который будет создан. • Имя временного табличного пространства для этого пользователя. • В каком табличном пространстве создавать объекты StatsPack. Этот параметр не запрашивается в версии 8.1.7 — только в 8.1.6. В данном табличном пространстве должно быть свободное место для примерно 60 экстентов (так что реальный размер будет зависеть от стандартного размера экстента). Сценарий будет запрашивать эту информацию в ходе выполнения. Если при вводе сделана ошибка или установка была прервана по ходу, надо с помощью сценариев spdrop.sql (8.1.7 и далее) или statsdrp.sql (8.1.6 и ранее) удалить пользователя и все уже установленные представления, прежде чем снова устанавливать StatsPack. При установке StatsPack будет создано три файла с расширением.lis (их имена выдаются на экран в ходе установки). Просмотрите эти файлы и убедитесь, что при установке не было ошибок. Все должно устанавливаться без проблем, если были указаны подходящие имена табличных пространств (и нет пользователя PERFSTAT). Теперь, после установки StatsPack, осталось собрать хотя бы два набора данных. Самый простой способ сделать это — с помощью пакета STATSPACK, принадлежащего пользователю PERFSTAT:

perfstat@DEV2.THINK.COM> exec statspack.snap PL/SQL procedure s u c c e s s f u l l y completed.

Теперь надо подождать некоторое время, дав системе поработать, и сделать еще один моментальный снимок. При наличии данных за два момента времени, создать отчет тоже просто. Для этого надо выполнить сценарий statsrep.sql (8.1.6) или spreport.sql (8.1.7). Это сценарий для утилиты SQL*Plus, который надо выполнять от имени пользователя PERFSTAT (по умолчанию его пароль — PERFSTAT, но его надо изменить сразу же после установки!). Формат отчета несколько изменился при переходе с версии 8.1.6 на 8.1.7, причем формат версии 8.1.7 мне нравится больше;

его мы и рассмотрим. Для создания отчета достаточно выполнить команду:

perfstat@ORA8I.WORLD> @spreport DB Id 4080044148 DB Name ORA8I Inst Num Instance 1 ora8i Completed Snapshots Instance ora8i DB Name ORA8I Snap Id Snap Started 1 18 Mar 2001 12:44 2 18 Mar 2001 12:47 Snap Level Comment 10 Specify the Begin and End Snapshot Ids Enter value for begin_snap:

Глава Выдается список моментов времени, для которых собрана информация, и предлагается выбрать два из них для сравнения. Затем будет сгенерировано стандартное имя отчета и предложено принять его или задать новое. После этого генерируется отчет. Ниже представлен отчет StatsPack версии 8.1.7, по разделам, с комментариями о том, на что обращать внимание и как интерпретировать результаты.

STATSPACK report for DB Name DB Id Instance ORA8I 4080044148 ora8i Snap Id Begin Snap: End Snap: Elapsed: Cache Sizes db_block_buffers: db_block_size: 16384 8192 log_buffer: 512000 shared_pool_size: 102400000 Inst Num Release OPS Host aria 1 8.1.6.2.0 NO Snap Time Sessions 1 18-Mar-01 12:44:41 3 18-Mar-01 12:57: 12.70 (mins) 22 Первая часть отчета носит справочный характер. Здесь показано, по какой базе данных был создан отчет, в частности имя и идентификатор базы данных. В вашей среде они должны быть уникальными. В поле Instance указан идентификатор SID для базы данных. Эти три параметра помогут разобраться, по какой именно базе данных был сгенерирован отчет. Одной из проблем в старых отчетах BSTAT/ESTAT было то, что они не включали никакой идентификационной информации. Неоднократно я получал отчет для анализа, а потом оказывалось, что он делался не на том сервере, где возникла проблема. Теперь такое не случится. Далее идет информация о моментах времени сбора данных и интервале между этими моментами. Для многих странно, что эти интервалы не обязательно должны быть большими — представленный выше отчет покрывает период продолжительностью 13 минут. Важно лишь, чтобы в этот период шла обычная работа с базой данных. Отчет StatsPack для периода продолжительностью 15 минут не менее показателен, чем для периода в один или несколько часов. Чем больше охватываемый период, тем сложнее прийти к определенным выводам по полученным числовым данным. Завершается этот раздел общей информацией о конфигурации сервера. Можно узнать параметры основных компонентов области SGA:

Load Profile Per secona Redo size: Logical reads: Block changes: Physical reads: Physical writes: User calls: Parses: Hard parses: 5,982.09 1,664.37 17.83 15.25 5.66 3.28 16.44 0.17 rar Transaction 13,446.47 3,741.15 40.09 34.29 12.73 7.37 36.96 0. Стратегии и средства настройки Sorts: Logons: Executes: Transactions: 2.95 0.14 30.23 6.64 0.32 67.95 0. В этом разделе компактно представлен большой объем информации. Можно увидеть, какой объем данных повторного выполнения (REDO) генерировался в среднем за секунду и за транзакцию (в данном случае генерировалось от 5 до 6 Кбайт информации повторного выполнения в секунду). Средняя транзакция генерировала около 13 Кбайт данных повторного выполнения. Следующий блок информации связан с логическим и физическим вводом/выводом. Показано, что около 1 процента логических считываний потребовали чтения физического — это очень хорошо. Также показано, что в среднем транзакции выполняли почти 4000 логических считываний. Много это или мало, зависит от системы. В моем случае работало несколько больших фоновых заданий, так что такой объем чтения вполне приемлем. Далее идет действительно важная информация — статистика по разборам. Она свидетельствует, что в среднем выполнялось по 16 разборов в секунду, причем выполнялось в среднем по 0,17 жестких разбора в секунду (разбирались никогда ранее не встречавшиеся операторы SQL). Примерно раз в шесть секунд система разбирала абсолютно новый оператор SQL. Это неплохо. Однако если бы в этом столбце за период, равный нескольким дням, сохранилось значение ноль, что свидетельствует о хорошей настройке системы, я был бы доволен. С некоторого момента все операторы SQL должны находится в разделяемом пуле.

% Blocks changed per Read: Rollback per transaction %: 1.07 0.29 Recursive Call %: Rows per Sort: 97.39 151. В следующем разделе приведен ряд интересных показателей. Параметр % Blocks Changed per Read показывает, что 99 логических чтений пришлись на блоки, которые только считывались, но не изменялись. Система изменяла только 1 процент прочитанных блоков. Процент рекурсивных вызовов (Recursive Call %) очень высок — более 97. Это не означает, что 97 процентов SQL-операторов в моей системе выполняются в ходе "управления пространством" или разбора. Если вернуться к анализу исходного трассировочного файла в разделе, посвященном SQL_TRACE, там было показано, что операторы SQL, выполняющиеся в PL/SQL, также считаются "рекурсивными". В моей системе почти все, кроме модуля mod_plsql (это модуль Web-сервера Apache) и редких пакетных заданий, выполняется с помощью PL/SQL;

все остальное написано на языке PL/SQL. Поэтому я бы удивился низкому значению Recursive Call %. Процент отмененных транзакций (Rollback per transaction %) — очень низкий, и это хорошо. Откат — весьма дорогостоящая операция. Сначала мы что-то делаем, и на это тратятся ресурсы. Затем мы отменяем сделанное, и на это тоже требуются ресурсы. Много ресурсов потрачено без всякого результата. Если большинство транзакций откатывается, значит, основные ресурсы сервера уходят на то, чтобы что-то делать и тут же отменять сделанное. Надо разобраться, чем вызван такой объем отката и как можно переделать приложение, чтобы это изменить. В рассматриваемой системе лишь одна из примерно 345 транзакций откатывается — это приемлемо.

Глава Instance Efficiency Percentages (Target 100%) Buffer Nowait Buffer Hit Library Hit Execute to Parse Parse CPU to Parse Elapsd %: %: %: %: %: 100.00 99.08 99.46 45.61 87.88 Redo NoWait %: In-memory Sort %: Soft Parse %: Latch Hit %: % Non-Parse CPU: 100.00 99.60 98.99 100.00 100. Далее показана эффективность работы экземпляра, Instance Efficiency Percentages. Утверждается, что по этим показателям надо стремиться к 100 процентам, и это почти правда. Единственным исключением, по моему мнению, является показатель Execute to Parse. Он показывает, сколько раз в среднем выполнялся разобранный оператор. В системе, где оператор разбирается, выполняется один раз и больше никогда не выполняется в том же сеансе, этот показатель будет равен нулю. В представленном примере каждый разобранный оператор выполнялся в среднем 1,8 раза (отношение почти два к одному). Хорошо это или плохо, зависит от особенностей системы. В моей системе для всех приложений используется модуль mod_plsql. Создается сеанс, выполняется хранимая процедура, формирующая Web-страницу, и сеанс завершается. Если только в одной хранимой процедуре один и тот же SQL-оператор не выполняется несколько раз, отношение количества выполнений к количеству разборов будет небольшим. С другой стороны, если используется клиент-серверное приложение или подключение к базе данных выполняется с сохранением состояния (например, через интерфейс сервлетов), этот коэффициент (он вычисляется как отношение выполнений без разбора к выполнениям с разбором — прим. научн. ред.) действительно должен быть близок к 100 процентам. Я понимаю, однако, что с учетом используемой архитектуры, существенного повышения этого коэффициента в своей системе я добиться не смогу. Для меня наиболее важными являются показатели разбора, я сразу обращаю на них внимание. Коэффициент Soft Parse показывает процент мягких разборов по отношению к общему количеству выполненных разборов. 99 процентов разборов в моей системе были мягкими (повторно использовались планы выполнения запросов из разделяемого пула). Это хорошо. Если процент мягких разборов — низкий, значит, в системе не используются связываемые переменные. Я считаю, что этот показатель должен быть очень близок к 100 процентам, независимо от использовавшихся для разработки приложений средств и методов. Низкое значение показывает, что напрасно тратятся ресурсы и появляются конфликты доступа. Затем надо обратить внимание на коэффициент Parse CPU to Parse Elapsd. В данном случае он имеет значение около 88 процентов. Это маловато;

мне надо над этим поработать. В данном случае на каждую секунду процессорного времени, потраченного на разбор, приходится около 1,13 секунды реального времени. Это означает, что часть времени уходит на ожидание ресурсов. Если бы этот коэффициент имел значение 100 процентов, то реальное время было бы равно процессорному, т.е. при обработке никто бы никого не ждал. Наконец, коэффициент Non-Parse CPU показывает отношение времени, потраченного на реальную работу, к общему времени, включая разбор операторов. В отчете это значение вычисляется как round(100*(l-PARSE_CPU/ TOT_CPU),2). Если общее время работы, TOT_CPU, намного превосходит время разбора, PARSE_CPU (как и должно быть), этот коэффициент будет очень близок к Стратегии и средства настройки процентам, как у меня. Это хорошо и показывает, что основное время работы компьютера ушло на выполнение, а не на разбор запросов. Подводя итоги по предыдущему разделу, я бы рекомендовал сократить количество жестких разборов. Скорее всего в системе есть еще несколько операторов, не использующих связываемые переменные (каждые шесть секунд появляется новый запрос). Это, в свою очередь, сократит общее количество выполняемых разборов, поскольку при жестком разборе выполняется множество рекурсивных SQL-операторов. Убрав лишь один жесткий разбор, можно сократить также и количество мягких разборов. Все остальные показатели в данном разделе выглядят вполне приемлемыми. Рассмотренная первая часть отчета StatsPack мне нравится больше всего — она дает общее представление об относительном "здоровье" системы. Теперь переходим к остальной части отчета:

Shared Pool Statistics Begin End 75.26 78.72 73. Memory Usage %: 75.03 % SQL with executions>l: 79.18 % Memory for SQL w/exec>l: 74. Этот маленький фрагмент дает некоторую информацию об использовании разделяемого пула. Рассмотрим показатели более детально: • Memory Usage. Процент использования разделяемого пула. Со временем это значение должно стабилизироваться в диапазоне от 70 с небольшим до 90 процентов. Если процент использования слишком низкий, значит, память тратится напрасно. Если процент слишком высок, значит, происходит вытеснение компонентов разделяемого пула как устаревших, что приводит к жесткому разбору SQLоператоров при повторном выполнении. При правильно подобранном размере разделяемого пула должно использоваться от 75 до не более чем 90 процентов его пространства. • SQL with executions>1. Этот показатель определяет, сколько SQL-операторов в разделяемом пуле выполнялось больше одного раза. К оценке его значения в системах, работающих циклически, с разными задачами в течение дня (например, задачи класса оперативной обработки транзакций в рабочее время и задачи систем поддержки принятия решений по ночам) надо подходить вдумчиво. За изучаемый период многие SQL-операторы в разделяемом пуле могут не выполниться повторно только потому, что в этот период не выполнялись посылающие их процессы. Только если в системе постоянно выполняются одни и те же SQL-операторы, этот показатель может приблизиться к 100 процентам. В данном случае около 80 процентов SQL-операторов в разделяемом пуле использовалось более одного раза за рассмотренный период продолжительностью 13 минут. Остальные 20 процентов моей системе, вероятно, просто не понадобилось повторно выполнять. • Memory for SQL w/exec>l. Этот показатель определяет, сколько памяти используют часто выполняемые операторы SQL по сравнению с теми, которые выполняются редко. В общем случае его значение будет очень близким к проценту нео Глава днократно выполнявшихся операторов SQL, если только нет запросов, требующих слишком много памяти. Этот показатель мне не кажется особенно полезным. Итак, в общем случае в стабильном состоянии должно использоваться от 75 до 85 процентов разделяемого пула. SQL-операторы, выполнявшиеся более одного раза, должны составлять около 100 процентов, если в отчете StatsPack рассматривается достаточно продолжительный период, охватывающий все циклы работы. На этот показатель как раз влияет продолжительность периода между наблюдениями. Чем больший период рассматривается, тем больше должно быть это значение. Теперь переходим к следующему разделу:

Тор 5 Wait Events Event SQL*Net more data from dblink control file parallel write log file sync db file scattered read db file sequential read Waits 1,661 245 150 1,020 483 Time Wait (cs) 836 644 280 275 165 % Total Wt Time 35.86 27.63 12.01 11.80 7. Wait Events for DB: ORA8I Instance: ora8i Snaps: 1 -3 -> cs - centisecond - 100th of a second -> ms - millisecond - 1000th of a second -> ordered by wait time desc, waits desc (idle events last) Вот ваша ближайшая цель: события, замедляющие работу намного больше всего остального. Сначала надо посмотреть на значение Wait Time, чтобы понять, стоит ли время ожидания того, чтобы настраивать систему для его уменьшения. Например, за 13 минут я потратил 8,36 секунд в ожидании данных из удаленной базы (data from a dblink). Стоил ли тратить время на поиски и "устранение" причины? В данном случае, я считаю, не стоит: среднее ожидание составило 0,004 секунды. Более того, я знаю, что работает фоновый процесс, выполняющий сложную операцию с удаленной базой данных, так что с учетом всех факторов время ожидания получилось весьма небольшим. Итак, пусть найдено событие, требующее внимания. Сначала нужно понять, что это за событие. Например, если посмотреть описание события log file sync в руководстве Oracle Reference Manual, то можно узнать, что: Когда пользовательский сеанс фиксирует транзакцию, информация повторного выполнения должна быть сброшена в файл журнала повторного выполнения. Пользовательский сеанс выдает задание процессу LGWR на запись буфера журнала повторного выполнения в файл журнала. Когда процесс LGWR завершит запись, он уведомляет об этом пользовательский сеанс. Wait Time: время ожидания включает время записи буфера журнала и время уведомления. Теперь, когда понятно, чего именно пришлось ждать, можно придумать, как от этого ожидания избавиться. Когда ожидается синхронизация файла журнала, надо настра Стратегии и средства настройки ивать работу процесса LGWR. Чтобы уменьшить время ожидания можно использовать более быстрые диски, генерировать меньше информации повторного выполнения, снизить конфликты доступа к дискам, содержащим журналы, и т.д. Найти причину ожидания — одно дело, устранить ее — совсем другое. В Oracle измеряется время ожидания более 200 событий, причем ни для одного из них нет простого способа сократить время ожидания. Не стоит забывать, что ждать чего-нибудь придется всегда. Если устранить одно препятствие, появится другое. Нельзя вообще избавиться от длительного ожидания событий — всегда придется чего-то ждать. Настройка "для максимально быстрой работы" может продолжаться бесконечно. Всегда можно сделать так, чтобы скорость работы возросла на один процент, но время, которое необходимо затратить на обеспечение каждого последующего процента прироста производительности, растет экспоненциально. Настройкой надо заниматься при наличии конкретной конечной цели. Если нельзя сказать, что настройка закончена, если достигнут показатель X, где X можно измерить, значит, вы напрасно тратите время. Следующий раздел отчета:

Wait Events for DB: ORA8I Instance: ora8i Snaps: 1 -3 -> cs - centisecond - 100th of a second -> ms - millisecond - 1000th of a second -> ordered by wait tine desc, waits desc (idle events last) Avg Total Wait wait Event Waits Timeouts Time (cs) (ms) SQL*Net more data from dblin control file parallel write log file sync db file scattered read db file sequential read control file sequential read SQL*Net message from dblink refresh controlfile command log file parallel write latch free SQL*Net more data to client single-task message direct path read direct path write file open SQL*Net message to dblink db file parallel write LGWR wait for redo copy file identify SQL*Net message from client virtual circuit status pipe get SQL*Net more data from clien SQL*Net message to client 1,861 245 150 1,020 483 206 51 21 374 13 586 1 716 28 28 51 24 3 1 2,470 25 739 259 2, Waits /txn 5.5 0.7 0.4 3.0 1.4 0.6 0.2 0.1 1.1 0.0 1.7 0.0 2.1 0.1 0.1 0.2 0.1 0.0 0.0 7.3 0.1 2.2 0.8 7. 0 0 0 0 0 0 0 0 10 0 0 0 0 0 0 0 0 0 25 739 836 644 280 275 165 44 35 28 14 3 2 2 1 1 1 0 0 0 0 1,021,740 76,825 76,106 3 26 19 3 3 2 7 0 2 0 20 0 0 0 0 0 0 4137 30730 Глава показывает все ожидания событий клиентами, произошедшие за рассматриваемый период. Кроме информации, представленной в разделе Тор 5, показано среднее время ожидания в тысячных долях секунды, а также, сколько раз транзакция ожидала этого события. Это помогает найти существенные события. Обращаю ваше внимание, что в этом разделе множество событий надо игнорировать. Например, ожидание события SQL*Net message from client можно игнорировать в тех системах, где клиенту необходимо время на размышление. Это время, в течение которого клиент не обращался к базе данных с запросами (с другой стороны, если подобные ожидания происходят при загрузке данных, значит, клиент недостаточно быстро передает данные, и это уже проблема). В нашем случае, однако, это ожидание означает, что клиент был подключен, но не делал никаких запросов. В заголовке раздела сказано, что записи ожиданий событий, связанные с простоями, приведены в конце. Все события, начиная с SQL*Net message from client и ниже, связаны с простоями: процесс ждал, пока к нему обратятся. В большинстве случаев все эти ожидания можно игнорировать.

Background Wait Events for DB: ORA8I Instance: ora8i Snaps: 1 -3 -> ordered by trait tine desc, waits desc (idle events last) Avg Total Wait wait Waits Event Waits Timeouts Time (cs) (ms) /txn control file parallel write control file sequential read log file parallel write db file parallel write LGHR wait for redo copy rdbms ipc message smon timer pmon timer 245 42 374 24 3 1,379 3 248 0 0 0 0 0 741 3 248 644 25 14 0 0 564,886 92,163 76,076 26 0.7 0.1 1.1 0.1 0.0 4.1 0.0 0. 0 0 0 4096 Представленный выше раздел отчета StatsPack показывает ожидания событий "фоновыми" процессами (DBWR, LGWR и т.д.). И в этом разделе записи для событий, связанных с простоями, приведены в конце, и тоже, в общем случае, могут быть проигнорированы. Раздел пригодится при настройке экземпляра в целом, чтобы понять, чего именно ждут фоновые процессы. Что именно замедляет работу сеанса, определить несложно — мы уже многократно делали это в примерах, посвященных использованию связываемых переменных, и в других разделах: достаточно выполнить запрос к представлению V$SESSION_EVENT. Этот фрагмент отчета показывает, каких событий ожидают фоновые процессы, во многом аналогично тому, как ожидания представлены для отдельных сеансов.

SQL ordered by Gets for DB: ORA8I Instance: ora8i Snaps: 1 -3 -> End Buffer Gets Threshold: 10000 -> Note that resources reported for PL/SQL includes the resources used by all SQL statements called within the PL/SQL code. As individual SQL statements are also reported, it is possible and valid for the summed total % to exceed Стратегии и средства настройки Buffer Gets 713,388 Executions 1 Gets per Exec 713,388.0 % Total 56.2 Hash Value BEGIN sys.sync_usera.do_it;

END;

485,161 1 485,161.0 38.3 1989876028 SELECT DECODE (SA. GRANTEE#, 1, ' PUBLIC', U1.NAME) "GRANTEE", U2.NAME "GRANTED_ROLE", DECODE (OPTION$, 1, 'YES', ' NO') "ADMIN_OPTION" FRO M SYSAUTH$@ORACLE8.WORLD SA,DEFROLE$@ORACLE8.WORLD UD,USER$@ORAC LE8. WORLD Ul,USER$@ORACLE8.WORLD U2 WHERE SA.GRANTEE# = UD.USER # (+) AND SA.PRIVILEGE# = UD.ROLE# (+) AND U1.USER* = SA.G 239,778 2 BEGIN statspack.snap(lO);

END;

119,889.0 18.9 В этом разделе представлены "основные" операторы SQL. Все SQL-операторы упорядочены по убыванию показателя Buffer Gets, другими словами, по убыванию выполняемых логических операций ввода/вывода. Как сказано в комментарии в начале отчета, количество прочитанных буферов для программной единицы PL/SQL равно сумме обращений к буферам всех SQL-операторов, выполненных в соответствующем блоке кода. Поэтому часто в начале списка можно обнаружить PL/SQL-процедуры — показатели отдельных составляющих операторов для них суммируются. В нашем случае первой указана PL/SQL-процедура sync_users.do_it. Она затрагивает более 700000 блоков при каждом выполнении. Хорошо это или плохо, по данному фрагменту отчета не понятно. Здесь представлены только факты — никаких оценок. Я знаю, что sync_users — большое фоновое задание, синхронизирующее словари данных двух баз и гарантирующее, что пользователь, созданный в одной базе данных, создается и в другой, а также что совпадают все роли и пароли пользователей. Вполне понятно, что она обрабатывает большой объем информации. Как оказалось, именно это задание и ждало поступления информации из удаленной базы данных (это ожидание мы обнаружили ранее).

SQL ordered by Reads for DB: ORA8I Instance: oxa8i -> End Disk Reads Threshold: 1000 Physical Reads Executions Reads per Exec 8,484.0 1,405.0 Snaps: 1 -3 Hash Value 1907729738 % Total 73.0 24. 8,484 1 BEGIN sys.sync_users.do_it;

END;

2,810 2 BEGIN statspack.snap(lO);

END;

Этот раздел очень похож на предыдущий, но вместо логического ввода/вывода он информирует о физическом вводе/выводе. В нем показаны SQL-операторы, наиболее активно физически читающие данные. Именно на эти запросы и процессы надо обратить внимание, если система не справляется с объемом ввода/вывода. Процедуру sync_users, видимо, надо настроить — она является основным потребителем ресурсов дисковой подсистемы.

Глава 10 Instance: ora8i Snaps: 1 - SQL ordered by Executions for DB: ORA8I -> End Executions Threshold: 100 Executions Rows Processed Rows per Exec Hash Value 2,583 0 0.0 4044433098 SELECT TRANSLATE_TO_TEXT FROM WWV_FLOW_DYNAMIC_TRANSLATIONS$ WHERE TRANSLATE_FROM_TEXT = :b1 AND TRANSLATE_TO_LANG_CODE = :b 2 2,065 SELECT DISPLAY_NAME AME = :b1 2,065 1.0 2573952486 FROM WWC_PEOPLE_LABEL_NAMES WHERE LABEL_N Эта часть отчета об "основных" SQL-операторах показывает, какие операторы выполнялись чаще всего за рассматриваемый период. Эта информация может пригодиться для выявления ряда наиболее часто выполняемых запросов с целью изменения алгоритмов работы приложений так, чтобы эти запросы выполнялись не так часто. Возможно, запрос выполняется в цикле, а мог бы выполняться один раз за пределами цикла —несложное изменение алгоритма может уменьшить количество выполнений запроса. Даже если запрос выполняется мгновенно, его выполнение миллион раз требует существенного времени.

SQL ordered by Version Count for DB: ORA8I -> End Version Count Threshold: 20 Version Count Executions Hash Value Instance: ora8i Snaps: 1 - 21 415 451919557 SELECT SHORTCUT_NAME,ID FROM WWV_FLOW_SHORTCUTS WHERE FLOW_ID = :bl AND (:b2 IS NULL OR SHORTCUT_NAME = :Ь2 ) AND NOT EXIST S (SELECT 1 FROM WWV_FLOW_PATCHES WHERE FLOW_ID = :Ы AND I D = BUILD_OPTION AND PATCH_STATUS = 'EXCLUDE' ) ORDER BY SHORT CUT_NAME, SHORTCUT_CONSIDERATION_SEQ 21 110 1510890808 SELECT DECODE ( :b1, 1, ICON_IMAGE, 2, ICON_IMAGE2,3, ICON_IMAGE3) ICON _IMAGE,DECODE(:b1,1,ICON_SUBTEXT,2,ICON_SUBTEXT2,3,ICON_SUBTEXT3 ) ICON_SUBTEXT, ICON_TARGET, ICON_IMAGE_ALT, DECODE (:b1, 1, ICON_HEIG HT, 2,NVL (ICON_HEIGHT2, ICON_HEIGHT), 3,NVL (ICON_HEIGHT3, ICON_HEIGH T) ) ICON_HEIGHT, DECODE (:b1, 1, ICON_WIDTH, 2, NVL (ICON_WIDTH2, ICON_H В этом разделе показаны SQL-операторы по убыванию количества экземпляров одного и того же оператора в разделяемом пуле. Причин наличия нескольких экземпляров одного и того же SQL-оператора в разделяемом пуле может быть много. Вот некоторые из них. • Разные пользователи выполняли один и тот же SQL-оператор, но обращается он к разным таблицам. • Тот же запрос выполняется в принципиально отличающейся среде, например, с другим режимом оптимизации.

Pages:     | 1 |   ...   | 8 | 9 || 11 | 12 |   ...   | 24 |



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

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