What changed?

--- 9.6
+++ 10
@@ -1,6 +1,6 @@
 (relation) The catalog pg_aggregate stores information about aggregate functions. An aggregate function is a function that operates on a set of values (typically one column from each row that matches a query condition) and returns a single value computed from all these values. Typical aggregate functions are sum, count, and max. Each entry in pg_aggregate is an extension of an entry in pg_proc. The pg_proc entry carries the aggregate's name, input and output data types, and other information that is similar to ordinary functions.
 aggfnoid: pg_proc OID of the aggregate function
-aggkind: Aggregate kind: n for "normal" aggregates, o for "ordered-set" aggregates, or h for "hypothetical-set" aggregates
+aggkind: Aggregate kind: n for “normal” aggregates, o for “ordered-set” aggregates, or h for “hypothetical-set” aggregates
 aggnumdirectargs: Number of direct (non-aggregated) arguments of an ordered-set or hypothetical-set aggregate, counting a variadic array as one argument. If equal to pronargs, the aggregate must be variadic and the variadic array describes the aggregated arguments as well as the final direct arguments. Always zero for normal aggregates.
 aggtransfn: Transition function
 aggfinalfn: Final function (zero if none)

--- 9.6
+++ 10
@@ -1,4 +1,4 @@
-(relation) The catalog pg_am stores information about relation access methods. There is one row for each access method supported by the system. Currently, only indexes have access methods. The requirements for index access methods are discussed in detail in Chapter 59.
+(relation) The catalog pg_am stores information about relation access methods. There is one row for each access method supported by the system. Currently, only indexes have access methods. The requirements for index access methods are discussed in detail in Chapter 60.
 oid: Row identifier (hidden attribute; must be explicitly selected)
 amname: Name of the access method
 amhandler: OID of a handler function that is responsible for supplying information about the access method

9.6 → 10
+ attidentity  "char"

--- 9.6
+++ 10
@@ -1,4 +1,4 @@
-(relation) The catalog pg_authid contains information about database authorization identifiers (roles). A role subsumes the concepts of "users" and "groups". A user is essentially just a role with the rolcanlogin flag set. Any role (with or without rolcanlogin) can have other roles as members; see pg_auth_members. Since this catalog contains passwords, it must not be publicly readable. pg_roles is a publicly readable view on pg_authid that blanks out the password field. Chapter 21 contains detailed information about user and privilege management. Because user identities are cluster-wide, pg_authid is shared across all databases of a cluster: there is only one copy of pg_authid per cluster, not one per database.
+(relation) The catalog pg_authid contains information about database authorization identifiers (roles). A role subsumes the concepts of “users” and “groups”. A user is essentially just a role with the rolcanlogin flag set. Any role (with or without rolcanlogin) can have other roles as members; see pg_auth_members. Since this catalog contains passwords, it must not be publicly readable. pg_roles is a publicly readable view on pg_authid that blanks out the password field. Chapter 21 contains detailed information about user and privilege management. Because user identities are cluster-wide, pg_authid is shared across all databases of a cluster: there is only one copy of pg_authid per cluster, not one per database.
 oid: Row identifier (hidden attribute; must be explicitly selected)
 rolname: Role name
 rolsuper: Role has superuser privileges
@@ -9,5 +9,5 @@
 rolreplication: Role is a replication role. A replication role can initiate replication connections and create and drop replication slots.
 rolbypassrls: Role bypasses every row level security policy, see Section 5.7 for more information.
 rolconnlimit: For roles that can log in, this sets maximum number of concurrent connections this role can make. -1 means no limit.
-rolpassword: Password (possibly encrypted); null if none. If the password is encrypted, this column will begin with the string md5 followed by a 32-character hexadecimal MD5 hash. The MD5 hash will be of the user's password concatenated to their user name. For example, if user joe has password xyzzy, PostgreSQL will store the md5 hash of xyzzyjoe. A password that does not follow that format is assumed to be unencrypted.
+rolpassword: Password (possibly encrypted); null if none. The format depends on the form of encryption used.
 rolvaliduntil: Password expiry time (only used for password authentication); null if no expiration

--- 9.6
+++ 10
@@ -1,4 +1,4 @@
-(relation) The catalog pg_cast stores data type conversion paths, both built-in and user-defined. It should be noted that pg_cast does not represent every type conversion that the system knows how to perform; only those that cannot be deduced from some generic rule. For example, casting between a domain and its base type is not explicitly represented in pg_cast. Another important exception is that "automatic I/O conversion casts", those performed using a data type's own I/O functions to convert to or from text or other string types, are not explicitly represented in pg_cast.
+(relation) The catalog pg_cast stores data type conversion paths, both built-in and user-defined. It should be noted that pg_cast does not represent every type conversion that the system knows how to perform; only those that cannot be deduced from some generic rule. For example, casting between a domain and its base type is not explicitly represented in pg_cast. Another important exception is that “automatic I/O conversion casts”, those performed using a data type's own I/O functions to convert to or from text or other string types, are not explicitly represented in pg_cast.
 oid: Row identifier (hidden attribute; must be explicitly selected)
 castsource: OID of the source data type
 casttarget: OID of the target data type

9.6 → 10
+ relispartition  boolean
+ relpartbound  pg_node_tree

9.6 → 10
+ collprovider  "char"
+ collversion  text

--- 9.6
+++ 10
@@ -1,4 +1,4 @@
-(relation) The pg_cursors view lists the cursors that are currently available. Cursors can be defined in several ways: via the DECLARE statement in SQL via the Bind message in the frontend/backend protocol, as described in Section 51.2.3 via the Server Programming Interface (SPI), as described in Section 45.1 The pg_cursors view displays cursors created by any of these means. Cursors only exist for the duration of the transaction that defines them, unless they have been declared WITH HOLD. Therefore non-holdable cursors are only present in the view until the end of their creating transaction.
+(relation) The pg_cursors view lists the cursors that are currently available. Cursors can be defined in several ways: via the DECLARE statement in SQL via the Bind message in the frontend/backend protocol, as described in Section 52.2.3 via the Server Programming Interface (SPI), as described in Section 46.1 The pg_cursors view displays cursors created by any of these means. Cursors only exist for the duration of the transaction that defines them, unless they have been declared WITH HOLD. Therefore non-holdable cursors are only present in the view until the end of their creating transaction.
 name: The name of the cursor
 statement: The verbatim query string submitted to declare this cursor
 is_holdable: true if the cursor is holdable (that is, it can be accessed after the transaction that declared the cursor has committed); false otherwise

