psql (16.10)
Type "help" for help.

postgres=# -- 创建测试表
postgres=# CREATE UNLOGGED TABLE test_unlogged_table(a int);
CREATE TABLE
postgres=# -- 查看测试表信息 获取relfilenode
postgres=# SELECT * FROM PG_CLASS WHERE relname = 'test_unlogged_table' \gx
-[ RECORD 1 ]-------+--------------------
oid                 | 157241
relname             | test_unlogged_table
relnamespace        | 2200
reltype             | 157243
reloftype           | 0
relowner            | 10
relam               | 2
relfilenode         | 157241
reltablespace       | 0
relpages            | 0
reltuples           | -1
relallvisible       | 0
reltoastrelid       | 0
relhasindex         | f
relisshared         | f
relpersistence      | u
relkind             | r
relnatts            | 1
relchecks           | 0
relhasrules         | f
relhastriggers      | f
relhassubclass      | f
relrowsecurity      | f
relforcerowsecurity | f
relispopulated      | t
relreplident        | d
relispartition      | f
relrewrite          | 0
relfrozenxid        | 7288
relminmxid          | 1
relacl              | 
reloptions          | 
relpartbound        | 

postgres=# -- 查看当前数据库信息 获取对应的oid
postgres=# SELECT * FROM PG_DATABASE WHERE datname = current_database() \gx
-[ RECORD 1 ]--+-------------------------------------
oid            | 5
datname        | postgres
datdba         | 10
encoding       | 6
datlocprovider | c
datistemplate  | f
datallowconn   | t
datconnlimit   | -1
datfrozenxid   | 722
datminmxid     | 1
dattablespace  | 1663
datcollate     | zh_CN.UTF-8
datctype       | zh_CN.UTF-8
daticulocale   | 
daticurules    | 
datcollversion | 2.39
datacl         | {=Tc/postgres,postgres=CTc/postgres}

postgres=# \! ls $PGDATA/base/5/157241* -al
-rw------- 1 postgres postgres 0  9月  2 15:43 /data/16/base/5/157241
-rw------- 1 postgres postgres 0  9月  2 15:43 /data/16/base/5/157241_init
postgres=# -- 插入一行数据
postgres=# INSERT INTO test_unlogged_table values(1);
INSERT 0 1
postgres=# -- VACUUM
postgres=# VACUUM test_unlogged_table;
VACUUM
postgres=# -- 查看所有分支文件
postgres=# \! ls $PGDATA/base/5/157241* -al
-rw------- 1 postgres postgres  8192  9月  2 15:44 /data/16/base/5/157241
-rw------- 1 postgres postgres 24576  9月  2 15:44 /data/16/base/5/157241_fsm
-rw------- 1 postgres postgres     0  9月  2 15:43 /data/16/base/5/157241_init
-rw------- 1 postgres postgres  8192  9月  2 15:44 /data/16/base/5/157241_vm
postgres=# 

RelFileNumber
GetNewRelFileNumber(Oid reltablespace, Relation pg_class, char relpersistence)
{
	RelFileLocatorBackend rlocator;
	char	   *rpath;
	bool		collides;
	BackendId	backend;

	/*
	 * If we ever get here during pg_upgrade, there's something wrong; all
	 * relfilenumber assignments during a binary-upgrade run should be
	 * determined by commands in the dump script.
	 */
	Assert(!IsBinaryUpgrade);

	switch (relpersistence)
	{
		case RELPERSISTENCE_TEMP:
			backend = BackendIdForTempRelations();
			break;
		case RELPERSISTENCE_UNLOGGED:
		case RELPERSISTENCE_PERMANENT:
			backend = InvalidBackendId;
			break;
		default:
			elog(ERROR, "invalid relpersistence: %c", relpersistence);
			return InvalidRelFileNumber;	/* placate compiler */
	}

	/* This logic should match RelationInitPhysicalAddr */
	rlocator.locator.spcOid = reltablespace ? reltablespace : MyDatabaseTableSpace;
	rlocator.locator.dbOid =
		(rlocator.locator.spcOid == GLOBALTABLESPACE_OID) ?
		InvalidOid : MyDatabaseId;

	/*
	 * The relpath will vary based on the backend ID, so we must initialize
	 * that properly here to make sure that any collisions based on filename
	 * are properly detected.
	 */
	rlocator.backend = backend;

	do
	{
		CHECK_FOR_INTERRUPTS();

		/* Generate the OID */
		if (pg_class)
			rlocator.locator.relNumber = GetNewOidWithIndex(pg_class, ClassOidIndexId,
															Anum_pg_class_oid);
		else
			rlocator.locator.relNumber = GetNewObjectId();

		/* Check for existing file of same name */
		rpath = relpath(rlocator, MAIN_FORKNUM);

		if (access(rpath, F_OK) == 0)
		{
			/* definite collision */
			collides = true;
		}
		else
		{
			/*
			 * Here we have a little bit of a dilemma: if errno is something
			 * other than ENOENT, should we declare a collision and loop? In
			 * practice it seems best to go ahead regardless of the errno.  If
			 * there is a colliding file we will get an smgr failure when we
			 * attempt to create the new relation file.
			 */
			collides = false;
		}

		pfree(rpath);
	} while (collides);

	return rlocator.locator.relNumber;
}

