Full Table Scan

A full table scan (also known as a sequential scan) is a scan made on a database where each row of the table is read in a sequential (serial) order and the columns encountered are checked for the validity of a condition. Full table scans are usually the slowest method of scanning a table due to the heavy amount of I/O reads required from the disk which consists of multiple seeks as well as costly disk to memory transfers.

Overview

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.

When the Optimizer Considers a Full Table Scan{{Cite web, url=https://docs.oracle.com/database/121/TGSQL/tgsql_optop.htm, title=Optimizer Access Paths, last=, first=, date=2013, website=, publisher=Oracle, access-date=

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.

Examples

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 and Cons

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.

See also

* Database
* Optimizing compiler
* SQL

Oracle full table scan tips

References

Database theory