Exploring the Fundamentals of Database Cluster, Databases, Tables, and Internal Layout in PostgreSQL
Tags: sql, postgressql, database, apacheage
Published: 2023-06-29 00:00:21

**Introduction**

PostgreSQL, a feature-rich open-source relational database management system, provides a solid foundation for managing data efficiently. Understanding the core concepts of a database cluster, databases, tables, and the internal layout of heap table files is essential for effectively working with PostgreSQL. In this article, we will explore these topics, providing a comprehensive overview to support your understanding of subsequent chapters in [The Internals of PostgreSQL](https://www.interdb.jp/pg/index.html).


### 1. Logical Structure of a Database Cluster

A database cluster in PostgreSQL refers to a collection of databases managed by a single PostgreSQL server instance. It is important to note that a database cluster does not refer to a group of database servers; rather, it represents a single PostgreSQL server running on a host and managing a database cluster.
![Fig. 1.1. Logical structure of a database cluster](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/6s5i9q82qt81e7y6uafw.png)

It includes various files and directories that store data and configuration settings. When setting up a new PostgreSQL instance, initializing a database cluster is the first step. It involves creating essential files and directories, defining cluster-wide settings, and establishing communication protocols.

Within a database cluster, databases act as logical containers for organizing and separating data. A database consists of various database objects, such as tables, indexes, sequences, views, and functions. Databases themselves are also considered database objects and are logically separated from one another.

PostgreSQL maintains the relationships between these objects using object identifiers (OIDs), the OIDs and their associations are stored in system catalogs, depending on the type of objects. For example, OIDs of databases and heap tables are stored in pg_database and pg_class respectively, so you can find out the OIDs you want to know by issuing the queries such as the following:

![Image description 1.2](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/6qul8zyf1arjz6njkjvc.PNG)


### 2. Physical Structure of a Database Cluster
The physical structure of a PostgreSQL database cluster consists of a base directory, subdirectories, and numerous files. When initializing a new database cluster using the _`initdb`_ utility, a base directory is created. Typically, the base directory path is set to the _**PGDATA**_ environment variable.

The base directory contains subdirectories representing individual databases. Each table, index, and other database objects associated with a database are stored as separate files within their respective subdirectories. Additionally, there are specific subdirectories for data storage, configuration files, and tablespaces.

Fig 2 shows an example of database cluster in PostgreSQL for more understanding ![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/g0joo5jem2snlv3y6sta.png)

PostgreSQL's concept of tablespaces refers to additional data areas located outside the base directory. They provide flexibility in data storage and management.


### 3. Internal Layout of a Heap Table File
Within a database cluster, tables serve as fundamental units for storing data. The internal layout of a heap table file describes how data is organized within a table. In PostgreSQL, the heap-based storage model is utilized, where new rows are appended to the end of the table.

Heap table files are divided into fixed-length pages (or blocks), typically 8KB in size. Each page is assigned a block number, and these pages are sequentially numbered within the file. If a file becomes full, PostgreSQL automatically adds a new empty page to accommodate additional data.

See Fig. 3. Page layout of a heap table file.
![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ahpn3mcpybwikxku6b6w.png)
Understanding the internal layout of a heap table file is crucial for optimizing query performance, managing indexes, and ensuring data integrity. It involves knowledge of table structure, metadata pages, and data pages.

A heap table file page comprises three key components:

_**a.**_ Heap Tuples: Heap tuples store the actual record data and are stacked in order from the bottom of the page. Each tuple's internal structure is described in detail in the Concurrency Control (CC) and Write-Ahead Logging (WAL) [chapters](https://www.interdb.jp/pg/index.html), as they are crucial for data integrity and consistency.

**_b._** Line Pointers: Line pointers are 4-byte pointers that reference individual heap tuples. They form an array, serving as an index for accessing tuples within the page. As new tuples are added, new line pointers are appended to this array.

**_c._** Header Data: The header data, defined by the PageHeaderData structure, is located at the beginning of each page. It contains general information about the page, such as the last Log Sequence Number (LSN), checksum value, and pointers to line pointers and heap tuples.


### 4. Methods of Writing and Reading Tuples:
Understanding how to write and read tuples in PostgreSQL is essential for effective data manipulation.
**_a._** Writing Heap Tuples: When inserting a new tuple into a table, PostgreSQL ensures proper placement within the heap table file. As an example, consider a table with a single-page containing one heap tuple. The page's metadata, including line pointers and pointers to heap tuples, is adjusted accordingly when a new tuple is inserted. This ensures proper sequencing and organization of the tuples.

**_b._** Reading Heap Tuples: PostgreSQL provides two primary methods for accessing heap tuples:

Sequential Scan: In a sequential scan, all tuples in all pages are read by sequentially scanning line pointers in each page. This method is suitable for scenarios where a complete scan of all tuples is required.

B-tree Index Scan: In an index scan, an index file stores index tuples comprising an index key and a Tuple Identifier (TID) pointing to the target heap tuple. By locating the appropriate index tuple, PostgreSQL retrieves the desired heap tuple using the TID value. This method allows for efficient retrieval of specific tuples without scanning unnecessary pages.


**Conclusion**

In conclusion, a thorough understanding of database cluster, databases, tables, and the internal layout of heap table files is essential for proficient use of PostgreSQL. By comprehending the logical and physical structures of a database cluster, users can effectively organize and manage their data. Similarly, knowledge about the internal layout of heap table files and the methods of writing and reading tuples enables efficient data manipulation in PostgreSQL. Armed with this knowledge, developers and database administrators can optimize storage, retrieval, and manipulation operations, ensuring the efficiency and reliability of their PostgreSQL databases. With PostgreSQL's powerful features and capabilities, users can confidently design and manage advanced database systems that meet the requirements of modern data-driven applications.