--- 9.6
+++ 10
@@ -9,7 +9,7 @@
 datallowconn: If false then no one can connect to this database. This is used to protect the template0 database from being altered.
 datconnlimit: Sets maximum number of concurrent connections that can be made to this database. -1 means no limit.
 datlastsysoid: Last system OID in the database; useful particularly to pg_dump
-datfrozenxid: All transaction IDs before this one have been replaced with a permanent ("frozen") transaction ID in this database. This is used to track whether the database needs to be vacuumed in order to prevent transaction ID wraparound or to allow pg_clog to be shrunk. It is the minimum of the per-table pg_class.relfrozenxid values.
+datfrozenxid: All transaction IDs before this one have been replaced with a permanent (“frozen”) transaction ID in this database. This is used to track whether the database needs to be vacuumed in order to prevent transaction ID wraparound or to allow pg_xact to be shrunk. It is the minimum of the per-table pg_class.relfrozenxid values.
 datminmxid: All multixact IDs before this one have been replaced with a transaction ID in this database. This is used to track whether the database needs to be vacuumed in order to prevent multixact ID wraparound or to allow pg_multixact to be shrunk. It is the minimum of the per-table pg_class.relminmxid values.
 dattablespace: The default tablespace for the database. Within this database, all tables for which pg_class.reltablespace is zero will be stored in this tablespace; in particular, all the non-shared system catalogs will be there.
 datacl: Access privileges; see GRANT and REVOKE for details

--- 9.6
+++ 10
@@ -2,5 +2,5 @@
 oid: Row identifier (hidden attribute; must be explicitly selected)
 defaclrole: The OID of the role associated with this entry
 defaclnamespace: The OID of the namespace associated with this entry, or 0 if none
-defaclobjtype: Type of object this entry is for: r = relation (table, view), S = sequence, f = function, T = type
+defaclobjtype: Type of object this entry is for: r = relation (table, view), S = sequence, f = function, T = type, n = schema
 defaclacl: Access privileges that this type of object should have on creation

--- 9.6
+++ 10
@@ -1,7 +1,7 @@
-(relation) The catalog pg_event_trigger stores event triggers. See Chapter 38 for more information.
+(relation) The catalog pg_event_trigger stores event triggers. See Chapter 39 for more information.
 evtname: Trigger name (must be unique)
 evtevent: Identifies the event for which this trigger fires
 evtowner: Owner of the event trigger
 evtfoid: The function to be called
-evtenabled: Controls in which session_replication_role modes the event trigger fires. O = trigger fires in "origin" and "local" modes, D = trigger is disabled, R = trigger fires in "replica" mode, A = trigger fires always.
+evtenabled: Controls in which session_replication_role modes the event trigger fires. O = trigger fires in “origin” and “local” modes, D = trigger is disabled, R = trigger fires in “replica” mode, A = trigger fires always.
 evttags: Command tags for which this trigger will fire. If NULL, the firing of this trigger is not restricted on the basis of the command tag.

--- 9.6
+++ 10
@@ -1,4 +1,4 @@
-(relation) The catalog pg_extension stores information about the installed extensions. See Section 36.15 for details about extensions.
+(relation) The catalog pg_extension stores information about the installed extensions. See Section 37.15 for details about extensions.
 oid: Row identifier (hidden attribute; must be explicitly selected)
 extname: Name of the extension
 extowner: Owner of the extension

--- 9.6
+++ 10
@@ -1,4 +1,4 @@
-(relation) The view pg_file_settings provides a summary of the contents of the server's configuration file(s). A row appears in this view for each "name = value" entry appearing in the files, with annotations indicating whether the value could be applied successfully. Additional row(s) may appear for problems not linked to a "name = value" entry, such as syntax errors in the files. This view is helpful for checking whether planned changes in the configuration files will work, or for diagnosing a previous failure. Note that this view reports on the current contents of the files, not on what was last applied by the server. (The pg_settings view is usually sufficient to determine that.) By default, the pg_file_settings view can be read only by superusers.
+(relation) The view pg_file_settings provides a summary of the contents of the server's configuration file(s). A row appears in this view for each “name = value” entry appearing in the files, with annotations indicating whether the value could be applied successfully. Additional row(s) may appear for problems not linked to a “name = value” entry, such as syntax errors in the files. This view is helpful for checking whether planned changes in the configuration files will work, or for diagnosing a previous failure. Note that this view reports on the current contents of the files, not on what was last applied by the server. (The pg_settings view is usually sufficient to determine that.) By default, the pg_file_settings view can be read only by superusers.
 sourcefile: Full path name of the configuration file
 sourceline: Line number within the configuration file where the entry appears
 seqno: Order in which the entries are processed (1..n)

--- 9.6
+++ 10
@@ -5,4 +5,4 @@
 fdwhandler: References a handler function that is responsible for supplying execution routines for the foreign-data wrapper. Zero if no handler is provided
 fdwvalidator: References a validator function that is responsible for checking the validity of the options given to the foreign-data wrapper, as well as options for foreign servers and user mappings using the foreign-data wrapper. Zero if no validator is provided
 fdwacl: Access privileges; see GRANT and REVOKE for details
-fdwoptions: Foreign-data wrapper specific options, as "keyword=value" strings
+fdwoptions: Foreign-data wrapper specific options, as “keyword=value” strings

--- 9.6
+++ 10
@@ -6,4 +6,4 @@
 srvtype: Type of the server (optional)
 srvversion: Version of the server (optional)
 srvacl: Access privileges; see GRANT and REVOKE for details
-srvoptions: Foreign server specific options, as "keyword=value" strings
+srvoptions: Foreign server specific options, as “keyword=value” strings

--- 9.6
+++ 10
@@ -1,4 +1,4 @@
 (relation) The catalog pg_foreign_table contains auxiliary information about foreign tables. A foreign table is primarily represented by a pg_class entry, just like a regular table. Its pg_foreign_table entry contains the information that is pertinent only to foreign tables and not any other kind of relation.
 ftrelid: OID of the pg_class entry for this foreign table
 ftserver: OID of the foreign server for this foreign table
-ftoptions: Foreign table options, as "keyword=value" strings
+ftoptions: Foreign table options, as “keyword=value” strings

--- 9.6
+++ 10
@@ -0,0 +1,9 @@
+line_number  integer
+type  text
+database  text[]
+user_name  text[]
+address  text
+netmask  text
+auth_method  text
+options  text[]
+error  text

--- 9.6
+++ 10
@@ -11,9 +11,9 @@
 indcheckxmin: If true, queries must not use the index until the xmin of this pg_index row is below their TransactionXmin event horizon, because the table may contain broken HOT chains with incompatible rows that they can see
 indisready: If true, the index is currently ready for inserts. False means the index must be ignored by INSERT/UPDATE operations.
 indislive: If false, the index is in process of being dropped, and should be ignored for all purposes (including HOT-safety decisions)