postgres=# SELECT pg_relation_filepath('test_unlogged_table');
 pg_relation_filepath 
----------------------
 base/5/157247
(1 row)

postgres=# \! ls $PGDATA/base/5/157247* -al
-rw------- 1 postgres postgres 0  9月  2 17:41 /data/16/base/5/157247
-rw------- 1 postgres postgres 0  9月  2 17:41 /data/16/base/5/157247_init
postgres=# SELECT * FROM PG_CLASS WHERE relname = 'test_unlogged_table' \gx
-[ RECORD 1 ]-------+--------------------
oid                 | 157247
relname             | test_unlogged_table
relnamespace        | 2200
reltype             | 157249
reloftype           | 0
relowner            | 10
relam               | 2
relfilenode         | 157247
reltablespace       | 0
relpages            | 0
reltuples           | -1
relallvisible       | 0
reltoastrelid       | 0
relhasindex         | f
relisshared         | f
relpersistence      | u
relkind             | r
relnatts            | 1
relchecks           | 0
relhasrules         | f
relhastriggers      | f
relhassubclass      | f
relrowsecurity      | f
relforcerowsecurity | f
relispopulated      | t
relreplident        | d
relispartition      | f
relrewrite          | 0
relfrozenxid        | 7293
relminmxid          | 1
relacl              | 
reloptions          | 
relpartbound        | 

postgres=# 

postgres@zxm-VMware-Virtual-Platform:~$ psql
psql (16.10)
Type "help" for help.

postgres=# -- 创建测试表
postgres=# CREATE UNLOGGED TABLE test_unlogged_table(a int);
CREATE TABLE
postgres=# -- 获取主分支文件路径  
postgres=# SELECT pg_relation_filepath('test_unlogged_table');
 pg_relation_filepath 
----------------------
 base/5/173637
(1 row)

postgres=# \q
postgres@zxm-VMware-Virtual-Platform:~$ rm $PGDATA/base/5/173637
postgres@zxm-VMware-Virtual-Platform:~$ ls $PGDATA/base/5/173637* -al 
-rw------- 1 postgres postgres 0  9月  2 19:17 /data/16/base/5/173637_init
postgres@zxm-VMware-Virtual-Platform:~$ pg_ctl restart
waiting for server to shut down.... done
server stopped
waiting for server to start....2025-09-02 19:18:15.616 CST [12493] LOG:  redirecting log output to logging collector process
2025-09-02 19:18:15.616 CST [12493] HINT:  Future log output will appear in directory "log".
 done
server started
postgres@zxm-VMware-Virtual-Platform:~$ psql
psql (16.10)
Type "help" for help.

postgres=# select * from test_unlogged_table;
 a 
---
(0 rows)

postgres=# SELECT pg_relation_filepath('test_unlogged_table');
 pg_relation_filepath 
----------------------
 base/5/173637
(1 row)

postgres=# 

postgres@zxm-VMware-Virtual-Platform:~$ psql
psql (16.10)
Type "help" for help.

postgres=# -- 创建测试表
postgres=# CREATE UNLOGGED TABLE test_unlogged_table(a int);
CREATE TABLE
postgres=# -- 获取主分支文件路径  
postgres=# SELECT pg_relation_filepath('test_unlogged_table');
 pg_relation_filepath 
----------------------
 base/5/181829
(1 row)

