public inbox for [email protected]help / color / mirror / Atom feed
[PATCH 3/3] Rename smgrDoPendingDeletes to smgrDoPendingOperations 5+ messages / 3 participants [nested] [flat]
* [PATCH 3/3] Rename smgrDoPendingDeletes to smgrDoPendingOperations @ 2019-05-29 14:03 Kyotaro Horiguchi <[email protected]> 0 siblings, 0 replies; 5+ messages in thread From: Kyotaro Horiguchi @ 2019-05-29 14:03 UTC (permalink / raw) The function longer does only deletions but also syncs. Rename the function to refect that. smgrGetPendingDeletes is not renamed since it does not change behavior. --- src/backend/access/transam/xact.c | 4 +-- src/backend/catalog/storage.c | 57 ++++++++++++++++++++------------------- src/include/catalog/storage.h | 2 +- 3 files changed, 32 insertions(+), 31 deletions(-) diff --git a/src/backend/access/transam/xact.c b/src/backend/access/transam/xact.c index d7930c077d..cc0c43b2dd 100644 --- a/src/backend/access/transam/xact.c +++ b/src/backend/access/transam/xact.c @@ -2228,7 +2228,7 @@ CommitTransaction(void) * Other backends will observe the attendant catalog changes and not * attempt to access affected files. */ - smgrDoPendingDeletes(true); + smgrDoPendingOperations(true); AtCommit_Notify(); AtEOXact_GUC(true, 1); @@ -2716,7 +2716,7 @@ AbortTransaction(void) ResourceOwnerRelease(TopTransactionResourceOwner, RESOURCE_RELEASE_AFTER_LOCKS, false, true); - smgrDoPendingDeletes(false); + smgrDoPendingOperations(false); AtEOXact_GUC(false, 1); AtEOXact_SPI(false); diff --git a/src/backend/catalog/storage.c b/src/backend/catalog/storage.c index e4bcdc390f..6ebe75aa37 100644 --- a/src/backend/catalog/storage.c +++ b/src/backend/catalog/storage.c @@ -53,17 +53,17 @@ * but I'm being paranoid. */ -typedef struct PendingRelDelete +typedef struct PendingRelOps { RelFileNode relnode; /* relation that may need to be deleted */ BackendId backend; /* InvalidBackendId if not a temp rel */ bool atCommit; /* T=work at commit; F=work at abort */ bool dosync; /* T=work is sync; F=work is delete */ int nestLevel; /* xact nesting level of request */ - struct PendingRelDelete *next; /* linked-list link */ -} PendingRelDelete; + struct PendingRelOps *next; /* linked-list link */ +} PendingRelOps; -static PendingRelDelete *pendingDeletes = NULL; /* head of linked list */ +static PendingRelOps *pendingDeletes = NULL; /* head of linked list */ /* * RelationCreateStorage @@ -79,7 +79,7 @@ static PendingRelDelete *pendingDeletes = NULL; /* head of linked list */ SMgrRelation RelationCreateStorage(RelFileNode rnode, char relpersistence) { - PendingRelDelete *pending; + PendingRelOps *pending; SMgrRelation srel; BackendId backend; bool needs_wal; @@ -110,8 +110,8 @@ RelationCreateStorage(RelFileNode rnode, char relpersistence) log_smgrcreate(&srel->smgr_rnode.node, MAIN_FORKNUM); /* Add the relation to the list of stuff to delete at abort */ - pending = (PendingRelDelete *) - MemoryContextAlloc(TopMemoryContext, sizeof(PendingRelDelete)); + pending = (PendingRelOps *) + MemoryContextAlloc(TopMemoryContext, sizeof(PendingRelOps)); pending->relnode = rnode; pending->backend = backend; pending->atCommit = false; /* delete if abort */ @@ -127,8 +127,8 @@ RelationCreateStorage(RelFileNode rnode, char relpersistence) */ if (relpersistence == RELPERSISTENCE_PERMANENT && !XLogIsNeeded()) { - pending = (PendingRelDelete *) - MemoryContextAlloc(TopMemoryContext, sizeof(PendingRelDelete)); + pending = (PendingRelOps *) + MemoryContextAlloc(TopMemoryContext, sizeof(PendingRelOps)); pending->relnode = rnode; pending->backend = backend; pending->atCommit = true; @@ -167,11 +167,11 @@ log_smgrcreate(const RelFileNode *rnode, ForkNumber forkNum) void RelationDropStorage(Relation rel) { - PendingRelDelete *pending; + PendingRelOps *pending; /* Add the relation to the list of stuff to delete at commit */ - pending = (PendingRelDelete *) - MemoryContextAlloc(TopMemoryContext, sizeof(PendingRelDelete)); + pending = (PendingRelOps *) + MemoryContextAlloc(TopMemoryContext, sizeof(PendingRelOps)); pending->relnode = rel->rd_node; pending->backend = rel->rd_backend; pending->atCommit = true; /* delete if commit */ @@ -185,9 +185,9 @@ RelationDropStorage(Relation rel) * present in the pending-delete list twice, once with atCommit true and * once with atCommit false. Hence, it will be physically deleted at end * of xact in either case (and the other entry will be ignored by - * smgrDoPendingDeletes, so no error will occur). We could instead remove - * the existing list entry and delete the physical file immediately, but - * for now I'll keep the logic simple. + * smgrDoPendingOperations, so no error will occur). We could instead + * remove the existing list entry and delete the physical file + * immediately, but for now I'll keep the logic simple. */ RelationCloseSmgr(rel); @@ -213,9 +213,9 @@ RelationDropStorage(Relation rel) void RelationPreserveStorage(RelFileNode rnode, bool atCommit) { - PendingRelDelete *pending; - PendingRelDelete *prev; - PendingRelDelete *next; + PendingRelOps *pending; + PendingRelOps *prev; + PendingRelOps *next; prev = NULL; for (pending = pendingDeletes; pending != NULL; pending = next) @@ -406,7 +406,8 @@ RelationCopyStorage(SMgrRelation src, SMgrRelation dst, } /* - * smgrDoPendingDeletes() -- Take care of relation deletes at end of xact. + * smgrDoPendingOperations() -- Take care of relation deletes and syncs at + * end of xact. * * This also runs when aborting a subxact; we want to clean up a failed * subxact immediately. @@ -417,12 +418,12 @@ RelationCopyStorage(SMgrRelation src, SMgrRelation dst, * already recovered the physical storage. */ void -smgrDoPendingDeletes(bool isCommit) +smgrDoPendingOperations(bool isCommit) { int nestLevel = GetCurrentTransactionNestLevel(); - PendingRelDelete *pending; - PendingRelDelete *prev; - PendingRelDelete *next; + PendingRelOps *pending; + PendingRelOps *prev; + PendingRelOps *next; int nrels = 0, i = 0, maxrels = 0; @@ -518,7 +519,7 @@ smgrGetPendingDeletes(bool forCommit, RelFileNode **ptr) int nestLevel = GetCurrentTransactionNestLevel(); int nrels; RelFileNode *rptr; - PendingRelDelete *pending; + PendingRelOps *pending; nrels = 0; for (pending = pendingDeletes; pending != NULL; pending = pending->next) @@ -558,8 +559,8 @@ smgrGetPendingDeletes(bool forCommit, RelFileNode **ptr) void PostPrepare_smgr(void) { - PendingRelDelete *pending; - PendingRelDelete *next; + PendingRelOps *pending; + PendingRelOps *next; for (pending = pendingDeletes; pending != NULL; pending = next) { @@ -580,7 +581,7 @@ void AtSubCommit_smgr(void) { int nestLevel = GetCurrentTransactionNestLevel(); - PendingRelDelete *pending; + PendingRelOps *pending; for (pending = pendingDeletes; pending != NULL; pending = pending->next) { @@ -599,7 +600,7 @@ AtSubCommit_smgr(void) void AtSubAbort_smgr(void) { - smgrDoPendingDeletes(false); + smgrDoPendingOperations(false); } void diff --git a/src/include/catalog/storage.h b/src/include/catalog/storage.h index 3579d3f3eb..43836cf11c 100644 --- a/src/include/catalog/storage.h +++ b/src/include/catalog/storage.h @@ -30,7 +30,7 @@ extern void RelationCopyStorage(SMgrRelation src, SMgrRelation dst, * These functions used to be in storage/smgr/smgr.c, which explains the * naming */ -extern void smgrDoPendingDeletes(bool isCommit); +extern void smgrDoPendingOperations(bool isCommit); extern int smgrGetPendingDeletes(bool forCommit, RelFileNode **ptr); extern void AtSubCommit_smgr(void); extern void AtSubAbort_smgr(void); -- 2.16.3 ----Next_Part(Fri_Jul_12_17_37_25_2019_721)---- ^ permalink raw reply [nested|flat] 5+ messages in thread
* [PATCH 3/3] Rename smgrDoPendingDeletes to smgrDoPendingOperations @ 2019-05-29 14:03 Kyotaro Horiguchi <[email protected]> 0 siblings, 0 replies; 5+ messages in thread From: Kyotaro Horiguchi @ 2019-05-29 14:03 UTC (permalink / raw) The function longer does only deletions but also syncs. Rename the function to reflect that. smgrGetPendingDeletes is not renamed since it does not change behavior. --- src/backend/access/transam/xact.c | 4 +- src/backend/catalog/storage.c | 91 ++++++++++++++++++++------------------- src/include/catalog/storage.h | 2 +- 3 files changed, 49 insertions(+), 48 deletions(-) diff --git a/src/backend/access/transam/xact.c b/src/backend/access/transam/xact.c index f594d33e7a..0123fb0f7f 100644 --- a/src/backend/access/transam/xact.c +++ b/src/backend/access/transam/xact.c @@ -2228,7 +2228,7 @@ CommitTransaction(void) * Other backends will observe the attendant catalog changes and not * attempt to access affected files. */ - smgrDoPendingDeletes(true); + smgrDoPendingOperations(true); AtCommit_Notify(); AtEOXact_GUC(true, 1); @@ -2716,7 +2716,7 @@ AbortTransaction(void) ResourceOwnerRelease(TopTransactionResourceOwner, RESOURCE_RELEASE_AFTER_LOCKS, false, true); - smgrDoPendingDeletes(false); + smgrDoPendingOperations(false); AtEOXact_GUC(false, 1); AtEOXact_SPI(false); diff --git a/src/backend/catalog/storage.c b/src/backend/catalog/storage.c index 354a74c27c..544ef3aa55 100644 --- a/src/backend/catalog/storage.c +++ b/src/backend/catalog/storage.c @@ -54,18 +54,18 @@ * but I'm being paranoid. */ -/* entry type of pendingDeletes */ -typedef struct PendingRelDelete +/* entry type of pendingOperations */ +typedef struct PendingRelOp { RelFileNode relnode; /* relation that may need to be deleted */ BackendId backend; /* InvalidBackendId if not a temp rel */ bool atCommit; /* T=work at commit; F=work at abort */ PendingOpType op; /* type of operation to do */ int nestLevel; /* xact nesting level of request */ - struct PendingRelDelete *next; /* linked-list link */ -} PendingRelDelete; + struct PendingRelOp *next; /* linked-list link */ +} PendingRelOp; -static PendingRelDelete *pendingDeletes = NULL; /* head of linked list */ +static PendingRelOp *pendingOperations = NULL; /* head of linked list */ /* * RelationCreateStorage @@ -81,7 +81,7 @@ static PendingRelDelete *pendingDeletes = NULL; /* head of linked list */ SMgrRelation RelationCreateStorage(RelFileNode rnode, char relpersistence) { - PendingRelDelete *pending; + PendingRelOp *pending; SMgrRelation srel; BackendId backend; bool needs_wal; @@ -112,15 +112,15 @@ RelationCreateStorage(RelFileNode rnode, char relpersistence) log_smgrcreate(&srel->smgr_rnode.node, MAIN_FORKNUM); /* Add the relation to the list of stuff to delete at abort */ - pending = (PendingRelDelete *) - MemoryContextAlloc(TopMemoryContext, sizeof(PendingRelDelete)); + pending = (PendingRelOp *) + MemoryContextAlloc(TopMemoryContext, sizeof(PendingRelOp)); pending->relnode = rnode; pending->backend = backend; pending->atCommit = false; /* delete if abort */ pending->op = PENDING_DELETE; pending->nestLevel = GetCurrentTransactionNestLevel(); - pending->next = pendingDeletes; - pendingDeletes = pending; + pending->next = pendingOperations; + pendingOperations = pending; /* * We are going to skip WAL-logging for storage of persistent relations @@ -129,15 +129,15 @@ RelationCreateStorage(RelFileNode rnode, char relpersistence) */ if (relpersistence == RELPERSISTENCE_PERMANENT && !XLogIsNeeded()) { - pending = (PendingRelDelete *) - MemoryContextAlloc(TopMemoryContext, sizeof(PendingRelDelete)); + pending = (PendingRelOp *) + MemoryContextAlloc(TopMemoryContext, sizeof(PendingRelOp)); pending->relnode = rnode; pending->backend = backend; pending->atCommit = true; pending->op = PENDING_SYNC; pending->nestLevel = GetCurrentTransactionNestLevel(); - pending->next = pendingDeletes; - pendingDeletes = pending; + pending->next = pendingOperations; + pendingOperations = pending; } return srel; @@ -169,27 +169,27 @@ log_smgrcreate(const RelFileNode *rnode, ForkNumber forkNum) void RelationDropStorage(Relation rel) { - PendingRelDelete *pending; + PendingRelOp *pending; /* Add the relation to the list of stuff to delete at commit */ - pending = (PendingRelDelete *) - MemoryContextAlloc(TopMemoryContext, sizeof(PendingRelDelete)); + pending = (PendingRelOp *) + MemoryContextAlloc(TopMemoryContext, sizeof(PendingRelOp)); pending->relnode = rel->rd_node; pending->backend = rel->rd_backend; pending->atCommit = true; /* delete if commit */ pending->op = PENDING_DELETE; pending->nestLevel = GetCurrentTransactionNestLevel(); - pending->next = pendingDeletes; - pendingDeletes = pending; + pending->next = pendingOperations; + pendingOperations = pending; /* * NOTE: if the relation was created in this transaction, it will now be * present in the pending-delete list twice, once with atCommit true and * once with atCommit false. Hence, it will be physically deleted at end * of xact in either case (and the other entry will be ignored by - * smgrDoPendingDeletes, so no error will occur). We could instead remove - * the existing list entry and delete the physical file immediately, but - * for now I'll keep the logic simple. + * smgrDoPendingOperations, so no error will occur). We could instead + * remove the existing list entry and delete the physical file + * immediately, but for now I'll keep the logic simple. */ RelationCloseSmgr(rel); @@ -215,12 +215,12 @@ RelationDropStorage(Relation rel) void RelationPreserveStorage(RelFileNode rnode, bool atCommit) { - PendingRelDelete *pending; - PendingRelDelete *prev; - PendingRelDelete *next; + PendingRelOp *pending; + PendingRelOp *prev; + PendingRelOp *next; prev = NULL; - for (pending = pendingDeletes; pending != NULL; pending = next) + for (pending = pendingOperations; pending != NULL; pending = next) { next = pending->next; if (RelFileNodeEquals(rnode, pending->relnode) @@ -231,7 +231,7 @@ RelationPreserveStorage(RelFileNode rnode, bool atCommit) if (prev) prev->next = next; else - pendingDeletes = next; + pendingOperations = next; pfree(pending); /* prev does not change */ } @@ -409,7 +409,8 @@ RelationCopyStorage(SMgrRelation src, SMgrRelation dst, } /* - * smgrDoPendingDeletes() -- Take care of relation deletes at end of xact. + * smgrDoPendingOperations() -- Take care of relation deletes and syncs at + * end of xact. * * This also runs when aborting a subxact; we want to clean up a failed * subxact immediately. @@ -420,12 +421,12 @@ RelationCopyStorage(SMgrRelation src, SMgrRelation dst, * already recovered the physical storage. */ void -smgrDoPendingDeletes(bool isCommit) +smgrDoPendingOperations(bool isCommit) { int nestLevel = GetCurrentTransactionNestLevel(); - PendingRelDelete *pending; - PendingRelDelete *prev; - PendingRelDelete *next; + PendingRelOp *pending; + PendingRelOp *prev; + PendingRelOp *next; int nrels = 0, i = 0, maxrels = 0; @@ -433,7 +434,7 @@ smgrDoPendingDeletes(bool isCommit) struct HTAB *synchash = NULL; prev = NULL; - for (pending = pendingDeletes; pending != NULL; pending = next) + for (pending = pendingOperations; pending != NULL; pending = next) { next = pending->next; if (pending->nestLevel < nestLevel) @@ -447,7 +448,7 @@ smgrDoPendingDeletes(bool isCommit) if (prev) prev->next = next; else - pendingDeletes = next; + pendingOperations = next; /* do deletion if called for */ if (pending->atCommit == isCommit) { @@ -576,10 +577,10 @@ smgrGetPendingOperations(PendingOpType op, bool forCommit, RelFileNode **ptr) int nestLevel = GetCurrentTransactionNestLevel(); int nrels; RelFileNode *rptr; - PendingRelDelete *pending; + PendingRelOp *pending; nrels = 0; - for (pending = pendingDeletes; pending != NULL; pending = pending->next) + for (pending = pendingOperations; pending != NULL; pending = pending->next) { if (pending->nestLevel >= nestLevel && pending->atCommit == forCommit && pending->backend == InvalidBackendId @@ -593,7 +594,7 @@ smgrGetPendingOperations(PendingOpType op, bool forCommit, RelFileNode **ptr) } rptr = (RelFileNode *) palloc(nrels * sizeof(RelFileNode)); *ptr = rptr; - for (pending = pendingDeletes; pending != NULL; pending = pending->next) + for (pending = pendingOperations; pending != NULL; pending = pending->next) { if (pending->nestLevel >= nestLevel && pending->atCommit == forCommit && pending->backend == InvalidBackendId @@ -630,13 +631,13 @@ smgrGetPendingSyncs(bool forCommit, RelFileNode **ptr) void PostPrepare_smgr(void) { - PendingRelDelete *pending; - PendingRelDelete *next; + PendingRelOp *pending; + PendingRelOp *next; - for (pending = pendingDeletes; pending != NULL; pending = next) + for (pending = pendingOperations; pending != NULL; pending = next) { next = pending->next; - pendingDeletes = next; + pendingOperations = next; /* must explicitly free the list entry */ pfree(pending); } @@ -646,15 +647,15 @@ PostPrepare_smgr(void) /* * AtSubCommit_smgr() --- Take care of subtransaction commit. * - * Reassign all items in the pending-deletes list to the parent transaction. + * Reassign all items in the pending-operations list to the parent transaction. */ void AtSubCommit_smgr(void) { int nestLevel = GetCurrentTransactionNestLevel(); - PendingRelDelete *pending; + PendingRelOp *pending; - for (pending = pendingDeletes; pending != NULL; pending = pending->next) + for (pending = pendingOperations; pending != NULL; pending = pending->next) { if (pending->nestLevel >= nestLevel) pending->nestLevel = nestLevel - 1; @@ -671,7 +672,7 @@ AtSubCommit_smgr(void) void AtSubAbort_smgr(void) { - smgrDoPendingDeletes(false); + smgrDoPendingOperations(false); } void diff --git a/src/include/catalog/storage.h b/src/include/catalog/storage.h index 1de6f1655c..dcb3bc4b69 100644 --- a/src/include/catalog/storage.h +++ b/src/include/catalog/storage.h @@ -37,7 +37,7 @@ extern void RelationCopyStorage(SMgrRelation src, SMgrRelation dst, * These functions used to be in storage/smgr/smgr.c, which explains the * naming */ -extern void smgrDoPendingDeletes(bool isCommit); +extern void smgrDoPendingOperations(bool isCommit); extern int smgrGetPendingDeletes(bool forCommit, RelFileNode **ptr); extern int smgrGetPendingSyncs(bool forCommit, RelFileNode **ptr); extern void AtSubCommit_smgr(void); -- 2.16.3 ----Next_Part(Wed_Aug_21_16_32_38_2019_483)---- ^ permalink raw reply [nested|flat] 5+ messages in thread
* [PATCH 3/3] Rename smgrDoPendingDeletes to smgrDoPendingOperations @ 2019-05-29 14:03 Kyotaro Horiguchi <[email protected]> 0 siblings, 0 replies; 5+ messages in thread From: Kyotaro Horiguchi @ 2019-05-29 14:03 UTC (permalink / raw) The function longer does only deletions but also syncs. Rename the function to refect that. smgrGetPendingDeletes is not renamed since it does not change behavior. --- src/backend/access/transam/xact.c | 4 +-- src/backend/catalog/storage.c | 57 ++++++++++++++++++++------------------- src/include/catalog/storage.h | 2 +- 3 files changed, 32 insertions(+), 31 deletions(-) diff --git a/src/backend/access/transam/xact.c b/src/backend/access/transam/xact.c index d7930c077d..cc0c43b2dd 100644 --- a/src/backend/access/transam/xact.c +++ b/src/backend/access/transam/xact.c @@ -2228,7 +2228,7 @@ CommitTransaction(void) * Other backends will observe the attendant catalog changes and not * attempt to access affected files. */ - smgrDoPendingDeletes(true); + smgrDoPendingOperations(true); AtCommit_Notify(); AtEOXact_GUC(true, 1); @@ -2716,7 +2716,7 @@ AbortTransaction(void) ResourceOwnerRelease(TopTransactionResourceOwner, RESOURCE_RELEASE_AFTER_LOCKS, false, true); - smgrDoPendingDeletes(false); + smgrDoPendingOperations(false); AtEOXact_GUC(false, 1); AtEOXact_SPI(false); diff --git a/src/backend/catalog/storage.c b/src/backend/catalog/storage.c index e4bcdc390f..6ebe75aa37 100644 --- a/src/backend/catalog/storage.c +++ b/src/backend/catalog/storage.c @@ -53,17 +53,17 @@ * but I'm being paranoid. */ -typedef struct PendingRelDelete +typedef struct PendingRelOps { RelFileNode relnode; /* relation that may need to be deleted */ BackendId backend; /* InvalidBackendId if not a temp rel */ bool atCommit; /* T=work at commit; F=work at abort */ bool dosync; /* T=work is sync; F=work is delete */ int nestLevel; /* xact nesting level of request */ - struct PendingRelDelete *next; /* linked-list link */ -} PendingRelDelete; + struct PendingRelOps *next; /* linked-list link */ +} PendingRelOps; -static PendingRelDelete *pendingDeletes = NULL; /* head of linked list */ +static PendingRelOps *pendingDeletes = NULL; /* head of linked list */ /* * RelationCreateStorage @@ -79,7 +79,7 @@ static PendingRelDelete *pendingDeletes = NULL; /* head of linked list */ SMgrRelation RelationCreateStorage(RelFileNode rnode, char relpersistence) { - PendingRelDelete *pending; + PendingRelOps *pending; SMgrRelation srel; BackendId backend; bool needs_wal; @@ -110,8 +110,8 @@ RelationCreateStorage(RelFileNode rnode, char relpersistence) log_smgrcreate(&srel->smgr_rnode.node, MAIN_FORKNUM); /* Add the relation to the list of stuff to delete at abort */ - pending = (PendingRelDelete *) - MemoryContextAlloc(TopMemoryContext, sizeof(PendingRelDelete)); + pending = (PendingRelOps *) + MemoryContextAlloc(TopMemoryContext, sizeof(PendingRelOps)); pending->relnode = rnode; pending->backend = backend; pending->atCommit = false; /* delete if abort */ @@ -127,8 +127,8 @@ RelationCreateStorage(RelFileNode rnode, char relpersistence) */ if (relpersistence == RELPERSISTENCE_PERMANENT && !XLogIsNeeded()) { - pending = (PendingRelDelete *) - MemoryContextAlloc(TopMemoryContext, sizeof(PendingRelDelete)); + pending = (PendingRelOps *) + MemoryContextAlloc(TopMemoryContext, sizeof(PendingRelOps)); pending->relnode = rnode; pending->backend = backend; pending->atCommit = true; @@ -167,11 +167,11 @@ log_smgrcreate(const RelFileNode *rnode, ForkNumber forkNum) void RelationDropStorage(Relation rel) { - PendingRelDelete *pending; + PendingRelOps *pending; /* Add the relation to the list of stuff to delete at commit */ - pending = (PendingRelDelete *) - MemoryContextAlloc(TopMemoryContext, sizeof(PendingRelDelete)); + pending = (PendingRelOps *) + MemoryContextAlloc(TopMemoryContext, sizeof(PendingRelOps)); pending->relnode = rel->rd_node; pending->backend = rel->rd_backend; pending->atCommit = true; /* delete if commit */ @@ -185,9 +185,9 @@ RelationDropStorage(Relation rel) * present in the pending-delete list twice, once with atCommit true and * once with atCommit false. Hence, it will be physically deleted at end * of xact in either case (and the other entry will be ignored by - * smgrDoPendingDeletes, so no error will occur). We could instead remove - * the existing list entry and delete the physical file immediately, but - * for now I'll keep the logic simple. + * smgrDoPendingOperations, so no error will occur). We could instead + * remove the existing list entry and delete the physical file + * immediately, but for now I'll keep the logic simple. */ RelationCloseSmgr(rel); @@ -213,9 +213,9 @@ RelationDropStorage(Relation rel) void RelationPreserveStorage(RelFileNode rnode, bool atCommit) { - PendingRelDelete *pending; - PendingRelDelete *prev; - PendingRelDelete *next; + PendingRelOps *pending; + PendingRelOps *prev; + PendingRelOps *next; prev = NULL; for (pending = pendingDeletes; pending != NULL; pending = next) @@ -406,7 +406,8 @@ RelationCopyStorage(SMgrRelation src, SMgrRelation dst, } /* - * smgrDoPendingDeletes() -- Take care of relation deletes at end of xact. + * smgrDoPendingOperations() -- Take care of relation deletes and syncs at + * end of xact. * * This also runs when aborting a subxact; we want to clean up a failed * subxact immediately. @@ -417,12 +418,12 @@ RelationCopyStorage(SMgrRelation src, SMgrRelation dst, * already recovered the physical storage. */ void -smgrDoPendingDeletes(bool isCommit) +smgrDoPendingOperations(bool isCommit) { int nestLevel = GetCurrentTransactionNestLevel(); - PendingRelDelete *pending; - PendingRelDelete *prev; - PendingRelDelete *next; + PendingRelOps *pending; + PendingRelOps *prev; + PendingRelOps *next; int nrels = 0, i = 0, maxrels = 0; @@ -518,7 +519,7 @@ smgrGetPendingDeletes(bool forCommit, RelFileNode **ptr) int nestLevel = GetCurrentTransactionNestLevel(); int nrels; RelFileNode *rptr; - PendingRelDelete *pending; + PendingRelOps *pending; nrels = 0; for (pending = pendingDeletes; pending != NULL; pending = pending->next) @@ -558,8 +559,8 @@ smgrGetPendingDeletes(bool forCommit, RelFileNode **ptr) void PostPrepare_smgr(void) { - PendingRelDelete *pending; - PendingRelDelete *next; + PendingRelOps *pending; + PendingRelOps *next; for (pending = pendingDeletes; pending != NULL; pending = next) { @@ -580,7 +581,7 @@ void AtSubCommit_smgr(void) { int nestLevel = GetCurrentTransactionNestLevel(); - PendingRelDelete *pending; + PendingRelOps *pending; for (pending = pendingDeletes; pending != NULL; pending = pending->next) { @@ -599,7 +600,7 @@ AtSubCommit_smgr(void) void AtSubAbort_smgr(void) { - smgrDoPendingDeletes(false); + smgrDoPendingOperations(false); } void diff --git a/src/include/catalog/storage.h b/src/include/catalog/storage.h index 3579d3f3eb..43836cf11c 100644 --- a/src/include/catalog/storage.h +++ b/src/include/catalog/storage.h @@ -30,7 +30,7 @@ extern void RelationCopyStorage(SMgrRelation src, SMgrRelation dst, * These functions used to be in storage/smgr/smgr.c, which explains the * naming */ -extern void smgrDoPendingDeletes(bool isCommit); +extern void smgrDoPendingOperations(bool isCommit); extern int smgrGetPendingDeletes(bool forCommit, RelFileNode **ptr); extern void AtSubCommit_smgr(void); extern void AtSubAbort_smgr(void); -- 2.16.3 ----Next_Part(Wed_Jul_10_13_19_14_2019_952)---- ^ permalink raw reply [nested|flat] 5+ messages in thread
* [PATCH v4 5/7] Row pattern recognition patch (docs). @ 2023-08-09 07:56 Tatsuo Ishii <[email protected]> 0 siblings, 0 replies; 5+ messages in thread From: Tatsuo Ishii @ 2023-08-09 07:56 UTC (permalink / raw) --- doc/src/sgml/advanced.sgml | 52 ++++++++++++++++++++++++++++++++++ doc/src/sgml/func.sgml | 54 ++++++++++++++++++++++++++++++++++++ doc/src/sgml/ref/select.sgml | 38 +++++++++++++++++++++++-- 3 files changed, 142 insertions(+), 2 deletions(-) diff --git a/doc/src/sgml/advanced.sgml b/doc/src/sgml/advanced.sgml index 755c9f1485..eda3612822 100644 --- a/doc/src/sgml/advanced.sgml +++ b/doc/src/sgml/advanced.sgml @@ -537,6 +537,58 @@ WHERE pos < 3; <literal>rank</literal> less than 3. </para> + <para> + Row pattern common syntax can be used with row pattern common syntax to + perform row pattern recognition in a query. Row pattern common syntax + includes two sub clauses. <literal>DEFINE</literal> defines definition + variables along with an expression. The expression must be a logical + expression, which means it must + return <literal>TRUE</literal>, <literal>FALSE</literal> + or <literal>NULL</literal>. Moreover if the expression comprises a column + reference, it must be the argument of <function>rpr</function>. An example + of <literal>DEFINE</literal> is as follows. + +<programlisting> +DEFINE + LOWPRICE AS price <= 100, + UP AS price > PREV(price), + DOWN AS price < PREV(price) +</programlisting> + + Note that <function>PREV</function> returns price column in the previous + row if it's called in a context of row pattern recognition. So in the + second line means the definition variable "UP" is <literal>TRUE</literal> + when price column in the current row is greater than the price column in + the previous row. Likewise, "DOWN" is <literal>TRUE</literal> when when + price column in the current row is lower than the price column in the + previous row. + </para> + <para> + Once <literal>DEFINE</literal> exists, <literal>PATTERN</literal> can be + used. <literal>PATTERN</literal> defines a sequence of rows that satisfies + certain conditions. For example following <literal>PATTERN</literal> + defines that a row starts with the condition "LOWPRICE", then one or more + rows satisfy "UP" and finally one or more rows satisfy "DOWN". If a + sequence of rows found, rpr returns the column at the starting row. + Example of a <literal>SELECT</literal> using the <literal>DEFINE</literal> + and <literal>PATTERN</literal> clause is as follows. + +<programlisting> +SELECT company, tdate, price, max(price) OVER w FROM stock + WINDOW w AS ( + PARTITION BY company + ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING + AFTER MATCH SKIP PAST LAST ROW + INITIAL + PATTERN (LOWPRICE UP+ DOWN+) + DEFINE + LOWPRICE AS price <= 100, + UP AS price > PREV(price), + DOWN AS price < PREV(price) +); +</programlisting> + </para> + <para> When a query involves multiple window functions, it is possible to write out each one with a separate <literal>OVER</literal> clause, but this is diff --git a/doc/src/sgml/func.sgml b/doc/src/sgml/func.sgml index be2f54c914..6cda164522 100644 --- a/doc/src/sgml/func.sgml +++ b/doc/src/sgml/func.sgml @@ -21715,6 +21715,7 @@ SELECT count(*) FROM sometable; returns <literal>NULL</literal> if there is no such row. </para></entry> </row> + </tbody> </tgroup> </table> @@ -21754,6 +21755,59 @@ SELECT count(*) FROM sometable; Other frame specifications can be used to obtain other effects. </para> + <para> + Row pattern recognition navigation functions are listed in + <xref linkend="functions-rpr-navigation-table"/>. These functions + can be used to describe DEFINE clause of Row pattern recognition. + </para> + + <table id="functions-rpr-navigation-table"> + <title>Row Pattern Navigation Functions</title> + <tgroup cols="1"> + <thead> + <row> + <entry role="func_table_entry"><para role="func_signature"> + Function + </para> + <para> + Description + </para></entry> + </row> + </thead> + + <tbody> + <row> + <entry role="func_table_entry"><para role="func_signature"> + <indexterm> + <primary>prev</primary> + </indexterm> + <function>prev</function> ( <parameter>value</parameter> <type>anyelement</type> ) + <returnvalue>anyelement</returnvalue> + </para> + <para> + Returns the column value at the previous row; + returns NULL if there is no previous row in the window frame. + </para></entry> + </row> + + <row> + <entry role="func_table_entry"><para role="func_signature"> + <indexterm> + <primary>next</primary> + </indexterm> + <function>next</function> ( <parameter>value</parameter> <type>anyelement</type> ) + <returnvalue>anyelement</returnvalue> + </para> + <para> + Returns the column value at the next row; + returns NULL if there is no next row in the window frame. + </para></entry> + </row> + + </tbody> + </tgroup> + </table> + <note> <para> The SQL standard defines a <literal>RESPECT NULLS</literal> or diff --git a/doc/src/sgml/ref/select.sgml b/doc/src/sgml/ref/select.sgml index 0ee0cc7e64..8d3becd57a 100644 --- a/doc/src/sgml/ref/select.sgml +++ b/doc/src/sgml/ref/select.sgml @@ -966,8 +966,8 @@ WINDOW <replaceable class="parameter">window_name</replaceable> AS ( <replaceabl The <replaceable class="parameter">frame_clause</replaceable> can be one of <synopsis> -{ RANGE | ROWS | GROUPS } <replaceable>frame_start</replaceable> [ <replaceable>frame_exclusion</replaceable> ] -{ RANGE | ROWS | GROUPS } BETWEEN <replaceable>frame_start</replaceable> AND <replaceable>frame_end</replaceable> [ <replaceable>frame_exclusion</replaceable> ] +{ RANGE | ROWS | GROUPS } <replaceable>frame_start</replaceable> [ <replaceable>frame_exclusion</replaceable> ] [row_pattern_common_syntax] +{ RANGE | ROWS | GROUPS } BETWEEN <replaceable>frame_start</replaceable> AND <replaceable>frame_end</replaceable> [ <replaceable>frame_exclusion</replaceable> ] [row_pattern_common_syntax] </synopsis> where <replaceable>frame_start</replaceable> @@ -1074,6 +1074,40 @@ EXCLUDE NO OTHERS a given peer group will be in the frame or excluded from it. </para> + <para> + The + optional <replaceable class="parameter">row_pattern_common_syntax</replaceable> + defines the <firstterm>row pattern recognition condition</firstterm> for + this + window. <replaceable class="parameter">row_pattern_common_syntax</replaceable> + includes following subclauses. <literal>AFTER MATCH SKIP PAST LAST + ROW</literal> or <literal>AFTER MATCH SKIP TO NEXT ROW</literal> controls + how to proceed to next row position after a match + found. With <literal>AFTER MATCH SKIP PAST LAST ROW</literal> (the + default) next row position is next to the last row of previous match. On + the other hand, with <literal>AFTER MATCH SKIP TO NEXT ROW</literal> next + row position is always next to the last row of previous + match. <literal>DEFINE</literal> defines definition variables along with a + boolean expression. <literal>PATTERN</literal> defines a sequence of rows + that satisfies certain conditions using variables defined + in <literal>DEFINE</literal> clause. If the variable is not defined in + the <literal>DEFINE</literal> clause, it is implicitly assumed + following is defined in the <literal>DEFINE</literal> clause. + +<synopsis> +<literal>variable_name</literal> AS TRUE +</synopsis> + + Note that the maximu number of variables defined + in <literal>DEFINE</literal> clause is 26. + +<synopsis> +[ AFTER MATCH SKIP PAST LAST ROW | AFTER MATCH SKIP TO NEXT ROW ] +PATTERN <replaceable class="parameter">pattern_variable_name</replaceable>[+] [, ...] +DEFINE <replaceable class="parameter">definition_varible_name</replaceable> AS <replaceable class="parameter">expression</replaceable> [, ...] +</synopsis> + </para> + <para> The purpose of a <literal>WINDOW</literal> clause is to specify the behavior of <firstterm>window functions</firstterm> appearing in the query's -- 2.25.1 ----Next_Part(Wed_Aug__9_17_41_12_2023_134)-- Content-Type: Text/X-Patch; charset=us-ascii Content-Transfer-Encoding: 7bit Content-Disposition: inline; filename="v4-0006-Row-pattern-recognition-patch-tests.patch" ^ permalink raw reply [nested|flat] 5+ messages in thread
* [PATCH v4 3/4] Remove useless calls to flush some stats @ 2026-01-06 11:06 Bertrand Drouvot <[email protected]> 0 siblings, 0 replies; 5+ messages in thread From: Bertrand Drouvot @ 2026-01-06 11:06 UTC (permalink / raw) Now that some stats can be flushed outside of transaction boundaries, remove useless calls to report/flush some stats. Those calls were in place because before commit <XXXX> stats were flushed only at transaction boundaries. Note that: - it reverts 039549d70f6 (it just keeps its tests) - it can't be done for checkpointer and bgworker for example because they don't have a flush callback to call - it can't be done for auxiliary process (walsummarizer for example) because they currently do not register the new timeout handler --- src/backend/replication/walreceiver.c | 10 ------ src/backend/replication/walsender.c | 36 ++------------------ src/backend/utils/activity/pgstat_relation.c | 13 ------- src/test/recovery/t/001_stream_rep.pl | 1 + src/test/subscription/t/001_rep_changes.pl | 1 + 5 files changed, 4 insertions(+), 57 deletions(-) 69.9% src/backend/replication/ 22.8% src/backend/utils/activity/ 3.5% src/test/recovery/t/ 3.6% src/test/subscription/t/ diff --git a/src/backend/replication/walreceiver.c b/src/backend/replication/walreceiver.c index 6970af3f3ff..dcbe3517b46 100644 --- a/src/backend/replication/walreceiver.c +++ b/src/backend/replication/walreceiver.c @@ -565,16 +565,6 @@ WalReceiverMain(const void *startup_data, size_t startup_data_len) */ bool requestReply = false; - /* - * Report pending statistics to the cumulative stats - * system. This location is useful for the report as it - * is not within a tight loop in the WAL receiver, to - * avoid bloating pgstats with requests, while also making - * sure that the reports happen each time a status update - * is sent. - */ - pgstat_report_wal(false); - /* * Check if time since last receive from primary has * reached the configured limit. diff --git a/src/backend/replication/walsender.c b/src/backend/replication/walsender.c index a0e6a3d200c..74102def9c7 100644 --- a/src/backend/replication/walsender.c +++ b/src/backend/replication/walsender.c @@ -94,14 +94,10 @@ #include "utils/lsyscache.h" #include "utils/memutils.h" #include "utils/pg_lsn.h" -#include "utils/pgstat_internal.h" #include "utils/ps_status.h" #include "utils/timeout.h" #include "utils/timestamp.h" -/* Minimum interval used by walsender for stats flushes, in ms */ -#define WALSENDER_STATS_FLUSH_INTERVAL 1000 - /* * Maximum data payload in a WAL data message. Must be >= XLOG_BLCKSZ. * @@ -1825,7 +1821,6 @@ WalSndWaitForWal(XLogRecPtr loc) int wakeEvents; uint32 wait_event = 0; static XLogRecPtr RecentFlushPtr = InvalidXLogRecPtr; - TimestampTz last_flush = 0; /* * Fast path to avoid acquiring the spinlock in case we already know we @@ -1846,7 +1841,6 @@ WalSndWaitForWal(XLogRecPtr loc) { bool wait_for_standby_at_stop = false; long sleeptime; - TimestampTz now; /* Clear any already-pending wakeups */ ResetLatch(MyLatch); @@ -1957,8 +1951,7 @@ WalSndWaitForWal(XLogRecPtr loc) * new WAL to be generated. (But if we have nothing to send, we don't * want to wake on socket-writable.) */ - now = GetCurrentTimestamp(); - sleeptime = WalSndComputeSleeptime(now); + sleeptime = WalSndComputeSleeptime(GetCurrentTimestamp()); wakeEvents = WL_SOCKET_READABLE; @@ -1967,15 +1960,6 @@ WalSndWaitForWal(XLogRecPtr loc) Assert(wait_event != 0); - /* Report IO statistics, if needed */ - if (TimestampDifferenceExceeds(last_flush, now, - WALSENDER_STATS_FLUSH_INTERVAL)) - { - pgstat_flush_io(false); - (void) pgstat_flush_backend(false, PGSTAT_BACKEND_FLUSH_IO); - last_flush = now; - } - WalSndWait(wakeEvents, sleeptime, wait_event); } @@ -2878,8 +2862,6 @@ WalSndCheckTimeOut(void) static void WalSndLoop(WalSndSendDataCallback send_data) { - TimestampTz last_flush = 0; - /* * Initialize the last reply timestamp. That enables timeout processing * from hereon. @@ -2974,9 +2956,6 @@ WalSndLoop(WalSndSendDataCallback send_data) * WalSndWaitForWal() handle any other blocking; idle receivers need * its additional actions. For physical replication, also block if * caught up; its send_data does not block. - * - * The IO statistics are reported in WalSndWaitForWal() for the - * logical WAL senders. */ if ((WalSndCaughtUp && send_data != XLogSendLogical && !streamingDoneSending) || @@ -2984,7 +2963,6 @@ WalSndLoop(WalSndSendDataCallback send_data) { long sleeptime; int wakeEvents; - TimestampTz now; if (!streamingDoneReceiving) wakeEvents = WL_SOCKET_READABLE; @@ -2995,21 +2973,11 @@ WalSndLoop(WalSndSendDataCallback send_data) * Use fresh timestamp, not last_processing, to reduce the chance * of reaching wal_sender_timeout before sending a keepalive. */ - now = GetCurrentTimestamp(); - sleeptime = WalSndComputeSleeptime(now); + sleeptime = WalSndComputeSleeptime(GetCurrentTimestamp()); if (pq_is_send_pending()) wakeEvents |= WL_SOCKET_WRITEABLE; - /* Report IO statistics, if needed */ - if (TimestampDifferenceExceeds(last_flush, now, - WALSENDER_STATS_FLUSH_INTERVAL)) - { - pgstat_flush_io(false); - (void) pgstat_flush_backend(false, PGSTAT_BACKEND_FLUSH_IO); - last_flush = now; - } - /* Sleep until something happens or we time out */ WalSndWait(wakeEvents, sleeptime, WAIT_EVENT_WAL_SENDER_MAIN); } diff --git a/src/backend/utils/activity/pgstat_relation.c b/src/backend/utils/activity/pgstat_relation.c index bc8c43b96aa..feae2ae5f44 100644 --- a/src/backend/utils/activity/pgstat_relation.c +++ b/src/backend/utils/activity/pgstat_relation.c @@ -260,15 +260,6 @@ pgstat_report_vacuum(Relation rel, PgStat_Counter livetuples, } pgstat_unlock_entry(entry_ref); - - /* - * Flush IO statistics now. pgstat_report_stat() will flush IO stats, - * however this will not be called until after an entire autovacuum cycle - * is done -- which will likely vacuum many relations -- or until the - * VACUUM command has processed all tables and committed. - */ - pgstat_flush_io(false); - (void) pgstat_flush_backend(false, PGSTAT_BACKEND_FLUSH_IO); } /* @@ -360,10 +351,6 @@ pgstat_report_analyze(Relation rel, } pgstat_unlock_entry(entry_ref); - - /* see pgstat_report_vacuum() */ - pgstat_flush_io(false); - (void) pgstat_flush_backend(false, PGSTAT_BACKEND_FLUSH_IO); } /* diff --git a/src/test/recovery/t/001_stream_rep.pl b/src/test/recovery/t/001_stream_rep.pl index e9ac67813c7..c058a5f9b1f 100644 --- a/src/test/recovery/t/001_stream_rep.pl +++ b/src/test/recovery/t/001_stream_rep.pl @@ -15,6 +15,7 @@ my $node_primary = PostgreSQL::Test::Cluster->new('primary'); $node_primary->init( allows_streaming => 1, auth_extra => [ '--create-role' => 'repl_role' ]); +$node_primary->append_conf('postgresql.conf', "stats_flush_interval= '1s'"); $node_primary->start; my $backup_name = 'my_backup'; diff --git a/src/test/subscription/t/001_rep_changes.pl b/src/test/subscription/t/001_rep_changes.pl index d7e62e4d488..dda872f7074 100644 --- a/src/test/subscription/t/001_rep_changes.pl +++ b/src/test/subscription/t/001_rep_changes.pl @@ -11,6 +11,7 @@ use Test::More; # Initialize publisher node my $node_publisher = PostgreSQL::Test::Cluster->new('publisher'); $node_publisher->init(allows_streaming => 'logical'); +$node_publisher->append_conf('postgresql.conf', "stats_flush_interval= '1s'"); $node_publisher->start; # Create subscriber node -- 2.34.1 --wR/mWGXukst4NraF Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v4-0004-Add-FLUSH_MIXED-support-and-implement-it-for-RELA.patch" ^ permalink raw reply [nested|flat] 5+ messages in thread
end of thread, other threads:[~2026-01-06 11:06 UTC | newest] Thread overview: 5+ messages (download: mbox mbox.gz follow: Atom feed) -- links below jump to the message on this page -- 2019-05-29 14:03 [PATCH 3/3] Rename smgrDoPendingDeletes to smgrDoPendingOperations Kyotaro Horiguchi <[email protected]> 2019-05-29 14:03 [PATCH 3/3] Rename smgrDoPendingDeletes to smgrDoPendingOperations Kyotaro Horiguchi <[email protected]> 2019-05-29 14:03 [PATCH 3/3] Rename smgrDoPendingDeletes to smgrDoPendingOperations Kyotaro Horiguchi <[email protected]> 2023-08-09 07:56 [PATCH v4 5/7] Row pattern recognition patch (docs). Tatsuo Ishii <[email protected]> 2026-01-06 11:06 [PATCH v4 3/4] Remove useless calls to flush some stats Bertrand Drouvot <[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