-indisreplident: If true this index has been chosen as "replica identity" using ALTER TABLE ... REPLICA IDENTITY USING INDEX ...
+indisreplident: If true this index has been chosen as “replica identity” using ALTER TABLE ... REPLICA IDENTITY USING INDEX ...
 indkey: This is an array of indnatts values that indicate which table columns this index indexes. For example a value of 1 3 would mean that the first and the third table columns make up the index key. A zero in this array indicates that the corresponding index attribute is an expression over the table columns, rather than a simple column reference.
-indcollation: For each column in the index key, this contains the OID of the collation to use for the index.
+indcollation: For each column in the index key, this contains the OID of the collation to use for the index, or zero if the column is not of a collatable data type.
 indclass: For each column in the index key, this contains the OID of the operator class to use. See pg_opclass for details.
 indoption: This is an array of indnatts values that store per-column flag bits. The meaning of the bits is defined by the index's access method.
 indexprs: Expression trees (in nodeToString() representation) for index attributes that are not simple column references. This is a list with one element for each zero entry in indkey. Null if all index attributes are simple references.

--- 9.6
+++ 10
@@ -1,10 +1,10 @@
-(relation) The catalog pg_language registers languages in which you can write functions or stored procedures. See CREATE LANGUAGE and Chapter 40 for more information about language handlers.
+(relation) The catalog pg_language registers languages in which you can write functions or stored procedures. See CREATE LANGUAGE and Chapter 41 for more information about language handlers.
 oid: Row identifier (hidden attribute; must be explicitly selected)
 lanname: Name of the language
 lanowner: Owner of the language
 lanispl: This is false for internal languages (such as SQL) and true for user-defined languages. Currently, pg_dump still uses this to determine which languages need to be dumped, but this might be replaced by a different mechanism in the future.
 lanpltrusted: True if this is a trusted language, which means that it is believed not to grant access to anything outside the normal SQL execution environment. Only superusers can create functions in untrusted languages.
 lanplcallfoid: For noninternal languages this references the language handler, which is a special function that is responsible for executing all functions that are written in the particular language
-laninline: This references a function that is responsible for executing "inline" anonymous code blocks (DO blocks). Zero if inline blocks are not supported.
+laninline: This references a function that is responsible for executing “inline” anonymous code blocks (DO blocks). Zero if inline blocks are not supported.
 lanvalidator: This references a language validator function that is responsible for checking the syntax and validity of new functions when they are created. Zero if no validator is provided.
 lanacl: Access privileges; see GRANT and REVOKE for details

--- 9.6
+++ 10
@@ -1,4 +1,4 @@
-(relation) The catalog pg_largeobject holds the data making up "large objects". A large object is identified by an OID assigned when it is created. Each large object is broken into segments or "pages" small enough to be conveniently stored as rows in pg_largeobject. The amount of data per page is defined to be LOBLKSIZE (which is currently BLCKSZ/4, or typically 2 kB). Prior to PostgreSQL 9.0, there was no permission structure associated with large objects. As a result, pg_largeobject was publicly readable and could be used to obtain the OIDs (and contents) of all large objects in the system. This is no longer the case; use pg_largeobject_metadata to obtain a list of large object OIDs.
+(relation) The catalog pg_largeobject holds the data making up “large objects”. A large object is identified by an OID assigned when it is created. Each large object is broken into segments or “pages” small enough to be conveniently stored as rows in pg_largeobject. The amount of data per page is defined to be LOBLKSIZE (which is currently BLCKSZ/4, or typically 2 kB). Prior to PostgreSQL 9.0, there was no permission structure associated with large objects. As a result, pg_largeobject was publicly readable and could be used to obtain the OIDs (and contents) of all large objects in the system. This is no longer the case; use pg_largeobject_metadata to obtain a list of large object OIDs.
 loid: Identifier of the large object that includes this page
 pageno: Page number of this page within its large object (counting from zero)
 data: Actual data stored in the large object. This will never be more than LOBLKSIZE bytes and might be less.

--- 9.6
+++ 10
@@ -1,4 +1,4 @@
-(relation) The view pg_locks provides access to information about the locks held by active processes within the database server. See Chapter 13 for more discussion of locking. pg_locks contains one row per active lockable object, requested lock mode, and relevant process. Thus, the same lockable object might appear many times, if multiple processes are holding or waiting for locks on it. However, an object that currently has no locks on it will not appear at all. There are several distinct types of lockable objects: whole relations (e.g., tables), individual pages of relations, individual tuples of relations, transaction IDs (both virtual and permanent IDs), and general database objects (identified by class OID and object OID, in the same way as in pg_description or pg_depend). Also, the right to extend a relation is represented as a separate lockable object, as is the right to update pg_database.datfrozenxid. Also, "advisory" locks can be taken on numbers that have user-defined meanings.
+(relation) The view pg_locks provides access to information about the locks held by active processes within the database server. See Chapter 13 for more discussion of locking. pg_locks contains one row per active lockable object, requested lock mode, and relevant process. Thus, the same lockable object might appear many times, if multiple processes are holding or waiting for locks on it. However, an object that currently has no locks on it will not appear at all. There are several distinct types of lockable objects: whole relations (e.g., tables), individual pages of relations, individual tuples of relations, transaction IDs (both virtual and permanent IDs), and general database objects (identified by class OID and object OID, in the same way as in pg_description or pg_depend). Also, the right to extend a relation is represented as a separate lockable object, as is the right to update pg_database.datfrozenxid. Also, “advisory” locks can be taken on numbers that have user-defined meanings.
 locktype: Type of the lockable object: relation, extend, frozenid, page, tuple, transactionid, virtualxid, object, userlock, or advisory
 database: OID of the database in which the lock target exists, or zero if the target is a shared object, or null if the target is a transaction ID
 relation: OID of the relation targeted by the lock, or null if the target is not a relation or part of a relation

--- 9.6
+++ 10
@@ -1,4 +1,4 @@
-(relation) The catalog pg_opclass defines index access method operator classes. Each operator class defines semantics for index columns of a particular data type and a particular index access method. An operator class essentially specifies that a particular operator family is applicable to a particular indexable column data type. The set of operators from the family that are actually usable with the indexed column are whichever ones accept the column's data type as their left-hand input. Operator classes are described at length in Section 36.14.
+(relation) The catalog pg_opclass defines index access method operator classes. Each operator class defines semantics for index columns of a particular data type and a particular index access method. An operator class essentially specifies that a particular operator family is applicable to a particular indexable column data type. The set of operators from the family that are actually usable with the indexed column are whichever ones accept the column's data type as their left-hand input. Operator classes are described at length in Section 37.14.
 oid: Row identifier (hidden attribute; must be explicitly selected)
 opcmethod: Index access method operator class is for
 opcname: Name of this operator class