postgres=# checkpoint;
CHECKPOINT
postgres=# \q
postgres@zxm-VMware-Virtual-Platform:~$ rm $PGDATA/base/5/181829
postgres@zxm-VMware-Virtual-Platform:~$ ls $PGDATA/base/5/181829* -al
-rw------- 1 postgres postgres 0  9月  2 19:19 /data/16/base/5/181829_init
postgres@zxm-VMware-Virtual-Platform:~$ pg_ctl restart
waiting for server to shut down.... done
server stopped
waiting for server to start....2025-09-02 19:19:59.113 CST [12510] LOG:  redirecting log output to logging collector process
2025-09-02 19:19:59.113 CST [12510] HINT:  Future log output will appear in directory "log".
 done
server started
postgres@zxm-VMware-Virtual-Platform:~$ psql
psql (16.10)
Type "help" for help.

postgres=# select * from test_unlogged_table;
ERROR:  could not open file "base/5/181829": 没有那个文件或目录
postgres=# 

postgres@zxm-VMware-Virtual-Platform:~$ psql
psql (16.10)
Type "help" for help.

postgres=# select * from test_unlogged_table;
ERROR:  could not open file "base/5/181829": 没有那个文件或目录
postgres=# \! touch $PGDATA/base/5/181829
postgres=# select * from test_unlogged_table;
 a 
---
(0 rows)

postgres=# 

