## 52.11. `pg_class`

[]()

 The catalog `pg_class` catalogs tables and most everything else that has columns or is otherwise similar to a table. This includes indexes (but see also [`pg_index`](catalog-pg-index.html)), sequences (but see also [`pg_sequence`](catalog-pg-sequence.html)), views, materialized views, composite types, and TOAST tables; see `relkind`. Below, when we mean all of these kinds of objects we speak of “relations”. Not all columns are meaningful for all relation types.

**Table 52.11. `pg_class` Columns**

|                                                                                                                                                                              Column Type<br/><br/> Description                                                                                                                                                                             |
|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|                                                                                                                                                                            `oid` `oid`<br/><br/> Row identifier                                                                                                                                                                            |
|                                                                                                                                                              `relname` `name`<br/><br/> Name of the table, index, view, etc.                                                                                                                                                               |
|                                                                                                                     `relnamespace` `oid` (references [`pg_namespace`](catalog-pg-namespace.html).`oid`)<br/><br/> The OID of the namespace that contains this relation                                                                                                                     |
|                                                                          `reltype` `oid` (references [`pg_type`](catalog-pg-type.html).`oid`)<br/><br/> The OID of the data type that corresponds to this table's row type, if any; zero for indexes, sequences, and toast tables, which have no `pg_type` entry                                                                           |
|                                                                                                         `reloftype` `oid` (references [`pg_type`](catalog-pg-type.html).`oid`)<br/><br/> For typed tables, the OID of the underlying composite type; zero for all other relations                                                                                                          |
|                                                                                                                                         `relowner` `oid` (references [`pg_authid`](catalog-pg-authid.html).`oid`)<br/><br/> Owner of the relation                                                                                                                                          |
|                                                                `relam` `oid` (references [`pg_am`](catalog-pg-am.html).`oid`)<br/><br/> If this is a table or an index, the access method used (heap, B-tree, hash, etc.); otherwise zero (zero occurs for sequences, as well as relations without storage, such as views)                                                                 |
|                                                                                                           `relfilenode` `oid`<br/><br/> Name of the on-disk file of this relation; zero means this is a “mapped” relation whose disk file name is determined by low-level state                                                                                                            |
|                                                               `reltablespace` `oid` (references [`pg_tablespace`](catalog-pg-tablespace.html).`oid`)<br/><br/> The tablespace in which this relation is stored. If zero, the database's default tablespace is implied. (Not meaningful if the relation has no on-disk file.)                                                               |
|                                        `relpages` `int4`<br/><br/> Size of the on-disk representation of this table in pages (of size `BLCKSZ`). This is only an estimate used by the planner. It is updated by [`VACUUM`](sql-vacuum.html), [`ANALYZE`](sql-analyze.html), and a few DDL commands such as [`CREATE INDEX`](sql-createindex.html).                                         |
|`reltuples` `float4`<br/><br/> Number of live rows in the table. This is only an estimate used by the planner. It is updated by [`VACUUM`](sql-vacuum.html), [`ANALYZE`](sql-analyze.html), and a few DDL commands such as [`CREATE INDEX`](sql-createindex.html). If the table has never yet been vacuumed or analyzed, `reltuples` contains `-1` indicating that the row count is unknown.|
|                                       `relallvisible` `int4`<br/><br/> Number of pages that are marked all-visible in the table's visibility map. This is only an estimate used by the planner. It is updated by [`VACUUM`](sql-vacuum.html), [`ANALYZE`](sql-analyze.html), and a few DDL commands such as [`CREATE INDEX`](sql-createindex.html).                                        |
|                                                                            `reltoastrelid` `oid` (references [`pg_class`](catalog-pg-class.html).`oid`)<br/><br/> OID of the TOAST table associated with this table, zero if none. The TOAST table stores large attributes “out of line” in a secondary table.                                                                             |
|                                                                                                                                              `relhasindex` `bool`<br/><br/> True if this is a table and it has (or recently had) any indexes                                                                                                                                               |
|                                                                                               `relisshared` `bool`<br/><br/> True if this table is shared across all databases in the cluster. Only certain system catalogs (such as [`pg_database`](catalog-pg-database.html)) are shared.                                                                                                |
|                                                                                                                                            `relpersistence` `char`<br/><br/>`p` = permanent table, `u` = unlogged table, `t` = temporary table                                                                                                                                             |
|                                                                              `relkind` `char`<br/><br/>`r` = ordinary table, `i` = index, `S` = sequence, `t` = TOAST table, `v` = view, `m` = materialized view, `c` = composite type, `f` = foreign table, `p` = partitioned table, `I` = partitioned index                                                                              |
|                                                                              `relnatts` `int2`<br/><br/> Number of user columns in the relation (system columns not counted). There must be this many corresponding entries in [`pg_attribute`](catalog-pg-attribute.html). See also `pg_attribute`.`attnum`.                                                                              |
|                                                                                                                             `relchecks` `int2`<br/><br/> Number of `CHECK` constraints on the table; see [`pg_constraint`](catalog-pg-constraint.html) catalog                                                                                                                             |
|                                                                                                                                 `relhasrules` `bool`<br/><br/> True if table has (or once had) rules; see [`pg_rewrite`](catalog-pg-rewrite.html) catalog                                                                                                                                  |
|                                                                                                                              `relhastriggers` `bool`<br/><br/> True if table has (or once had) triggers; see [`pg_trigger`](catalog-pg-trigger.html) catalog                                                                                                                               |
|                                                                                                                                            `relhassubclass` `bool`<br/><br/> True if table or index has (or once had) any inheritance children                                                                                                                                             |
|                                                                                                                             `relrowsecurity` `bool`<br/><br/> True if table has row-level security enabled; see [`pg_policy`](catalog-pg-policy.html) catalog                                                                                                                              |
|                                                                                                             `relforcerowsecurity` `bool`<br/><br/> True if row-level security (when enabled) will also apply to table owner; see [`pg_policy`](catalog-pg-policy.html) catalog                                                                                                             |
|                                                                                                                            `relispopulated` `bool`<br/><br/> True if relation is populated (this is true for all relations other than some materialized views)                                                                                                                             |
|                                                                    `relreplident` `char`<br/><br/> Columns used to form “replica identity” for rows: `d` = default (primary key, if any), `n` = nothing, `f` = all columns, `i` = index with `indisreplident` set (same as nothing if the index used has been dropped)                                                                     |
|                                                                                                                                                          `relispartition` `bool`<br/><br/> True if table or index is a partition                                                                                                                                                           |
|           `relrewrite` `oid` (references [`pg_class`](catalog-pg-class.html).`oid`)<br/><br/> For new relations being written during a DDL operation that requires a table rewrite, this contains the OID of the original relation; otherwise zero. That state is only visible internally; this field should never contain anything other than zero for a user-visible relation.           |
|                `relfrozenxid` `xid`<br/><br/> All transaction IDs before this one have been replaced with a permanent (“frozen”) transaction ID in this table. This is used to track whether the table needs to be vacuumed in order to prevent transaction ID wraparound or to allow `pg_xact` to be shrunk. Zero (`InvalidTransactionId`) if the relation is not a table.                |
|                             `relminmxid` `xid`<br/><br/> All multixact IDs before this one have been replaced by a transaction ID in this table. This is used to track whether the table needs to be vacuumed in order to prevent multixact ID wraparound or to allow `pg_multixact` to be shrunk. Zero (`InvalidMultiXactId`) if the relation is not a table.                             |
|                                                                                                                                               `relacl` `aclitem[]`<br/><br/> Access privileges; see [Section 5.7](ddl-priv.html) for details                                                                                                                                               |
|                                                                                                                                                 `reloptions` `text[]`<br/><br/> Access-method-specific options, as “keyword=value” strings                                                                                                                                                 |
|                                                                                                                           `relpartbound` `pg_node_tree`<br/><br/> If table is a partition (see `relispartition`), internal representation of the partition bound                                                                                                                           |

 Several of the Boolean flags in `pg_class` are maintained lazily: they are guaranteed to be true if that's the correct state, but may not be reset to false immediately when the condition is no longer true. For example, `relhasindex` is set by [`CREATE INDEX`](sql-createindex.html), but it is never cleared by [`DROP INDEX`](sql-dropindex.html). Instead, [`VACUUM`](sql-vacuum.html) clears `relhasindex` if it finds the table has no indexes. This arrangement avoids race conditions and improves concurrency.