--- 9.6
+++ 10
@@ -1,9 +1,9 @@
-(relation) The catalog pg_operator stores information about operators. See CREATE OPERATOR and Section 36.12 for more information.
+(relation) The catalog pg_operator stores information about operators. See CREATE OPERATOR and Section 37.12 for more information.
 oid: Row identifier (hidden attribute; must be explicitly selected)
 oprname: Name of the operator
 oprnamespace: The OID of the namespace that contains this operator
 oprowner: Owner of the operator
-oprkind: b = infix ("both"), l = prefix ("left"), r = postfix ("right")
+oprkind: b = infix (“both”), l = prefix (“left”), r = postfix (“right”)
 oprcanmerge: This operator supports merge joins
 oprcanhash: This operator supports hash joins
 oprleft: Type of the left operand

--- 9.6
+++ 10
@@ -1,4 +1,4 @@
-(relation) The catalog pg_opfamily defines operator families. Each operator family is a collection of operators and associated support routines that implement the semantics specified for a particular index access method. Furthermore, the operators in a family are all "compatible", in a way that is specified by the access method. The operator family concept allows cross-data-type operators to be used with indexes and to be reasoned about using knowledge of access method semantics. Operator families are described at length in Section 36.14.
+(relation) The catalog pg_opfamily defines operator families. Each operator family is a collection of operators and associated support routines that implement the semantics specified for a particular index access method. Furthermore, the operators in a family are all “compatible”, in a way that is specified by the access method. The operator family concept allows cross-data-type operators to be used with indexes and to be reasoned about using knowledge of access method semantics. Operator families are described at length in Section 37.14.
 oid: Row identifier (hidden attribute; must be explicitly selected)
 opfmethod: Index access method operator family is for
 opfname: Name of this operator family

--- 9.6
+++ 10
@@ -0,0 +1,7 @@
+partrelid  oid
+partstrat  "char"
+partnatts  smallint
+partattrs  int2vector
+partclass  oidvector
+partcollation  oidvector
+partexprs  pg_node_tree

--- 9.6
+++ 10
@@ -1,4 +1,4 @@
-(relation) The catalog pg_pltemplate stores "template" information for procedural languages. A template for a language allows the language to be created in a particular database by a simple CREATE LANGUAGE command, with no need to specify implementation details. Unlike most system catalogs, pg_pltemplate is shared across all databases of a cluster: there is only one copy of pg_pltemplate per cluster, not one per database. This allows the information to be accessible in each database as it is needed.
+(relation) The catalog pg_pltemplate stores “template” information for procedural languages. A template for a language allows the language to be created in a particular database by a simple CREATE LANGUAGE command, with no need to specify implementation details. Unlike most system catalogs, pg_pltemplate is shared across all databases of a cluster: there is only one copy of pg_pltemplate per cluster, not one per database. This allows the information to be accessible in each database as it is needed.
 tmplname: Name of the language this template is for
 tmpltrusted: True if language is considered trusted
 tmpldbacreate: True if language may be created by a database owner

9.6 → 10
+ permissive  (reported by the 10.23 server; the manual does not list it)
= polpermissive  (now listed by the manual; the column exists in both releases)

9.6 → 10
+ polpermissive  boolean

--- 9.6
+++ 10
@@ -1,4 +1,4 @@
-(relation) The catalog pg_proc stores information about functions (or procedures). See CREATE FUNCTION and Section 36.3 for more information. The table contains data for aggregate functions as well as plain functions. If proisagg is true, there should be a matching row in pg_aggregate.
+(relation) The catalog pg_proc stores information about functions (or procedures). See CREATE FUNCTION and Section 37.3 for more information. The table contains data for aggregate functions as well as plain functions. If proisagg is true, there should be a matching row in pg_aggregate.
 oid: Row identifier (hidden attribute; must be explicitly selected)
 proname: Name of the function
 pronamespace: The OID of the namespace that contains this function
@@ -7,14 +7,14 @@
 procost: Estimated execution cost (in units of cpu_operator_cost); if proretset, this is cost per row returned
 prorows: Estimated number of result rows (zero if not proretset)
 provariadic: Data type of the variadic array parameter's elements, or zero if the function does not have a variadic parameter
-protransform: Calls to this function can be simplified by this other function (see Section 36.9.11)
+protransform: Calls to this function can be simplified by this other function (see Section 37.9.10)
 proisagg: Function is an aggregate function
 proiswindow: Function is a window function
-prosecdef: Function is a security definer (i.e., a "setuid" function)
+prosecdef: Function is a security definer (i.e., a “setuid” function)
 proleakproof: The function has no side effects. No information about the arguments is conveyed except via the return value. Any function that might throw an error depending on the values of its arguments is not leak-proof.
-proisstrict: Function returns null if any call argument is null. In that case the function won't actually be called at all. Functions that are not "strict" must be prepared to handle null inputs.
+proisstrict: Function returns null if any call argument is null. In that case the function won't actually be called at all. Functions that are not “strict” must be prepared to handle null inputs.
 proretset: Function returns a set (i.e., multiple values of the specified data type)
-provolatile: provolatile tells whether the function's result depends only on its input arguments, or is affected by outside factors. It is i for "immutable" functions, which always deliver the same result for the same inputs. It is s for "stable" functions, whose results (for fixed inputs) do not change within a scan. It is v for "volatile" functions, whose results might change at any time. (Use v also for functions with side-effects, so that calls to them cannot get optimized away.)
+provolatile: provolatile tells whether the function's result depends only on its input arguments, or is affected by outside factors. It is i for “immutable” functions, which always deliver the same result for the same inputs. It is s for “stable” functions, whose results (for fixed inputs) do not change within a scan. It is v for “volatile” functions, whose results might change at any time. (Use v also for functions with side-effects, so that calls to them cannot get optimized away.)
 proparallel: proparallel tells whether the function can be safely run in parallel mode. It is s for functions which are safe to run in parallel mode without restriction. It is r for functions which can be run in parallel mode, but their execution is restricted to the parallel group leader; parallel worker processes cannot invoke these functions. It is u for functions which are unsafe in parallel mode; the presence of such a function forces a serial execution plan.
 pronargs: Number of input arguments
 pronargdefaults: Number of arguments that have defaults

