Em um artigo anterior já mostramos a importância do índice composto para melhorar o desempenho de uma instrução SQL, agora vamos estudar um pouco como a ordem das colunas no índice composto pode impactar o desempenho de uma instrução SQL. A ordem das colunas no índice composto é importante, no…
3 maneiras incomuns de utilização de índices
A utilização do índice B-TREE com uma coluna ou com um grupo de colunas é muito comum nas aplicações, estas colunas são referenciadas na cláusula WHERE das instruções SQL e possibilitam uma rápida recuperação dos dados que o usuário deseja, mas existem outras formas de utilizar os índices que são pouco empregadas no dia a dia, mas que podem melhorar muito o desempenho da instrução SQL. Neste artigo vamos abordar 3 destas situações e mostrar sua eficácia através de exemplos:
1) Como eliminar o acesso a tabela, recuperando os dados somente de índices através da junção de índices.
2) Como utilizar um índice numa coluna onde o filtro especificado para essa coluna é um valor nulo.
3) Como utilizar um índice em colunas que são referenciadas na cláusula WHERE como uma função.
1) Eliminando o acesso a tabela
Para demonstrar esta situação vamos utilizar uma consulta na tabela CUSTOMERS do esquema SH, na primeira execução o Otimizador vai escolher o índice CUSTOMERS_PK que indexa a coluna CUST_ID e vai selecionar os ROWID dos registros que serão acessados na tabela.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 | SQL > SELECT * FROM V$VERSION where rownum < 2; BANNER -------------------------------------------------------------------------------- Oracle Database 11g Enterprise Edition Release 11.2.0.4.0 - 64bit Production 1 linha selecionada. SQL > create index sh.CUST_NAME_IDX on sh.CUSTOMERS(CUST_FIRST_NAME, CUST_LAST_NAME); Índice criado. SQL > ALTER SESSION SET statistics_level=ALL; Sessão alterada. SQL > ALTER SESSION SET current_schema=SH; Sessão alterada. SQL > SQL > SELECT /* DBTW001 */ 2 c.cust_id, c.cust_first_name, c.cust_last_name 3 FROM sh.customers c 4 WHERE c.cust_id >=100 5 AND c.cust_id <=400 6 AND c.cust_last_name like 'Her%'; CUST_ID CUST_FIRST_NAME CUST_LAST_NAME ---------- -------------------- ---------------------------------------- 161 Linda Hermann 167 Eve Herd 2 linhas selecionadas. SQL > SQL > column sql_id new_value m_sql_id SQL > column child_number new_value m_child_no SQL > SELECT sql_id, child_number 2 FROM v$sql 3 WHERE sql_text LIKE '%DBTW001%' 4 AND sql_text NOT LIKE '%v$sql%'; SQL_ID CHILD_NUMBER ---------------- ------------ 0y7sa312c8y0q 0 1 linha selecionada. SQL > SQL > SELECT * 2 FROM TABLE (dbms_xplan.display_cursor ('&m_sql_id',&m_child_no,'typical iostats last')); PLAN_TABLE_OUTPUT ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ SQL_ID 0y7sa312c8y0q, child number 0 ------------------------------------- SELECT /* DBTW001 */ c.cust_id, c.cust_first_name, c.cust_last_name FROM sh.customers c WHERE c.cust_id >=:"SYS_B_0" AND c.cust_id <=:"SYS_B_1" AND c.cust_last_name like :"SYS_B_2" Plan hash value: 2754890837 --------------------------------------------------------------------------------------------------------------------------------------- | Id | Operation | Name | Starts | E-Rows |E-Bytes| Cost (%CPU)| E-Time | A-Rows | A-Time | Buffers | --------------------------------------------------------------------------------------------------------------------------------------- | 0 | SELECT STATEMENT | | 1 | | | 160 (100)| | 2 |00:00:00.01 | 294 | |* 1 | FILTER | | 1 | | | | | 2 |00:00:00.01 | 294 | |* 2 | TABLE ACCESS BY INDEX ROWID| CUSTOMERS | 1 | 1 | 20 | 160 (0)| 00:00:02 | 2 |00:00:00.01 | 294 | |* 3 | INDEX RANGE SCAN | CUSTOMERS_PK | 1 | 161 | | 2 (0)| 00:00:01 | 301 |00:00:00.01 | 3 | --------------------------------------------------------------------------------------------------------------------------------------- Predicate Information (identified by operation id): --------------------------------------------------- 1 - filter(:SYS_B_1>=:SYS_B_0) 2 - filter("C"."CUST_LAST_NAME" LIKE :SYS_B_2) 3 - access("C"."CUST_ID">=:SYS_B_0 AND "C"."CUST_ID"<=:SYS_B_1) 24 linhas selecionadas. SQL > |
Analisando a consulta verificamos que as colunas referenciadas na cláusula WHERE e a colunas que vão ser apresentadas como resultado da consulta estão presentes em dois índices da tabela CUSTOMERS, os índices CUSTOMERS_PK e CUST_NAME_IDX. Assim podemos forçar o Otimizador através do “HINT INDEX_JOIN” a recuperar todas as informações necessárias dos índices, não sendo necessário o acesso a tabela, com isso a quantidade de blocos de dados acessados será menor.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 | SQL > set tab off; SQL > SQL > ALTER SESSION SET statistics_level=ALL; Sessão alterada. SQL > ALTER SESSION SET current_schema=SH; Sessão alterada. SQL > SQL > SELECT /*+ index_join(c) */ /* DBTW002 */ 2 c.cust_id, c.cust_first_name, c.cust_last_name 3 FROM sh.customers c 4 WHERE c.cust_id >=100 5 AND c.cust_id <=400 6 AND c.cust_last_name like 'Her%'; CUST_ID CUST_FIRST_NAME CUST_LAST_NAME ---------- -------------------- ---------------------------------------- 167 Eve Herd 161 Linda Hermann 2 linhas selecionadas. SQL > SQL > column sql_id new_value m_sql_id SQL > column child_number new_value m_child_no SQL > SELECT sql_id, child_number 2 FROM v$sql 3 WHERE sql_text LIKE '%DBTW002%' 4 AND sql_text NOT LIKE '%v$sql%'; SQL_ID CHILD_NUMBER ---------------- ------------ ba75mduk0kz6q 0 1 linha selecionada. SQL > SQL > SELECT * 2 FROM TABLE (dbms_xplan.display_cursor ('&m_sql_id',&m_child_no,'typical iostats last')); PLAN_TABLE_OUTPUT ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ SQL_ID ba75mduk0kz6q, child number 0 ------------------------------------- SELECT /*+ index_join(c) */ /* DBTW002 */ c.cust_id, c.cust_first_name, c.cust_last_name FROM sh.customers c WHERE c.cust_id >=:"SYS_B_0" AND c.cust_id <=:"SYS_B_1" AND c.cust_last_name like :"SYS_B_2" Plan hash value: 1080046246 -------------------------------------------------------------------------------------------------------------------------------------- | Id | Operation | Name | Starts | E-Rows |E-Bytes| Cost (%CPU)| E-Time | A-Rows | A-Time | Buffers | -------------------------------------------------------------------------------------------------------------------------------------- | 0 | SELECT STATEMENT | | 1 | | | 197 (100)| | 2 |00:00:00.01 | 203 | |* 1 | FILTER | | 1 | | | | | 2 |00:00:00.01 | 203 | |* 2 | VIEW | index$_join$_001 | 1 | 1 | 20 | 197 (1)| 00:00:03 | 2 |00:00:00.01 | 203 | |* 3 | HASH JOIN | | 1 | | | | | 2 |00:00:00.01 | 203 | |* 4 | INDEX RANGE SCAN | CUSTOMERS_PK | 1 | 1 | 20 | 2 (0)| 00:00:01 | 301 |00:00:00.01 | 2 | |* 5 | INDEX FAST FULL SCAN| CUST_NAME_IDX | 1 | 1 | 20 | 243 (0)| 00:00:03 | 82 |00:00:00.01 | 201 | -------------------------------------------------------------------------------------------------------------------------------------- Predicate Information (identified by operation id): --------------------------------------------------- 1 - filter(:SYS_B_1>=:SYS_B_0) 2 - filter(("C"."CUST_ID"<=:SYS_B_1 AND "C"."CUST_ID">=:SYS_B_0)) 3 - access(ROWID=ROWID) 4 - access("C"."CUST_ID">=:SYS_B_0 AND "C"."CUST_ID"<=:SYS_B_1) 5 - filter("C"."CUST_LAST_NAME" LIKE :SYS_B_2) 29 linhas selecionadas. SQL > |
Ajudo DBAs e analistas de sistema a se destacarem em suas empresas
e obter um crescimento mais acelerado em suas carreiras, quer saber mais click no link abaixo:
Comparando os dois planos de execução verificamos que na primeira execução da consulta a quantidade de buffers acessados foi 294 enquanto na segunda execução foram acessados 203 buffers, o plano mostra que os dois índices foram acessados através da operação HASH JOIN.
2) Utilizando filtros de valor nulo
Quando criamos um índice em uma coluna da tabela onde existem registros com valores nulos, este índice irá reconhecer somente os registros ou linhas que não possuem valores nulos. Por esta razão quando executamos uma consulta com o filtro de valores nulos em uma determinada coluna, o plano de execução desta consulta utilizará a operação TABLE FULL SCAN mesmo que exista um índice para esta coluna e o numero de registros nulos seja pequeno. Abaixo podemos verificar um exemplo prático dessa situação:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 | SQL > SELECT * FROM V$VERSION where rownum < 2; BANNER -------------------------------------------------------------------------------- Oracle Database 11g Enterprise Edition Release 11.2.0.4.0 - 64bit Production 1 linha selecionada. SQL > SQL > SQL > create index CURSO01.DBTW_OBJECTS_ID_IDX on CURSO01.DBTW_OBJECTS(OBJECT_ID); Índice criado. SQL > SQL > set tab off; SQL > SQL > ALTER SESSION SET statistics_level=ALL; Sessão alterada. SQL > ALTER SESSION SET current_schema=CURSO01; Sessão alterada. SQL > SQL > col OBJECT_NAME for a30; SQL > select /* DBTW101 */ OBJECT_NAME, 2 OBJECT_TYPE, 3 CREATED 4 from DBTW_OBJECTS 5 where OBJECT_ID is null; OBJECT_NAME OBJECT_TYPE CREATED ------------------------------ ------------------- -------- YPKHOMO DATABASE LINK 09/05/15 APPL338 DATABASE LINK 17/12/15 APPL359 DATABASE LINK 16/12/15 XPTO_05 DATABASE LINK 09/05/15 ATIVO_YPK DATABASE LINK 07/10/15 APPL306 DATABASE LINK 07/10/15 YPK DATABASE LINK 09/05/15 APPL308 DATABASE LINK 09/05/15 APPL302 DATABASE LINK 09/05/15 DESENV_YPK DATABASE LINK 25/08/15 DESENV_XPTO DATABASE LINK 17/11/15 11 linhas selecionadas. SQL > SQL > column sql_id new_value m_sql_id SQL > column child_number new_value m_child_no SQL > SELECT sql_id, child_number 2 FROM v$sql 3 WHERE sql_text LIKE '%DBTW101%' 4 AND sql_text NOT LIKE '%v$sql%'; SQL_ID CHILD_NUMBER ---------------- ------------ 7cqnxfyjkud1r 0 1 linha selecionada. SQL > SQL > SELECT * 2 FROM TABLE (dbms_xplan.display_cursor ('&m_sql_id',&m_child_no,'typical iostats last')); PLAN_TABLE_OUTPUT ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ SQL_ID 7cqnxfyjkud1r, child number 0 ------------------------------------- select /* DBTW101 */ OBJECT_NAME, OBJECT_TYPE, CREATED from DBTW_OBJECTS where OBJECT_ID is null Plan hash value: 3768306837 ---------------------------------------------------------------------------------------------------------------------------- | Id | Operation | Name | Starts | E-Rows |E-Bytes| Cost (%CPU)| E-Time | A-Rows | A-Time | Buffers | ---------------------------------------------------------------------------------------------------------------------------- | 0 | SELECT STATEMENT | | 1 | | | 476 (100)| | 11 |00:00:00.01 | 1717 | |* 1 | TABLE ACCESS FULL| DBTW_OBJECTS | 1 | 11 | 495 | 476 (1)| 00:00:06 | 11 |00:00:00.01 | 1717 | ---------------------------------------------------------------------------------------------------------------------------- Predicate Information (identified by operation id): --------------------------------------------------- 1 - filter("OBJECT_ID" IS NULL) 19 linhas selecionadas. SQL > |
Para permitir que o índice trate os registros que apresentam valores nulos na coluna especificada, podemos criar um índice composto onde o primeiro campo é a coluna da tabela que queremos indexar e o segundo campo e um valor fixo qualquer. Abaixo recriamos o índice utilizando esta técnica e executamos a consulta novamente:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 | SQL > drop index CURSO01.DBTW_OBJECTS_ID_IDX; Índice eliminado. SQL > SQL > create index CURSO01.DBTW_OBJECTS_ID_IDX on CURSO01.DBTW_OBJECTS(OBJECT_ID,0); Índice criado. SQL > set tab off; SQL > SQL > ALTER SESSION SET statistics_level=ALL; Sessão alterada. SQL > ALTER SESSION SET current_schema=CURSO01; Sessão alterada. SQL > SQL > SQL > select /* DBTW102 */ OBJECT_NAME, 2 OBJECT_TYPE, 3 CREATED 4 from DBTW_OBJECTS 5 where OBJECT_ID is null; OBJECT_NAME OBJECT_TYPE CREATED ------------------------------ ------------------- -------- YPKHOMO DATABASE LINK 09/05/15 APPL338 DATABASE LINK 17/12/15 APPL359 DATABASE LINK 16/12/15 XPTO_05 DATABASE LINK 09/05/15 ATIVO_YPK DATABASE LINK 07/10/15 APPL306 DATABASE LINK 07/10/15 YPK DATABASE LINK 09/05/15 APPL308 DATABASE LINK 09/05/15 APPL302 DATABASE LINK 09/05/15 DESENV_YPK DATABASE LINK 25/08/15 DESENV_XPTO DATABASE LINK 17/11/15 11 linhas selecionadas. SQL > SQL > column sql_id new_value m_sql_id SQL > column child_number new_value m_child_no SQL > SELECT sql_id, child_number 2 FROM v$sql 3 WHERE sql_text LIKE '%DBTW102%' 4 AND sql_text NOT LIKE '%v$sql%'; SQL_ID CHILD_NUMBER ---------------- ------------ 0x60spb2w32s6 0 1 linha selecionada. SQL > SQL > SELECT * 2 FROM TABLE (dbms_xplan.display_cursor ('&m_sql_id',&m_child_no,'typical iostats last')); PLAN_TABLE_OUTPUT ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ SQL_ID 0x60spb2w32s6, child number 0 ------------------------------------- select /* DBTW102 */ OBJECT_NAME, OBJECT_TYPE, CREATED from DBTW_OBJECTS where OBJECT_ID is null Plan hash value: 3646832289 --------------------------------------------------------------------------------------------------------------------------------------------- | Id | Operation | Name | Starts | E-Rows |E-Bytes| Cost (%CPU)| E-Time | A-Rows | A-Time | Buffers | --------------------------------------------------------------------------------------------------------------------------------------------- | 0 | SELECT STATEMENT | | 1 | | | 3 (100)| | 11 |00:00:00.01 | 5 | | 1 | TABLE ACCESS BY INDEX ROWID| DBTW_OBJECTS | 1 | 11 | 495 | 3 (0)| 00:00:01 | 11 |00:00:00.01 | 5 | |* 2 | INDEX RANGE SCAN | DBTW_OBJECTS_ID_IDX | 1 | 11 | | 2 (0)| 00:00:01 | 11 |00:00:00.01 | 3 | --------------------------------------------------------------------------------------------------------------------------------------------- Predicate Information (identified by operation id): --------------------------------------------------- 2 - access("OBJECT_ID" IS NULL) 20 linhas selecionadas. SQL > |
Agora podemos observar que no plano de execução acima o índice foi utilizado e o desempenho da consulta foi muito melhor que na primeira execução, a quantidade de buffers lidos caiu de 1717 para 5 buffers.
3) Utilizando funções na cláusula WHERE
Não é incomum encontrarmos instruções SQL utilizando funções como filtro na cláusula WHERE e na maioria desses casos verificamos que o plano de execução acaba executando uma operação de TABLE FULL SCAN na tabela para recuperar os registros que atendam ao filtro da função, como no exemplo abaixo:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 | SQL > SELECT * FROM V$VERSION where rownum < 2; BANNER -------------------------------------------------------------------------------- Oracle Database 11g Enterprise Edition Release 11.2.0.4.0 - 64bit Production 1 linha selecionada. SQL > SQL > SQL > set tab off; SQL > SQL > ALTER SESSION SET statistics_level=ALL; Sessão alterada. SQL > ALTER SESSION SET current_schema=SH; Sessão alterada. SQL > SQL > SQL > select /* DBTW301 */ PROD_ID, 2 (quantity_sold * amount_sold) total_sold 3 from sales 4 where (quantity_sold * amount_sold) > 5000; PROD_ID TOTAL_SOLD ---------- ---------- 13 13553,76 13 13562,89 13 13562,89 13 13265,89 4 linhas selecionadas. SQL > SQL > column sql_id new_value m_sql_id SQL > column child_number new_value m_child_no SQL > SELECT sql_id, child_number 2 FROM v$sql 3 WHERE sql_text LIKE '%DBTW301%' 4 AND sql_text NOT LIKE '%v$sql%'; SQL_ID CHILD_NUMBER ---------------- ------------ a4c214bz2rgb0 0 1 linha selecionada. SQL > SQL > SELECT * 2 FROM TABLE (dbms_xplan.display_cursor ('&m_sql_id',&m_child_no,'typical iostats last')); PLAN_TABLE_OUTPUT ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ SQL_ID a4c214bz2rgb0, child number 0 ------------------------------------- select /* DBTW301 */ PROD_ID, (quantity_sold * amount_sold) total_sold from sales where (quantity_sold * amount_sold) > :"SYS_B_0" Plan hash value: 1550251865 ------------------------------------------------------------------------------------------------------------------------------------------------ | Id | Operation | Name | Starts | E-Rows |E-Bytes| Cost (%CPU)| E-Time | Pstart| Pstop | A-Rows | A-Time | Buffers | Reads | ------------------------------------------------------------------------------------------------------------------------------------------------ | 0 | SELECT STATEMENT | | 1 | | | 1292 (100)| | | | 4 |00:00:00.87 | 4472 | 4439 | | 1 | PARTITION RANGE ALL| | 1 | 45942 | 538K| 1292 (1)| 00:00:16 | 1 | 28 | 4 |00:00:00.87 | 4472 | 4439 | |* 2 | TABLE ACCESS FULL | SALES | 28 | 45942 | 538K| 1292 (1)| 00:00:16 | 1 | 28 | 4 |00:00:00.87 | 4472 | 4439 | ------------------------------------------------------------------------------------------------------------------------------------------------ Predicate Information (identified by operation id): --------------------------------------------------- 2 - filter("QUANTITY_SOLD"*"AMOUNT_SOLD">:SYS_B_0) 21 linhas selecionadas. SQL > |
A boa noticia é que podemos criar um índice para este tipo de situação e com ele tornar o desempenho da consulta muito melhor, veja a seguir como podemos criar um Function Base Index (FBI) que torna da execução desta consulta muito mais eficiente.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 | SQL > create index sh.sales_total_IDX on sh.sales(quantity_sold * amount_sold); Índice criado. SQL > SQL > set tab off; SQL > SQL > ALTER SESSION SET statistics_level=ALL; Sessão alterada. SQL > ALTER SESSION SET current_schema=SH; Sessão alterada. SQL > SQL > SQL > select /* DBTW302 */ PROD_ID, 2 (quantity_sold * amount_sold) total_sold 3 from sales 4 where (quantity_sold * amount_sold) > 5000; PROD_ID TOTAL_SOLD ---------- ---------- 13 13265,89 13 13553,76 13 13562,89 13 13562,89 4 linhas selecionadas. SQL > SQL > column sql_id new_value m_sql_id SQL > column child_number new_value m_child_no SQL > SELECT sql_id, child_number 2 FROM v$sql 3 WHERE sql_text LIKE '%DBTW302%' 4 AND sql_text NOT LIKE '%v$sql%'; SQL_ID CHILD_NUMBER ---------------- ------------ b171zy5vbtm1u 0 1 linha selecionada. SQL > SQL > SELECT * 2 FROM TABLE (dbms_xplan.display_cursor ('&m_sql_id',&m_child_no,'typical iostats last')); PLAN_TABLE_OUTPUT ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ SQL_ID b171zy5vbtm1u, child number 0 ------------------------------------- select /* DBTW302 */ PROD_ID, (quantity_sold * amount_sold) total_sold from sales where (quantity_sold * amount_sold) > :"SYS_B_0" Plan hash value: 4182791213 ---------------------------------------------------------------------------------------------------------------------------------------------------------------- | Id | Operation | Name | Starts | E-Rows |E-Bytes| Cost (%CPU)| E-Time | Pstart| Pstop | A-Rows | A-Time | Buffers | ---------------------------------------------------------------------------------------------------------------------------------------------------------------- | 0 | SELECT STATEMENT | | 1 | | | 271 (100)| | | | 4 |00:00:00.01 | 8 | | 1 | TABLE ACCESS BY GLOBAL INDEX ROWID| SALES | 1 | 45942 | 762K| 271 (0)| 00:00:04 | ROWID | ROWID | 4 |00:00:00.01 | 8 | |* 2 | INDEX RANGE SCAN | SALES_TOTAL_IDX | 1 | 8270 | | 25 (0)| 00:00:01 | | | 4 |00:00:00.01 | 5 | ---------------------------------------------------------------------------------------------------------------------------------------------------------------- Predicate Information (identified by operation id): --------------------------------------------------- 2 - access("SALES"."SYS_NC00009$">:SYS_B_0) 21 linhas selecionadas. SQL > |
Quando examinamos o plano de execução verificamos que o índice criado foi utilizado e o desempenho da consulta foi bem melhor que na primeira execução onde o numero de buffers lidos foi 4472 contra 8 buffers lidos no plano que utilizou o índice.
Referências:
https://docs.oracle.com/cloud/latest/db112/SQLRF/statements_5012.htm#SQLRF01209
