DEV Community

Aadil Bashir
Aadil Bashir

Posted on • Updated on

Heap Only Tuples and Index-Only Scans - A Comprehensive Guide

Welcome to the seventh article of my blog series, in this blog I will be discussing HOT and IOS comprehensively.


Welcome to an exciting exploration of PostgreSQL's internals, where we will delve into two intriguing features: Heap Only Tuples (HOT) and Index-Only Scans. These features are closely related to the index scan operation, a fundamental aspect of PostgreSQL. We will dive into the intricate details of these features, their implementation, and their impact on database performance.

PostgreSQL, as one of the most advanced open-source database management systems, is known for its robustness, flexibility, and compliance with standards. It provides developers with a wide range of features to build scalable and efficient applications. Among these features, PostgreSQL's approach to indexing and scanning plays a vital role in enhancing its performance and efficiency.
By the end of this blog, you will have a comprehensive understanding of HOT and Index-Only Scans, empowering you to optimize your PostgreSQL database effectively. So, let's begin this journey and uncover the inner workings of these features!

Overview of Heat Only Tuples (HOT)

Heap Only Tuples (HOT) is a feature introduced in PostgreSQL 8.3 to optimize the usage of pages in both tables and indexes when an updated row is stored on the same table page as the old row. Its primary goal is to address the issue of excessive storage consumption and increased I/O operations that arise when a row is updated.

In PostgreSQL, when a row is updated, a new version of the row is created and stored in the table, resulting in increased storage requirements. Additionally, if the updated row has an associated index, a new index entry is also created. This process can be resource-intensive and impact database performance.

HOT tackles this problem by eliminating the necessity of creating a new index entry when a row is updated, as long as the updated row can be accommodated within the same table page as the old row. By doing so, HOT significantly reduces storage consumption and minimizes the number of I/O operations required for updating the index.


When a row is updated using Heap Only Tuples (HOT) in PostgreSQL, and the updated row is stored in the same table page as the old row, the corresponding index tuple is not inserted. Instead, certain flags are set to indicate the update.

During a HOT update, the HEAP_HOT_UPDATED bit is set in the t_infomask2 field of the old tuple, indicating that this tuple has been updated using HOT. Additionally, the HEAP_ONLY_TUPLE bit is set in the t_infomask2 field of the new tuple, indicating that this tuple is the result of a HOT update and does not have its own index entry.

By employing these flags, PostgreSQL can keep track of updated tuples without the need to create new index entries. This approach significantly reduces the consumption of both index and table pages, resulting in improved performance. It reduces the number of index tuple insertions caused by updates and decreases the workload for VACUUM processing.

By leveraging HOT, PostgreSQL optimizes performance by reducing the frequency of index tuple insertions during updates and minimizing the need for VACUUM processing. This leads to more efficient resource utilization and improved overall database performance.

HOT Performance Impact

HOT in PostgreSQL offers significant performance improvements by reducing the need for creating new index entries and minimizing the necessity of VACUUM processing.

In PostgreSQL, the VACUUM process is responsible for reclaiming storage occupied by "dead" tuples, which are old versions of updated rows that are no longer needed. This process can be resource-intensive, especially for databases with frequent updates. By reducing the number of tuples that the VACUUM process has to process, HOT reduces the workload on VACUUM and improves the overall performance of the database.

Furthermore, HOT's elimination of new index entries also results in substantial storage space savings. This is especially advantageous for databases with large tables and numerous indexes, as the reuse of existing index entries for updated rows reduces the need for additional storage. By optimizing storage utilization, HOT contributes to better performance and efficiency in PostgreSQL databases.

Overall, HOT's ability to minimize the creation of new index entries and reduce the workload on the VACUUM process leads to improved performance and resource utilization, making it a valuable feature for PostgreSQL databases, particularly in scenarios with frequent updates and large amounts of data.

Overview of Index-Only Scans

Index-Only Scans is a powerful feature introduced in PostgreSQL 9.2 that optimizes database performance by reducing I/O costs.

In a traditional index scan, PostgreSQL utilizes the index to locate the rows in the table and subsequently retrieves the rows from the table itself. This process involves two separate I/O operations: one to read the index and another to read the corresponding table data.

Index-Only Scans improve this process by eliminating the necessity of accessing the table when all the desired entries of a SELECT statement are present in the index key. In such scenarios, PostgreSQL can directly fetch the required data from the index, eliminating the need for an additional I/O operation to access the table.


During an Index-Only Scan in PostgreSQL, when executing a SELECT statement, the database first verifies if all the targeted entries can be found within the index key. If they are present, PostgreSQL can fetch the required data directly from the index, without needing to access the associated table pages.

However, a crucial aspect of executing a SELECT statement is ensuring the visibility of the tuples returned. Tuple visibility is determined by the transaction that created or modified the tuple and the current transaction. In a conventional index scan, PostgreSQL checks tuple visibility by accessing the table itself. However, in an Index-Only Scan, accessing the table is not possible. So, how does PostgreSQL check tuple visibility in this scenario?

The answer lies in the visibility map, which is a data structure utilized by PostgreSQL to track the visibility of tuples within a table. If all the tuples stored on a specific page are marked as visible in the visibility map, PostgreSQL can rely on the index tuple's key and does not need to access the corresponding table page to check visibility. By leveraging the visibility map in this manner, the need for accessing the table pages and performing additional I/O operations is significantly reduced.

By employing the visibility map to determine tuple visibility, Index-Only Scans optimize performance by minimizing I/O costs. This streamlined approach enhances the efficiency of database operations, allowing PostgreSQL to fetch the necessary data directly from the index and avoiding the overhead of accessing the table pages whenever possible.

Index-Only Scans Performance Impact

Index-Only Scans in PostgreSQL offer substantial performance enhancements by reducing the I/O cost associated with accessing table pages. This optimization is especially advantageous for databases that have large tables and numerous indexes, as the I/O cost can be a significant performance bottleneck in such scenarios.

By eliminating the need to access the table pages, Index-Only Scans not only improve query execution speed but also result in substantial savings in storage space. This benefit is particularly valuable for databases with limited storage resources, as it allows for more efficient utilization of available space.


PostgreSQL's Heap Only Tuples (HOT) and Index-Only Scans are powerful features that play a crucial role in enhancing database performance. HOT optimizes the utilization of pages in both indexes and tables by efficiently storing updated rows within the same table page, thereby reducing the need for resource-intensive VACUUM processing. Index-Only Scans, on the other hand, minimize I/O costs by directly utilizing the index key to fetch data, bypassing the necessity of accessing corresponding table pages when all targeted entries are present in the index key.

By gaining a comprehensive understanding of these features, database administrators and system developers can effectively optimize their PostgreSQL databases for improved performance and efficiency. These features exemplify the robustness and adaptability of PostgreSQL, underscoring why it remains one of the most popular and widely adopted open-source database management systems globally.

If you want to explore it further, click the link below.
Chapter-7 The Internals of PostgreSQL

Top comments (0)