Full table scan

In a database, a query that is not indexed results in a full table scan, where the database processes each record of the table to find all records meeting the given requirements. Even if the query selects just a few rows from the table, all rows in the entire table will be examined. This usually results in suboptimal performance but may be acceptable with very small tables or when the overhead of keeping indexes up to date is high.

The most important factor in choosing depends on speed. This means that a full table scan should be used when it is the fastest and cannot use a different access path. Several full table scan examples are as follows.

• No index

The optimizer must use a full table scan since no index exists.

• Small number of rows

The cost of full table scan is less than index range scan due to small table.

• When query processed SELECT COUNT(*), nulls existed in the column

The query is counting the number of null columns in a typical index. However, SELECT COUNT(*) can't count the number of null columns.

• The query is unselective

The number of return rows is too large and takes nearly 100% in the whole table. These rows are unselective.

• The table statistics does not update

The number of rows in the table is higher than before, but table statistics haven't been updated yet. The optimizer can't correctly estimate that using the index is faster.

• The table has a high degree of parallelism

The high degree of parallelism table distorts the optimizer from a true way, because optimizer would use full table scan.

• A full table scan hint

The hint lets optimizer to use full table scan.

The first example shows a SQL statement that returns the name of every fruit in the fruits table whose color is red. If the fruits table does not have an index for the color column, then the database engine must load and examine every row within fruits in order to compare each row's color to 'red':

   SELECT   name
   FROM     fruits
   WHERE    color = 'red';

The second example shows a SQL statement which returns the name of all fruits in the fruits table. Because this statement has no condition - no WHERE clause - the database engine will use a table scan to load and return the data for this query even if the fruits table has an index on the name column because accessing - i.e. scanning - the table directly is faster than accessing the table through the extra abstraction layer of an index:

   SELECT   name 
   FROM     fruits

The third example is a counter-example that will almost certainly cause the SQL engine to use an index instead of a table scan. This example uses almost the same query as the previous one, but adds an ORDER BY clause so that the returned names will be in alphabetical order. Assuming that the fruits table has an index on the name column, the database engine will now use that index to return the names in order because accessing the table through the extra abstraction layer of the index provides the benefit of returning the rows in the requested order. Had the engine loaded the rows using a table scan, it would then have to perform the additional work of sorting the returned rows. In some extreme cases - e.g. the statistics maintained by the database engine indicate that the table contains a very small number of rows - the optimizer may still decide to use a table scan for this type of query:

   SELECT   name 
   FROM     fruits
   ORDER BY name

Pros:

• The cost is predictable, as every time database system needs to scan full table row by row.
• When table is less than 2 percent of database block buffer, the full scan table is quicker.

Cons:

• Full table scan occurs when there is no index or index is not being used by SQL. And the result of full scan table is usually slower that index table scan. The situation is that: the larger the table, the slower of the data returns.
• Unnecessary full-table scan will lead to a huge amount of unnecessary I/O with a process burden on the entire database.

• Database
• Optimizing compiler
• SQL
• Oracle full table scan tips