Miscellaneous Operations
| FOR UPDATE | | Locks returned rows as a result of the FOR UPDATE clause. |
FOR UPDATE places a row-level lock on all the rows that can be retrieved from the SELECT statement.
Using FOR UPDATE allows you to use the WHERE CURRENT OF clause in INSERT, UPDATE, and DELETE commands. A COMMIT will invalidate the cursor, so you will need to reissue the SELECT FOR UPDATE after every commit.
Example
select Name, City, State from COMPANY where City > ‘Roanoke’ and Active_Flag = ‘Y’
for update of Name;
Execution Plan
FOR UPDATE
TABLE ACCESS BY ROWID COMPANY
INDEX RANGE SCAN COMPANY$CITY
Interpreting the Execution Plan
The Execution Plan shows that the index on the City column is used to find ROWIDs in the COMPANY that satisfy the limiting condition on the City value (City > ‘Roanoke’). The ROWIDs from the index scan are used to query the COMPANY table for the Name and State values. The Active_Flag=‘Y’ criteria is implicitly applied during the TABLE ACCESS BY ROWID operation. The FOR UPDATE operation is then applied to give the user row-level locks on each row returned from the query.
| FILTER | Eliminates rows from a result set not matching the selection criteria. |
FILTER performs a WHERE clause condition when no index can be used to assist in the evaluation. Unfortunately, the FILTER operation is sometimes implicit. Any FILTER condition that is applied when performing a table access (such as during a TABLE ACCESS BY ROWID) does not show up in the plan. When FILTER shows up in an Explain plan, it usually the result of a missing index or the disabling of an existing index.
The FILTER operation was in a prior example—the CONNECT BY operation’s example. In the query shown in the following listing, the WHERE criteria on the State column is not applied until after the CONNECT BY hierarchy has completed; the resulting rows are filtered to determine which meet the specified State criteria.
Example
select Company_ID, Name from COMPANY where State = ‘VA’
connect by Parent_Company_ID = prior Company_ID start with Company_ID = 1;
Execution Plan
FILTER
CONNECT BY
INDEX UNIQUE SCAN COMPANY_PK
TABLE ACCESS BY ROWID COMPANY
TABLE ACCESS BY ROWID COMPANY
INDEX RANGE SCAN COMPANY$PARENT
Interpreting the Execution Plan
The plan shows that first the COMPANY_PK index is being used to find the root node (Company_ID = 1), then the index on the Parent_Company_ID column is used to provide values for queries against the Company_ID column in an iterative fashion. After the hierarchy of Company_IDs is complete, the FILTER operation—the WHERE clause related to the State value—is applied. The query does not use the index on the State column, although it is available and the column is used in the WHERE clause.
| REMOTE | Accesses an external database through a database link. |
REMOTE sends a SQL statement to be executed at a remote node via a database link. The syntax of the SQL statement sent to the remote node is shown in the Other column of PLAN_TABLE.
Example
Since REMOTE requires a remote database access, a database link will be created for this example. The database link connects to the Hobbes account in the database that is identified via the ‘test’ service name in the local tnsnames.ora file.
create database link REMOTE1 connect to hobbes identified by tiger using ‘test’;
In the example query, a local COMPANY is joined to a remote SALES via a NESTED LOOPS join.
Example
select COMPANY.Name from COMPANY, SALES@REMOTE1 where COMPANY.Company_ID = SALES.Company_ID and SALES.Period_ID = 3 and SALES.Sales_Total > 1000;
Execution Plan
NESTED LOOPS
REMOTE
TABLE ACCESS BY ROWID COMPANY
INDEX UNIQUE SCAN COMPANY_PK
For the step with the REMOTE operation, you can query PLAN_TABLE for the syntax of the query sent to the remote node:
select Other from PLAN_TABLE where Operation = ‘REMOTE’;
The value of the Other column for this example is:
SELECT "COMPANY_ID","PERIOD_ID","SALES_TOTAL"
FROM "SALES" SALES WHERE "SALES_TOTAL">1000 AND "PERIOD_ID"=3
Interpreting the Execution Plan
The Explain Plan shows that the remote SALES table is used as the driving table for the NESTED LOOPS join (see the NESTED LOOPS operation for a brief discussion of driving tables). The text in the PLAN_TABLE. The Other column shows the query that is executed in the remote database. For each Company_ID value returned by the query of the remote SALES table, the COMPANY_PK index will be checked to see if a matching Company_ID value exists in the COMPANY table. When a match exists, that row is returned to the user by using the NESTED LOOPS operation.
| FIRST ROW | Retrieves the first row of a query. |
FIRST ROWS uses a cost-based approach for all SQL statements in the session regardless of the presence of statistics and optimizes with a goal of best response time (minimum resource use to return the first row of the result set).
The following statement changes the goal of the cost-based optimizer for your session to best response time:
ALTER SESSION SET OPTIMIZER_MODE = FIRST_ROWS;
| SEQUENCE | Accesses an Oracle sequence generator to obtain a unique sequence number |
SEQUENCE is used when accessing a database sequence via the NextVal and CurrVal pseudo-columns.
Example
Since the SEQUENCE operation requires a sequence to exist, a sequence named COMPANY_ID_SEQ will be created.
create sequence COMPANY_ID_SEQ
start with 1 increment by 1;
In the example query, the next value is selected from the sequence by selecting the NextVal pseudo-column from DUAL.
select COMPANY_ID_SEQ.NextVal from DUAL;
Execution Plan
SEQUENCE COMPANY_ID_SEQ
TABLE ACCESS FULL DUAL
Interpreting the Execution Plan
The Execution Plan shows that the DUAL table (comprising 1 row, and owned by SYS) is scanned. The COMPANY_ID_SEQ sequence is used to generate the value of the NextVal pseudo-column for the returned row, using the SEQUENCE operation.
| INLIST ITERATOR | Performs the next operation once for each value in an IN list predicate. |
An INLIST ITERATOR operation appears in the Execution Plan output if an index implements an INLIST predicate.
Example
SELECT * FROM emp WHERE empno IN (7876, 7900, 7902);
Execution Plan
| Operation | Options | Object_name |
| SELECT STATEMENT |
|
|
| INLIST ITERATOR |
|
|
| TABLE ACCESS | BY ROWID | EMP |
| INDEX | RANGE SCAN | EMP_EMPNO |
The INLIST ITERATOR operation iterates over the operation below it for each value in the IN-list predicate. For partitioned tables and indexes, the three possible types of INLIST columns are:
· Index column
· Index and partition column
· Partition column
Index Column
When the INLIST column empno is an index column but not a partition column, then the plan is as follows (the INLIST operator appears above the table operation but below the partition operation):
| Operation | Options | Object_name | Partition Start | Partition Stop |
| SELECT STATEMENT |
|
|
|
|
| PARTITION | INLIST |
| KEY(INLIST) | KEY(INLIST) |
| INLIST ITERATOR |
|
|
|
|
| TABLE ACCESS | BY ROWID | EMP | KEY(INLIST) | KEY(INLIST) |
| INDEX | RANGE SCAN | EMP_EMPNO | KEY(INLIST) | KEY(INLIST) |
The KEY(INLIST) designation for the partition start and stop keys specifies that an INLIST predicate appears on the index start/stop keys.
Index and Partition Columns
When empno is an indexed and a partition column, the Explain plan contains an INLIST ITERATOR operation above the partition operation:
| Operation | Options | Object_name | Partition Start | Partition Stop |
| SELECT STATEMENT |
|
|
|
|
| INLIST ITERATOR |
|
|
|
|
| PARTITION | ITERATOR |
| KEY(INLIST) | KEY(INLIST) |
| TABLE ACCESS | BY ROWID | EMP | KEY(INLIST) | KEY(INLIST) |
| INDEX | RANGE SCAN | EMP_EMPNO | KEY(INLIST) | KEY(INLIST) |
Partition Column
When empno is a partition column and there are no indexes, then no INLIST ITERATOR operation is allocated:
| Operation | Options | Object_name | Partition Start | Partition Stop |
| SELECT STATEMENT |
|
|
|
|
| PARTITION |
|
| KEY(INLIST) | KEY(INLIST) |
| TABLE ACCESS | BY ROWID | EMP | KEY(INLIST) | KEY(INLIST) |
| INDEX | RANGE SCAN | EMP_EMPNO | KEY(INLIST) | KEY(INLIST) |
When emp_empno is a bitmap index, the Execution plan is as follows:
| Operation | Options | Object_name |
| SELECT STATEMENT |
|
|
| INLIST ITERATOR |
|
|
| TABLE ACCESS | BY INDEX ROWID | EMP |
| BITMAP CONVERSION |
| TO ROWIDS |
| BITMAP INDEX | SINGLE VALUE | EMP_EMPNO |
| LOAD AS SELECT | Denotes a direct path INSERT based on a SELECT statement. |
LOAD AS SELECT bypasses the buffer cache when performing a direct path load based on a SELECT statement.
An Execution plan will denote the presence of a direct load operation with the LOAD AS SELECT operation:
| Rows | Explain Plan |
|
| 0 | SELECT STATEMENT GOAL: CHOOSE |
|
| 0 | LOAD AS SELECT |
|
| 0 | TABLE ACCESS (FULL) OF 'CUSTOMERS' |
|
| FIXED TABLE | Accesses a "fixed" (X$) table. |
|
|
|
|
|
Fixed tables are those not in Oracle’s data dictionary. FIXED TABLE is normally used to optimize V$ and X$ statements. However, join order for a V$ query will be entirely determined by the order of tables in the FROM clause. Be careful when using FIXED TABLE because:
· Neither the cost-based optimizer nor the rule-based optimizer recognizes the presence of V$ indexes when determining join order or method.
· There are never any optimizer statistics held against the V$ or X$ tables and consequently the cost-based optimizer has no information to use to determine the best join order.
| FIXED INDEX | Accesses an "index" on "fixed" (X$) table. |
Where an index exists on a V$ table, it will normally be used whenever the column is used for an exact lookup. The Explain Plan reveals that this is so through the special access path FIXED INDEX. For instance, the following query uses the SID index on V$SESSION:
select * from v$session where sid=171
| Rows | Explain Plan |
| 1 | FIXED TABLE FIXED INDEX #1 X$KSUSE
cpu=1 elapsed=1 logical=0 physical=0 |
Remembering that the "index" is not really an Oracle B-tree index and in has more in common with a hash cluster, it’s not surprising to see that the index is disabled if a range scan is attempted:
select * from v$session where sid<8
| Rows | Explain Plan |
|
| 700 | FIXED TABLE FULL X$KSUSE
cpu=19 elapsed=19 logical=0 physical=0 |
|
| TEMP TABLE GENERATION | Creates a temporary dimension table for dimension tables joined by a Star Transformation. |
|
|
|
|
|
The TEMP TABLE GENERATION operation creates a temporary dimension table for dimension tables that have been joined by a Star Transformation. For each dimension table in the joined set, TEMP TABLE GENERATION creates a temporary table to replace the table in the Execution Plan. A temporary table is created using two steps: create table and insert each. Since there are at least two tables in a join, this operation creates a minimum of four temporary tables.
| COLLECTION ITERATOR | Returns certain values from a collection such as VARRAY and nested table. |
The Collection Iterator operation returns certain values from a collection such as VARRAY and nested table.