--- 9.6
+++ 10
@@ -0,0 +1,6 @@
+pubname  name
+pubowner  oid
+puballtables  boolean
+pubinsert  boolean
+pubupdate  boolean
+pubdelete  boolean

--- 9.6
+++ 10
@@ -0,0 +1,2 @@
+prpubid  oid
+prrelid  oid

--- 9.6
+++ 10
@@ -0,0 +1,3 @@
+pubname  name
+schemaname  name
+tablename  name

--- 9.6
+++ 10
@@ -1,3 +1,3 @@
-(relation) The pg_replication_origin catalog contains all replication origins created. For more on replication origins see Chapter 48.
+(relation) The pg_replication_origin catalog contains all replication origins created. For more on replication origins see Chapter 49.
 roident: A unique, cluster-wide identifier for the replication origin. Should never leave the system.
 roname: The external, user defined, name of a replication origin.

--- 9.6
+++ 10
@@ -1,4 +1,4 @@
-(relation) The pg_replication_origin_status view contains information about how far replay for a certain origin has progressed. For more on replication origins see Chapter 48.
+(relation) The pg_replication_origin_status view contains information about how far replay for a certain origin has progressed. For more on replication origins see Chapter 49.
 local_id: internal node identifier
 external_id: external node identifier
 remote_lsn: The origin node's LSN up to which data has been replicated.

9.6 → 10
+ temporary  boolean

--- 9.6
+++ 10
@@ -3,7 +3,7 @@
 rulename: Rule name
 ev_class: The table this rule is for
 ev_type: Event type that the rule is for: 1 = SELECT, 2 = UPDATE, 3 = INSERT, 4 = DELETE
-ev_enabled: Controls in which session_replication_role modes the rule fires. O = rule fires in "origin" and "local" modes, D = rule is disabled, R = rule fires in "replica" mode, A = rule fires always.
+ev_enabled: Controls in which session_replication_role modes the rule fires. O = rule fires in “origin” and “local” modes, D = rule is disabled, R = rule fires in “replica” mode, A = rule fires always.
 is_instead: True if the rule is an INSTEAD rule
 ev_qual: Expression tree (in the form of a nodeToString() representation) for the rule's qualifying condition
 ev_action: Query tree (in the form of a nodeToString() representation) for the rule's action

--- 9.6
+++ 10
@@ -1,4 +1,4 @@
-(relation) The catalog pg_seclabel stores security labels on database objects. Security labels can be manipulated with the SECURITY LABEL command. For an easier way to view security labels, see Section 50.74. See also pg_shseclabel, which performs a similar function for security labels of database objects that are shared across a database cluster.
+(relation) The catalog pg_seclabel stores security labels on database objects. Security labels can be manipulated with the SECURITY LABEL command. For an easier way to view security labels, see Section 51.83. See also pg_shseclabel, which performs a similar function for security labels of database objects that are shared across a database cluster.
 objoid: The OID of the object this security label pertains to
 classoid: The OID of the system catalog this object appears in
 objsubid: For a security label on a table column, this is the column number (the objoid and classoid refer to the table itself). For all other object types, this column is zero.

--- 9.6
+++ 10
@@ -0,0 +1,8 @@
+seqrelid  oid
+seqtypid  oid
+seqstart  bigint
+seqincrement  bigint
+seqmax  bigint
+seqmin  bigint
+seqcache  bigint
+seqcycle  boolean

--- 9.6
+++ 10
@@ -0,0 +1,11 @@
+schemaname  name
+sequencename  name
+sequenceowner  name
+data_type  regtype
+start_value  bigint
+min_value  bigint
+max_value  bigint
+increment_by  bigint
+cycle  boolean
+cache_size  bigint
+last_value  bigint

--- 9.6
+++ 10
@@ -13,6 +13,6 @@
 enumvals: Allowed values of an enum parameter (null for non-enum values)
 boot_val: Parameter value assumed at server startup if the parameter is not otherwise set
 reset_val: Value that RESET would reset the parameter to in the current session
-sourcefile: Configuration file the current value was set in (null for values set from sources other than configuration files, or when examined by a non-superuser); helpful when using include directives in configuration files
-sourceline: Line number within the configuration file the current value was set at (null for values set from sources other than configuration files, or when examined by a non-superuser)
+sourcefile: Configuration file the current value was set in (null for values set from sources other than configuration files, or when examined by a user who is neither a superuser or a member of pg_read_all_settings); helpful when using include directives in configuration files
+sourceline: Line number within the configuration file the current value was set at (null for values set from sources other than configuration files, or when examined by a user who is neither a superuser or a member of pg_read_all_settings).
 pending_restart: true if the value has been changed in the configuration file but needs a restart; or false otherwise.

--- 9.6
+++ 10
@@ -1,4 +1,4 @@
-(relation) The catalog pg_shseclabel stores security labels on shared database objects. Security labels can be manipulated with the SECURITY LABEL command. For an easier way to view security labels, see Section 50.74. See also pg_seclabel, which performs a similar function for security labels involving objects within a single database. Unlike most system catalogs, pg_shseclabel is shared across all databases of a cluster: there is only one copy of pg_shseclabel per cluster, not one per database.
+(relation) The catalog pg_shseclabel stores security labels on shared database objects. Security labels can be manipulated with the SECURITY LABEL command. For an easier way to view security labels, see Section 51.83. See also pg_seclabel, which performs a similar function for security labels involving objects within a single database. Unlike most system catalogs, pg_shseclabel is shared across all databases of a cluster: there is only one copy of pg_shseclabel per cluster, not one per database.
 objoid: The OID of the object this security label pertains to
 classoid: The OID of the system catalog this object appears in
 provider: The label provider associated with this label.

9.6 → 10
+ backend_type  text

--- 9.6
+++ 10
@@ -3,7 +3,7 @@
 datid: OID of the database to which this backend is connected.
 datname: Name of the database to which this backend is connected.
 relid: OID of the table being vacuumed.
-phase: Current processing phase of vacuum. See Table 28-21.
+phase: Current processing phase of vacuum. See Table 28.22.
 heap_blks_total: Total number of heap blocks in the table. This number is reported as of the beginning of the scan; blocks added later will not be (and need not be) visited by this VACUUM.
 heap_blks_scanned: Number of heap blocks scanned. Because the visibility map is used to optimize scans, some blocks will be skipped without inspection; skipped blocks are included in this total, so that this number will eventually become equal to heap_blks_total when the vacuum is complete. This counter only advances when the phase is scanning heap.
 heap_blks_vacuumed: Number of heap blocks vacuumed. Unless the table has no indexes, this counter only advances when the phase is vacuuming heap. Blocks that contain no dead tuples are skipped, so the counter may sometimes skip forward in large increments.

