{"kind": "storage", "major": "18", "item": {"slug": "fork-vm", "name": "vm fork", "name_zh": "", "category": "Relation forks", "summary": "Each table and index is stored in a separate file. For ordinary relations, these files are named after the table or index's filenode number, which can be found in pg_class . relfilenode . But for temporary relations, the file name is of the form t BBB _ FFF , where BBB is the process number of the backend which created the file, and FFF is the filenode number. In either case, in addition to the main file (a/k/a main fork), each table and index has a free space map (see Section 66.3 ), which stores information about free space available in the relation. The free space map is stored in a file named with the filenode number plus the suffix _fsm . Tables also have a visibility map , stored in a fork with the suffix _vm , to track which pages are known to have no dead tuples. The visibility map is described further in Section 66.4 . Unlogged tables and indexes have a third fork, known as the initialization fork, which is stored in a fork with the suffix _init (see Section 66.5 ).", "aliases": [], "content_hash": "81541f39506de6e8f7ec102bb097e7d8e597eeeb7ec9db7657e8a3d807575178", "versions": {"10": {"facts": [{"label": "Fork", "value": "vm"}], "tables": [], "related": [{"url": "/wiki/storage/storage-file-layout/?v=10", "label": "Database file layout"}], "release": {"ref": "https://ftp.postgresql.org/pub/source/v10.23/postgresql-10.23.tar.bz2", "label": "10.23", "major": "10", "channel": "stable", "revision": "94a4b2528372458e5662c18d406629266667c437198160a18cdfd2c4a4d6eee9"}, "sources": [{"url": "/docs/10/storage-file-layout.html", "path": "storage-file-layout.html", "label": "PostgreSQL 10 English manual", "sha256": "093b3f235454c71a726c19d2a533af52677d400170ccbc8f4b8cab5cfb19946a"}], "sections": [], "signature": "", "description": ["Each table and index is stored in a separate file. For ordinary relations, these files are named after the table or index's filenode number, which can be found in pg_class . relfilenode . But for temporary relations, the file name is of the form t BBB _ FFF , where BBB is the backend ID of the backend which created the file, and FFF is the filenode number. In either case, in addition to the main file (a/k/a main fork), each table and index has a free space map (see Section 67.3 ), which stores information about free space available in the relation. The free space map is stored in a file named with the filenode number plus the suffix _fsm . Tables also have a visibility map , stored in a fork with the suffix _vm , to track which pages are known to have no dead tuples. The visibility map is described further in Section 67.4 . Unlogged tables and indexes have a third fork, known as the initialization fork, which is stored in a fork with the suffix _init (see Section 67.5 ).", "When a table or index exceeds 1 GB, it is divided into gigabyte-sized segments . The first segment's file name is the same as the filenode; subsequent segments are named filenode.1, filenode.2, etc. This arrangement avoids problems on platforms that have file size limitations. (Actually, 1 GB is just the default segment size. The segment size can be adjusted using the configuration option --with-segsize when building PostgreSQL .) In principle, free space map and visibility map forks could require multiple segments as well, though this is unlikely to happen in practice."], "manual_html": "", "manual_path": "/docs/10/storage-file-layout.html", "comparison_data": {"fork": "vm"}, "comparison_hash": "0f7e444c74befed2e9e038b208922f35c10a3caa1ec789947fda5dd19339d4d4"}, "11": {"facts": [{"label": "Fork", "value": "vm"}], "tables": [], "related": [{"url": "/wiki/storage/storage-file-layout/?v=11", "label": "Database file layout"}], "release": {"ref": "https://ftp.postgresql.org/pub/source/v11.22/postgresql-11.22.tar.bz2", "label": "11.22", "major": "11", "channel": "stable", "revision": "2cb7c97d7a0d7278851bbc9c61f467b69c094c72b81740b751108e7892ebe1f0"}, "sources": [{"url": "/docs/11/storage-file-layout.html", "path": "storage-file-layout.html", "label": "PostgreSQL 11 English manual", "sha256": "cbed09542ca2b0c2412d9e0810e5283a7626385224a23e094412d8f62be81985"}], "sections": [], "signature": "", "description": ["Each table and index is stored in a separate file. For ordinary relations, these files are named after the table or index's filenode number, which can be found in pg_class . relfilenode . But for temporary relations, the file name is of the form t BBB _ FFF , where BBB is the backend ID of the backend which created the file, and FFF is the filenode number. In either case, in addition to the main file (a/k/a main fork), each table and index has a free space map (see Section 69.3 ), which stores information about free space available in the relation. The free space map is stored in a file named with the filenode number plus the suffix _fsm . Tables also have a visibility map , stored in a fork with the suffix _vm , to track which pages are known to have no dead tuples. The visibility map is described further in Section 69.4 . Unlogged tables and indexes have a third fork, known as the initialization fork, which is stored in a fork with the suffix _init (see Section 69.5 ).", "When a table or index exceeds 1 GB, it is divided into gigabyte-sized segments . The first segment's file name is the same as the filenode; subsequent segments are named filenode.1, filenode.2, etc. This arrangement avoids problems on platforms that have file size limitations. (Actually, 1 GB is just the default segment size. The segment size can be adjusted using the configuration option --with-segsize when building PostgreSQL .) In principle, free space map and visibility map forks could require multiple segments as well, though this is unlikely to happen in practice."], "manual_html": "", "manual_path": "/docs/11/storage-file-layout.html", "comparison_data": {"fork": "vm"}, "comparison_hash": "0f7e444c74befed2e9e038b208922f35c10a3caa1ec789947fda5dd19339d4d4"}, "12": {"facts": [{"label": "Fork", "value": "vm"}], "tables": [], "related": [{"url": "/wiki/storage/storage-file-layout/?v=12", "label": "Database file layout"}], "release": {"ref": "https://ftp.postgresql.org/pub/source/v12.22/postgresql-12.22.tar.bz2", "label": "12.22", "major": "12", "channel": "stable", "revision": "8df3c0474782589d3c6f374b5133b1bd14d168086edbc13c6e72e67dd4527a3b"}, "sources": [{"url": "/docs/12/storage-file-layout.html", "path": "storage-file-layout.html", "label": "PostgreSQL 12 English manual", "sha256": "cb2e82b933c3712adaf61cc5a26d266e9f007698df549f999db9962bb6f39823"}], "sections": [], "signature": "", "description": ["Each table and index is stored in a separate file. For ordinary relations, these files are named after the table or index's filenode number, which can be found in pg_class . relfilenode . But for temporary relations, the file name is of the form t BBB _ FFF , where BBB is the backend ID of the backend which created the file, and FFF is the filenode number. In either case, in addition to the main file (a/k/a main fork), each table and index has a free space map (see Section 69.3 ), which stores information about free space available in the relation. The free space map is stored in a file named with the filenode number plus the suffix _fsm . Tables also have a visibility map , stored in a fork with the suffix _vm , to track which pages are known to have no dead tuples. The visibility map is described further in Section 69.4 . Unlogged tables and indexes have a third fork, known as the initialization fork, which is stored in a fork with the suffix _init (see Section 69.5 ).", "When a table or index exceeds 1 GB, it is divided into gigabyte-sized segments . The first segment's file name is the same as the filenode; subsequent segments are named filenode.1, filenode.2, etc. This arrangement avoids problems on platforms that have file size limitations. (Actually, 1 GB is just the default segment size. The segment size can be adjusted using the configuration option --with-segsize when building PostgreSQL .) In principle, free space map and visibility map forks could require multiple segments as well, though this is unlikely to happen in practice."], "manual_html": "", "manual_path": "/docs/12/storage-file-layout.html", "comparison_data": {"fork": "vm"}, "comparison_hash": "0f7e444c74befed2e9e038b208922f35c10a3caa1ec789947fda5dd19339d4d4"}, "13": {"facts": [{"label": "Fork", "value": "vm"}], "tables": [], "related": [{"url": "/wiki/storage/storage-file-layout/?v=13", "label": "Database file layout"}], "release": {"ref": "https://ftp.postgresql.org/pub/source/v13.23/postgresql-13.23.tar.bz2", "label": "13.23", "major": "13", "channel": "stable", "revision": "6ec3c82726af92b7dec873fa1cdf881eca92a4219787dfad05acb6b10e041fd6"}, "sources": [{"url": "/docs/13/storage-file-layout.html", "path": "storage-file-layout.html", "label": "PostgreSQL 13 English manual", "sha256": "2c839dc903912e2950982d087d63ebb1a03d2818c75443e237320784aa6443f8"}], "sections": [], "signature": "", "description": ["Each table and index is stored in a separate file. For ordinary relations, these files are named after the table or index's filenode number, which can be found in pg_class . relfilenode . But for temporary relations, the file name is of the form t BBB _ FFF , where BBB is the backend ID of the backend which created the file, and FFF is the filenode number. In either case, in addition to the main file (a/k/a main fork), each table and index has a free space map (see Section 69.3 ), which stores information about free space available in the relation. The free space map is stored in a file named with the filenode number plus the suffix _fsm . Tables also have a visibility map , stored in a fork with the suffix _vm , to track which pages are known to have no dead tuples. The visibility map is described further in Section 69.4 . Unlogged tables and indexes have a third fork, known as the initialization fork, which is stored in a fork with the suffix _init (see Section 69.5 ).", "When a table or index exceeds 1 GB, it is divided into gigabyte-sized segments . The first segment's file name is the same as the filenode; subsequent segments are named filenode.1, filenode.2, etc. This arrangement avoids problems on platforms that have file size limitations. (Actually, 1 GB is just the default segment size. The segment size can be adjusted using the configuration option --with-segsize when building PostgreSQL .) In principle, free space map and visibility map forks could require multiple segments as well, though this is unlikely to happen in practice."], "manual_html": "", "manual_path": "/docs/13/storage-file-layout.html", "comparison_data": {"fork": "vm"}, "comparison_hash": "0f7e444c74befed2e9e038b208922f35c10a3caa1ec789947fda5dd19339d4d4"}, "14": {"facts": [{"label": "Fork", "value": "vm"}], "tables": [], "related": [{"url": "/wiki/storage/storage-file-layout/?v=14", "label": "Database file layout"}], "release": {"ref": "https://ftp.postgresql.org/pub/source/v14.24/postgresql-14.24.tar.bz2", "label": "14.24", "major": "14", "channel": "stable", "revision": "a7fa7ed3d558172355f51406097a7bd4f6b473be80f311ef7cda96bf383d8897"}, "sources": [{"url": "/docs/14/storage-file-layout.html", "path": "storage-file-layout.html", "label": "PostgreSQL 14 English manual", "sha256": "6321dbd90cb8a8dfdc90c0e1caeaf3d480705176bba0428510fd986fe681eae3"}], "sections": [], "signature": "", "description": ["Each table and index is stored in a separate file. For ordinary relations, these files are named after the table or index's filenode number, which can be found in pg_class . relfilenode . But for temporary relations, the file name is of the form t BBB _ FFF , where BBB is the backend ID of the backend which created the file, and FFF is the filenode number. In either case, in addition to the main file (a/k/a main fork), each table and index has a free space map (see Section 70.3 ), which stores information about free space available in the relation. The free space map is stored in a file named with the filenode number plus the suffix _fsm . Tables also have a visibility map , stored in a fork with the suffix _vm , to track which pages are known to have no dead tuples. The visibility map is described further in Section 70.4 . Unlogged tables and indexes have a third fork, known as the initialization fork, which is stored in a fork with the suffix _init (see Section 70.5 ).", "When a table or index exceeds 1 GB, it is divided into gigabyte-sized segments . The first segment's file name is the same as the filenode; subsequent segments are named filenode.1, filenode.2, etc. This arrangement avoids problems on platforms that have file size limitations. (Actually, 1 GB is just the default segment size. The segment size can be adjusted using the configuration option --with-segsize when building PostgreSQL .) In principle, free space map and visibility map forks could require multiple segments as well, though this is unlikely to happen in practice."], "manual_html": "", "manual_path": "/docs/14/storage-file-layout.html", "comparison_data": {"fork": "vm"}, "comparison_hash": "0f7e444c74befed2e9e038b208922f35c10a3caa1ec789947fda5dd19339d4d4"}, "15": {"facts": [{"label": "Fork", "value": "vm"}], "tables": [], "related": [{"url": "/wiki/storage/storage-file-layout/?v=15", "label": "Database file layout"}], "release": {"ref": "https://ftp.postgresql.org/pub/source/v15.19/postgresql-15.19.tar.bz2", "label": "15.19", "major": "15", "channel": "stable", "revision": "e1a64a87a46b825b88c082e4518161a47aab53c45694964f8ba1df28f7859f89"}, "sources": [{"url": "/docs/15/storage-file-layout.html", "path": "storage-file-layout.html", "label": "PostgreSQL 15 English manual", "sha256": "01868f8e03e8749d2c1b113ab2988c459ac44259ce7416677e981e41e33015ea"}], "sections": [], "signature": "", "description": ["Each table and index is stored in a separate file. For ordinary relations, these files are named after the table or index's filenode number, which can be found in pg_class . relfilenode . But for temporary relations, the file name is of the form t BBB _ FFF , where BBB is the backend ID of the backend which created the file, and FFF is the filenode number. In either case, in addition to the main file (a/k/a main fork), each table and index has a free space map (see Section 73.3 ), which stores information about free space available in the relation. The free space map is stored in a file named with the filenode number plus the suffix _fsm . Tables also have a visibility map , stored in a fork with the suffix _vm , to track which pages are known to have no dead tuples. The visibility map is described further in Section 73.4 . Unlogged tables and indexes have a third fork, known as the initialization fork, which is stored in a fork with the suffix _init (see Section 73.5 ).", "When a table or index exceeds 1 GB, it is divided into gigabyte-sized segments . The first segment's file name is the same as the filenode; subsequent segments are named filenode.1, filenode.2, etc. This arrangement avoids problems on platforms that have file size limitations. (Actually, 1 GB is just the default segment size. The segment size can be adjusted using the configuration option --with-segsize when building PostgreSQL .) In principle, free space map and visibility map forks could require multiple segments as well, though this is unlikely to happen in practice."], "manual_html": "", "manual_path": "/docs/15/storage-file-layout.html", "comparison_data": {"fork": "vm"}, "comparison_hash": "0f7e444c74befed2e9e038b208922f35c10a3caa1ec789947fda5dd19339d4d4"}, "16": {"facts": [{"label": "Fork", "value": "vm"}], "tables": [], "related": [{"url": "/wiki/storage/storage-file-layout/?v=16", "label": "Database file layout"}], "release": {"ref": "https://ftp.postgresql.org/pub/source/v16.15/postgresql-16.15.tar.bz2", "label": "16.15", "major": "16", "channel": "stable", "revision": "c1575341fa7bd40f5274ea465b34390f4dc64cdd0770af327005caaeb9f6b7ed"}, "sources": [{"url": "/docs/16/storage-file-layout.html", "path": "storage-file-layout.html", "label": "PostgreSQL 16 English manual", "sha256": "f03daad7b39b5df902b4bc6e6f856e65af368a8507ffbf02199804aa4b0d0bd5"}], "sections": [], "signature": "", "description": ["Each table and index is stored in a separate file. For ordinary relations, these files are named after the table or index's filenode number, which can be found in pg_class . relfilenode . But for temporary relations, the file name is of the form t BBB _ FFF , where BBB is the backend ID of the backend which created the file, and FFF is the filenode number. In either case, in addition to the main file (a/k/a main fork), each table and index has a free space map (see Section 73.3 ), which stores information about free space available in the relation. The free space map is stored in a file named with the filenode number plus the suffix _fsm . Tables also have a visibility map , stored in a fork with the suffix _vm , to track which pages are known to have no dead tuples. The visibility map is described further in Section 73.4 . Unlogged tables and indexes have a third fork, known as the initialization fork, which is stored in a fork with the suffix _init (see Section 73.5 ).", "When a table or index exceeds 1 GB, it is divided into gigabyte-sized segments . The first segment's file name is the same as the filenode; subsequent segments are named filenode.1, filenode.2, etc. This arrangement avoids problems on platforms that have file size limitations. (Actually, 1 GB is just the default segment size. The segment size can be adjusted using the configuration option --with-segsize when building PostgreSQL .) In principle, free space map and visibility map forks could require multiple segments as well, though this is unlikely to happen in practice."], "manual_html": "", "manual_path": "/docs/16/storage-file-layout.html", "comparison_data": {"fork": "vm"}, "comparison_hash": "0f7e444c74befed2e9e038b208922f35c10a3caa1ec789947fda5dd19339d4d4"}, "17": {"facts": [{"label": "Fork", "value": "vm"}], "tables": [], "related": [{"url": "/wiki/storage/storage-file-layout/?v=17", "label": "Database file layout"}], "release": {"ref": "https://ftp.postgresql.org/pub/source/v17.11/postgresql-17.11.tar.bz2", "label": "17.11", "major": "17", "channel": "stable", "revision": "dd27f2b3c59e73ed14aa3324901242bf69a032a6347805f274e6260322d42979"}, "sources": [{"url": "/docs/17/storage-file-layout.html", "path": "storage-file-layout.html", "label": "PostgreSQL 17 English manual", "sha256": "f3de9587ca7d02f068a4307639ba9e24f7e90a722f8e71b496428de6aaba8652"}], "sections": [], "signature": "", "description": ["Each table and index is stored in a separate file. For ordinary relations, these files are named after the table or index's filenode number, which can be found in pg_class . relfilenode . But for temporary relations, the file name is of the form t BBB _ FFF , where BBB is the process number of the backend which created the file, and FFF is the filenode number. In either case, in addition to the main file (a/k/a main fork), each table and index has a free space map (see Section 65.3 ), which stores information about free space available in the relation. The free space map is stored in a file named with the filenode number plus the suffix _fsm . Tables also have a visibility map , stored in a fork with the suffix _vm , to track which pages are known to have no dead tuples. The visibility map is described further in Section 65.4 . Unlogged tables and indexes have a third fork, known as the initialization fork, which is stored in a fork with the suffix _init (see Section 65.5 ).", "When a table or index exceeds 1 GB, it is divided into gigabyte-sized segments . The first segment's file name is the same as the filenode; subsequent segments are named filenode.1, filenode.2, etc. This arrangement avoids problems on platforms that have file size limitations. (Actually, 1 GB is just the default segment size. The segment size can be adjusted using the configuration option --with-segsize when building PostgreSQL .) In principle, free space map and visibility map forks could require multiple segments as well, though this is unlikely to happen in practice."], "manual_html": "", "manual_path": "/docs/17/storage-file-layout.html", "comparison_data": {"fork": "vm"}, "comparison_hash": "0f7e444c74befed2e9e038b208922f35c10a3caa1ec789947fda5dd19339d4d4"}, "18": {"facts": [{"label": "Fork", "value": "vm"}], "tables": [], "related": [{"url": "/wiki/storage/storage-file-layout/?v=18", "label": "Database file layout"}], "release": {"ref": "https://ftp.postgresql.org/pub/source/v18.6/postgresql-18.6.tar.bz2", "label": "18.6", "major": "18", "channel": "stable", "revision": "555610c24d53e4316da5b7d3fc25c279d96856d5e0e23ee308c328c5fa881d9f"}, "sources": [{"url": "/docs/18/storage-file-layout.html", "path": "storage-file-layout.html", "label": "PostgreSQL 18 English manual", "sha256": "8cdf46b5af669f41f0a77c2541863d63454ef8fbb44d22a75e576cf1a7efc9c9"}], "sections": [], "signature": "", "description": ["Each table and index is stored in a separate file. For ordinary relations, these files are named after the table or index's filenode number, which can be found in pg_class . relfilenode . But for temporary relations, the file name is of the form t BBB _ FFF , where BBB is the process number of the backend which created the file, and FFF is the filenode number. In either case, in addition to the main file (a/k/a main fork), each table and index has a free space map (see Section 66.3 ), which stores information about free space available in the relation. The free space map is stored in a file named with the filenode number plus the suffix _fsm . Tables also have a visibility map , stored in a fork with the suffix _vm , to track which pages are known to have no dead tuples. The visibility map is described further in Section 66.4 . Unlogged tables and indexes have a third fork, known as the initialization fork, which is stored in a fork with the suffix _init (see Section 66.5 ).", "When a table or index exceeds 1 GB, it is divided into gigabyte-sized segments . The first segment's file name is the same as the filenode; subsequent segments are named filenode.1, filenode.2, etc. This arrangement avoids problems on platforms that have file size limitations. (Actually, 1 GB is just the default segment size. The segment size can be adjusted using the configuration option --with-segsize when building PostgreSQL .) In principle, free space map and visibility map forks could require multiple segments as well, though this is unlikely to happen in practice."], "manual_html": "", "manual_path": "/docs/18/storage-file-layout.html", "comparison_data": {"fork": "vm"}, "comparison_hash": "0f7e444c74befed2e9e038b208922f35c10a3caa1ec789947fda5dd19339d4d4"}, "19": {"facts": [{"label": "Fork", "value": "vm"}], "tables": [], "related": [{"url": "/wiki/storage/storage-file-layout/?v=19", "label": "Database file layout"}], "release": {"ref": "https://ftp.postgresql.org/pub/source/v19beta4/postgresql-19beta4.tar.bz2", "label": "19beta4", "major": "19", "channel": "preview", "revision": "83157ee9c599d03b2f7a3d73ef3a56ec24e0e79cc2b3501a64d1364f56398c86"}, "sources": [{"url": "/docs/19/storage-file-layout.html", "path": "storage-file-layout.html", "label": "PostgreSQL 19 English manual", "sha256": "64a2fe5f641ad71ef53151e63f4eab9f74fcedd6cde5ed49c6b1dac837c2ee2f"}], "sections": [], "signature": "", "description": ["Each table and index is stored in a separate file. For ordinary relations, these files are named after the table or index's filenode number, which can be found in pg_class . relfilenode . But for temporary relations, the file name is of the form t BBB _ FFF , where BBB is the process number of the backend which created the file, and FFF is the filenode number. In either case, in addition to the main file (a/k/a main fork), each table and index has a free space map (see Section 66.3 ), which stores information about free space available in the relation. The free space map is stored in a file named with the filenode number plus the suffix _fsm . Tables also have a visibility map , stored in a fork with the suffix _vm , to track which pages are known to have no dead tuples. The visibility map is described further in Section 66.4 . Unlogged tables and indexes have a third fork, known as the initialization fork, which is stored in a fork with the suffix _init (see Section 66.5 ).", "When a table or index exceeds 1 GB, it is divided into gigabyte-sized segments . The first segment's file name is the same as the filenode; subsequent segments are named filenode.1, filenode.2, etc. This arrangement avoids problems on platforms that have file size limitations. (Actually, 1 GB is just the default segment size. The segment size can be adjusted using the configuration option --with-segsize when building PostgreSQL .) In principle, free space map and visibility map forks could require multiple segments as well, though this is unlikely to happen in practice."], "manual_html": "", "manual_path": "/docs/19/storage-file-layout.html", "comparison_data": {"fork": "vm"}, "comparison_hash": "0f7e444c74befed2e9e038b208922f35c10a3caa1ec789947fda5dd19339d4d4"}, "20": {"facts": [{"label": "Fork", "value": "vm"}], "tables": [], "related": [{"url": "/wiki/storage/storage-file-layout/?v=20", "label": "Database file layout"}], "release": {"ref": "https://ftp.postgresql.org/pub/snapshot/dev/postgresql-snapshot.tar.bz2", "label": "20devel", "major": "20", "channel": "devel", "revision": "4d3346909b201ac1648232cf290462a7070c119326f56196f1f0253ed80fae41"}, "sources": [{"url": "/docs/devel/storage-file-layout.html", "path": "storage-file-layout.html", "label": "PostgreSQL 20 English manual", "sha256": "d6da97aa52fb525d5de5423d7993a2e42e7675a469110d0753f96dc8a66be1b0"}], "sections": [], "signature": "", "description": ["Each table and index is stored in a separate file. For ordinary relations, these files are named after the table or index's filenode number, which can be found in pg_class . relfilenode . But for temporary relations, the file name is of the form t BBB _ FFF , where BBB is the process number of the backend which created the file, and FFF is the filenode number. In either case, in addition to the main file (a/k/a main fork), each table and index has a free space map (see Section 66.3 ), which stores information about free space available in the relation. The free space map is stored in a file named with the filenode number plus the suffix _fsm . Tables also have a visibility map , stored in a fork with the suffix _vm , to track which pages are known to have no dead tuples. The visibility map is described further in Section 66.4 . Unlogged tables and indexes have a third fork, known as the initialization fork, which is stored in a fork with the suffix _init (see Section 66.5 ).", "When a table or index exceeds 1 GB, it is divided into gigabyte-sized segments . The first segment's file name is the same as the filenode; subsequent segments are named filenode.1, filenode.2, etc. This arrangement avoids problems on platforms that have file size limitations. (Actually, 1 GB is just the default segment size. The segment size can be adjusted using the configuration option --with-segsize when building PostgreSQL .) In principle, free space map and visibility map forks could require multiple segments as well, though this is unlikely to happen in practice."], "manual_html": "", "manual_path": "/docs/devel/storage-file-layout.html", "comparison_data": {"fork": "vm"}, "comparison_hash": "0f7e444c74befed2e9e038b208922f35c10a3caa1ec789947fda5dd19339d4d4"}}}, "snapshot": {"facts": [{"label": "Fork", "value": "vm"}], "tables": [], "related": [{"url": "/wiki/storage/storage-file-layout/?v=18", "label": "Database file layout"}], "release": {"ref": "https://ftp.postgresql.org/pub/source/v18.6/postgresql-18.6.tar.bz2", "label": "18.6", "major": "18", "channel": "stable", "revision": "555610c24d53e4316da5b7d3fc25c279d96856d5e0e23ee308c328c5fa881d9f"}, "sources": [{"url": "/docs/18/storage-file-layout.html", "path": "storage-file-layout.html", "label": "PostgreSQL 18 English manual", "sha256": "8cdf46b5af669f41f0a77c2541863d63454ef8fbb44d22a75e576cf1a7efc9c9"}], "sections": [], "signature": "", "description": ["Each table and index is stored in a separate file. For ordinary relations, these files are named after the table or index's filenode number, which can be found in pg_class . relfilenode . But for temporary relations, the file name is of the form t BBB _ FFF , where BBB is the process number of the backend which created the file, and FFF is the filenode number. In either case, in addition to the main file (a/k/a main fork), each table and index has a free space map (see Section 66.3 ), which stores information about free space available in the relation. The free space map is stored in a file named with the filenode number plus the suffix _fsm . Tables also have a visibility map , stored in a fork with the suffix _vm , to track which pages are known to have no dead tuples. The visibility map is described further in Section 66.4 . Unlogged tables and indexes have a third fork, known as the initialization fork, which is stored in a fork with the suffix _init (see Section 66.5 ).", "When a table or index exceeds 1 GB, it is divided into gigabyte-sized segments . The first segment's file name is the same as the filenode; subsequent segments are named filenode.1, filenode.2, etc. This arrangement avoids problems on platforms that have file size limitations. (Actually, 1 GB is just the default segment size. The segment size can be adjusted using the configuration option --with-segsize when building PostgreSQL .) In principle, free space map and visibility map forks could require multiple segments as well, though this is unlikely to happen in practice."], "manual_html": "", "manual_path": "/docs/18/storage-file-layout.html", "comparison_data": {"fork": "vm"}, "comparison_hash": "0f7e444c74befed2e9e038b208922f35c10a3caa1ec789947fda5dd19339d4d4"}, "comparison": {"left": "17", "right": "18", "status": "unchanged", "diff": ""}}