How to identify which indexes can be safely dropped in Oracle

The longer an application has been successfully run, the more likely you are to have indexes that are no longer used or beneficial. Removing these indexes not only saves space but can also improve the performance of any DML operations.

But knowing which indexes can be safely dropped can be tricky.

In Oracle Database 12c, things got a little easier with the introduction of a new view called DBA_INDEX_USAGE.

The DBA_INDEX_USAGE view displays cumulative index usage statistics, but unlike previous releases, it’s not just a binary value (YES or NO). This new view shows how often an index was used, who accessed it, and how effective it was via histogram based on the number of rows returned. The index access information is captured in memory and periodically flushed to disk every 15 minutes. You can query the last_flush_Time in v$INDEX_USAGE_INFO to determine when it was updated.

You should also be aware that index usage is sampled by default rather than tracked by all index usage. The sampling approach will likely notice all index usage in a standard running system, where indexes are repeatedly accessed, but it can easily miss indexes used for one-off tests. You can change the tracking approach so that we track every execution, but there is a significant performance overhead for this.

As always, it is easier to understand the benefits of a dictionary view by looking at an example. In my example below, I join the DBA_INDEX_USAGE view to USER_INDEXES via an outer join to ensure I capture information on indexes that are never used because these indexes won’t appear in DBA_INDEX_USAGE at all.

SELECT i.index_name, u.total_access_count tot_access, u.total_exec_count exec_cnt,
       u.bucket_0_access_count B0, u.bucket_1_access_count B1, u.bucket_2_10_access_count B2_10,
       u.bucket_11_100_access_count B11_100, u.bucket_101_1000_access_count B101_1K,
       u.bucket_1000_plus_access_count B1K, u.last_used
ON     i.index_name = 
WHERE  i.owner='MARIA'
ORDER BY u.total_access_count;

The output of this query should look something like this.

INDEX_NAME     	TOT_ACCESS    EXEC_CNT   B0      B1      B2_10  B11_100   B101_1K     B1K     LAST_USED
---------------- ---------- ---------- ------- ------- ------- -------- ---------- ---------- -----------
PROD_CUST_SALES       1  	1       0       0       0       0        	0          1 	06-APR-23
INDX_LOC       	      2  	2       0       1       1       0		0          0 	12-APR-23
INDX_DEPTNO    	     19        19      18       1       0       0   	        0          0 	26-APR-23
PROD_SUP_INDX        27        27      25       0       0       0        	2          0 	26-APR-23
EMPNO_PK_IND         82        82      48       32      0       2        	0          0 	26-APR-23

As you can see in the output above, for each index, we get the total number of accesses (TOT_ACCESS), the execution count (EXEC_CNT), the last date the index was used (LAST_USED), and a histogram of how many rows were returned across several buckets.

Let’s look at the  EMPNO_PK INDEX  index (the third row from the bottom). This index returned 0 rows 48 times out of  82 total accesses and a single row 32 times. So, it looks like this index is commonly used and valuable.

However, if we look at PROD_CUST_SALES (the first row), it was accessed only once and returned over 1,000 rows. Is that a helpful index?

Maybe/maybe not. It may be beneficial if this index access replaces a full table scan of an extremely wide table. If, on the other hand, it’s only marginally cheaper than a full table scan, it may not be worth the overhead of maintaining the index.

But perhaps the most exciting part of the query output above is that we have two indexes (CHAN_SOLD, PROD_SUB_IDX) that have never been accessed. These are good candidates to be dropped.

But dropping an index can be risky. What can you do to ensure you don’t get fired for dropping the wrong index?

Rather than dropping the index immediately, marking the index invisible is far easier. The optimizer will be unaware of the index in the future and won’t select it as part of any execution plan. However, the index will continue to be maintained.


If no one complains about their query performance digressing after some time, you can safely drop the index. If, on the other hand, someone does complain, you can alter the index visible again in a matter of seconds.


You can also create a new index as invisible. The optimizer is unaware of the new index until you can verify it improves performance by setting the parameter OPTIMIZER_USE_INVISBLE_INDEXES within a single session. This will allow the optimizer to consider the new index only for SQL statements issued within your session. All other sessions will continue to use the existing execution plans.

-- New indexes can be marked invisible until you have an opportunity to prove they improve performance
CREATE INDEX my_idx ON t(x, object_id) INVISIBLE; 
-- Test newly created invisible indexes by setting OPTIMIZER_USE_INVISBLE_INDEXES to TRUE
ALTER SESSION SET optimizer_use_invisible_indexes  = TRUE;

Update on March 15th, 2024
There have been several comments on this post around what each of the columns in the DBA_INDEX_USAGE view actual record and Jonathan Lewis has written a great explanation of each column in the view in the first part of his blog series on Index Usage.

10 thoughts on “How to identify which indexes can be safely dropped in Oracle”

  1. Hi,
    Thanks for great post.
    Is the following usage of index is recorded in DBA_INDEX_USAGE (most likely not):
    When dealing with index usage in Oracle, it’s essential to be aware of a scenario where the Cost-Based Optimizer (CBO) considers an index during the generation of an execution plan, even if the index is not directly utilized in the execution plan itself. This occurs because the statistics of the index contribute to the overall statistics of the table, influencing the decision-making process of the CBO.


    1. Hi Andjelko,
      Unfortunately, we don’t record the usage of index statistics to determine execution plans in the DBA_INDEX_USAGE view. It only records actual index accesses.
      So, you may not want to remove all indexes that are listed as unused if you suspect the Optimizer may be using their statistics.
      You can still use the trick of marking the index invisible to see if it impacts the performance of any of your SQL statements, including cases were the index stats are used, before safely dropping an index.

  2. Hi Maria
    Thanks for the blog but could you please elaborate about what the two columns TOTAL_ACCESS_COUNT & TOTAL_EXEC_COUNT represent ?
    The description in the manual is short but does not explain what counts as a”Access or what counts as a “Exec”.

  3. Could you elaborate more on indexes that are used, but not beneficial, as a FTS would be better? After our migration to 19c, this happens a lot.

  4. Arriving late at this note, but I can offer a couple of comments.

    Andjelko – my standard suggestion for dealing with the problem of “didn’t use the index, did use the value of distinct_keys” is to create a column group matching the index column list.

    Peter – my observations are: EXECUTIONS is about the number of executions of statement; ACCESSES is about the number of times an index probe took place, so (for example) if you have an index on t2 and a query that is a nested loop join from t1 to t2 with 10 rows from t1 used to drive the access to t2 you would see executions = 1, accesses = 10.

    Jonathan Lewis

    1. Jonathan,
      It makes sense to try, and it demonstrates a responsible step (approach) before dropping index
      Thanks for suggestion

  5. John,
    When discussing indexes used but not beneficial after a migration to Oracle 19c, it’s the specifics of your database environment, and the changes introduced by the migration; a lot of reasons why indexes might not be beneficial compared to a Full Table Scan:
    Index Clustering Factor, Histograms and Optimizer Statistics (Inaccurate or outdated statistics), Index Selectivity, parameters influencing the Cost-Based Optimizer (CBO) decisions, …
    In some cases, the overhead of maintaining indexes outweighs the benefits they provide, and this is not easy to for us to make decision to dropp index or not
    (I tried my best to answer, but if Jonathan has time, he will give you much better answer)

Leave a Reply

Your email address will not be published. Required fields are marked *