9.6 → 10
+ sent_lsn  pg_lsn
+ write_lsn  pg_lsn
+ flush_lsn  pg_lsn
+ replay_lsn  pg_lsn
+ write_lag  interval
+ flush_lag  interval
+ replay_lag  interval
- sent_location  pg_lsn
- write_location  pg_lsn
- flush_location  pg_lsn
- replay_location  pg_lsn

--- 9.6
+++ 10
@@ -0,0 +1,9 @@
+subid  oid
+subname  text
+pid  integer
+relid  oid
+received_lsn  pg_lsn
+last_msg_send_time  timestamp with time zone
+last_msg_receipt_time  timestamp with time zone
+latest_end_lsn  pg_lsn
+latest_end_time  timestamp with time zone

--- 9.6
+++ 10
@@ -1,13 +1,13 @@
 (relation) Only one row, showing statistics about the WAL receiver from that receiver's connected server. See pg_stat_wal_receiver for details.
 pid: Process ID of the WAL receiver process
 status: Activity status of the WAL receiver process
-receive_start_lsn: First transaction log position used when WAL receiver is started
+receive_start_lsn: First write-ahead log location used when WAL receiver is started
 receive_start_tli: First timeline number used when WAL receiver is started
-received_lsn: Last transaction log position already received and flushed to disk, the initial value of this field being the first log position used when WAL receiver is started
-received_tli: Timeline number of last transaction log position received and flushed to disk, the initial value of this field being the timeline number of the first log position used when WAL receiver is started
+received_lsn: Last write-ahead log location already received and flushed to disk, the initial value of this field being the first log location used when WAL receiver is started
+received_tli: Timeline number of last write-ahead log location received and flushed to disk, the initial value of this field being the timeline number of the first log location used when WAL receiver is started
 last_msg_send_time: Send time of last message received from origin WAL sender
 last_msg_receipt_time: Receipt time of last message received from origin WAL sender
-latest_end_lsn: Last transaction log position reported to origin WAL sender
-latest_end_time: Time of last transaction log position reported to origin WAL sender
+latest_end_lsn: Last write-ahead log location reported to origin WAL sender
+latest_end_time: Time of last write-ahead log location reported to origin WAL sender
 slot_name: Replication slot name used by this WAL receiver
 conninfo: Connection string used by this WAL receiver, with security-sensitive fields obfuscated.

--- 9.6
+++ 10
@@ -1,27 +1,27 @@
-(relation) The catalog pg_statistic stores statistical data about the contents of the database. Entries are created by ANALYZE and subsequently used by the query planner. Note that all the statistical data is inherently approximate, even assuming that it is up-to-date. Normally there is one entry, with stainherit = false, for each table column that has been analyzed. If the table has inheritance children, a second entry with stainherit = true is also created. This row represents the column's statistics over the inheritance tree, i.e., statistics for the data you'd see with SELECT column FROM table*, whereas the stainherit = false row represents the results of SELECT column FROM ONLY table. pg_statistic also stores statistical data about the values of index expressions. These are described as if they were actual data columns; in particular, starelid references the index. No entry is made for an ordinary non-expression index column, however, since it would be redundant with the entry for the underlying table column. Currently, entries for index expressions always have stainherit = false. Since different kinds of statistics might be appropriate for different kinds of data, pg_statistic is designed not to assume very much about what sort of statistics it stores. Only extremely general statistics (such as nullness) are given dedicated columns in pg_statistic. Everything else is stored in "slots", which are groups of associated columns whose content is identified by a code number in one of the slot's columns. For more information see src/include/catalog/pg_statistic.h. pg_statistic should not be readable by the public, since even statistical information about a table's contents might be considered sensitive. (Example: minimum and maximum values of a salary column might be quite interesting.) pg_stats is a publicly readable view on pg_statistic that only exposes information about those tables that are readable by the current user.
+(relation) The catalog pg_statistic stores statistical data about the contents of the database. Entries are created by ANALYZE and subsequently used by the query planner. Note that all the statistical data is inherently approximate, even assuming that it is up-to-date. Normally there is one entry, with stainherit = false, for each table column that has been analyzed. If the table has inheritance children, a second entry with stainherit = true is also created. This row represents the column's statistics over the inheritance tree, i.e., statistics for the data you'd see with SELECT column FROM table*, whereas the stainherit = false row represents the results of SELECT column FROM ONLY table. pg_statistic also stores statistical data about the values of index expressions. These are described as if they were actual data columns; in particular, starelid references the index. No entry is made for an ordinary non-expression index column, however, since it would be redundant with the entry for the underlying table column. Currently, entries for index expressions always have stainherit = false. Since different kinds of statistics might be appropriate for different kinds of data, pg_statistic is designed not to assume very much about what sort of statistics it stores. Only extremely general statistics (such as nullness) are given dedicated columns in pg_statistic. Everything else is stored in “slots”, which are groups of associated columns whose content is identified by a code number in one of the slot's columns. For more information see src/include/catalog/pg_statistic.h. pg_statistic should not be readable by the public, since even statistical information about a table's contents might be considered sensitive. (Example: minimum and maximum values of a salary column might be quite interesting.) pg_stats is a publicly readable view on pg_statistic that only exposes information about those tables that are readable by the current user.
 starelid: The table or index that the described column belongs to
 staattnum: The number of the described column
 stainherit: If true, the stats include inheritance child columns, not just the values in the specified relation
 stanullfrac: The fraction of the column's entries that are null
 stawidth: The average stored width, in bytes, of nonnull entries
 stadistinct: The number of distinct nonnull data values in the column. A value greater than zero is the actual number of distinct values. A value less than zero is the negative of a multiplier for the number of rows in the table; for example, a column in which about 80% of the values are nonnull and each nonnull value appears about twice on average could be represented by stadistinct = -0.4. A zero value means the number of distinct values is unknown.