static void
ResetUnloggedRelationsInDbspaceDir(const char *dbspacedirname, int op)
{
	DIR		   *dbspace_dir;
	struct dirent *de;
	char		rm_path[MAXPGPATH * 2];

	/* Caller must specify at least one operation. */
	Assert((op & (UNLOGGED_RELATION_CLEANUP | UNLOGGED_RELATION_INIT)) != 0);

	/*
	 * Cleanup is a two-pass operation.  First, we go through and identify all
	 * the files with init forks.  Then, we go through again and nuke
	 * everything with the same OID except the init fork.
	 */
	if ((op & UNLOGGED_RELATION_CLEANUP) != 0)
	{
		HTAB	   *hash;
		HASHCTL		ctl;

		/*
		 * It's possible that someone could create a ton of unlogged relations
		 * in the same database & tablespace, so we'd better use a hash table
		 * rather than an array or linked list to keep track of which files
		 * need to be reset.  Otherwise, this cleanup operation would be
		 * O(n^2).
		 */
		ctl.keysize = sizeof(Oid);
		ctl.entrysize = sizeof(unlogged_relation_entry);
		ctl.hcxt = CurrentMemoryContext;
		hash = hash_create("unlogged relation OIDs", 32, &ctl,
						   HASH_ELEM | HASH_BLOBS | HASH_CONTEXT);

		/* Scan the directory. */
		dbspace_dir = AllocateDir(dbspacedirname);
		while ((de = ReadDir(dbspace_dir, dbspacedirname)) != NULL)
		{
			ForkNumber	forkNum;
			int			relnumchars;
			unlogged_relation_entry ent;

			/* Skip anything that doesn't look like a relation data file. */
			if (!parse_filename_for_nontemp_relation(de->d_name, &relnumchars,
													 &forkNum))
				continue;

			/* Also skip it unless this is the init fork. */
			if (forkNum != INIT_FORKNUM)
				continue;

			/*
			 * Put the OID portion of the name into the hash table, if it
			 * isn't already.
			 */
			ent.reloid = atooid(de->d_name);
			(void) hash_search(hash, &ent, HASH_ENTER, NULL);
		}

		/* Done with the first pass. */
		FreeDir(dbspace_dir);

		/*
		 * If we didn't find any init forks, there's no point in continuing;
		 * we can bail out now.
		 */
		if (hash_get_num_entries(hash) == 0)
		{
			hash_destroy(hash);
			return;
		}

		/*
		 * Now, make a second pass and remove anything that matches.
		 */
		dbspace_dir = AllocateDir(dbspacedirname);
		while ((de = ReadDir(dbspace_dir, dbspacedirname)) != NULL)
		{
			ForkNumber	forkNum;
			int			relnumchars;
			unlogged_relation_entry ent;

			/* Skip anything that doesn't look like a relation data file. */
			if (!parse_filename_for_nontemp_relation(de->d_name, &relnumchars,
													 &forkNum))
				continue;

			/* We never remove the init fork. */
			if (forkNum == INIT_FORKNUM)
				continue;

			/*
			 * See whether the OID portion of the name shows up in the hash
			 * table.  If so, nuke it!
			 */
			ent.reloid = atooid(de->d_name);
			if (hash_search(hash, &ent, HASH_FIND, NULL))
			{
				snprintf(rm_path, sizeof(rm_path), "%s/%s",
						 dbspacedirname, de->d_name);
				if (unlink(rm_path) < 0)
					ereport(ERROR,
							(errcode_for_file_access(),
							 errmsg("could not remove file \"%s\": %m",
									rm_path)));
				else
					elog(DEBUG2, "unlinked file \"%s\"", rm_path);
			}
		}

		/* Cleanup is complete. */
		FreeDir(dbspace_dir);
		hash_destroy(hash);
	}

	/*
	 * Initialization happens after cleanup is complete: we copy each init
	 * fork file to the corresponding main fork file.  Note that if we are
	 * asked to do both cleanup and init, we may never get here: if the
	 * cleanup code determines that there are no init forks in this dbspace,
	 * it will return before we get to this point.
	 */
	if ((op & UNLOGGED_RELATION_INIT) != 0)
	{
		/* Scan the directory. */
		dbspace_dir = AllocateDir(dbspacedirname);
		while ((de = ReadDir(dbspace_dir, dbspacedirname)) != NULL)
		{
			ForkNumber	forkNum;
			int			relnumchars;
			char		relnumbuf[OIDCHARS + 1];
			char		srcpath[MAXPGPATH * 2];
			char		dstpath[MAXPGPATH];

			/* Skip anything that doesn't look like a relation data file. */
			if (!parse_filename_for_nontemp_relation(de->d_name, &relnumchars,
													 &forkNum))
				continue;

			/* Also skip it unless this is the init fork. */
			if (forkNum != INIT_FORKNUM)
				continue;

			/* Construct source pathname. */
			snprintf(srcpath, sizeof(srcpath), "%s/%s",
					 dbspacedirname, de->d_name);

			/* Construct destination pathname. */
			memcpy(relnumbuf, de->d_name, relnumchars);
			relnumbuf[relnumchars] = '\0';
			snprintf(dstpath, sizeof(dstpath), "%s/%s%s",
					 dbspacedirname, relnumbuf, de->d_name + relnumchars + 1 +
					 strlen(forkNames[INIT_FORKNUM]));

			/* OK, we're ready to perform the actual copy. */
			elog(DEBUG2, "copying %s to %s", srcpath, dstpath);
			copy_file(srcpath, dstpath);
		}

		FreeDir(dbspace_dir);

		/*
		 * copy_file() above has already called pg_flush_data() on the files
		 * it created. Now we need to fsync those files, because a checkpoint
		 * won't do it for us while we're in recovery. We do this in a
		 * separate pass to allow the kernel to perform all the flushes
		 * (especially the metadata ones) at once.
		 */
		dbspace_dir = AllocateDir(dbspacedirname);
		while ((de = ReadDir(dbspace_dir, dbspacedirname)) != NULL)
		{
			ForkNumber	forkNum;
			int			relnumchars;
			char		relnumbuf[OIDCHARS + 1];
			char		mainpath[MAXPGPATH];

			/* Skip anything that doesn't look like a relation data file. */
			if (!parse_filename_for_nontemp_relation(de->d_name, &relnumchars,
													 &forkNum))
				continue;

			/* Also skip it unless this is the init fork. */
			if (forkNum != INIT_FORKNUM)
				continue;

			/* Construct main fork pathname. */
			memcpy(relnumbuf, de->d_name, relnumchars);
			relnumbuf[relnumchars] = '\0';
			snprintf(mainpath, sizeof(mainpath), "%s/%s%s",
					 dbspacedirname, relnumbuf, de->d_name + relnumchars + 1 +
					 strlen(forkNames[INIT_FORKNUM]));

			fsync_fname(mainpath, false);
		}

		FreeDir(dbspace_dir);

		/*
		 * Lastly, fsync the database directory itself, ensuring the
		 * filesystem remembers the file creations and deletions we've done.
		 * We don't bother with this during a call that does only
		 * UNLOGGED_RELATION_CLEANUP, because if recovery crashes before we
		 * get to doing UNLOGGED_RELATION_INIT, we'll redo the cleanup step
		 * too at the next startup attempt.
		 */
		fsync_fname(dbspacedirname, true);
	}
}