agora inbox for [email protected]help / color / mirror / Atom feed
[PATCH v5 07/12] consistent language: to which 17+ messages / 5 participants [nested] [flat]
* [PATCH v5 07/12] consistent language: to which @ 2019-05-21 00:02 Justin Pryzby <[email protected]> 0 siblings, 0 replies; 17+ messages in thread From: Justin Pryzby @ 2019-05-21 00:02 UTC (permalink / raw) XXX: should have trailing period in tables? --- doc/src/sgml/monitoring.sgml | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/doc/src/sgml/monitoring.sgml b/doc/src/sgml/monitoring.sgml index cba36c0..df5df62 100644 --- a/doc/src/sgml/monitoring.sgml +++ b/doc/src/sgml/monitoring.sgml @@ -602,12 +602,12 @@ postgres 27093 0.0 0.0 30096 2752 ? Ss 11:34 0:00 postgres: ser <row> <entry><structfield>datid</structfield></entry> <entry><type>oid</type></entry> - <entry>OID of the database this backend is connected to</entry> + <entry>OID of the database to which this backend is connected</entry> </row> <row> <entry><structfield>datname</structfield></entry> <entry><type>name</type></entry> - <entry>Name of the database this backend is connected to</entry> + <entry>Name of the database to which this backend is connected</entry> </row> <row> <entry><structfield>pid</structfield></entry> @@ -2099,7 +2099,7 @@ SELECT pid, wait_event_type, wait_event FROM pg_stat_activity WHERE wait_event i <entry><type>text</type></entry> <entry> Host of the <productname>PostgreSQL</productname> instance - this WAL receiver is connected to. This can be a host name, + to which this WAL receiver is connected. This can be a host name, an IP address, or a directory path if the connection is via Unix socket. (The path case can be distinguished because it will always be an absolute path, beginning with <literal>/</literal>.) @@ -2110,7 +2110,7 @@ SELECT pid, wait_event_type, wait_event FROM pg_stat_activity WHERE wait_event i <entry><type>integer</type></entry> <entry> Port number of the <productname>PostgreSQL</productname> instance - this WAL receiver is connected to. + to which this WAL receiver is connected. </entry> </row> <row> @@ -3375,7 +3375,7 @@ SELECT pg_stat_get_backend_pid(s.backendid) AS pid, <row> <entry><literal><function>pg_stat_get_backend_dbid(integer)</function></literal></entry> <entry><type>oid</type></entry> - <entry>OID of the database this backend is connected to</entry> + <entry>OID of the database to which this backend is connected</entry> </row> <row> -- 2.7.4 --FkmkrVfFsRoUs1wW Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v5-0008-Consistent-language-contains.patch" ^ permalink raw reply [nested|flat] 17+ messages in thread
* [PATCH v17 1/3] Remember PK oid for partitioned tables even when it's invalid @ 2023-07-12 16:57 Alvaro Herrera <[email protected]> 0 siblings, 0 replies; 17+ messages in thread From: Alvaro Herrera @ 2023-07-12 16:57 UTC (permalink / raw) --- src/backend/utils/cache/relcache.c | 34 ++++++++++++++++++++++++------ 1 file changed, 28 insertions(+), 6 deletions(-) diff --git a/src/backend/utils/cache/relcache.c b/src/backend/utils/cache/relcache.c index 8e08ca1c68..7234cb3da6 100644 --- a/src/backend/utils/cache/relcache.c +++ b/src/backend/utils/cache/relcache.c @@ -4789,19 +4789,41 @@ RelationGetIndexList(Relation relation) result = lappend_oid(result, index->indexrelid); /* - * Invalid, non-unique, non-immediate or predicate indexes aren't - * interesting for either oid indexes or replication identity indexes, - * so don't check them. + * Non-unique, non-immediate or predicate indexes aren't interesting + * for either oid indexes or replication identity indexes, so don't + * check them. */ - if (!index->indisvalid || !index->indisunique || + if (!index->indisunique || !index->indimmediate || !heap_attisnull(htup, Anum_pg_index_indpred, NULL)) continue; - /* remember primary key index if any */ - if (index->indisprimary) + /* + * Remember primary key index, if any. We do this only if the index + * is valid; but if the table is partitioned, then we do it even if + * it's invalid. + * + * The reason for returning invalid primary keys for foreign tables is + * because of pg_dump of NOT NULL constraints, and the fact that PKs + * remain marked invalid until the partitions' PKs are attached to it. + * If we make rd_pkindex invalid, then the attnotnull flag is reset + * after the PK is created, which causes the ALTER INDEX ATTACH + * PARTITION to fail with 'column ... is not marked NOT NULL'. With + * this, dropconstraint_internal() will believe that the columns must + * not have attnotnull reset, so the PKs-on-partitions can be attached + * correctly, until finally the PK-on-parent is marked valid. + * + * Also, this doesn't harm anything, because rd_pkindex is not a + * "real" index anyway, but a RELKIND_PARTITIONED_INDEX. + */ + if (index->indisprimary && + (index->indisvalid || + relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)) pkeyIndex = index->indexrelid; + if (!index->indisvalid) + continue; + /* remember explicitly chosen replica index */ if (index->indisreplident) candidateIndex = index->indexrelid; -- 2.39.2 --u5bqxbslpyv5rwih Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v17-0002-Add-pg_constraint-rows-for-NOT-NULL-constraints.patch" ^ permalink raw reply [nested|flat] 17+ messages in thread
* [PATCH v17 1/3] Remember PK oid for partitioned tables even when it's invalid @ 2023-07-12 16:57 Alvaro Herrera <[email protected]> 0 siblings, 0 replies; 17+ messages in thread From: Alvaro Herrera @ 2023-07-12 16:57 UTC (permalink / raw) --- src/backend/utils/cache/relcache.c | 34 ++++++++++++++++++++++++------ 1 file changed, 28 insertions(+), 6 deletions(-) diff --git a/src/backend/utils/cache/relcache.c b/src/backend/utils/cache/relcache.c index 8e08ca1c68..7234cb3da6 100644 --- a/src/backend/utils/cache/relcache.c +++ b/src/backend/utils/cache/relcache.c @@ -4789,19 +4789,41 @@ RelationGetIndexList(Relation relation) result = lappend_oid(result, index->indexrelid); /* - * Invalid, non-unique, non-immediate or predicate indexes aren't - * interesting for either oid indexes or replication identity indexes, - * so don't check them. + * Non-unique, non-immediate or predicate indexes aren't interesting + * for either oid indexes or replication identity indexes, so don't + * check them. */ - if (!index->indisvalid || !index->indisunique || + if (!index->indisunique || !index->indimmediate || !heap_attisnull(htup, Anum_pg_index_indpred, NULL)) continue; - /* remember primary key index if any */ - if (index->indisprimary) + /* + * Remember primary key index, if any. We do this only if the index + * is valid; but if the table is partitioned, then we do it even if + * it's invalid. + * + * The reason for returning invalid primary keys for foreign tables is + * because of pg_dump of NOT NULL constraints, and the fact that PKs + * remain marked invalid until the partitions' PKs are attached to it. + * If we make rd_pkindex invalid, then the attnotnull flag is reset + * after the PK is created, which causes the ALTER INDEX ATTACH + * PARTITION to fail with 'column ... is not marked NOT NULL'. With + * this, dropconstraint_internal() will believe that the columns must + * not have attnotnull reset, so the PKs-on-partitions can be attached + * correctly, until finally the PK-on-parent is marked valid. + * + * Also, this doesn't harm anything, because rd_pkindex is not a + * "real" index anyway, but a RELKIND_PARTITIONED_INDEX. + */ + if (index->indisprimary && + (index->indisvalid || + relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)) pkeyIndex = index->indexrelid; + if (!index->indisvalid) + continue; + /* remember explicitly chosen replica index */ if (index->indisreplident) candidateIndex = index->indexrelid; -- 2.39.2 --u5bqxbslpyv5rwih Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v17-0002-Add-pg_constraint-rows-for-NOT-NULL-constraints.patch" ^ permalink raw reply [nested|flat] 17+ messages in thread
* [PATCH v15 1/2] Remember PK oid for partitioned tables even when it's invalid @ 2023-07-12 16:57 Alvaro Herrera <[email protected]> 0 siblings, 0 replies; 17+ messages in thread From: Alvaro Herrera @ 2023-07-12 16:57 UTC (permalink / raw) --- src/backend/utils/cache/relcache.c | 34 ++++++++++++++++++++++++------ 1 file changed, 28 insertions(+), 6 deletions(-) diff --git a/src/backend/utils/cache/relcache.c b/src/backend/utils/cache/relcache.c index 8e28335915..7c3bfde571 100644 --- a/src/backend/utils/cache/relcache.c +++ b/src/backend/utils/cache/relcache.c @@ -4789,19 +4789,41 @@ RelationGetIndexList(Relation relation) result = lappend_oid(result, index->indexrelid); /* - * Invalid, non-unique, non-immediate or predicate indexes aren't - * interesting for either oid indexes or replication identity indexes, - * so don't check them. + * Non-unique, non-immediate or predicate indexes aren't interesting + * for either oid indexes or replication identity indexes, so don't + * check them. */ - if (!index->indisvalid || !index->indisunique || + if (!index->indisunique || !index->indimmediate || !heap_attisnull(htup, Anum_pg_index_indpred, NULL)) continue; - /* remember primary key index if any */ - if (index->indisprimary) + /* + * Remember primary key index, if any. We do this only if the index + * is valid; but if the table is partitioned, then we do it even if + * it's invalid. + * + * The reason for returning invalid primary keys for foreign tables is + * because of pg_dump of NOT NULL constraints, and the fact that PKs + * remain marked invalid until the partitions' PKs are attached to it. + * If we make rd_pkindex invalid, then the attnotnull flag is reset + * after the PK is created, which causes the ALTER INDEX ATTACH + * PARTITION to fail with 'column ... is not marked NOT NULL'. With + * this, dropconstraint_internal() will believe that the columns must + * not have attnotnull reset, so the PKs-on-partitions can be attached + * correctly, until finally the PK-on-parent is marked valid. + * + * Also, this doesn't harm anything, because rd_pkindex is not a + * "real" index anyway, but a RELKIND_PARTITIONED_INDEX. + */ + if (index->indisprimary && + (index->indisvalid || + relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)) pkeyIndex = index->indexrelid; + if (!index->indisvalid) + continue; + /* remember explicitly chosen replica index */ if (index->indisreplident) candidateIndex = index->indexrelid; -- 2.39.2 --icqk4nrzalktuh5g Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v15-0002-Add-pg_constraint-rows-for-NOT-NULL-constraints.patch" ^ permalink raw reply [nested|flat] 17+ messages in thread
* [PATCH v17 1/3] Remember PK oid for partitioned tables even when it's invalid @ 2023-07-12 16:57 Alvaro Herrera <[email protected]> 0 siblings, 0 replies; 17+ messages in thread From: Alvaro Herrera @ 2023-07-12 16:57 UTC (permalink / raw) --- src/backend/utils/cache/relcache.c | 34 ++++++++++++++++++++++++------ 1 file changed, 28 insertions(+), 6 deletions(-) diff --git a/src/backend/utils/cache/relcache.c b/src/backend/utils/cache/relcache.c index 8e08ca1c68..7234cb3da6 100644 --- a/src/backend/utils/cache/relcache.c +++ b/src/backend/utils/cache/relcache.c @@ -4789,19 +4789,41 @@ RelationGetIndexList(Relation relation) result = lappend_oid(result, index->indexrelid); /* - * Invalid, non-unique, non-immediate or predicate indexes aren't - * interesting for either oid indexes or replication identity indexes, - * so don't check them. + * Non-unique, non-immediate or predicate indexes aren't interesting + * for either oid indexes or replication identity indexes, so don't + * check them. */ - if (!index->indisvalid || !index->indisunique || + if (!index->indisunique || !index->indimmediate || !heap_attisnull(htup, Anum_pg_index_indpred, NULL)) continue; - /* remember primary key index if any */ - if (index->indisprimary) + /* + * Remember primary key index, if any. We do this only if the index + * is valid; but if the table is partitioned, then we do it even if + * it's invalid. + * + * The reason for returning invalid primary keys for foreign tables is + * because of pg_dump of NOT NULL constraints, and the fact that PKs + * remain marked invalid until the partitions' PKs are attached to it. + * If we make rd_pkindex invalid, then the attnotnull flag is reset + * after the PK is created, which causes the ALTER INDEX ATTACH + * PARTITION to fail with 'column ... is not marked NOT NULL'. With + * this, dropconstraint_internal() will believe that the columns must + * not have attnotnull reset, so the PKs-on-partitions can be attached + * correctly, until finally the PK-on-parent is marked valid. + * + * Also, this doesn't harm anything, because rd_pkindex is not a + * "real" index anyway, but a RELKIND_PARTITIONED_INDEX. + */ + if (index->indisprimary && + (index->indisvalid || + relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)) pkeyIndex = index->indexrelid; + if (!index->indisvalid) + continue; + /* remember explicitly chosen replica index */ if (index->indisreplident) candidateIndex = index->indexrelid; -- 2.39.2 --u5bqxbslpyv5rwih Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v17-0002-Add-pg_constraint-rows-for-NOT-NULL-constraints.patch" ^ permalink raw reply [nested|flat] 17+ messages in thread
* [PATCH v13 1/2] Remember PK oid for partitioned tables even when it's invalid @ 2023-07-12 16:57 Alvaro Herrera <[email protected]> 0 siblings, 0 replies; 17+ messages in thread From: Alvaro Herrera @ 2023-07-12 16:57 UTC (permalink / raw) --- src/backend/utils/cache/relcache.c | 21 +++++++++++++++------ 1 file changed, 15 insertions(+), 6 deletions(-) diff --git a/src/backend/utils/cache/relcache.c b/src/backend/utils/cache/relcache.c index 8a08463c2b..b5a99b4edc 100644 --- a/src/backend/utils/cache/relcache.c +++ b/src/backend/utils/cache/relcache.c @@ -4788,19 +4788,28 @@ RelationGetIndexList(Relation relation) result = lappend_oid(result, index->indexrelid); /* - * Invalid, non-unique, non-immediate or predicate indexes aren't - * interesting for either oid indexes or replication identity indexes, - * so don't check them. + * Non-unique, non-immediate or predicate indexes aren't interesting + * for either oid indexes or replication identity indexes, so don't + * check them. */ - if (!index->indisvalid || !index->indisunique || + if (!index->indisunique || !index->indimmediate || !heap_attisnull(htup, Anum_pg_index_indpred, NULL)) continue; - /* remember primary key index if any */ - if (index->indisprimary) + /* + * Remember primary key index, if any. We do this only if the index + * is valid; but if the table is partitioned, then we do it even if + * it's invalid. XXX does this cause other problems? + */ + if (index->indisprimary && + (index->indisvalid || + relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)) pkeyIndex = index->indexrelid; + if (!index->indisvalid) + continue; + /* remember explicitly chosen replica index */ if (index->indisreplident) candidateIndex = index->indexrelid; -- 2.39.2 --57gotikuhuh4be5c Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v13-0002-Add-pg_constraint-rows-for-NOT-NULL-constraints.patch" ^ permalink raw reply [nested|flat] 17+ messages in thread
* [PATCH v14 1/2] Remember PK oid for partitioned tables even when it's invalid @ 2023-07-12 16:57 Alvaro Herrera <[email protected]> 0 siblings, 0 replies; 17+ messages in thread From: Alvaro Herrera @ 2023-07-12 16:57 UTC (permalink / raw) --- src/backend/utils/cache/relcache.c | 34 ++++++++++++++++++++++++------ 1 file changed, 28 insertions(+), 6 deletions(-) diff --git a/src/backend/utils/cache/relcache.c b/src/backend/utils/cache/relcache.c index 8e28335915..7c3bfde571 100644 --- a/src/backend/utils/cache/relcache.c +++ b/src/backend/utils/cache/relcache.c @@ -4789,19 +4789,41 @@ RelationGetIndexList(Relation relation) result = lappend_oid(result, index->indexrelid); /* - * Invalid, non-unique, non-immediate or predicate indexes aren't - * interesting for either oid indexes or replication identity indexes, - * so don't check them. + * Non-unique, non-immediate or predicate indexes aren't interesting + * for either oid indexes or replication identity indexes, so don't + * check them. */ - if (!index->indisvalid || !index->indisunique || + if (!index->indisunique || !index->indimmediate || !heap_attisnull(htup, Anum_pg_index_indpred, NULL)) continue; - /* remember primary key index if any */ - if (index->indisprimary) + /* + * Remember primary key index, if any. We do this only if the index + * is valid; but if the table is partitioned, then we do it even if + * it's invalid. + * + * The reason for returning invalid primary keys for foreign tables is + * because of pg_dump of NOT NULL constraints, and the fact that PKs + * remain marked invalid until the partitions' PKs are attached to it. + * If we make rd_pkindex invalid, then the attnotnull flag is reset + * after the PK is created, which causes the ALTER INDEX ATTACH + * PARTITION to fail with 'column ... is not marked NOT NULL'. With + * this, dropconstraint_internal() will believe that the columns must + * not have attnotnull reset, so the PKs-on-partitions can be attached + * correctly, until finally the PK-on-parent is marked valid. + * + * Also, this doesn't harm anything, because rd_pkindex is not a + * "real" index anyway, but a RELKIND_PARTITIONED_INDEX. + */ + if (index->indisprimary && + (index->indisvalid || + relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)) pkeyIndex = index->indexrelid; + if (!index->indisvalid) + continue; + /* remember explicitly chosen replica index */ if (index->indisreplident) candidateIndex = index->indexrelid; -- 2.39.2 --6opfqulj2xnxqhkn Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v14-0002-Add-pg_constraint-rows-for-NOT-NULL-constraints.patch" ^ permalink raw reply [nested|flat] 17+ messages in thread
* [PATCH v15 1/2] Remember PK oid for partitioned tables even when it's invalid @ 2023-07-12 16:57 Alvaro Herrera <[email protected]> 0 siblings, 0 replies; 17+ messages in thread From: Alvaro Herrera @ 2023-07-12 16:57 UTC (permalink / raw) --- src/backend/utils/cache/relcache.c | 34 ++++++++++++++++++++++++------ 1 file changed, 28 insertions(+), 6 deletions(-) diff --git a/src/backend/utils/cache/relcache.c b/src/backend/utils/cache/relcache.c index 8e28335915..7c3bfde571 100644 --- a/src/backend/utils/cache/relcache.c +++ b/src/backend/utils/cache/relcache.c @@ -4789,19 +4789,41 @@ RelationGetIndexList(Relation relation) result = lappend_oid(result, index->indexrelid); /* - * Invalid, non-unique, non-immediate or predicate indexes aren't - * interesting for either oid indexes or replication identity indexes, - * so don't check them. + * Non-unique, non-immediate or predicate indexes aren't interesting + * for either oid indexes or replication identity indexes, so don't + * check them. */ - if (!index->indisvalid || !index->indisunique || + if (!index->indisunique || !index->indimmediate || !heap_attisnull(htup, Anum_pg_index_indpred, NULL)) continue; - /* remember primary key index if any */ - if (index->indisprimary) + /* + * Remember primary key index, if any. We do this only if the index + * is valid; but if the table is partitioned, then we do it even if + * it's invalid. + * + * The reason for returning invalid primary keys for foreign tables is + * because of pg_dump of NOT NULL constraints, and the fact that PKs + * remain marked invalid until the partitions' PKs are attached to it. + * If we make rd_pkindex invalid, then the attnotnull flag is reset + * after the PK is created, which causes the ALTER INDEX ATTACH + * PARTITION to fail with 'column ... is not marked NOT NULL'. With + * this, dropconstraint_internal() will believe that the columns must + * not have attnotnull reset, so the PKs-on-partitions can be attached + * correctly, until finally the PK-on-parent is marked valid. + * + * Also, this doesn't harm anything, because rd_pkindex is not a + * "real" index anyway, but a RELKIND_PARTITIONED_INDEX. + */ + if (index->indisprimary && + (index->indisvalid || + relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)) pkeyIndex = index->indexrelid; + if (!index->indisvalid) + continue; + /* remember explicitly chosen replica index */ if (index->indisreplident) candidateIndex = index->indexrelid; -- 2.39.2 --icqk4nrzalktuh5g Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v15-0002-Add-pg_constraint-rows-for-NOT-NULL-constraints.patch" ^ permalink raw reply [nested|flat] 17+ messages in thread
* [PATCH v16 1/3] Remember PK oid for partitioned tables even when it's invalid @ 2023-07-12 16:57 Alvaro Herrera <[email protected]> 0 siblings, 0 replies; 17+ messages in thread From: Alvaro Herrera @ 2023-07-12 16:57 UTC (permalink / raw) --- src/backend/utils/cache/relcache.c | 34 ++++++++++++++++++++++++------ 1 file changed, 28 insertions(+), 6 deletions(-) diff --git a/src/backend/utils/cache/relcache.c b/src/backend/utils/cache/relcache.c index 8e28335915..7c3bfde571 100644 --- a/src/backend/utils/cache/relcache.c +++ b/src/backend/utils/cache/relcache.c @@ -4789,19 +4789,41 @@ RelationGetIndexList(Relation relation) result = lappend_oid(result, index->indexrelid); /* - * Invalid, non-unique, non-immediate or predicate indexes aren't - * interesting for either oid indexes or replication identity indexes, - * so don't check them. + * Non-unique, non-immediate or predicate indexes aren't interesting + * for either oid indexes or replication identity indexes, so don't + * check them. */ - if (!index->indisvalid || !index->indisunique || + if (!index->indisunique || !index->indimmediate || !heap_attisnull(htup, Anum_pg_index_indpred, NULL)) continue; - /* remember primary key index if any */ - if (index->indisprimary) + /* + * Remember primary key index, if any. We do this only if the index + * is valid; but if the table is partitioned, then we do it even if + * it's invalid. + * + * The reason for returning invalid primary keys for foreign tables is + * because of pg_dump of NOT NULL constraints, and the fact that PKs + * remain marked invalid until the partitions' PKs are attached to it. + * If we make rd_pkindex invalid, then the attnotnull flag is reset + * after the PK is created, which causes the ALTER INDEX ATTACH + * PARTITION to fail with 'column ... is not marked NOT NULL'. With + * this, dropconstraint_internal() will believe that the columns must + * not have attnotnull reset, so the PKs-on-partitions can be attached + * correctly, until finally the PK-on-parent is marked valid. + * + * Also, this doesn't harm anything, because rd_pkindex is not a + * "real" index anyway, but a RELKIND_PARTITIONED_INDEX. + */ + if (index->indisprimary && + (index->indisvalid || + relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)) pkeyIndex = index->indexrelid; + if (!index->indisvalid) + continue; + /* remember explicitly chosen replica index */ if (index->indisreplident) candidateIndex = index->indexrelid; -- 2.39.2 --arayebouu3vhq6bx Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v16-0002-Add-pg_constraint-rows-for-NOT-NULL-constraints.patch" ^ permalink raw reply [nested|flat] 17+ messages in thread
* Re: SLRU optimization - configurable buffer pool and partitioning the SLRU lock @ 2024-02-01 10:03 Dilip Kumar <[email protected]> 0 siblings, 1 reply; 17+ messages in thread From: Dilip Kumar @ 2024-02-01 10:03 UTC (permalink / raw) To: Alvaro Herrera <[email protected]>; +Cc: tender wang <[email protected]>; PostgreSQL Hackers <[email protected]> On Thu, Feb 1, 2024 at 3:19 PM Alvaro Herrera <[email protected]> wrote: > > Hah: > > postgres -c lc_messages=C -c shared_buffers=$((512*17)) > > 2024-02-01 10:48:13.548 CET [1535379] FATAL: invalid value for parameter "transaction_buffers": 17 > 2024-02-01 10:48:13.548 CET [1535379] DETAIL: "transaction_buffers" must be a multiple of 16 Maybe we should resize it to the next multiple of the SLRU_BANK_SIZE instead of giving an error? -- Regards, Dilip Kumar EnterpriseDB: http://www.enterprisedb.com ^ permalink raw reply [nested|flat] 17+ messages in thread
* Re: SLRU optimization - configurable buffer pool and partitioning the SLRU lock @ 2024-02-01 10:14 Alvaro Herrera <[email protected]> parent: Dilip Kumar <[email protected]> 0 siblings, 1 reply; 17+ messages in thread From: Alvaro Herrera @ 2024-02-01 10:14 UTC (permalink / raw) To: Dilip Kumar <[email protected]>; +Cc: tender wang <[email protected]>; PostgreSQL Hackers <[email protected]> On 2024-Feb-01, Dilip Kumar wrote: > On Thu, Feb 1, 2024 at 3:19 PM Alvaro Herrera <[email protected]> wrote: > > > > postgres -c lc_messages=C -c shared_buffers=$((512*17)) > > > > 2024-02-01 10:48:13.548 CET [1535379] FATAL: invalid value for parameter "transaction_buffers": 17 > > 2024-02-01 10:48:13.548 CET [1535379] DETAIL: "transaction_buffers" must be a multiple of 16 > > Maybe we should resize it to the next multiple of the SLRU_BANK_SIZE > instead of giving an error? Since this is the auto-tuning feature, I think it should use the previous multiple rather than the next, but yeah, something like that. While I have your attention -- if you could give a look to the 0001 patch I posted, I would appreciate it. -- Álvaro Herrera Breisgau, Deutschland — https://www.EnterpriseDB.com/ "Los trabajadores menos efectivos son sistematicamente llevados al lugar donde pueden hacer el menor daño posible: gerencia." (El principio Dilbert) ^ permalink raw reply [nested|flat] 17+ messages in thread
* Re: SLRU optimization - configurable buffer pool and partitioning the SLRU lock @ 2024-02-01 10:42 Dilip Kumar <[email protected]> parent: Alvaro Herrera <[email protected]> 0 siblings, 1 reply; 17+ messages in thread From: Dilip Kumar @ 2024-02-01 10:42 UTC (permalink / raw) To: Alvaro Herrera <[email protected]>; +Cc: tender wang <[email protected]>; PostgreSQL Hackers <[email protected]> On Thu, Feb 1, 2024 at 3:44 PM Alvaro Herrera <[email protected]> wrote: > > On 2024-Feb-01, Dilip Kumar wrote: > > > On Thu, Feb 1, 2024 at 3:19 PM Alvaro Herrera <[email protected]> wrote: > > > > > > postgres -c lc_messages=C -c shared_buffers=$((512*17)) > > > > > > 2024-02-01 10:48:13.548 CET [1535379] FATAL: invalid value for parameter "transaction_buffers": 17 > > > 2024-02-01 10:48:13.548 CET [1535379] DETAIL: "transaction_buffers" must be a multiple of 16 > > > > Maybe we should resize it to the next multiple of the SLRU_BANK_SIZE > > instead of giving an error? > > Since this is the auto-tuning feature, I think it should use the > previous multiple rather than the next, but yeah, something like that. Okay. > > While I have your attention -- if you could give a look to the 0001 > patch I posted, I would appreciate it. > I will look into it. Thanks. -- Regards, Dilip Kumar EnterpriseDB: http://www.enterprisedb.com ^ permalink raw reply [nested|flat] 17+ messages in thread
* Re: SLRU optimization - configurable buffer pool and partitioning the SLRU lock @ 2024-02-01 11:04 Dilip Kumar <[email protected]> parent: Dilip Kumar <[email protected]> 0 siblings, 1 reply; 17+ messages in thread From: Dilip Kumar @ 2024-02-01 11:04 UTC (permalink / raw) To: Alvaro Herrera <[email protected]>; +Cc: tender wang <[email protected]>; PostgreSQL Hackers <[email protected]> On Thu, Feb 1, 2024 at 4:12 PM Dilip Kumar <[email protected]> wrote: > > On Thu, Feb 1, 2024 at 3:44 PM Alvaro Herrera <[email protected]> wrote: > Okay. > > > > While I have your attention -- if you could give a look to the 0001 > > patch I posted, I would appreciate it. > > > > I will look into it. Thanks. Some quick observations, Do we need below two write barriers at the end of the function? because the next instruction is separated by the function boundary @@ -766,14 +766,11 @@ StartupCLOG(void) .. - XactCtl->shared->latest_page_number = pageno; - - LWLockRelease(XactSLRULock); + pg_atomic_init_u64(&XactCtl->shared->latest_page_number, pageno); + pg_write_barrier(); } /* * Initialize member's idea of the latest page number. */ pageno = MXOffsetToMemberPage(offset); - MultiXactMemberCtl->shared->latest_page_number = pageno; + pg_atomic_init_u64(&MultiXactMemberCtl->shared->latest_page_number, + pageno); + + pg_write_barrier(); } I am looking more into this from the concurrency point of view and will update you soon. -- Regards, Dilip Kumar EnterpriseDB: http://www.enterprisedb.com ^ permalink raw reply [nested|flat] 17+ messages in thread
* Re: SLRU optimization - configurable buffer pool and partitioning the SLRU lock @ 2024-02-02 06:06 Dilip Kumar <[email protected]> parent: Dilip Kumar <[email protected]> 0 siblings, 0 replies; 17+ messages in thread From: Dilip Kumar @ 2024-02-02 06:06 UTC (permalink / raw) To: Alvaro Herrera <[email protected]>; +Cc: tender wang <[email protected]>; PostgreSQL Hackers <[email protected]> On Thu, Feb 1, 2024 at 4:34 PM Dilip Kumar <[email protected]> wrote: > > On Thu, Feb 1, 2024 at 4:12 PM Dilip Kumar <[email protected]> wrote: > > > > On Thu, Feb 1, 2024 at 3:44 PM Alvaro Herrera <[email protected]> wrote: > > > Okay. > > > > > > While I have your attention -- if you could give a look to the 0001 > > > patch I posted, I would appreciate it. > > > > > > > I will look into it. Thanks. > > Some quick observations, > > Do we need below two write barriers at the end of the function? > because the next instruction is separated by the function boundary > > @@ -766,14 +766,11 @@ StartupCLOG(void) > .. > - XactCtl->shared->latest_page_number = pageno; > - > - LWLockRelease(XactSLRULock); > + pg_atomic_init_u64(&XactCtl->shared->latest_page_number, pageno); > + pg_write_barrier(); > } > > /* > * Initialize member's idea of the latest page number. > */ > pageno = MXOffsetToMemberPage(offset); > - MultiXactMemberCtl->shared->latest_page_number = pageno; > + pg_atomic_init_u64(&MultiXactMemberCtl->shared->latest_page_number, > + pageno); > + > + pg_write_barrier(); > } > I have checked the patch and it looks fine to me other than the above question related to memory barrier usage one more question about the same, basically below to instances 1 and 2 look similar but in 1 you are not using the memory write_barrier whereas in 2 you are using the write_barrier, why is it so? I mean why the reordering can not happen in 1 and it may happen in 2? 1. + pg_atomic_write_u64(&CommitTsCtl->shared->latest_page_number, + trunc->pageno); SimpleLruTruncate(CommitTsCtl, trunc->pageno); vs 2. - shared->latest_page_number = pageno; + pg_atomic_write_u64(&shared->latest_page_number, pageno); + pg_write_barrier(); /* update the stats counter of zeroed pages */ pgstat_count_slru_page_zeroed(shared->slru_stats_idx); -- Regards, Dilip Kumar EnterpriseDB: http://www.enterprisedb.com ^ permalink raw reply [nested|flat] 17+ messages in thread
* [PATCH v3a] edit comments and stuff @ 2026-01-05 14:26 Álvaro Herrera <[email protected]> 0 siblings, 0 replies; 17+ messages in thread From: Álvaro Herrera @ 2026-01-05 14:26 UTC (permalink / raw) --- src/backend/utils/sort/tuplesort.c | 2 +- src/include/executor/instrument_node.h | 146 ++++++++++++------------- src/include/utils/tuplesort.h | 15 --- 3 files changed, 73 insertions(+), 90 deletions(-) diff --git a/src/backend/utils/sort/tuplesort.c b/src/backend/utils/sort/tuplesort.c index 473d31188b8..9e4cd816137 100644 --- a/src/backend/utils/sort/tuplesort.c +++ b/src/backend/utils/sort/tuplesort.c @@ -200,7 +200,7 @@ struct Tuplesortstate int64 maxSpace; /* maximum amount of space occupied among sort * of groups, either in-memory or on-disk */ bool isMaxSpaceDisk; /* true when maxSpace is value for on-disk - * space, false when its value for in-memory + * space, false when it's value for in-memory * space */ TupSortStatus maxSpaceStatus; /* sort status when maxSpace was reached */ LogicalTapeSet *tapeset; /* logtape.c object for tapes in a temp file */ diff --git a/src/include/executor/instrument_node.h b/src/include/executor/instrument_node.h index 75520008c36..49627eb4a27 100644 --- a/src/include/executor/instrument_node.h +++ b/src/include/executor/instrument_node.h @@ -1,8 +1,12 @@ /*------------------------------------------------------------------------- * * instrument_node.h - * Definitions for node-specific instrumentation + * Definitions for node-specific support for parallel query instrumentation * + * These structs purposely contain no pointers because they are copied + * across processes during parallel query execution. Each worker copies its + * individual information into the container struct at executor shutdown time, + * to allow the leader to display the information in EXPLAIN ANALYZE. * * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group * Portions Copyright (c) 1994, Regents of the University of California @@ -15,32 +19,30 @@ #define INSTRUMENT_NODE_H - /* --------------------- - * per-worker aggregate information + * Instrumentation information for aggregate function execution * --------------------- */ typedef struct AggregateInstrumentation { - Size hash_mem_peak; /* peak hash table memory usage */ - uint64 hash_disk_used; /*kB of disk space used */ - int hash_batches_used; /* batches used during entire execution */ + Size hash_mem_peak; /* peak hash table memory usage */ + uint64 hash_disk_used; /* kB of disk space used */ + int hash_batches_used; /* batches used during entire execution */ } AggregateInstrumentation; -/* ---------------- - * Shared memory container for per-worker aggregate information - * ---------------- +/* + * Shared memory container for per-worker aggregate information */ typedef struct SharedAggInfo { - int num_workers; + int num_workers; AggregateInstrumentation sinstrument[FLEXIBLE_ARRAY_MEMBER]; } SharedAggInfo; -/* - * Struct for statistics maintained by amgettuple and amgetbitmap - * - * Note: IndexScanInstrumentation can't contain any pointers, since it is - * copied into a SharedIndexScanInstrumentation during parallel scans + + +/* --------------------- + * Instrumentation information for indexscans (amgettuple and amgetbitmap) + * --------------------- */ typedef struct IndexScanInstrumentation { @@ -49,7 +51,7 @@ typedef struct IndexScanInstrumentation } IndexScanInstrumentation; /* - * Struct for every worker's IndexScanInstrumentation, stored in shared memory + * Shared memory container for per-worker information */ typedef struct SharedIndexScanInstrumentation { @@ -57,11 +59,13 @@ typedef struct SharedIndexScanInstrumentation IndexScanInstrumentation winstrument[FLEXIBLE_ARRAY_MEMBER]; } SharedIndexScanInstrumentation; -/* - * BitmapHeapScanInstrumentation information + +/* --------------------- + * Instrumentation information for bitmap heap scans * * exact_pages total number of exact pages retrieved * lossy_pages total number of lossy pages retrieved + * --------------------- */ typedef struct BitmapHeapScanInstrumentation { @@ -70,11 +74,7 @@ typedef struct BitmapHeapScanInstrumentation } BitmapHeapScanInstrumentation; /* - * Instrumentation data for a parallel bitmap heap scan. - * - * A shared memory struct that each parallel worker copies its - * BitmapHeapScanInstrumentation information into at executor shutdown to - * allow the leader to display the information in EXPLAIN ANALYZE. + * Shared memory container for per-worker information */ typedef struct SharedBitmapHeapInstrumentation { @@ -83,25 +83,27 @@ typedef struct SharedBitmapHeapInstrumentation } SharedBitmapHeapInstrumentation; +/* --------------------- + * Instrumentation information for Memoize + * --------------------- + */ typedef struct MemoizeInstrumentation { - uint64 cache_hits; /* number of rescans where we've found the - * scan parameters values to be cached */ - uint64 cache_misses; /* number of rescans where we've not found the - * scan parameters values to be cached */ - uint64 cache_evictions; /* number of cache entries removed due to - * the need to free memory */ - uint64 cache_overflows; /* number of times we've had to bypass the - * cache when filling it due to not being - * able to free enough space to store the - * current scan's tuples */ - uint64 mem_peak; /* peak memory usage in bytes */ - + uint64 cache_hits; /* number of rescans where we've found the + * scan parameters values to be cached */ + uint64 cache_misses; /* number of rescans where we've not found the + * scan parameters values to be cached */ + uint64 cache_evictions; /* number of cache entries removed due to + * the need to free memory */ + uint64 cache_overflows; /* number of times we've had to bypass the + * cache when filling it due to not being + * able to free enough space to store the + * current scan's tuples */ + uint64 mem_peak; /* peak memory usage in bytes */ } MemoizeInstrumentation; -/* ---------------- - * Shared memory container for per-worker memoize information - * ---------------- +/* + * Shared memory container for per-worker memoize information */ typedef struct SharedMemoizeInfo { @@ -110,27 +112,25 @@ typedef struct SharedMemoizeInfo } SharedMemoizeInfo; -/* - * Data structures for reporting sort statistics. Note that - * TuplesortInstrumentation can't contain any pointers because we - * sometimes put it in shared memory. - * - * The parallel-sort infrastructure relies on having a zero TuplesortMethod - * to indicate that a worker never did anything, so we assign zero to - * SORT_TYPE_STILL_IN_PROGRESS. The other values of this enum can be - * OR'ed together to represent a situation where different workers used - * different methods, so we need a separate bit for each one. Keep the - * NUM_TUPLESORTMETHODS constant in sync with the number of bits! +/* --------------------- + * Instrumentation information for Sorts. + * --------------------- */ -#define NUM_TUPLESORTMETHODS 4 - typedef enum { SORT_SPACE_TYPE_DISK, SORT_SPACE_TYPE_MEMORY, } TuplesortSpaceType; +/* + * The parallel-sort infrastructure relies on having a zero TuplesortMethod + * to indicate that a worker never did anything, so we assign zero to + * SORT_TYPE_STILL_IN_PROGRESS. The other values of this enum can be + * OR'ed together to represent a situation where different workers used + * different methods, so we need a separate bit for each one. Keep the + * NUM_TUPLESORTMETHODS constant in sync with the number of bits! + */ typedef enum { SORT_TYPE_STILL_IN_PROGRESS = 0, @@ -139,40 +139,40 @@ typedef enum SORT_TYPE_EXTERNAL_SORT = 1 << 2, SORT_TYPE_EXTERNAL_MERGE = 1 << 3 } TuplesortMethod; +#define NUM_TUPLESORTMETHODS 4 typedef struct TuplesortInstrumentation { - TuplesortMethod sortMethod; /* sort algorithm used */ + TuplesortMethod sortMethod; /* sort algorithm used */ TuplesortSpaceType spaceType; /* type of space spaceUsed represents */ - int64 spaceUsed; /* space consumption, in kB */ + int64 spaceUsed; /* space consumption, in kB */ } TuplesortInstrumentation; -/* ---------------- - * Shared memory container for per-worker sort information - * ---------------- +/* + * Shared memory container for per-worker sort information */ typedef struct SharedSortInfo { - int num_workers; + int num_workers; TuplesortInstrumentation sinstrument[FLEXIBLE_ARRAY_MEMBER]; } SharedSortInfo; -/* ---------------- - * Values displayed by EXPLAIN ANALYZE - * ---------------- + +/* --------------------- + * Instrumentation information for nodeHash.c + * --------------------- */ typedef struct HashInstrumentation { - int nbuckets; /* number of buckets at end of execution */ - int nbuckets_original; /* planned number of buckets */ - int nbatch; /* number of batches at end of execution */ - int nbatch_original; /* planned number of batches */ - Size space_peak; /* peak memory usage in bytes */ + int nbuckets; /* number of buckets at end of execution */ + int nbuckets_original; /* planned number of buckets */ + int nbatch; /* number of batches at end of execution */ + int nbatch_original; /* planned number of batches */ + Size space_peak; /* peak memory usage in bytes */ } HashInstrumentation; -/* ---------------- - * Shared memory container for per-worker hash information - * ---------------- +/* + * Shared memory container for per-worker information */ typedef struct SharedHashInfo { @@ -180,9 +180,10 @@ typedef struct SharedHashInfo HashInstrumentation hinstrument[FLEXIBLE_ARRAY_MEMBER]; } SharedHashInfo; -/* ---------------- + +/* --------------------- * Instrumentation information for IncrementalSort - * ---------------- + * --------------------- */ typedef struct IncrementalSortGroupInfo { @@ -200,10 +201,7 @@ typedef struct IncrementalSortInfo IncrementalSortGroupInfo prefixsortGroupInfo; } IncrementalSortInfo; -/* ---------------- - * Shared memory container for per-worker incremental sort information - * ---------------- - */ +/* Shared memory container for per-worker incremental sort information */ typedef struct SharedIncrementalSortInfo { int num_workers; diff --git a/src/include/utils/tuplesort.h b/src/include/utils/tuplesort.h index a7e867f36b8..943a2b7dc93 100644 --- a/src/include/utils/tuplesort.h +++ b/src/include/utils/tuplesort.h @@ -62,21 +62,6 @@ typedef struct SortCoordinateData typedef struct SortCoordinateData *SortCoordinate; -/* - * Data structures for reporting sort statistics. Note that - * TuplesortInstrumentation can't contain any pointers because we - * sometimes put it in shared memory. - * - * The parallel-sort infrastructure relies on having a zero TuplesortMethod - * to indicate that a worker never did anything, so we assign zero to - * SORT_TYPE_STILL_IN_PROGRESS. The other values of this enum can be - * OR'ed together to represent a situation where different workers used - * different methods, so we need a separate bit for each one. Keep the - * NUM_TUPLESORTMETHODS constant in sync with the number of bits! - */ - -#define NUM_TUPLESORTMETHODS 4 - /* Bitwise option flags for tuple sorts */ #define TUPLESORT_NONE 0 -- 2.47.3 --xs5il3t73pzvzpq7-- ^ permalink raw reply [nested|flat] 17+ messages in thread
* [PATCH v3a] edit comments and stuff @ 2026-01-05 14:26 Álvaro Herrera <[email protected]> 0 siblings, 0 replies; 17+ messages in thread From: Álvaro Herrera @ 2026-01-05 14:26 UTC (permalink / raw) --- src/backend/utils/sort/tuplesort.c | 2 +- src/include/executor/instrument_node.h | 146 ++++++++++++------------- src/include/utils/tuplesort.h | 15 --- 3 files changed, 73 insertions(+), 90 deletions(-) diff --git a/src/backend/utils/sort/tuplesort.c b/src/backend/utils/sort/tuplesort.c index 473d31188b8..9e4cd816137 100644 --- a/src/backend/utils/sort/tuplesort.c +++ b/src/backend/utils/sort/tuplesort.c @@ -200,7 +200,7 @@ struct Tuplesortstate int64 maxSpace; /* maximum amount of space occupied among sort * of groups, either in-memory or on-disk */ bool isMaxSpaceDisk; /* true when maxSpace is value for on-disk - * space, false when its value for in-memory + * space, false when it's value for in-memory * space */ TupSortStatus maxSpaceStatus; /* sort status when maxSpace was reached */ LogicalTapeSet *tapeset; /* logtape.c object for tapes in a temp file */ diff --git a/src/include/executor/instrument_node.h b/src/include/executor/instrument_node.h index 75520008c36..49627eb4a27 100644 --- a/src/include/executor/instrument_node.h +++ b/src/include/executor/instrument_node.h @@ -1,8 +1,12 @@ /*------------------------------------------------------------------------- * * instrument_node.h - * Definitions for node-specific instrumentation + * Definitions for node-specific support for parallel query instrumentation * + * These structs purposely contain no pointers because they are copied + * across processes during parallel query execution. Each worker copies its + * individual information into the container struct at executor shutdown time, + * to allow the leader to display the information in EXPLAIN ANALYZE. * * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group * Portions Copyright (c) 1994, Regents of the University of California @@ -15,32 +19,30 @@ #define INSTRUMENT_NODE_H - /* --------------------- - * per-worker aggregate information + * Instrumentation information for aggregate function execution * --------------------- */ typedef struct AggregateInstrumentation { - Size hash_mem_peak; /* peak hash table memory usage */ - uint64 hash_disk_used; /*kB of disk space used */ - int hash_batches_used; /* batches used during entire execution */ + Size hash_mem_peak; /* peak hash table memory usage */ + uint64 hash_disk_used; /* kB of disk space used */ + int hash_batches_used; /* batches used during entire execution */ } AggregateInstrumentation; -/* ---------------- - * Shared memory container for per-worker aggregate information - * ---------------- +/* + * Shared memory container for per-worker aggregate information */ typedef struct SharedAggInfo { - int num_workers; + int num_workers; AggregateInstrumentation sinstrument[FLEXIBLE_ARRAY_MEMBER]; } SharedAggInfo; -/* - * Struct for statistics maintained by amgettuple and amgetbitmap - * - * Note: IndexScanInstrumentation can't contain any pointers, since it is - * copied into a SharedIndexScanInstrumentation during parallel scans + + +/* --------------------- + * Instrumentation information for indexscans (amgettuple and amgetbitmap) + * --------------------- */ typedef struct IndexScanInstrumentation { @@ -49,7 +51,7 @@ typedef struct IndexScanInstrumentation } IndexScanInstrumentation; /* - * Struct for every worker's IndexScanInstrumentation, stored in shared memory + * Shared memory container for per-worker information */ typedef struct SharedIndexScanInstrumentation { @@ -57,11 +59,13 @@ typedef struct SharedIndexScanInstrumentation IndexScanInstrumentation winstrument[FLEXIBLE_ARRAY_MEMBER]; } SharedIndexScanInstrumentation; -/* - * BitmapHeapScanInstrumentation information + +/* --------------------- + * Instrumentation information for bitmap heap scans * * exact_pages total number of exact pages retrieved * lossy_pages total number of lossy pages retrieved + * --------------------- */ typedef struct BitmapHeapScanInstrumentation { @@ -70,11 +74,7 @@ typedef struct BitmapHeapScanInstrumentation } BitmapHeapScanInstrumentation; /* - * Instrumentation data for a parallel bitmap heap scan. - * - * A shared memory struct that each parallel worker copies its - * BitmapHeapScanInstrumentation information into at executor shutdown to - * allow the leader to display the information in EXPLAIN ANALYZE. + * Shared memory container for per-worker information */ typedef struct SharedBitmapHeapInstrumentation { @@ -83,25 +83,27 @@ typedef struct SharedBitmapHeapInstrumentation } SharedBitmapHeapInstrumentation; +/* --------------------- + * Instrumentation information for Memoize + * --------------------- + */ typedef struct MemoizeInstrumentation { - uint64 cache_hits; /* number of rescans where we've found the - * scan parameters values to be cached */ - uint64 cache_misses; /* number of rescans where we've not found the - * scan parameters values to be cached */ - uint64 cache_evictions; /* number of cache entries removed due to - * the need to free memory */ - uint64 cache_overflows; /* number of times we've had to bypass the - * cache when filling it due to not being - * able to free enough space to store the - * current scan's tuples */ - uint64 mem_peak; /* peak memory usage in bytes */ - + uint64 cache_hits; /* number of rescans where we've found the + * scan parameters values to be cached */ + uint64 cache_misses; /* number of rescans where we've not found the + * scan parameters values to be cached */ + uint64 cache_evictions; /* number of cache entries removed due to + * the need to free memory */ + uint64 cache_overflows; /* number of times we've had to bypass the + * cache when filling it due to not being + * able to free enough space to store the + * current scan's tuples */ + uint64 mem_peak; /* peak memory usage in bytes */ } MemoizeInstrumentation; -/* ---------------- - * Shared memory container for per-worker memoize information - * ---------------- +/* + * Shared memory container for per-worker memoize information */ typedef struct SharedMemoizeInfo { @@ -110,27 +112,25 @@ typedef struct SharedMemoizeInfo } SharedMemoizeInfo; -/* - * Data structures for reporting sort statistics. Note that - * TuplesortInstrumentation can't contain any pointers because we - * sometimes put it in shared memory. - * - * The parallel-sort infrastructure relies on having a zero TuplesortMethod - * to indicate that a worker never did anything, so we assign zero to - * SORT_TYPE_STILL_IN_PROGRESS. The other values of this enum can be - * OR'ed together to represent a situation where different workers used - * different methods, so we need a separate bit for each one. Keep the - * NUM_TUPLESORTMETHODS constant in sync with the number of bits! +/* --------------------- + * Instrumentation information for Sorts. + * --------------------- */ -#define NUM_TUPLESORTMETHODS 4 - typedef enum { SORT_SPACE_TYPE_DISK, SORT_SPACE_TYPE_MEMORY, } TuplesortSpaceType; +/* + * The parallel-sort infrastructure relies on having a zero TuplesortMethod + * to indicate that a worker never did anything, so we assign zero to + * SORT_TYPE_STILL_IN_PROGRESS. The other values of this enum can be + * OR'ed together to represent a situation where different workers used + * different methods, so we need a separate bit for each one. Keep the + * NUM_TUPLESORTMETHODS constant in sync with the number of bits! + */ typedef enum { SORT_TYPE_STILL_IN_PROGRESS = 0, @@ -139,40 +139,40 @@ typedef enum SORT_TYPE_EXTERNAL_SORT = 1 << 2, SORT_TYPE_EXTERNAL_MERGE = 1 << 3 } TuplesortMethod; +#define NUM_TUPLESORTMETHODS 4 typedef struct TuplesortInstrumentation { - TuplesortMethod sortMethod; /* sort algorithm used */ + TuplesortMethod sortMethod; /* sort algorithm used */ TuplesortSpaceType spaceType; /* type of space spaceUsed represents */ - int64 spaceUsed; /* space consumption, in kB */ + int64 spaceUsed; /* space consumption, in kB */ } TuplesortInstrumentation; -/* ---------------- - * Shared memory container for per-worker sort information - * ---------------- +/* + * Shared memory container for per-worker sort information */ typedef struct SharedSortInfo { - int num_workers; + int num_workers; TuplesortInstrumentation sinstrument[FLEXIBLE_ARRAY_MEMBER]; } SharedSortInfo; -/* ---------------- - * Values displayed by EXPLAIN ANALYZE - * ---------------- + +/* --------------------- + * Instrumentation information for nodeHash.c + * --------------------- */ typedef struct HashInstrumentation { - int nbuckets; /* number of buckets at end of execution */ - int nbuckets_original; /* planned number of buckets */ - int nbatch; /* number of batches at end of execution */ - int nbatch_original; /* planned number of batches */ - Size space_peak; /* peak memory usage in bytes */ + int nbuckets; /* number of buckets at end of execution */ + int nbuckets_original; /* planned number of buckets */ + int nbatch; /* number of batches at end of execution */ + int nbatch_original; /* planned number of batches */ + Size space_peak; /* peak memory usage in bytes */ } HashInstrumentation; -/* ---------------- - * Shared memory container for per-worker hash information - * ---------------- +/* + * Shared memory container for per-worker information */ typedef struct SharedHashInfo { @@ -180,9 +180,10 @@ typedef struct SharedHashInfo HashInstrumentation hinstrument[FLEXIBLE_ARRAY_MEMBER]; } SharedHashInfo; -/* ---------------- + +/* --------------------- * Instrumentation information for IncrementalSort - * ---------------- + * --------------------- */ typedef struct IncrementalSortGroupInfo { @@ -200,10 +201,7 @@ typedef struct IncrementalSortInfo IncrementalSortGroupInfo prefixsortGroupInfo; } IncrementalSortInfo; -/* ---------------- - * Shared memory container for per-worker incremental sort information - * ---------------- - */ +/* Shared memory container for per-worker incremental sort information */ typedef struct SharedIncrementalSortInfo { int num_workers; diff --git a/src/include/utils/tuplesort.h b/src/include/utils/tuplesort.h index a7e867f36b8..943a2b7dc93 100644 --- a/src/include/utils/tuplesort.h +++ b/src/include/utils/tuplesort.h @@ -62,21 +62,6 @@ typedef struct SortCoordinateData typedef struct SortCoordinateData *SortCoordinate; -/* - * Data structures for reporting sort statistics. Note that - * TuplesortInstrumentation can't contain any pointers because we - * sometimes put it in shared memory. - * - * The parallel-sort infrastructure relies on having a zero TuplesortMethod - * to indicate that a worker never did anything, so we assign zero to - * SORT_TYPE_STILL_IN_PROGRESS. The other values of this enum can be - * OR'ed together to represent a situation where different workers used - * different methods, so we need a separate bit for each one. Keep the - * NUM_TUPLESORTMETHODS constant in sync with the number of bits! - */ - -#define NUM_TUPLESORTMETHODS 4 - /* Bitwise option flags for tuple sorts */ #define TUPLESORT_NONE 0 -- 2.47.3 --xs5il3t73pzvzpq7-- ^ permalink raw reply [nested|flat] 17+ messages in thread
* Re: Add a statistics view to track usage of deprecated features @ 2026-07-03 05:06 Shinya Kato <[email protected]> 0 siblings, 0 replies; 17+ messages in thread From: Shinya Kato @ 2026-07-03 05:06 UTC (permalink / raw) To: Tom Lane <[email protected]>; +Cc: Michael Paquier <[email protected]>; PostgreSQL Hackers <[email protected]> On Mon, Jun 29, 2026 at 11:58 AM Tom Lane <[email protected]> wrote: > > Michael Paquier <[email protected]> writes: > > On Mon, Jun 29, 2026 at 10:24:02AM +0900, Shinya Kato wrote: > >> I would like to propose a patch that adds a new cumulative statistics > >> view, pg_stat_deprecated_features, which tracks how often each > >> deprecated feature is used across the cluster. > > > I am unconvinced that this is useful. > > I'm pretty down on it as well, because it presupposes that we have > a well-defined set of deprecated features. We're not that well > organized in that area, and probably never will be. Thank you both for the quick feedback. Michael's point about GLOBAL/LOCAL made me look at the deprecated features one by one, and it corrected a wrong assumption on my side. I had been treating everything marked deprecated as something that would eventually be removed. In fact "deprecated" covers at least three different cases: 1. deprecated and documented to be removed. MD5 passwords are the clearest, with "deprecated and will be removed in a future release". Some are softer, such as the txid_* functions ("still supported for backward compatibility, but may be removed from a future release") and the old geometric operator names <^ and >^ ("deprecated and will eventually be removed"). 2. deprecated but kept deliberately for backward compatibility with no intent to remove, such as ALTER GROUP ("obsolete ... still accepted for backwards compatibility"). 3. deprecated but more likely to be reinterpreted than removed, which is the GLOBAL/LOCAL case Michael describes. The CREATE TABLE docs say PostgreSQL "might adopt a more standard-compliant interpretation of their meaning". Only the first case is what this view was meant for. The intent was to let an administrator confirm, before a major-version upgrade, whether their workload still relies on a feature that will be removed. Once it is filtered down to features the documentation actually says will or may be removed, though, the set is very small. It is essentially MD5, plus a few softer or niche cases. Everything else I had listed falls into the second or third case. For a set that small, a dedicated cumulative statistics kind and a standing view is out of proportion, which is Michael's point about not spending a stats kind ID on this. So I would like to withdraw this proposal. -- Best regards, Shinya Kato NTT OSS Center ^ permalink raw reply [nested|flat] 17+ messages in thread
end of thread, other threads:[~2026-07-03 05:06 UTC | newest] Thread overview: 17+ messages (download: mbox mbox.gz follow: Atom feed) -- links below jump to the message on this page -- 2019-05-21 00:02 [PATCH v5 07/12] consistent language: to which Justin Pryzby <[email protected]> 2023-07-12 16:57 [PATCH v15 1/2] Remember PK oid for partitioned tables even when it's invalid Alvaro Herrera <[email protected]> 2023-07-12 16:57 [PATCH v14 1/2] Remember PK oid for partitioned tables even when it's invalid Alvaro Herrera <[email protected]> 2023-07-12 16:57 [PATCH v15 1/2] Remember PK oid for partitioned tables even when it's invalid Alvaro Herrera <[email protected]> 2023-07-12 16:57 [PATCH v17 1/3] Remember PK oid for partitioned tables even when it's invalid Alvaro Herrera <[email protected]> 2023-07-12 16:57 [PATCH v17 1/3] Remember PK oid for partitioned tables even when it's invalid Alvaro Herrera <[email protected]> 2023-07-12 16:57 [PATCH v17 1/3] Remember PK oid for partitioned tables even when it's invalid Alvaro Herrera <[email protected]> 2023-07-12 16:57 [PATCH v13 1/2] Remember PK oid for partitioned tables even when it's invalid Alvaro Herrera <[email protected]> 2023-07-12 16:57 [PATCH v16 1/3] Remember PK oid for partitioned tables even when it's invalid Alvaro Herrera <[email protected]> 2024-02-01 10:03 Re: SLRU optimization - configurable buffer pool and partitioning the SLRU lock Dilip Kumar <[email protected]> 2024-02-01 10:14 ` Re: SLRU optimization - configurable buffer pool and partitioning the SLRU lock Alvaro Herrera <[email protected]> 2024-02-01 10:42 ` Re: SLRU optimization - configurable buffer pool and partitioning the SLRU lock Dilip Kumar <[email protected]> 2024-02-01 11:04 ` Re: SLRU optimization - configurable buffer pool and partitioning the SLRU lock Dilip Kumar <[email protected]> 2024-02-02 06:06 ` Re: SLRU optimization - configurable buffer pool and partitioning the SLRU lock Dilip Kumar <[email protected]> 2026-01-05 14:26 [PATCH v3a] edit comments and stuff Álvaro Herrera <[email protected]> 2026-01-05 14:26 [PATCH v3a] edit comments and stuff Álvaro Herrera <[email protected]> 2026-07-03 05:06 Re: Add a statistics view to track usage of deprecated features Shinya Kato <[email protected]>
This inbox is served by agora; see mirroring instructions for how to clone and mirror all data and code used for this inbox