-stakind1: A code number indicating the kind of statistics stored in the Nth "slot" of the pg_statistic row.
-stakind2: A code number indicating the kind of statistics stored in the Nth "slot" of the pg_statistic row.
-stakind3: A code number indicating the kind of statistics stored in the Nth "slot" of the pg_statistic row.
-stakind4: A code number indicating the kind of statistics stored in the Nth "slot" of the pg_statistic row.
-stakind5: A code number indicating the kind of statistics stored in the Nth "slot" of the pg_statistic row.
-staop1: An operator used to derive the statistics stored in the Nth "slot". For example, a histogram slot would show the < operator that defines the sort order of the data.
-staop2: An operator used to derive the statistics stored in the Nth "slot". For example, a histogram slot would show the < operator that defines the sort order of the data.
-staop3: An operator used to derive the statistics stored in the Nth "slot". For example, a histogram slot would show the < operator that defines the sort order of the data.
-staop4: An operator used to derive the statistics stored in the Nth "slot". For example, a histogram slot would show the < operator that defines the sort order of the data.
-staop5: An operator used to derive the statistics stored in the Nth "slot". For example, a histogram slot would show the < operator that defines the sort order of the data.
-stanumbers1: Numerical statistics of the appropriate kind for the Nth "slot", or null if the slot kind does not involve numerical values
-stanumbers2: Numerical statistics of the appropriate kind for the Nth "slot", or null if the slot kind does not involve numerical values
-stanumbers3: Numerical statistics of the appropriate kind for the Nth "slot", or null if the slot kind does not involve numerical values
-stanumbers4: Numerical statistics of the appropriate kind for the Nth "slot", or null if the slot kind does not involve numerical values
-stanumbers5: Numerical statistics of the appropriate kind for the Nth "slot", or null if the slot kind does not involve numerical values
-stavalues1: Column data values of the appropriate kind for the Nth "slot", or null if the slot kind does not store any data values. Each array's element values are actually of the specific column's data type, or a related type such as an array's element type, so there is no way to define these columns' type more specifically than anyarray.
-stavalues2: Column data values of the appropriate kind for the Nth "slot", or null if the slot kind does not store any data values. Each array's element values are actually of the specific column's data type, or a related type such as an array's element type, so there is no way to define these columns' type more specifically than anyarray.
-stavalues3: Column data values of the appropriate kind for the Nth "slot", or null if the slot kind does not store any data values. Each array's element values are actually of the specific column's data type, or a related type such as an array's element type, so there is no way to define these columns' type more specifically than anyarray.
-stavalues4: Column data values of the appropriate kind for the Nth "slot", or null if the slot kind does not store any data values. Each array's element values are actually of the specific column's data type, or a related type such as an array's element type, so there is no way to define these columns' type more specifically than anyarray.
-stavalues5: Column data values of the appropriate kind for the Nth "slot", or null if the slot kind does not store any data values. Each array's element values are actually of the specific column's data type, or a related type such as an array's element type, so there is no way to define these columns' type more specifically than anyarray.
+stakind1: A code number indicating the kind of statistics stored in the Nth “slot” of the pg_statistic row.
+stakind2: A code number indicating the kind of statistics stored in the Nth “slot” of the pg_statistic row.
+stakind3: A code number indicating the kind of statistics stored in the Nth “slot” of the pg_statistic row.
+stakind4: A code number indicating the kind of statistics stored in the Nth “slot” of the pg_statistic row.
+stakind5: A code number indicating the kind of statistics stored in the Nth “slot” of the pg_statistic row.
+staop1: An operator used to derive the statistics stored in the Nth “slot”. For example, a histogram slot would show the < operator that defines the sort order of the data.
+staop2: An operator used to derive the statistics stored in the Nth “slot”. For example, a histogram slot would show the < operator that defines the sort order of the data.
+staop3: An operator used to derive the statistics stored in the Nth “slot”. For example, a histogram slot would show the < operator that defines the sort order of the data.
+staop4: An operator used to derive the statistics stored in the Nth “slot”. For example, a histogram slot would show the < operator that defines the sort order of the data.
+staop5: An operator used to derive the statistics stored in the Nth “slot”. For example, a histogram slot would show the < operator that defines the sort order of the data.
+stanumbers1: Numerical statistics of the appropriate kind for the Nth “slot”, or null if the slot kind does not involve numerical values
+stanumbers2: Numerical statistics of the appropriate kind for the Nth “slot”, or null if the slot kind does not involve numerical values
+stanumbers3: Numerical statistics of the appropriate kind for the Nth “slot”, or null if the slot kind does not involve numerical values
+stanumbers4: Numerical statistics of the appropriate kind for the Nth “slot”, or null if the slot kind does not involve numerical values
+stanumbers5: Numerical statistics of the appropriate kind for the Nth “slot”, or null if the slot kind does not involve numerical values
+stavalues1: Column data values of the appropriate kind for the Nth “slot”, or null if the slot kind does not store any data values. Each array's element values are actually of the specific column's data type, or a related type such as an array's element type, so there is no way to define these columns' type more specifically than anyarray.
+stavalues2: Column data values of the appropriate kind for the Nth “slot”, or null if the slot kind does not store any data values. Each array's element values are actually of the specific column's data type, or a related type such as an array's element type, so there is no way to define these columns' type more specifically than anyarray.
+stavalues3: Column data values of the appropriate kind for the Nth “slot”, or null if the slot kind does not store any data values. Each array's element values are actually of the specific column's data type, or a related type such as an array's element type, so there is no way to define these columns' type more specifically than anyarray.
+stavalues4: Column data values of the appropriate kind for the Nth “slot”, or null if the slot kind does not store any data values. Each array's element values are actually of the specific column's data type, or a related type such as an array's element type, so there is no way to define these columns' type more specifically than anyarray.
+stavalues5: Column data values of the appropriate kind for the Nth “slot”, or null if the slot kind does not store any data values. Each array's element values are actually of the specific column's data type, or a related type such as an array's element type, so there is no way to define these columns' type more specifically than anyarray.

--- 9.6
+++ 10
@@ -0,0 +1,8 @@
+stxrelid  oid
+stxname  name
+stxnamespace  oid
+stxowner  oid
+stxkeys  int2vector
+stxkind  "char"[]
+stxndistinct  pg_ndistinct
+stxdependencies  pg_dependencies

--- 9.6
+++ 10
@@ -0,0 +1,8 @@
+subdbid  oid
+subname  name
+subowner  oid
+subenabled  boolean
+subsynccommit  text
+subconninfo  text
+subslotname  name
+subpublications  text[]

--- 9.6
+++ 10
@@ -0,0 +1,4 @@
+srsubid  oid
+srrelid  oid
+srsubstate  "char"
+srsublsn  pg_lsn

--- 9.6
+++ 10
@@ -3,4 +3,4 @@
 spcname: Tablespace name
 spcowner: Owner of the tablespace, usually the user who created it
 spcacl: Access privileges; see GRANT and REVOKE for details
-spcoptions: Tablespace-level options, as "keyword=value" strings
+spcoptions: Tablespace-level options, as “keyword=value” strings

9.6 → 10
+ tgoldtable  name
+ tgnewtable  name

