## 52.7. `pg_attribute`

[]()

 The catalog `pg_attribute` stores information about table columns. There will be exactly one `pg_attribute` row for every column in every table in the database. (There will also be attribute entries for indexes, and indeed all objects that have [`pg_class`](catalog-pg-class.html) entries.)

 The term attribute is equivalent to column and is used for historical reasons.

**Table 52.7. `pg_attribute` Columns**

|                                                                                                                                                                                                                                       Column Type<br/><br/> Description                                                                                                                                                                                                                                       |
|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|                                                                                                                                                                                              `attrelid` `oid` (references [`pg_class`](catalog-pg-class.html).`oid`)<br/><br/> The table this column belongs to                                                                                                                                                                                               |
|                                                                                                                                                                                                                                  `attname` `name`<br/><br/> The column name                                                                                                                                                                                                                                   |
|                                                                                                                                                                                   `atttypid` `oid` (references [`pg_type`](catalog-pg-type.html).`oid`)<br/><br/> The data type of this column (zero for a dropped column)                                                                                                                                                                                    |
|`attstattarget` `int4`<br/><br/>`attstattarget` controls the level of detail of statistics accumulated for this column by [`ANALYZE`](sql-analyze.html). A zero value indicates that no statistics should be collected. A negative value says to use the system default statistics target. The exact meaning of positive values is data type-dependent. For scalar data types, `attstattarget` is both the target number of “most common values” to collect, and the target number of histogram bins to create.|
|                                                                                                                                                                                                                  `attlen` `int2`<br/><br/> A copy of `pg_type.typlen` of this column's type                                                                                                                                                                                                                   |
|                                                                                                                                                                        `attnum` `int2`<br/><br/> The number of the column. Ordinary columns are numbered from 1 up. System columns, such as `ctid`, have (arbitrary) negative numbers.                                                                                                                                                                        |
|                                                                                                                                           `attndims` `int4`<br/><br/> Number of dimensions, if the column is an array type; otherwise 0. (Presently, the number of dimensions of an array is not enforced, so any nonzero value effectively means “it's an array”.)                                                                                                                                           |
|                                                                                                                                                                `attcacheoff` `int4`<br/><br/> Always -1 in storage, but when loaded into a row descriptor in memory this might be updated to cache the offset of the attribute within the row                                                                                                                                                                 |
|                                                                                                `atttypmod` `int4`<br/><br/>`atttypmod` records type-specific data supplied at table creation time (for example, the maximum length of a `varchar` column). It is passed to type-specific input functions and length coercion functions. The value will generally be -1 for types that do not need `atttypmod`.                                                                                                |
|                                                                                                                                                                                                                `attbyval` `bool`<br/><br/> A copy of `pg_type.typbyval` of this column's type                                                                                                                                                                                                                 |
|                                                                                                                                                                                                                `attalign` `char`<br/><br/> A copy of `pg_type.typalign` of this column's type                                                                                                                                                                                                                 |
|                                                                                                                                                         `attstorage` `char`<br/><br/> Normally a copy of `pg_type.typstorage` of this column's type. For TOAST-able data types, this can be altered after column creation to control storage policy.                                                                                                                                                          |
|                                            `attcompression` `char`<br/><br/> The current compression method of the column. Typically this is `'\0'` to specify use of the current default setting (see [default\_toast\_compression](runtime-config-client.html#GUC-DEFAULT-TOAST-COMPRESSION)). Otherwise, `'p'` selects pglz compression, while `'l'` selects LZ4 compression. However, this field is ignored whenever `attstorage` does not allow compression.                                             |
|                                                                                                                                                                                                                     `attnotnull` `bool`<br/><br/> This represents a not-null constraint.                                                                                                                                                                                                                      |
|                                                                                     `atthasdef` `bool`<br/><br/> This column has a default expression or generation expression, in which case there will be a corresponding entry in the [`pg_attrdef`](catalog-pg-attrdef.html) catalog that actually defines the expression. (Check `attgenerated` to determine whether this is a default or a generation expression.)                                                                                      |
|                                                                                                           `atthasmissing` `bool`<br/><br/> This column has a value which is used where the column is entirely missing from the row, as happens when a column is added with a non-volatile `DEFAULT` value after the row is created. The actual value used is stored in the `attmissingval` column.                                                                                                            |
|                                                                                                                                                                               `attidentity` `char`<br/><br/> If a zero byte (`''`), then not an identity column. Otherwise, `a` = generated always, `d` = generated by default.                                                                                                                                                                               |
|                                                                                                                                                                           `attgenerated` `char`<br/><br/> If a zero byte (`''`), then not a generated column. Otherwise, `s` = stored. (Other values might be added in the future.)                                                                                                                                                                           |
|                                                                                                                                                `attisdropped` `bool`<br/><br/> This column has been dropped and is no longer valid. A dropped column is still physically present in the table, but is ignored by the parser and so cannot be accessed via SQL.                                                                                                                                                |
|                                                                                                                                                                             `attislocal` `bool`<br/><br/> This column is defined locally in the relation. Note that a column can be locally defined and inherited simultaneously.                                                                                                                                                                             |
|                                                                                                                                                                           `attinhcount` `int4`<br/><br/> The number of direct ancestors this column has. A column with a nonzero number of ancestors cannot be dropped nor renamed.                                                                                                                                                                           |
|                                                                                                                                                           `attcollation` `oid` (references [`pg_collation`](catalog-pg-collation.html).`oid`)<br/><br/> The defined collation of the column, or zero if the column is not of a collatable data type                                                                                                                                                           |
|                                                                                                                                                                                              `attacl` `aclitem[]`<br/><br/> Column-level access privileges, if any have been granted specifically on this column                                                                                                                                                                                              |
|                                                                                                                                                                                                              `attoptions` `text[]`<br/><br/> Attribute-level options, as “keyword=value” strings                                                                                                                                                                                                              |
|                                                                                                                                                                                                  `attfdwoptions` `text[]`<br/><br/> Attribute-level foreign data wrapper options, as “keyword=value” strings                                                                                                                                                                                                  |
|                                                                             `attmissingval` `anyarray`<br/><br/> This column has a one element array containing the value used when the column is entirely missing from the row, as happens when the column is added with a non-volatile `DEFAULT` value after the row is created. The value is only used when `atthasmissing` is true. If there is no value the column is null.                                                                              |

 In a dropped column's `pg_attribute` entry, `atttypid` is reset to zero, but `attlen` and the other fields copied from [`pg_type`](catalog-pg-type.html) are still valid. This arrangement is needed to cope with the situation where the dropped column's data type was later dropped, and so there is no `pg_type` row anymore. `attlen` and the other fields can be used to interpret the contents of a row of the table.