--- 9.6
+++ 10
@@ -3,16 +3,16 @@
 typname: Data type name
 typnamespace: The OID of the namespace that contains this type
 typowner: Owner of the type
-typlen: For a fixed-size type, typlen is the number of bytes in the internal representation of the type. But for a variable-length type, typlen is negative. -1 indicates a "varlena" type (one that has a length word), -2 indicates a null-terminated C string.
+typlen: For a fixed-size type, typlen is the number of bytes in the internal representation of the type. But for a variable-length type, typlen is negative. -1 indicates a “varlena” type (one that has a length word), -2 indicates a null-terminated C string.
 typbyval: typbyval determines whether internal routines pass a value of this type by value or by reference. typbyval had better be false if typlen is not 1, 2, or 4 (or 8 on machines where Datum is 8 bytes). Variable-length types are always passed by reference. Note that typbyval can be false even if the length would allow pass-by-value.
 typtype: typtype is b for a base type, c for a composite type (e.g., a table's row type), d for a domain, e for an enum type, p for a pseudo-type, or r for a range type. See also typrelid and typbasetype.
-typcategory: typcategory is an arbitrary classification of data types that is used by the parser to determine which implicit casts should be "preferred". See Table 50-56.
+typcategory: typcategory is an arbitrary classification of data types that is used by the parser to determine which implicit casts should be “preferred”. See Table 51.63.
 typispreferred: True if the type is a preferred cast target within its typcategory
 typisdefined: True if the type is defined, false if this is a placeholder entry for a not-yet-defined type. When typisdefined is false, nothing except the type name, namespace, and OID can be relied on.
 typdelim: Character that separates two values of this type when parsing array input. Note that the delimiter is associated with the array element data type, not the array data type.
 typrelid: If this is a composite type (see typtype), then this column points to the pg_class entry that defines the corresponding table. (For a free-standing composite type, the pg_class entry doesn't really represent a table, but it is needed anyway for the type's pg_attribute entries to link to.) Zero for non-composite types.
-typelem: If typelem is not 0 then it identifies another row in pg_type. The current type can then be subscripted like an array yielding values of type typelem. A "true" array type is variable length (typlen = -1), but some fixed-length (typlen > 0) types also have nonzero typelem, for example name and point. If a fixed-length type has a typelem then its internal representation must be some number of values of the typelem data type with no other data. Variable-length array types have a header defined by the array subroutines.
-typarray: If typarray is not 0 then it identifies another row in pg_type, which is the "true" array type having this type as element
+typelem: If typelem is not 0 then it identifies another row in pg_type. The current type can then be subscripted like an array yielding values of type typelem. A “true” array type is variable length (typlen = -1), but some fixed-length (typlen > 0) types also have nonzero typelem, for example name and point. If a fixed-length type has a typelem then its internal representation must be some number of values of the typelem data type with no other data. Variable-length array types have a header defined by the array subroutines.
+typarray: If typarray is not 0 then it identifies another row in pg_type, which is the “true” array type having this type as element
 typinput: Input conversion function (text format)
 typoutput: Output conversion function (text format)
 typreceive: Input conversion function (binary format), or 0 if none
@@ -20,8 +20,8 @@
 typmodin: Type modifier input function, or 0 if type does not support modifiers
 typmodout: Type modifier output function, or 0 to use the standard format
 typanalyze: Custom ANALYZE function, or 0 to use the standard function
-typalign: typalign is the alignment required when storing a value of this type. It applies to storage on disk as well as most representations of the value inside PostgreSQL. When multiple values are stored consecutively, such as in the representation of a complete row on disk, padding is inserted before a datum of this type so that it begins on the specified boundary. The alignment reference is the beginning of the first datum in the sequence. Possible values are: c = char alignment, i.e., no alignment needed. s = short alignment (2 bytes on most machines). i = int alignment (4 bytes on most machines). d = double alignment (8 bytes on many machines, but by no means all). Note: For types used in system tables, it is critical that the size and alignment defined in pg_type agree with the way that the compiler will lay out the column in a structure representing a table row.
-typstorage: typstorage tells for varlena types (those with typlen = -1) if the type is prepared for toasting and what the default strategy for attributes of this type should be. Possible values are p: Value must always be stored plain. e: Value can be stored in a "secondary" relation (if relation has one, see pg_class.reltoastrelid). m: Value can be stored compressed inline. x: Value can be stored compressed inline or stored in "secondary" storage. Note that m columns can also be moved out to secondary storage, but only as a last resort (e and x columns are moved first).
+typalign: typalign is the alignment required when storing a value of this type. It applies to storage on disk as well as most representations of the value inside PostgreSQL. When multiple values are stored consecutively, such as in the representation of a complete row on disk, padding is inserted before a datum of this type so that it begins on the specified boundary. The alignment reference is the beginning of the first datum in the sequence. Possible values are: c = char alignment, i.e., no alignment needed. s = short alignment (2 bytes on most machines). i = int alignment (4 bytes on most machines). d = double alignment (8 bytes on many machines, but by no means all). Note For types used in system tables, it is critical that the size and alignment defined in pg_type agree with the way that the compiler will lay out the column in a structure representing a table row.
+typstorage: typstorage tells for varlena types (those with typlen = -1) if the type is prepared for toasting and what the default strategy for attributes of this type should be. Possible values are p: Value must always be stored plain. e: Value can be stored in a “secondary” relation (if relation has one, see pg_class.reltoastrelid). m: Value can be stored compressed inline. x: Value can be stored compressed inline or stored in “secondary” storage. Note that m columns can also be moved out to secondary storage, but only as a last resort (e and x columns are moved first).
 typnotnull: typnotnull represents a not-null constraint on a type. Used for domains only.
 typbasetype: If this is a domain (see typtype), then typbasetype identifies the type that this one is based on. Zero if this type is not a domain.
 typtypmod: Domains use typtypmod to record the typmod to be applied to their base type (-1 if base type does not use a typmod). -1 if this type is not a domain.

--- 9.6
+++ 10
@@ -2,4 +2,4 @@
 oid: Row identifier (hidden attribute; must be explicitly selected)
 umuser: OID of the local role being mapped, 0 if the user mapping is public
 umserver: The OID of the foreign server that contains this mapping
-umoptions: User mapping specific options, as "keyword=value" strings
+umoptions: User mapping specific options, as “keyword=value” strings

--- 9.6
+++ 10
@@ -4,4 +4,4 @@
 srvname: Name of the foreign server
 umuser: OID of the local role being mapped, 0 if the user mapping is public
 usename: Name of the local user to be mapped
-umoptions: User mapping specific options, as "keyword=value" strings
+umoptions: User mapping specific options, as “keyword=value” strings