public inbox for [email protected]help / color / mirror / Atom feed
[PATCH v3 2/2] Invalidate relation map cache in subscriber syscache invalidation callbacks 22+ messages / 2 participants [nested] [flat]
* [PATCH v3 2/2] Invalidate relation map cache in subscriber syscache invalidation callbacks @ 2021-01-13 11:53 Bharath Rupireddy <[email protected]> 0 siblings, 0 replies; 22+ messages in thread From: Bharath Rupireddy @ 2021-01-13 11:53 UTC (permalink / raw) Currently, in logical replication, relation map cache in the subscriber is not getting invalidated when anything changes in pg_subscription_rel or pg_subscription catalogues. So we end up not reading the latest system catalogues always in logicalrep_rel_open using GetSubscriptionRelState. To fix this, invalidate the relation map cache entries in invalidate_syncing_table_states and subscription_change_cb which are invalidation callbacks for pg_subscription_rel and pg_subscription catalogues respectively. --- src/backend/replication/logical/relation.c | 26 +++++++++++++++++++++ src/backend/replication/logical/tablesync.c | 3 +++ src/backend/replication/logical/worker.c | 3 +++ src/include/replication/logicalrelation.h | 1 + 4 files changed, 33 insertions(+) diff --git a/src/backend/replication/logical/relation.c b/src/backend/replication/logical/relation.c index e861c0ff80..88ac772444 100644 --- a/src/backend/replication/logical/relation.c +++ b/src/backend/replication/logical/relation.c @@ -96,6 +96,32 @@ logicalrep_relmap_invalidate_cb(Datum arg, Oid reloid) } } +/* + * Invalidate relation map cache whenever syscache of pg_subscription_rel or + * pg_subscription gets changed. + */ +void +logicalrep_relmap_invalidate(void) +{ + LogicalRepRelMapEntry *entry; + HASH_SEQ_STATUS status; + + /* Just to be sure. */ + if (LogicalRepRelMap == NULL) + return; + + /* + * There is no way to find the cache entry for which the syscache has been + * changed, so we mark all the cache entries state as unknown. Because of + * this, in logicalrep_rel_open the cache entry state will be read from + * the system catalogue using GetSubscriptionRelState. + */ + hash_seq_init(&status, LogicalRepRelMap); + + while ((entry = (LogicalRepRelMapEntry *) hash_seq_search(&status)) != NULL) + entry->state = SUBREL_STATE_UNKNOWN; +} + /* * Initialize the relation map cache. */ diff --git a/src/backend/replication/logical/tablesync.c b/src/backend/replication/logical/tablesync.c index 863d196fd7..6b29173a5c 100644 --- a/src/backend/replication/logical/tablesync.c +++ b/src/backend/replication/logical/tablesync.c @@ -257,6 +257,9 @@ void invalidate_syncing_table_states(Datum arg, int cacheid, uint32 hashvalue) { table_states_valid = false; + + /* Invalidate relation map cache. */ + logicalrep_relmap_invalidate(); } /* diff --git a/src/backend/replication/logical/worker.c b/src/backend/replication/logical/worker.c index f2b2549a51..347264e4a8 100644 --- a/src/backend/replication/logical/worker.c +++ b/src/backend/replication/logical/worker.c @@ -2487,6 +2487,9 @@ static void subscription_change_cb(Datum arg, int cacheid, uint32 hashvalue) { MySubscriptionValid = false; + + /* Invalidate relation map cache. */ + logicalrep_relmap_invalidate(); } /* diff --git a/src/include/replication/logicalrelation.h b/src/include/replication/logicalrelation.h index 3f0b3deefb..f5e70b75b0 100644 --- a/src/include/replication/logicalrelation.h +++ b/src/include/replication/logicalrelation.h @@ -49,4 +49,5 @@ extern void logicalrep_rel_close(LogicalRepRelMapEntry *rel, extern void logicalrep_typmap_update(LogicalRepTyp *remotetyp); extern char *logicalrep_typmap_gettypname(Oid remoteid); +extern void logicalrep_relmap_invalidate(void); #endif /* LOGICALRELATION_H */ -- 2.30.0 --=-=-=-- ^ permalink raw reply [nested|flat] 22+ messages in thread
* [PATCH v3 2/2] Invalidate relation map cache in subscriber syscache invalidation callbacks @ 2021-01-13 11:53 Bharath Rupireddy <[email protected]> 0 siblings, 0 replies; 22+ messages in thread From: Bharath Rupireddy @ 2021-01-13 11:53 UTC (permalink / raw) Currently, in logical replication, relation map cache in the subscriber is not getting invalidated when anything changes in pg_subscription_rel or pg_subscription catalogues. So we end up not reading the latest system catalogues always in logicalrep_rel_open using GetSubscriptionRelState. To fix this, invalidate the relation map cache entries in invalidate_syncing_table_states and subscription_change_cb which are invalidation callbacks for pg_subscription_rel and pg_subscription catalogues respectively. --- src/backend/replication/logical/relation.c | 26 +++++++++++++++++++++ src/backend/replication/logical/tablesync.c | 3 +++ src/backend/replication/logical/worker.c | 3 +++ src/include/replication/logicalrelation.h | 1 + 4 files changed, 33 insertions(+) diff --git a/src/backend/replication/logical/relation.c b/src/backend/replication/logical/relation.c index e861c0ff80..88ac772444 100644 --- a/src/backend/replication/logical/relation.c +++ b/src/backend/replication/logical/relation.c @@ -96,6 +96,32 @@ logicalrep_relmap_invalidate_cb(Datum arg, Oid reloid) } } +/* + * Invalidate relation map cache whenever syscache of pg_subscription_rel or + * pg_subscription gets changed. + */ +void +logicalrep_relmap_invalidate(void) +{ + LogicalRepRelMapEntry *entry; + HASH_SEQ_STATUS status; + + /* Just to be sure. */ + if (LogicalRepRelMap == NULL) + return; + + /* + * There is no way to find the cache entry for which the syscache has been + * changed, so we mark all the cache entries state as unknown. Because of + * this, in logicalrep_rel_open the cache entry state will be read from + * the system catalogue using GetSubscriptionRelState. + */ + hash_seq_init(&status, LogicalRepRelMap); + + while ((entry = (LogicalRepRelMapEntry *) hash_seq_search(&status)) != NULL) + entry->state = SUBREL_STATE_UNKNOWN; +} + /* * Initialize the relation map cache. */ diff --git a/src/backend/replication/logical/tablesync.c b/src/backend/replication/logical/tablesync.c index 863d196fd7..6b29173a5c 100644 --- a/src/backend/replication/logical/tablesync.c +++ b/src/backend/replication/logical/tablesync.c @@ -257,6 +257,9 @@ void invalidate_syncing_table_states(Datum arg, int cacheid, uint32 hashvalue) { table_states_valid = false; + + /* Invalidate relation map cache. */ + logicalrep_relmap_invalidate(); } /* diff --git a/src/backend/replication/logical/worker.c b/src/backend/replication/logical/worker.c index f2b2549a51..347264e4a8 100644 --- a/src/backend/replication/logical/worker.c +++ b/src/backend/replication/logical/worker.c @@ -2487,6 +2487,9 @@ static void subscription_change_cb(Datum arg, int cacheid, uint32 hashvalue) { MySubscriptionValid = false; + + /* Invalidate relation map cache. */ + logicalrep_relmap_invalidate(); } /* diff --git a/src/include/replication/logicalrelation.h b/src/include/replication/logicalrelation.h index 3f0b3deefb..f5e70b75b0 100644 --- a/src/include/replication/logicalrelation.h +++ b/src/include/replication/logicalrelation.h @@ -49,4 +49,5 @@ extern void logicalrep_rel_close(LogicalRepRelMapEntry *rel, extern void logicalrep_typmap_update(LogicalRepTyp *remotetyp); extern char *logicalrep_typmap_gettypname(Oid remoteid); +extern void logicalrep_relmap_invalidate(void); #endif /* LOGICALRELATION_H */ -- 2.30.0 --=-=-=-- ^ permalink raw reply [nested|flat] 22+ messages in thread
* [PATCH v3 2/2] Invalidate relation map cache in subscriber syscache invalidation callbacks @ 2021-01-13 11:53 Bharath Rupireddy <[email protected]> 0 siblings, 0 replies; 22+ messages in thread From: Bharath Rupireddy @ 2021-01-13 11:53 UTC (permalink / raw) Currently, in logical replication, relation map cache in the subscriber is not getting invalidated when anything changes in pg_subscription_rel or pg_subscription catalogues. So we end up not reading the latest system catalogues always in logicalrep_rel_open using GetSubscriptionRelState. To fix this, invalidate the relation map cache entries in invalidate_syncing_table_states and subscription_change_cb which are invalidation callbacks for pg_subscription_rel and pg_subscription catalogues respectively. --- src/backend/replication/logical/relation.c | 26 +++++++++++++++++++++ src/backend/replication/logical/tablesync.c | 3 +++ src/backend/replication/logical/worker.c | 3 +++ src/include/replication/logicalrelation.h | 1 + 4 files changed, 33 insertions(+) diff --git a/src/backend/replication/logical/relation.c b/src/backend/replication/logical/relation.c index e861c0ff80..88ac772444 100644 --- a/src/backend/replication/logical/relation.c +++ b/src/backend/replication/logical/relation.c @@ -96,6 +96,32 @@ logicalrep_relmap_invalidate_cb(Datum arg, Oid reloid) } } +/* + * Invalidate relation map cache whenever syscache of pg_subscription_rel or + * pg_subscription gets changed. + */ +void +logicalrep_relmap_invalidate(void) +{ + LogicalRepRelMapEntry *entry; + HASH_SEQ_STATUS status; + + /* Just to be sure. */ + if (LogicalRepRelMap == NULL) + return; + + /* + * There is no way to find the cache entry for which the syscache has been + * changed, so we mark all the cache entries state as unknown. Because of + * this, in logicalrep_rel_open the cache entry state will be read from + * the system catalogue using GetSubscriptionRelState. + */ + hash_seq_init(&status, LogicalRepRelMap); + + while ((entry = (LogicalRepRelMapEntry *) hash_seq_search(&status)) != NULL) + entry->state = SUBREL_STATE_UNKNOWN; +} + /* * Initialize the relation map cache. */ diff --git a/src/backend/replication/logical/tablesync.c b/src/backend/replication/logical/tablesync.c index 863d196fd7..6b29173a5c 100644 --- a/src/backend/replication/logical/tablesync.c +++ b/src/backend/replication/logical/tablesync.c @@ -257,6 +257,9 @@ void invalidate_syncing_table_states(Datum arg, int cacheid, uint32 hashvalue) { table_states_valid = false; + + /* Invalidate relation map cache. */ + logicalrep_relmap_invalidate(); } /* diff --git a/src/backend/replication/logical/worker.c b/src/backend/replication/logical/worker.c index f2b2549a51..347264e4a8 100644 --- a/src/backend/replication/logical/worker.c +++ b/src/backend/replication/logical/worker.c @@ -2487,6 +2487,9 @@ static void subscription_change_cb(Datum arg, int cacheid, uint32 hashvalue) { MySubscriptionValid = false; + + /* Invalidate relation map cache. */ + logicalrep_relmap_invalidate(); } /* diff --git a/src/include/replication/logicalrelation.h b/src/include/replication/logicalrelation.h index 3f0b3deefb..f5e70b75b0 100644 --- a/src/include/replication/logicalrelation.h +++ b/src/include/replication/logicalrelation.h @@ -49,4 +49,5 @@ extern void logicalrep_rel_close(LogicalRepRelMapEntry *rel, extern void logicalrep_typmap_update(LogicalRepTyp *remotetyp); extern char *logicalrep_typmap_gettypname(Oid remoteid); +extern void logicalrep_relmap_invalidate(void); #endif /* LOGICALRELATION_H */ -- 2.30.0 --=-=-=-- ^ permalink raw reply [nested|flat] 22+ messages in thread
* [PATCH v3 2/2] Invalidate relation map cache in subscriber syscache invalidation callbacks @ 2021-01-13 11:53 Bharath Rupireddy <[email protected]> 0 siblings, 0 replies; 22+ messages in thread From: Bharath Rupireddy @ 2021-01-13 11:53 UTC (permalink / raw) Currently, in logical replication, relation map cache in the subscriber is not getting invalidated when anything changes in pg_subscription_rel or pg_subscription catalogues. So we end up not reading the latest system catalogues always in logicalrep_rel_open using GetSubscriptionRelState. To fix this, invalidate the relation map cache entries in invalidate_syncing_table_states and subscription_change_cb which are invalidation callbacks for pg_subscription_rel and pg_subscription catalogues respectively. --- src/backend/replication/logical/relation.c | 26 +++++++++++++++++++++ src/backend/replication/logical/tablesync.c | 3 +++ src/backend/replication/logical/worker.c | 3 +++ src/include/replication/logicalrelation.h | 1 + 4 files changed, 33 insertions(+) diff --git a/src/backend/replication/logical/relation.c b/src/backend/replication/logical/relation.c index e861c0ff80..88ac772444 100644 --- a/src/backend/replication/logical/relation.c +++ b/src/backend/replication/logical/relation.c @@ -96,6 +96,32 @@ logicalrep_relmap_invalidate_cb(Datum arg, Oid reloid) } } +/* + * Invalidate relation map cache whenever syscache of pg_subscription_rel or + * pg_subscription gets changed. + */ +void +logicalrep_relmap_invalidate(void) +{ + LogicalRepRelMapEntry *entry; + HASH_SEQ_STATUS status; + + /* Just to be sure. */ + if (LogicalRepRelMap == NULL) + return; + + /* + * There is no way to find the cache entry for which the syscache has been + * changed, so we mark all the cache entries state as unknown. Because of + * this, in logicalrep_rel_open the cache entry state will be read from + * the system catalogue using GetSubscriptionRelState. + */ + hash_seq_init(&status, LogicalRepRelMap); + + while ((entry = (LogicalRepRelMapEntry *) hash_seq_search(&status)) != NULL) + entry->state = SUBREL_STATE_UNKNOWN; +} + /* * Initialize the relation map cache. */ diff --git a/src/backend/replication/logical/tablesync.c b/src/backend/replication/logical/tablesync.c index 863d196fd7..6b29173a5c 100644 --- a/src/backend/replication/logical/tablesync.c +++ b/src/backend/replication/logical/tablesync.c @@ -257,6 +257,9 @@ void invalidate_syncing_table_states(Datum arg, int cacheid, uint32 hashvalue) { table_states_valid = false; + + /* Invalidate relation map cache. */ + logicalrep_relmap_invalidate(); } /* diff --git a/src/backend/replication/logical/worker.c b/src/backend/replication/logical/worker.c index f2b2549a51..347264e4a8 100644 --- a/src/backend/replication/logical/worker.c +++ b/src/backend/replication/logical/worker.c @@ -2487,6 +2487,9 @@ static void subscription_change_cb(Datum arg, int cacheid, uint32 hashvalue) { MySubscriptionValid = false; + + /* Invalidate relation map cache. */ + logicalrep_relmap_invalidate(); } /* diff --git a/src/include/replication/logicalrelation.h b/src/include/replication/logicalrelation.h index 3f0b3deefb..f5e70b75b0 100644 --- a/src/include/replication/logicalrelation.h +++ b/src/include/replication/logicalrelation.h @@ -49,4 +49,5 @@ extern void logicalrep_rel_close(LogicalRepRelMapEntry *rel, extern void logicalrep_typmap_update(LogicalRepTyp *remotetyp); extern char *logicalrep_typmap_gettypname(Oid remoteid); +extern void logicalrep_relmap_invalidate(void); #endif /* LOGICALRELATION_H */ -- 2.30.0 --=-=-=-- ^ permalink raw reply [nested|flat] 22+ messages in thread
* [PATCH v3 2/2] Invalidate relation map cache in subscriber syscache invalidation callbacks @ 2021-01-13 11:53 Bharath Rupireddy <[email protected]> 0 siblings, 0 replies; 22+ messages in thread From: Bharath Rupireddy @ 2021-01-13 11:53 UTC (permalink / raw) Currently, in logical replication, relation map cache in the subscriber is not getting invalidated when anything changes in pg_subscription_rel or pg_subscription catalogues. So we end up not reading the latest system catalogues always in logicalrep_rel_open using GetSubscriptionRelState. To fix this, invalidate the relation map cache entries in invalidate_syncing_table_states and subscription_change_cb which are invalidation callbacks for pg_subscription_rel and pg_subscription catalogues respectively. --- src/backend/replication/logical/relation.c | 26 +++++++++++++++++++++ src/backend/replication/logical/tablesync.c | 3 +++ src/backend/replication/logical/worker.c | 3 +++ src/include/replication/logicalrelation.h | 1 + 4 files changed, 33 insertions(+) diff --git a/src/backend/replication/logical/relation.c b/src/backend/replication/logical/relation.c index e861c0ff80..88ac772444 100644 --- a/src/backend/replication/logical/relation.c +++ b/src/backend/replication/logical/relation.c @@ -96,6 +96,32 @@ logicalrep_relmap_invalidate_cb(Datum arg, Oid reloid) } } +/* + * Invalidate relation map cache whenever syscache of pg_subscription_rel or + * pg_subscription gets changed. + */ +void +logicalrep_relmap_invalidate(void) +{ + LogicalRepRelMapEntry *entry; + HASH_SEQ_STATUS status; + + /* Just to be sure. */ + if (LogicalRepRelMap == NULL) + return; + + /* + * There is no way to find the cache entry for which the syscache has been + * changed, so we mark all the cache entries state as unknown. Because of + * this, in logicalrep_rel_open the cache entry state will be read from + * the system catalogue using GetSubscriptionRelState. + */ + hash_seq_init(&status, LogicalRepRelMap); + + while ((entry = (LogicalRepRelMapEntry *) hash_seq_search(&status)) != NULL) + entry->state = SUBREL_STATE_UNKNOWN; +} + /* * Initialize the relation map cache. */ diff --git a/src/backend/replication/logical/tablesync.c b/src/backend/replication/logical/tablesync.c index 863d196fd7..6b29173a5c 100644 --- a/src/backend/replication/logical/tablesync.c +++ b/src/backend/replication/logical/tablesync.c @@ -257,6 +257,9 @@ void invalidate_syncing_table_states(Datum arg, int cacheid, uint32 hashvalue) { table_states_valid = false; + + /* Invalidate relation map cache. */ + logicalrep_relmap_invalidate(); } /* diff --git a/src/backend/replication/logical/worker.c b/src/backend/replication/logical/worker.c index f2b2549a51..347264e4a8 100644 --- a/src/backend/replication/logical/worker.c +++ b/src/backend/replication/logical/worker.c @@ -2487,6 +2487,9 @@ static void subscription_change_cb(Datum arg, int cacheid, uint32 hashvalue) { MySubscriptionValid = false; + + /* Invalidate relation map cache. */ + logicalrep_relmap_invalidate(); } /* diff --git a/src/include/replication/logicalrelation.h b/src/include/replication/logicalrelation.h index 3f0b3deefb..f5e70b75b0 100644 --- a/src/include/replication/logicalrelation.h +++ b/src/include/replication/logicalrelation.h @@ -49,4 +49,5 @@ extern void logicalrep_rel_close(LogicalRepRelMapEntry *rel, extern void logicalrep_typmap_update(LogicalRepTyp *remotetyp); extern char *logicalrep_typmap_gettypname(Oid remoteid); +extern void logicalrep_relmap_invalidate(void); #endif /* LOGICALRELATION_H */ -- 2.30.0 --=-=-=-- ^ permalink raw reply [nested|flat] 22+ messages in thread
* [PATCH v3 2/2] Invalidate relation map cache in subscriber syscache invalidation callbacks @ 2021-01-13 11:53 Bharath Rupireddy <[email protected]> 0 siblings, 0 replies; 22+ messages in thread From: Bharath Rupireddy @ 2021-01-13 11:53 UTC (permalink / raw) Currently, in logical replication, relation map cache in the subscriber is not getting invalidated when anything changes in pg_subscription_rel or pg_subscription catalogues. So we end up not reading the latest system catalogues always in logicalrep_rel_open using GetSubscriptionRelState. To fix this, invalidate the relation map cache entries in invalidate_syncing_table_states and subscription_change_cb which are invalidation callbacks for pg_subscription_rel and pg_subscription catalogues respectively. --- src/backend/replication/logical/relation.c | 26 +++++++++++++++++++++ src/backend/replication/logical/tablesync.c | 3 +++ src/backend/replication/logical/worker.c | 3 +++ src/include/replication/logicalrelation.h | 1 + 4 files changed, 33 insertions(+) diff --git a/src/backend/replication/logical/relation.c b/src/backend/replication/logical/relation.c index e861c0ff80..88ac772444 100644 --- a/src/backend/replication/logical/relation.c +++ b/src/backend/replication/logical/relation.c @@ -96,6 +96,32 @@ logicalrep_relmap_invalidate_cb(Datum arg, Oid reloid) } } +/* + * Invalidate relation map cache whenever syscache of pg_subscription_rel or + * pg_subscription gets changed. + */ +void +logicalrep_relmap_invalidate(void) +{ + LogicalRepRelMapEntry *entry; + HASH_SEQ_STATUS status; + + /* Just to be sure. */ + if (LogicalRepRelMap == NULL) + return; + + /* + * There is no way to find the cache entry for which the syscache has been + * changed, so we mark all the cache entries state as unknown. Because of + * this, in logicalrep_rel_open the cache entry state will be read from + * the system catalogue using GetSubscriptionRelState. + */ + hash_seq_init(&status, LogicalRepRelMap); + + while ((entry = (LogicalRepRelMapEntry *) hash_seq_search(&status)) != NULL) + entry->state = SUBREL_STATE_UNKNOWN; +} + /* * Initialize the relation map cache. */ diff --git a/src/backend/replication/logical/tablesync.c b/src/backend/replication/logical/tablesync.c index 863d196fd7..6b29173a5c 100644 --- a/src/backend/replication/logical/tablesync.c +++ b/src/backend/replication/logical/tablesync.c @@ -257,6 +257,9 @@ void invalidate_syncing_table_states(Datum arg, int cacheid, uint32 hashvalue) { table_states_valid = false; + + /* Invalidate relation map cache. */ + logicalrep_relmap_invalidate(); } /* diff --git a/src/backend/replication/logical/worker.c b/src/backend/replication/logical/worker.c index f2b2549a51..347264e4a8 100644 --- a/src/backend/replication/logical/worker.c +++ b/src/backend/replication/logical/worker.c @@ -2487,6 +2487,9 @@ static void subscription_change_cb(Datum arg, int cacheid, uint32 hashvalue) { MySubscriptionValid = false; + + /* Invalidate relation map cache. */ + logicalrep_relmap_invalidate(); } /* diff --git a/src/include/replication/logicalrelation.h b/src/include/replication/logicalrelation.h index 3f0b3deefb..f5e70b75b0 100644 --- a/src/include/replication/logicalrelation.h +++ b/src/include/replication/logicalrelation.h @@ -49,4 +49,5 @@ extern void logicalrep_rel_close(LogicalRepRelMapEntry *rel, extern void logicalrep_typmap_update(LogicalRepTyp *remotetyp); extern char *logicalrep_typmap_gettypname(Oid remoteid); +extern void logicalrep_relmap_invalidate(void); #endif /* LOGICALRELATION_H */ -- 2.30.0 --=-=-=-- ^ permalink raw reply [nested|flat] 22+ messages in thread
* [PATCH v3 2/2] Invalidate relation map cache in subscriber syscache invalidation callbacks @ 2021-01-13 11:53 Bharath Rupireddy <[email protected]> 0 siblings, 0 replies; 22+ messages in thread From: Bharath Rupireddy @ 2021-01-13 11:53 UTC (permalink / raw) Currently, in logical replication, relation map cache in the subscriber is not getting invalidated when anything changes in pg_subscription_rel or pg_subscription catalogues. So we end up not reading the latest system catalogues always in logicalrep_rel_open using GetSubscriptionRelState. To fix this, invalidate the relation map cache entries in invalidate_syncing_table_states and subscription_change_cb which are invalidation callbacks for pg_subscription_rel and pg_subscription catalogues respectively. --- src/backend/replication/logical/relation.c | 26 +++++++++++++++++++++ src/backend/replication/logical/tablesync.c | 3 +++ src/backend/replication/logical/worker.c | 3 +++ src/include/replication/logicalrelation.h | 1 + 4 files changed, 33 insertions(+) diff --git a/src/backend/replication/logical/relation.c b/src/backend/replication/logical/relation.c index e861c0ff80..88ac772444 100644 --- a/src/backend/replication/logical/relation.c +++ b/src/backend/replication/logical/relation.c @@ -96,6 +96,32 @@ logicalrep_relmap_invalidate_cb(Datum arg, Oid reloid) } } +/* + * Invalidate relation map cache whenever syscache of pg_subscription_rel or + * pg_subscription gets changed. + */ +void +logicalrep_relmap_invalidate(void) +{ + LogicalRepRelMapEntry *entry; + HASH_SEQ_STATUS status; + + /* Just to be sure. */ + if (LogicalRepRelMap == NULL) + return; + + /* + * There is no way to find the cache entry for which the syscache has been + * changed, so we mark all the cache entries state as unknown. Because of + * this, in logicalrep_rel_open the cache entry state will be read from + * the system catalogue using GetSubscriptionRelState. + */ + hash_seq_init(&status, LogicalRepRelMap); + + while ((entry = (LogicalRepRelMapEntry *) hash_seq_search(&status)) != NULL) + entry->state = SUBREL_STATE_UNKNOWN; +} + /* * Initialize the relation map cache. */ diff --git a/src/backend/replication/logical/tablesync.c b/src/backend/replication/logical/tablesync.c index 863d196fd7..6b29173a5c 100644 --- a/src/backend/replication/logical/tablesync.c +++ b/src/backend/replication/logical/tablesync.c @@ -257,6 +257,9 @@ void invalidate_syncing_table_states(Datum arg, int cacheid, uint32 hashvalue) { table_states_valid = false; + + /* Invalidate relation map cache. */ + logicalrep_relmap_invalidate(); } /* diff --git a/src/backend/replication/logical/worker.c b/src/backend/replication/logical/worker.c index f2b2549a51..347264e4a8 100644 --- a/src/backend/replication/logical/worker.c +++ b/src/backend/replication/logical/worker.c @@ -2487,6 +2487,9 @@ static void subscription_change_cb(Datum arg, int cacheid, uint32 hashvalue) { MySubscriptionValid = false; + + /* Invalidate relation map cache. */ + logicalrep_relmap_invalidate(); } /* diff --git a/src/include/replication/logicalrelation.h b/src/include/replication/logicalrelation.h index 3f0b3deefb..f5e70b75b0 100644 --- a/src/include/replication/logicalrelation.h +++ b/src/include/replication/logicalrelation.h @@ -49,4 +49,5 @@ extern void logicalrep_rel_close(LogicalRepRelMapEntry *rel, extern void logicalrep_typmap_update(LogicalRepTyp *remotetyp); extern char *logicalrep_typmap_gettypname(Oid remoteid); +extern void logicalrep_relmap_invalidate(void); #endif /* LOGICALRELATION_H */ -- 2.30.0 --=-=-=-- ^ permalink raw reply [nested|flat] 22+ messages in thread
* [PATCH v3 2/2] Invalidate relation map cache in subscriber syscache invalidation callbacks @ 2021-01-13 11:53 Bharath Rupireddy <[email protected]> 0 siblings, 0 replies; 22+ messages in thread From: Bharath Rupireddy @ 2021-01-13 11:53 UTC (permalink / raw) Currently, in logical replication, relation map cache in the subscriber is not getting invalidated when anything changes in pg_subscription_rel or pg_subscription catalogues. So we end up not reading the latest system catalogues always in logicalrep_rel_open using GetSubscriptionRelState. To fix this, invalidate the relation map cache entries in invalidate_syncing_table_states and subscription_change_cb which are invalidation callbacks for pg_subscription_rel and pg_subscription catalogues respectively. --- src/backend/replication/logical/relation.c | 26 +++++++++++++++++++++ src/backend/replication/logical/tablesync.c | 3 +++ src/backend/replication/logical/worker.c | 3 +++ src/include/replication/logicalrelation.h | 1 + 4 files changed, 33 insertions(+) diff --git a/src/backend/replication/logical/relation.c b/src/backend/replication/logical/relation.c index e861c0ff80..88ac772444 100644 --- a/src/backend/replication/logical/relation.c +++ b/src/backend/replication/logical/relation.c @@ -96,6 +96,32 @@ logicalrep_relmap_invalidate_cb(Datum arg, Oid reloid) } } +/* + * Invalidate relation map cache whenever syscache of pg_subscription_rel or + * pg_subscription gets changed. + */ +void +logicalrep_relmap_invalidate(void) +{ + LogicalRepRelMapEntry *entry; + HASH_SEQ_STATUS status; + + /* Just to be sure. */ + if (LogicalRepRelMap == NULL) + return; + + /* + * There is no way to find the cache entry for which the syscache has been + * changed, so we mark all the cache entries state as unknown. Because of + * this, in logicalrep_rel_open the cache entry state will be read from + * the system catalogue using GetSubscriptionRelState. + */ + hash_seq_init(&status, LogicalRepRelMap); + + while ((entry = (LogicalRepRelMapEntry *) hash_seq_search(&status)) != NULL) + entry->state = SUBREL_STATE_UNKNOWN; +} + /* * Initialize the relation map cache. */ diff --git a/src/backend/replication/logical/tablesync.c b/src/backend/replication/logical/tablesync.c index 863d196fd7..6b29173a5c 100644 --- a/src/backend/replication/logical/tablesync.c +++ b/src/backend/replication/logical/tablesync.c @@ -257,6 +257,9 @@ void invalidate_syncing_table_states(Datum arg, int cacheid, uint32 hashvalue) { table_states_valid = false; + + /* Invalidate relation map cache. */ + logicalrep_relmap_invalidate(); } /* diff --git a/src/backend/replication/logical/worker.c b/src/backend/replication/logical/worker.c index f2b2549a51..347264e4a8 100644 --- a/src/backend/replication/logical/worker.c +++ b/src/backend/replication/logical/worker.c @@ -2487,6 +2487,9 @@ static void subscription_change_cb(Datum arg, int cacheid, uint32 hashvalue) { MySubscriptionValid = false; + + /* Invalidate relation map cache. */ + logicalrep_relmap_invalidate(); } /* diff --git a/src/include/replication/logicalrelation.h b/src/include/replication/logicalrelation.h index 3f0b3deefb..f5e70b75b0 100644 --- a/src/include/replication/logicalrelation.h +++ b/src/include/replication/logicalrelation.h @@ -49,4 +49,5 @@ extern void logicalrep_rel_close(LogicalRepRelMapEntry *rel, extern void logicalrep_typmap_update(LogicalRepTyp *remotetyp); extern char *logicalrep_typmap_gettypname(Oid remoteid); +extern void logicalrep_relmap_invalidate(void); #endif /* LOGICALRELATION_H */ -- 2.30.0 --=-=-=-- ^ permalink raw reply [nested|flat] 22+ messages in thread
* [PATCH v3 2/2] Invalidate relation map cache in subscriber syscache invalidation callbacks @ 2021-01-13 11:53 Bharath Rupireddy <[email protected]> 0 siblings, 0 replies; 22+ messages in thread From: Bharath Rupireddy @ 2021-01-13 11:53 UTC (permalink / raw) Currently, in logical replication, relation map cache in the subscriber is not getting invalidated when anything changes in pg_subscription_rel or pg_subscription catalogues. So we end up not reading the latest system catalogues always in logicalrep_rel_open using GetSubscriptionRelState. To fix this, invalidate the relation map cache entries in invalidate_syncing_table_states and subscription_change_cb which are invalidation callbacks for pg_subscription_rel and pg_subscription catalogues respectively. --- src/backend/replication/logical/relation.c | 26 +++++++++++++++++++++ src/backend/replication/logical/tablesync.c | 3 +++ src/backend/replication/logical/worker.c | 3 +++ src/include/replication/logicalrelation.h | 1 + 4 files changed, 33 insertions(+) diff --git a/src/backend/replication/logical/relation.c b/src/backend/replication/logical/relation.c index e861c0ff80..88ac772444 100644 --- a/src/backend/replication/logical/relation.c +++ b/src/backend/replication/logical/relation.c @@ -96,6 +96,32 @@ logicalrep_relmap_invalidate_cb(Datum arg, Oid reloid) } } +/* + * Invalidate relation map cache whenever syscache of pg_subscription_rel or + * pg_subscription gets changed. + */ +void +logicalrep_relmap_invalidate(void) +{ + LogicalRepRelMapEntry *entry; + HASH_SEQ_STATUS status; + + /* Just to be sure. */ + if (LogicalRepRelMap == NULL) + return; + + /* + * There is no way to find the cache entry for which the syscache has been + * changed, so we mark all the cache entries state as unknown. Because of + * this, in logicalrep_rel_open the cache entry state will be read from + * the system catalogue using GetSubscriptionRelState. + */ + hash_seq_init(&status, LogicalRepRelMap); + + while ((entry = (LogicalRepRelMapEntry *) hash_seq_search(&status)) != NULL) + entry->state = SUBREL_STATE_UNKNOWN; +} + /* * Initialize the relation map cache. */ diff --git a/src/backend/replication/logical/tablesync.c b/src/backend/replication/logical/tablesync.c index 863d196fd7..6b29173a5c 100644 --- a/src/backend/replication/logical/tablesync.c +++ b/src/backend/replication/logical/tablesync.c @@ -257,6 +257,9 @@ void invalidate_syncing_table_states(Datum arg, int cacheid, uint32 hashvalue) { table_states_valid = false; + + /* Invalidate relation map cache. */ + logicalrep_relmap_invalidate(); } /* diff --git a/src/backend/replication/logical/worker.c b/src/backend/replication/logical/worker.c index f2b2549a51..347264e4a8 100644 --- a/src/backend/replication/logical/worker.c +++ b/src/backend/replication/logical/worker.c @@ -2487,6 +2487,9 @@ static void subscription_change_cb(Datum arg, int cacheid, uint32 hashvalue) { MySubscriptionValid = false; + + /* Invalidate relation map cache. */ + logicalrep_relmap_invalidate(); } /* diff --git a/src/include/replication/logicalrelation.h b/src/include/replication/logicalrelation.h index 3f0b3deefb..f5e70b75b0 100644 --- a/src/include/replication/logicalrelation.h +++ b/src/include/replication/logicalrelation.h @@ -49,4 +49,5 @@ extern void logicalrep_rel_close(LogicalRepRelMapEntry *rel, extern void logicalrep_typmap_update(LogicalRepTyp *remotetyp); extern char *logicalrep_typmap_gettypname(Oid remoteid); +extern void logicalrep_relmap_invalidate(void); #endif /* LOGICALRELATION_H */ -- 2.30.0 --=-=-=-- ^ permalink raw reply [nested|flat] 22+ messages in thread
* [PATCH v3 2/2] Invalidate relation map cache in subscriber syscache invalidation callbacks @ 2021-01-13 11:53 Bharath Rupireddy <[email protected]> 0 siblings, 0 replies; 22+ messages in thread From: Bharath Rupireddy @ 2021-01-13 11:53 UTC (permalink / raw) Currently, in logical replication, relation map cache in the subscriber is not getting invalidated when anything changes in pg_subscription_rel or pg_subscription catalogues. So we end up not reading the latest system catalogues always in logicalrep_rel_open using GetSubscriptionRelState. To fix this, invalidate the relation map cache entries in invalidate_syncing_table_states and subscription_change_cb which are invalidation callbacks for pg_subscription_rel and pg_subscription catalogues respectively. --- src/backend/replication/logical/relation.c | 26 +++++++++++++++++++++ src/backend/replication/logical/tablesync.c | 3 +++ src/backend/replication/logical/worker.c | 3 +++ src/include/replication/logicalrelation.h | 1 + 4 files changed, 33 insertions(+) diff --git a/src/backend/replication/logical/relation.c b/src/backend/replication/logical/relation.c index e861c0ff80..88ac772444 100644 --- a/src/backend/replication/logical/relation.c +++ b/src/backend/replication/logical/relation.c @@ -96,6 +96,32 @@ logicalrep_relmap_invalidate_cb(Datum arg, Oid reloid) } } +/* + * Invalidate relation map cache whenever syscache of pg_subscription_rel or + * pg_subscription gets changed. + */ +void +logicalrep_relmap_invalidate(void) +{ + LogicalRepRelMapEntry *entry; + HASH_SEQ_STATUS status; + + /* Just to be sure. */ + if (LogicalRepRelMap == NULL) + return; + + /* + * There is no way to find the cache entry for which the syscache has been + * changed, so we mark all the cache entries state as unknown. Because of + * this, in logicalrep_rel_open the cache entry state will be read from + * the system catalogue using GetSubscriptionRelState. + */ + hash_seq_init(&status, LogicalRepRelMap); + + while ((entry = (LogicalRepRelMapEntry *) hash_seq_search(&status)) != NULL) + entry->state = SUBREL_STATE_UNKNOWN; +} + /* * Initialize the relation map cache. */ diff --git a/src/backend/replication/logical/tablesync.c b/src/backend/replication/logical/tablesync.c index 863d196fd7..6b29173a5c 100644 --- a/src/backend/replication/logical/tablesync.c +++ b/src/backend/replication/logical/tablesync.c @@ -257,6 +257,9 @@ void invalidate_syncing_table_states(Datum arg, int cacheid, uint32 hashvalue) { table_states_valid = false; + + /* Invalidate relation map cache. */ + logicalrep_relmap_invalidate(); } /* diff --git a/src/backend/replication/logical/worker.c b/src/backend/replication/logical/worker.c index f2b2549a51..347264e4a8 100644 --- a/src/backend/replication/logical/worker.c +++ b/src/backend/replication/logical/worker.c @@ -2487,6 +2487,9 @@ static void subscription_change_cb(Datum arg, int cacheid, uint32 hashvalue) { MySubscriptionValid = false; + + /* Invalidate relation map cache. */ + logicalrep_relmap_invalidate(); } /* diff --git a/src/include/replication/logicalrelation.h b/src/include/replication/logicalrelation.h index 3f0b3deefb..f5e70b75b0 100644 --- a/src/include/replication/logicalrelation.h +++ b/src/include/replication/logicalrelation.h @@ -49,4 +49,5 @@ extern void logicalrep_rel_close(LogicalRepRelMapEntry *rel, extern void logicalrep_typmap_update(LogicalRepTyp *remotetyp); extern char *logicalrep_typmap_gettypname(Oid remoteid); +extern void logicalrep_relmap_invalidate(void); #endif /* LOGICALRELATION_H */ -- 2.30.0 --=-=-=-- ^ permalink raw reply [nested|flat] 22+ messages in thread
* [PATCH v3 2/2] Invalidate relation map cache in subscriber syscache invalidation callbacks @ 2021-01-13 11:53 Bharath Rupireddy <[email protected]> 0 siblings, 0 replies; 22+ messages in thread From: Bharath Rupireddy @ 2021-01-13 11:53 UTC (permalink / raw) Currently, in logical replication, relation map cache in the subscriber is not getting invalidated when anything changes in pg_subscription_rel or pg_subscription catalogues. So we end up not reading the latest system catalogues always in logicalrep_rel_open using GetSubscriptionRelState. To fix this, invalidate the relation map cache entries in invalidate_syncing_table_states and subscription_change_cb which are invalidation callbacks for pg_subscription_rel and pg_subscription catalogues respectively. --- src/backend/replication/logical/relation.c | 26 +++++++++++++++++++++ src/backend/replication/logical/tablesync.c | 3 +++ src/backend/replication/logical/worker.c | 3 +++ src/include/replication/logicalrelation.h | 1 + 4 files changed, 33 insertions(+) diff --git a/src/backend/replication/logical/relation.c b/src/backend/replication/logical/relation.c index e861c0ff80..88ac772444 100644 --- a/src/backend/replication/logical/relation.c +++ b/src/backend/replication/logical/relation.c @@ -96,6 +96,32 @@ logicalrep_relmap_invalidate_cb(Datum arg, Oid reloid) } } +/* + * Invalidate relation map cache whenever syscache of pg_subscription_rel or + * pg_subscription gets changed. + */ +void +logicalrep_relmap_invalidate(void) +{ + LogicalRepRelMapEntry *entry; + HASH_SEQ_STATUS status; + + /* Just to be sure. */ + if (LogicalRepRelMap == NULL) + return; + + /* + * There is no way to find the cache entry for which the syscache has been + * changed, so we mark all the cache entries state as unknown. Because of + * this, in logicalrep_rel_open the cache entry state will be read from + * the system catalogue using GetSubscriptionRelState. + */ + hash_seq_init(&status, LogicalRepRelMap); + + while ((entry = (LogicalRepRelMapEntry *) hash_seq_search(&status)) != NULL) + entry->state = SUBREL_STATE_UNKNOWN; +} + /* * Initialize the relation map cache. */ diff --git a/src/backend/replication/logical/tablesync.c b/src/backend/replication/logical/tablesync.c index 863d196fd7..6b29173a5c 100644 --- a/src/backend/replication/logical/tablesync.c +++ b/src/backend/replication/logical/tablesync.c @@ -257,6 +257,9 @@ void invalidate_syncing_table_states(Datum arg, int cacheid, uint32 hashvalue) { table_states_valid = false; + + /* Invalidate relation map cache. */ + logicalrep_relmap_invalidate(); } /* diff --git a/src/backend/replication/logical/worker.c b/src/backend/replication/logical/worker.c index f2b2549a51..347264e4a8 100644 --- a/src/backend/replication/logical/worker.c +++ b/src/backend/replication/logical/worker.c @@ -2487,6 +2487,9 @@ static void subscription_change_cb(Datum arg, int cacheid, uint32 hashvalue) { MySubscriptionValid = false; + + /* Invalidate relation map cache. */ + logicalrep_relmap_invalidate(); } /* diff --git a/src/include/replication/logicalrelation.h b/src/include/replication/logicalrelation.h index 3f0b3deefb..f5e70b75b0 100644 --- a/src/include/replication/logicalrelation.h +++ b/src/include/replication/logicalrelation.h @@ -49,4 +49,5 @@ extern void logicalrep_rel_close(LogicalRepRelMapEntry *rel, extern void logicalrep_typmap_update(LogicalRepTyp *remotetyp); extern char *logicalrep_typmap_gettypname(Oid remoteid); +extern void logicalrep_relmap_invalidate(void); #endif /* LOGICALRELATION_H */ -- 2.30.0 --=-=-=-- ^ permalink raw reply [nested|flat] 22+ messages in thread
* [PATCH v3 2/2] Invalidate relation map cache in subscriber syscache invalidation callbacks @ 2021-01-13 11:53 Bharath Rupireddy <[email protected]> 0 siblings, 0 replies; 22+ messages in thread From: Bharath Rupireddy @ 2021-01-13 11:53 UTC (permalink / raw) Currently, in logical replication, relation map cache in the subscriber is not getting invalidated when anything changes in pg_subscription_rel or pg_subscription catalogues. So we end up not reading the latest system catalogues always in logicalrep_rel_open using GetSubscriptionRelState. To fix this, invalidate the relation map cache entries in invalidate_syncing_table_states and subscription_change_cb which are invalidation callbacks for pg_subscription_rel and pg_subscription catalogues respectively. --- src/backend/replication/logical/relation.c | 26 +++++++++++++++++++++ src/backend/replication/logical/tablesync.c | 3 +++ src/backend/replication/logical/worker.c | 3 +++ src/include/replication/logicalrelation.h | 1 + 4 files changed, 33 insertions(+) diff --git a/src/backend/replication/logical/relation.c b/src/backend/replication/logical/relation.c index e861c0ff80..88ac772444 100644 --- a/src/backend/replication/logical/relation.c +++ b/src/backend/replication/logical/relation.c @@ -96,6 +96,32 @@ logicalrep_relmap_invalidate_cb(Datum arg, Oid reloid) } } +/* + * Invalidate relation map cache whenever syscache of pg_subscription_rel or + * pg_subscription gets changed. + */ +void +logicalrep_relmap_invalidate(void) +{ + LogicalRepRelMapEntry *entry; + HASH_SEQ_STATUS status; + + /* Just to be sure. */ + if (LogicalRepRelMap == NULL) + return; + + /* + * There is no way to find the cache entry for which the syscache has been + * changed, so we mark all the cache entries state as unknown. Because of + * this, in logicalrep_rel_open the cache entry state will be read from + * the system catalogue using GetSubscriptionRelState. + */ + hash_seq_init(&status, LogicalRepRelMap); + + while ((entry = (LogicalRepRelMapEntry *) hash_seq_search(&status)) != NULL) + entry->state = SUBREL_STATE_UNKNOWN; +} + /* * Initialize the relation map cache. */ diff --git a/src/backend/replication/logical/tablesync.c b/src/backend/replication/logical/tablesync.c index 863d196fd7..6b29173a5c 100644 --- a/src/backend/replication/logical/tablesync.c +++ b/src/backend/replication/logical/tablesync.c @@ -257,6 +257,9 @@ void invalidate_syncing_table_states(Datum arg, int cacheid, uint32 hashvalue) { table_states_valid = false; + + /* Invalidate relation map cache. */ + logicalrep_relmap_invalidate(); } /* diff --git a/src/backend/replication/logical/worker.c b/src/backend/replication/logical/worker.c index f2b2549a51..347264e4a8 100644 --- a/src/backend/replication/logical/worker.c +++ b/src/backend/replication/logical/worker.c @@ -2487,6 +2487,9 @@ static void subscription_change_cb(Datum arg, int cacheid, uint32 hashvalue) { MySubscriptionValid = false; + + /* Invalidate relation map cache. */ + logicalrep_relmap_invalidate(); } /* diff --git a/src/include/replication/logicalrelation.h b/src/include/replication/logicalrelation.h index 3f0b3deefb..f5e70b75b0 100644 --- a/src/include/replication/logicalrelation.h +++ b/src/include/replication/logicalrelation.h @@ -49,4 +49,5 @@ extern void logicalrep_rel_close(LogicalRepRelMapEntry *rel, extern void logicalrep_typmap_update(LogicalRepTyp *remotetyp); extern char *logicalrep_typmap_gettypname(Oid remoteid); +extern void logicalrep_relmap_invalidate(void); #endif /* LOGICALRELATION_H */ -- 2.30.0 --=-=-=-- ^ permalink raw reply [nested|flat] 22+ messages in thread
* [PATCH v3 2/2] Invalidate relation map cache in subscriber syscache invalidation callbacks @ 2021-01-13 11:53 Bharath Rupireddy <[email protected]> 0 siblings, 0 replies; 22+ messages in thread From: Bharath Rupireddy @ 2021-01-13 11:53 UTC (permalink / raw) Currently, in logical replication, relation map cache in the subscriber is not getting invalidated when anything changes in pg_subscription_rel or pg_subscription catalogues. So we end up not reading the latest system catalogues always in logicalrep_rel_open using GetSubscriptionRelState. To fix this, invalidate the relation map cache entries in invalidate_syncing_table_states and subscription_change_cb which are invalidation callbacks for pg_subscription_rel and pg_subscription catalogues respectively. --- src/backend/replication/logical/relation.c | 26 +++++++++++++++++++++ src/backend/replication/logical/tablesync.c | 3 +++ src/backend/replication/logical/worker.c | 3 +++ src/include/replication/logicalrelation.h | 1 + 4 files changed, 33 insertions(+) diff --git a/src/backend/replication/logical/relation.c b/src/backend/replication/logical/relation.c index e861c0ff80..88ac772444 100644 --- a/src/backend/replication/logical/relation.c +++ b/src/backend/replication/logical/relation.c @@ -96,6 +96,32 @@ logicalrep_relmap_invalidate_cb(Datum arg, Oid reloid) } } +/* + * Invalidate relation map cache whenever syscache of pg_subscription_rel or + * pg_subscription gets changed. + */ +void +logicalrep_relmap_invalidate(void) +{ + LogicalRepRelMapEntry *entry; + HASH_SEQ_STATUS status; + + /* Just to be sure. */ + if (LogicalRepRelMap == NULL) + return; + + /* + * There is no way to find the cache entry for which the syscache has been + * changed, so we mark all the cache entries state as unknown. Because of + * this, in logicalrep_rel_open the cache entry state will be read from + * the system catalogue using GetSubscriptionRelState. + */ + hash_seq_init(&status, LogicalRepRelMap); + + while ((entry = (LogicalRepRelMapEntry *) hash_seq_search(&status)) != NULL) + entry->state = SUBREL_STATE_UNKNOWN; +} + /* * Initialize the relation map cache. */ diff --git a/src/backend/replication/logical/tablesync.c b/src/backend/replication/logical/tablesync.c index 863d196fd7..6b29173a5c 100644 --- a/src/backend/replication/logical/tablesync.c +++ b/src/backend/replication/logical/tablesync.c @@ -257,6 +257,9 @@ void invalidate_syncing_table_states(Datum arg, int cacheid, uint32 hashvalue) { table_states_valid = false; + + /* Invalidate relation map cache. */ + logicalrep_relmap_invalidate(); } /* diff --git a/src/backend/replication/logical/worker.c b/src/backend/replication/logical/worker.c index f2b2549a51..347264e4a8 100644 --- a/src/backend/replication/logical/worker.c +++ b/src/backend/replication/logical/worker.c @@ -2487,6 +2487,9 @@ static void subscription_change_cb(Datum arg, int cacheid, uint32 hashvalue) { MySubscriptionValid = false; + + /* Invalidate relation map cache. */ + logicalrep_relmap_invalidate(); } /* diff --git a/src/include/replication/logicalrelation.h b/src/include/replication/logicalrelation.h index 3f0b3deefb..f5e70b75b0 100644 --- a/src/include/replication/logicalrelation.h +++ b/src/include/replication/logicalrelation.h @@ -49,4 +49,5 @@ extern void logicalrep_rel_close(LogicalRepRelMapEntry *rel, extern void logicalrep_typmap_update(LogicalRepTyp *remotetyp); extern char *logicalrep_typmap_gettypname(Oid remoteid); +extern void logicalrep_relmap_invalidate(void); #endif /* LOGICALRELATION_H */ -- 2.30.0 --=-=-=-- ^ permalink raw reply [nested|flat] 22+ messages in thread
* [PATCH v3 2/2] Invalidate relation map cache in subscriber syscache invalidation callbacks @ 2021-01-13 11:53 Bharath Rupireddy <[email protected]> 0 siblings, 0 replies; 22+ messages in thread From: Bharath Rupireddy @ 2021-01-13 11:53 UTC (permalink / raw) Currently, in logical replication, relation map cache in the subscriber is not getting invalidated when anything changes in pg_subscription_rel or pg_subscription catalogues. So we end up not reading the latest system catalogues always in logicalrep_rel_open using GetSubscriptionRelState. To fix this, invalidate the relation map cache entries in invalidate_syncing_table_states and subscription_change_cb which are invalidation callbacks for pg_subscription_rel and pg_subscription catalogues respectively. --- src/backend/replication/logical/relation.c | 26 +++++++++++++++++++++ src/backend/replication/logical/tablesync.c | 3 +++ src/backend/replication/logical/worker.c | 3 +++ src/include/replication/logicalrelation.h | 1 + 4 files changed, 33 insertions(+) diff --git a/src/backend/replication/logical/relation.c b/src/backend/replication/logical/relation.c index e861c0ff80..88ac772444 100644 --- a/src/backend/replication/logical/relation.c +++ b/src/backend/replication/logical/relation.c @@ -96,6 +96,32 @@ logicalrep_relmap_invalidate_cb(Datum arg, Oid reloid) } } +/* + * Invalidate relation map cache whenever syscache of pg_subscription_rel or + * pg_subscription gets changed. + */ +void +logicalrep_relmap_invalidate(void) +{ + LogicalRepRelMapEntry *entry; + HASH_SEQ_STATUS status; + + /* Just to be sure. */ + if (LogicalRepRelMap == NULL) + return; + + /* + * There is no way to find the cache entry for which the syscache has been + * changed, so we mark all the cache entries state as unknown. Because of + * this, in logicalrep_rel_open the cache entry state will be read from + * the system catalogue using GetSubscriptionRelState. + */ + hash_seq_init(&status, LogicalRepRelMap); + + while ((entry = (LogicalRepRelMapEntry *) hash_seq_search(&status)) != NULL) + entry->state = SUBREL_STATE_UNKNOWN; +} + /* * Initialize the relation map cache. */ diff --git a/src/backend/replication/logical/tablesync.c b/src/backend/replication/logical/tablesync.c index 863d196fd7..6b29173a5c 100644 --- a/src/backend/replication/logical/tablesync.c +++ b/src/backend/replication/logical/tablesync.c @@ -257,6 +257,9 @@ void invalidate_syncing_table_states(Datum arg, int cacheid, uint32 hashvalue) { table_states_valid = false; + + /* Invalidate relation map cache. */ + logicalrep_relmap_invalidate(); } /* diff --git a/src/backend/replication/logical/worker.c b/src/backend/replication/logical/worker.c index f2b2549a51..347264e4a8 100644 --- a/src/backend/replication/logical/worker.c +++ b/src/backend/replication/logical/worker.c @@ -2487,6 +2487,9 @@ static void subscription_change_cb(Datum arg, int cacheid, uint32 hashvalue) { MySubscriptionValid = false; + + /* Invalidate relation map cache. */ + logicalrep_relmap_invalidate(); } /* diff --git a/src/include/replication/logicalrelation.h b/src/include/replication/logicalrelation.h index 3f0b3deefb..f5e70b75b0 100644 --- a/src/include/replication/logicalrelation.h +++ b/src/include/replication/logicalrelation.h @@ -49,4 +49,5 @@ extern void logicalrep_rel_close(LogicalRepRelMapEntry *rel, extern void logicalrep_typmap_update(LogicalRepTyp *remotetyp); extern char *logicalrep_typmap_gettypname(Oid remoteid); +extern void logicalrep_relmap_invalidate(void); #endif /* LOGICALRELATION_H */ -- 2.30.0 --=-=-=-- ^ permalink raw reply [nested|flat] 22+ messages in thread
* [PATCH v3 2/2] Invalidate relation map cache in subscriber syscache invalidation callbacks @ 2021-01-13 11:53 Bharath Rupireddy <[email protected]> 0 siblings, 0 replies; 22+ messages in thread From: Bharath Rupireddy @ 2021-01-13 11:53 UTC (permalink / raw) Currently, in logical replication, relation map cache in the subscriber is not getting invalidated when anything changes in pg_subscription_rel or pg_subscription catalogues. So we end up not reading the latest system catalogues always in logicalrep_rel_open using GetSubscriptionRelState. To fix this, invalidate the relation map cache entries in invalidate_syncing_table_states and subscription_change_cb which are invalidation callbacks for pg_subscription_rel and pg_subscription catalogues respectively. --- src/backend/replication/logical/relation.c | 26 +++++++++++++++++++++ src/backend/replication/logical/tablesync.c | 3 +++ src/backend/replication/logical/worker.c | 3 +++ src/include/replication/logicalrelation.h | 1 + 4 files changed, 33 insertions(+) diff --git a/src/backend/replication/logical/relation.c b/src/backend/replication/logical/relation.c index e861c0ff80..88ac772444 100644 --- a/src/backend/replication/logical/relation.c +++ b/src/backend/replication/logical/relation.c @@ -96,6 +96,32 @@ logicalrep_relmap_invalidate_cb(Datum arg, Oid reloid) } } +/* + * Invalidate relation map cache whenever syscache of pg_subscription_rel or + * pg_subscription gets changed. + */ +void +logicalrep_relmap_invalidate(void) +{ + LogicalRepRelMapEntry *entry; + HASH_SEQ_STATUS status; + + /* Just to be sure. */ + if (LogicalRepRelMap == NULL) + return; + + /* + * There is no way to find the cache entry for which the syscache has been + * changed, so we mark all the cache entries state as unknown. Because of + * this, in logicalrep_rel_open the cache entry state will be read from + * the system catalogue using GetSubscriptionRelState. + */ + hash_seq_init(&status, LogicalRepRelMap); + + while ((entry = (LogicalRepRelMapEntry *) hash_seq_search(&status)) != NULL) + entry->state = SUBREL_STATE_UNKNOWN; +} + /* * Initialize the relation map cache. */ diff --git a/src/backend/replication/logical/tablesync.c b/src/backend/replication/logical/tablesync.c index 863d196fd7..6b29173a5c 100644 --- a/src/backend/replication/logical/tablesync.c +++ b/src/backend/replication/logical/tablesync.c @@ -257,6 +257,9 @@ void invalidate_syncing_table_states(Datum arg, int cacheid, uint32 hashvalue) { table_states_valid = false; + + /* Invalidate relation map cache. */ + logicalrep_relmap_invalidate(); } /* diff --git a/src/backend/replication/logical/worker.c b/src/backend/replication/logical/worker.c index f2b2549a51..347264e4a8 100644 --- a/src/backend/replication/logical/worker.c +++ b/src/backend/replication/logical/worker.c @@ -2487,6 +2487,9 @@ static void subscription_change_cb(Datum arg, int cacheid, uint32 hashvalue) { MySubscriptionValid = false; + + /* Invalidate relation map cache. */ + logicalrep_relmap_invalidate(); } /* diff --git a/src/include/replication/logicalrelation.h b/src/include/replication/logicalrelation.h index 3f0b3deefb..f5e70b75b0 100644 --- a/src/include/replication/logicalrelation.h +++ b/src/include/replication/logicalrelation.h @@ -49,4 +49,5 @@ extern void logicalrep_rel_close(LogicalRepRelMapEntry *rel, extern void logicalrep_typmap_update(LogicalRepTyp *remotetyp); extern char *logicalrep_typmap_gettypname(Oid remoteid); +extern void logicalrep_relmap_invalidate(void); #endif /* LOGICALRELATION_H */ -- 2.30.0 --=-=-=-- ^ permalink raw reply [nested|flat] 22+ messages in thread
* [PATCH v3 2/2] Invalidate relation map cache in subscriber syscache invalidation callbacks @ 2021-01-13 11:53 Bharath Rupireddy <[email protected]> 0 siblings, 0 replies; 22+ messages in thread From: Bharath Rupireddy @ 2021-01-13 11:53 UTC (permalink / raw) Currently, in logical replication, relation map cache in the subscriber is not getting invalidated when anything changes in pg_subscription_rel or pg_subscription catalogues. So we end up not reading the latest system catalogues always in logicalrep_rel_open using GetSubscriptionRelState. To fix this, invalidate the relation map cache entries in invalidate_syncing_table_states and subscription_change_cb which are invalidation callbacks for pg_subscription_rel and pg_subscription catalogues respectively. --- src/backend/replication/logical/relation.c | 26 +++++++++++++++++++++ src/backend/replication/logical/tablesync.c | 3 +++ src/backend/replication/logical/worker.c | 3 +++ src/include/replication/logicalrelation.h | 1 + 4 files changed, 33 insertions(+) diff --git a/src/backend/replication/logical/relation.c b/src/backend/replication/logical/relation.c index e861c0ff80..88ac772444 100644 --- a/src/backend/replication/logical/relation.c +++ b/src/backend/replication/logical/relation.c @@ -96,6 +96,32 @@ logicalrep_relmap_invalidate_cb(Datum arg, Oid reloid) } } +/* + * Invalidate relation map cache whenever syscache of pg_subscription_rel or + * pg_subscription gets changed. + */ +void +logicalrep_relmap_invalidate(void) +{ + LogicalRepRelMapEntry *entry; + HASH_SEQ_STATUS status; + + /* Just to be sure. */ + if (LogicalRepRelMap == NULL) + return; + + /* + * There is no way to find the cache entry for which the syscache has been + * changed, so we mark all the cache entries state as unknown. Because of + * this, in logicalrep_rel_open the cache entry state will be read from + * the system catalogue using GetSubscriptionRelState. + */ + hash_seq_init(&status, LogicalRepRelMap); + + while ((entry = (LogicalRepRelMapEntry *) hash_seq_search(&status)) != NULL) + entry->state = SUBREL_STATE_UNKNOWN; +} + /* * Initialize the relation map cache. */ diff --git a/src/backend/replication/logical/tablesync.c b/src/backend/replication/logical/tablesync.c index 863d196fd7..6b29173a5c 100644 --- a/src/backend/replication/logical/tablesync.c +++ b/src/backend/replication/logical/tablesync.c @@ -257,6 +257,9 @@ void invalidate_syncing_table_states(Datum arg, int cacheid, uint32 hashvalue) { table_states_valid = false; + + /* Invalidate relation map cache. */ + logicalrep_relmap_invalidate(); } /* diff --git a/src/backend/replication/logical/worker.c b/src/backend/replication/logical/worker.c index f2b2549a51..347264e4a8 100644 --- a/src/backend/replication/logical/worker.c +++ b/src/backend/replication/logical/worker.c @@ -2487,6 +2487,9 @@ static void subscription_change_cb(Datum arg, int cacheid, uint32 hashvalue) { MySubscriptionValid = false; + + /* Invalidate relation map cache. */ + logicalrep_relmap_invalidate(); } /* diff --git a/src/include/replication/logicalrelation.h b/src/include/replication/logicalrelation.h index 3f0b3deefb..f5e70b75b0 100644 --- a/src/include/replication/logicalrelation.h +++ b/src/include/replication/logicalrelation.h @@ -49,4 +49,5 @@ extern void logicalrep_rel_close(LogicalRepRelMapEntry *rel, extern void logicalrep_typmap_update(LogicalRepTyp *remotetyp); extern char *logicalrep_typmap_gettypname(Oid remoteid); +extern void logicalrep_relmap_invalidate(void); #endif /* LOGICALRELATION_H */ -- 2.30.0 --=-=-=-- ^ permalink raw reply [nested|flat] 22+ messages in thread
* [PATCH v3 2/2] Invalidate relation map cache in subscriber syscache invalidation callbacks @ 2021-01-13 11:53 Bharath Rupireddy <[email protected]> 0 siblings, 0 replies; 22+ messages in thread From: Bharath Rupireddy @ 2021-01-13 11:53 UTC (permalink / raw) Currently, in logical replication, relation map cache in the subscriber is not getting invalidated when anything changes in pg_subscription_rel or pg_subscription catalogues. So we end up not reading the latest system catalogues always in logicalrep_rel_open using GetSubscriptionRelState. To fix this, invalidate the relation map cache entries in invalidate_syncing_table_states and subscription_change_cb which are invalidation callbacks for pg_subscription_rel and pg_subscription catalogues respectively. --- src/backend/replication/logical/relation.c | 26 +++++++++++++++++++++ src/backend/replication/logical/tablesync.c | 3 +++ src/backend/replication/logical/worker.c | 3 +++ src/include/replication/logicalrelation.h | 1 + 4 files changed, 33 insertions(+) diff --git a/src/backend/replication/logical/relation.c b/src/backend/replication/logical/relation.c index e861c0ff80..88ac772444 100644 --- a/src/backend/replication/logical/relation.c +++ b/src/backend/replication/logical/relation.c @@ -96,6 +96,32 @@ logicalrep_relmap_invalidate_cb(Datum arg, Oid reloid) } } +/* + * Invalidate relation map cache whenever syscache of pg_subscription_rel or + * pg_subscription gets changed. + */ +void +logicalrep_relmap_invalidate(void) +{ + LogicalRepRelMapEntry *entry; + HASH_SEQ_STATUS status; + + /* Just to be sure. */ + if (LogicalRepRelMap == NULL) + return; + + /* + * There is no way to find the cache entry for which the syscache has been + * changed, so we mark all the cache entries state as unknown. Because of + * this, in logicalrep_rel_open the cache entry state will be read from + * the system catalogue using GetSubscriptionRelState. + */ + hash_seq_init(&status, LogicalRepRelMap); + + while ((entry = (LogicalRepRelMapEntry *) hash_seq_search(&status)) != NULL) + entry->state = SUBREL_STATE_UNKNOWN; +} + /* * Initialize the relation map cache. */ diff --git a/src/backend/replication/logical/tablesync.c b/src/backend/replication/logical/tablesync.c index 863d196fd7..6b29173a5c 100644 --- a/src/backend/replication/logical/tablesync.c +++ b/src/backend/replication/logical/tablesync.c @@ -257,6 +257,9 @@ void invalidate_syncing_table_states(Datum arg, int cacheid, uint32 hashvalue) { table_states_valid = false; + + /* Invalidate relation map cache. */ + logicalrep_relmap_invalidate(); } /* diff --git a/src/backend/replication/logical/worker.c b/src/backend/replication/logical/worker.c index f2b2549a51..347264e4a8 100644 --- a/src/backend/replication/logical/worker.c +++ b/src/backend/replication/logical/worker.c @@ -2487,6 +2487,9 @@ static void subscription_change_cb(Datum arg, int cacheid, uint32 hashvalue) { MySubscriptionValid = false; + + /* Invalidate relation map cache. */ + logicalrep_relmap_invalidate(); } /* diff --git a/src/include/replication/logicalrelation.h b/src/include/replication/logicalrelation.h index 3f0b3deefb..f5e70b75b0 100644 --- a/src/include/replication/logicalrelation.h +++ b/src/include/replication/logicalrelation.h @@ -49,4 +49,5 @@ extern void logicalrep_rel_close(LogicalRepRelMapEntry *rel, extern void logicalrep_typmap_update(LogicalRepTyp *remotetyp); extern char *logicalrep_typmap_gettypname(Oid remoteid); +extern void logicalrep_relmap_invalidate(void); #endif /* LOGICALRELATION_H */ -- 2.30.0 --=-=-=-- ^ permalink raw reply [nested|flat] 22+ messages in thread
* [PATCH v3 2/2] Invalidate relation map cache in subscriber syscache invalidation callbacks @ 2021-01-13 11:53 Bharath Rupireddy <[email protected]> 0 siblings, 0 replies; 22+ messages in thread From: Bharath Rupireddy @ 2021-01-13 11:53 UTC (permalink / raw) Currently, in logical replication, relation map cache in the subscriber is not getting invalidated when anything changes in pg_subscription_rel or pg_subscription catalogues. So we end up not reading the latest system catalogues always in logicalrep_rel_open using GetSubscriptionRelState. To fix this, invalidate the relation map cache entries in invalidate_syncing_table_states and subscription_change_cb which are invalidation callbacks for pg_subscription_rel and pg_subscription catalogues respectively. --- src/backend/replication/logical/relation.c | 26 +++++++++++++++++++++ src/backend/replication/logical/tablesync.c | 3 +++ src/backend/replication/logical/worker.c | 3 +++ src/include/replication/logicalrelation.h | 1 + 4 files changed, 33 insertions(+) diff --git a/src/backend/replication/logical/relation.c b/src/backend/replication/logical/relation.c index e861c0ff80..88ac772444 100644 --- a/src/backend/replication/logical/relation.c +++ b/src/backend/replication/logical/relation.c @@ -96,6 +96,32 @@ logicalrep_relmap_invalidate_cb(Datum arg, Oid reloid) } } +/* + * Invalidate relation map cache whenever syscache of pg_subscription_rel or + * pg_subscription gets changed. + */ +void +logicalrep_relmap_invalidate(void) +{ + LogicalRepRelMapEntry *entry; + HASH_SEQ_STATUS status; + + /* Just to be sure. */ + if (LogicalRepRelMap == NULL) + return; + + /* + * There is no way to find the cache entry for which the syscache has been + * changed, so we mark all the cache entries state as unknown. Because of + * this, in logicalrep_rel_open the cache entry state will be read from + * the system catalogue using GetSubscriptionRelState. + */ + hash_seq_init(&status, LogicalRepRelMap); + + while ((entry = (LogicalRepRelMapEntry *) hash_seq_search(&status)) != NULL) + entry->state = SUBREL_STATE_UNKNOWN; +} + /* * Initialize the relation map cache. */ diff --git a/src/backend/replication/logical/tablesync.c b/src/backend/replication/logical/tablesync.c index 863d196fd7..6b29173a5c 100644 --- a/src/backend/replication/logical/tablesync.c +++ b/src/backend/replication/logical/tablesync.c @@ -257,6 +257,9 @@ void invalidate_syncing_table_states(Datum arg, int cacheid, uint32 hashvalue) { table_states_valid = false; + + /* Invalidate relation map cache. */ + logicalrep_relmap_invalidate(); } /* diff --git a/src/backend/replication/logical/worker.c b/src/backend/replication/logical/worker.c index f2b2549a51..347264e4a8 100644 --- a/src/backend/replication/logical/worker.c +++ b/src/backend/replication/logical/worker.c @@ -2487,6 +2487,9 @@ static void subscription_change_cb(Datum arg, int cacheid, uint32 hashvalue) { MySubscriptionValid = false; + + /* Invalidate relation map cache. */ + logicalrep_relmap_invalidate(); } /* diff --git a/src/include/replication/logicalrelation.h b/src/include/replication/logicalrelation.h index 3f0b3deefb..f5e70b75b0 100644 --- a/src/include/replication/logicalrelation.h +++ b/src/include/replication/logicalrelation.h @@ -49,4 +49,5 @@ extern void logicalrep_rel_close(LogicalRepRelMapEntry *rel, extern void logicalrep_typmap_update(LogicalRepTyp *remotetyp); extern char *logicalrep_typmap_gettypname(Oid remoteid); +extern void logicalrep_relmap_invalidate(void); #endif /* LOGICALRELATION_H */ -- 2.30.0 --=-=-=-- ^ permalink raw reply [nested|flat] 22+ messages in thread
* [PATCH v3 2/2] Invalidate relation map cache in subscriber syscache invalidation callbacks @ 2021-01-13 11:53 Bharath Rupireddy <[email protected]> 0 siblings, 0 replies; 22+ messages in thread From: Bharath Rupireddy @ 2021-01-13 11:53 UTC (permalink / raw) Currently, in logical replication, relation map cache in the subscriber is not getting invalidated when anything changes in pg_subscription_rel or pg_subscription catalogues. So we end up not reading the latest system catalogues always in logicalrep_rel_open using GetSubscriptionRelState. To fix this, invalidate the relation map cache entries in invalidate_syncing_table_states and subscription_change_cb which are invalidation callbacks for pg_subscription_rel and pg_subscription catalogues respectively. --- src/backend/replication/logical/relation.c | 26 +++++++++++++++++++++ src/backend/replication/logical/tablesync.c | 3 +++ src/backend/replication/logical/worker.c | 3 +++ src/include/replication/logicalrelation.h | 1 + 4 files changed, 33 insertions(+) diff --git a/src/backend/replication/logical/relation.c b/src/backend/replication/logical/relation.c index e861c0ff80..88ac772444 100644 --- a/src/backend/replication/logical/relation.c +++ b/src/backend/replication/logical/relation.c @@ -96,6 +96,32 @@ logicalrep_relmap_invalidate_cb(Datum arg, Oid reloid) } } +/* + * Invalidate relation map cache whenever syscache of pg_subscription_rel or + * pg_subscription gets changed. + */ +void +logicalrep_relmap_invalidate(void) +{ + LogicalRepRelMapEntry *entry; + HASH_SEQ_STATUS status; + + /* Just to be sure. */ + if (LogicalRepRelMap == NULL) + return; + + /* + * There is no way to find the cache entry for which the syscache has been + * changed, so we mark all the cache entries state as unknown. Because of + * this, in logicalrep_rel_open the cache entry state will be read from + * the system catalogue using GetSubscriptionRelState. + */ + hash_seq_init(&status, LogicalRepRelMap); + + while ((entry = (LogicalRepRelMapEntry *) hash_seq_search(&status)) != NULL) + entry->state = SUBREL_STATE_UNKNOWN; +} + /* * Initialize the relation map cache. */ diff --git a/src/backend/replication/logical/tablesync.c b/src/backend/replication/logical/tablesync.c index 863d196fd7..6b29173a5c 100644 --- a/src/backend/replication/logical/tablesync.c +++ b/src/backend/replication/logical/tablesync.c @@ -257,6 +257,9 @@ void invalidate_syncing_table_states(Datum arg, int cacheid, uint32 hashvalue) { table_states_valid = false; + + /* Invalidate relation map cache. */ + logicalrep_relmap_invalidate(); } /* diff --git a/src/backend/replication/logical/worker.c b/src/backend/replication/logical/worker.c index f2b2549a51..347264e4a8 100644 --- a/src/backend/replication/logical/worker.c +++ b/src/backend/replication/logical/worker.c @@ -2487,6 +2487,9 @@ static void subscription_change_cb(Datum arg, int cacheid, uint32 hashvalue) { MySubscriptionValid = false; + + /* Invalidate relation map cache. */ + logicalrep_relmap_invalidate(); } /* diff --git a/src/include/replication/logicalrelation.h b/src/include/replication/logicalrelation.h index 3f0b3deefb..f5e70b75b0 100644 --- a/src/include/replication/logicalrelation.h +++ b/src/include/replication/logicalrelation.h @@ -49,4 +49,5 @@ extern void logicalrep_rel_close(LogicalRepRelMapEntry *rel, extern void logicalrep_typmap_update(LogicalRepTyp *remotetyp); extern char *logicalrep_typmap_gettypname(Oid remoteid); +extern void logicalrep_relmap_invalidate(void); #endif /* LOGICALRELATION_H */ -- 2.30.0 --=-=-=-- ^ permalink raw reply [nested|flat] 22+ messages in thread
* [PATCH v3 2/2] Invalidate relation map cache in subscriber syscache invalidation callbacks @ 2021-01-13 11:53 Bharath Rupireddy <[email protected]> 0 siblings, 0 replies; 22+ messages in thread From: Bharath Rupireddy @ 2021-01-13 11:53 UTC (permalink / raw) Currently, in logical replication, relation map cache in the subscriber is not getting invalidated when anything changes in pg_subscription_rel or pg_subscription catalogues. So we end up not reading the latest system catalogues always in logicalrep_rel_open using GetSubscriptionRelState. To fix this, invalidate the relation map cache entries in invalidate_syncing_table_states and subscription_change_cb which are invalidation callbacks for pg_subscription_rel and pg_subscription catalogues respectively. --- src/backend/replication/logical/relation.c | 26 +++++++++++++++++++++ src/backend/replication/logical/tablesync.c | 3 +++ src/backend/replication/logical/worker.c | 3 +++ src/include/replication/logicalrelation.h | 1 + 4 files changed, 33 insertions(+) diff --git a/src/backend/replication/logical/relation.c b/src/backend/replication/logical/relation.c index e861c0ff80..88ac772444 100644 --- a/src/backend/replication/logical/relation.c +++ b/src/backend/replication/logical/relation.c @@ -96,6 +96,32 @@ logicalrep_relmap_invalidate_cb(Datum arg, Oid reloid) } } +/* + * Invalidate relation map cache whenever syscache of pg_subscription_rel or + * pg_subscription gets changed. + */ +void +logicalrep_relmap_invalidate(void) +{ + LogicalRepRelMapEntry *entry; + HASH_SEQ_STATUS status; + + /* Just to be sure. */ + if (LogicalRepRelMap == NULL) + return; + + /* + * There is no way to find the cache entry for which the syscache has been + * changed, so we mark all the cache entries state as unknown. Because of + * this, in logicalrep_rel_open the cache entry state will be read from + * the system catalogue using GetSubscriptionRelState. + */ + hash_seq_init(&status, LogicalRepRelMap); + + while ((entry = (LogicalRepRelMapEntry *) hash_seq_search(&status)) != NULL) + entry->state = SUBREL_STATE_UNKNOWN; +} + /* * Initialize the relation map cache. */ diff --git a/src/backend/replication/logical/tablesync.c b/src/backend/replication/logical/tablesync.c index 863d196fd7..6b29173a5c 100644 --- a/src/backend/replication/logical/tablesync.c +++ b/src/backend/replication/logical/tablesync.c @@ -257,6 +257,9 @@ void invalidate_syncing_table_states(Datum arg, int cacheid, uint32 hashvalue) { table_states_valid = false; + + /* Invalidate relation map cache. */ + logicalrep_relmap_invalidate(); } /* diff --git a/src/backend/replication/logical/worker.c b/src/backend/replication/logical/worker.c index f2b2549a51..347264e4a8 100644 --- a/src/backend/replication/logical/worker.c +++ b/src/backend/replication/logical/worker.c @@ -2487,6 +2487,9 @@ static void subscription_change_cb(Datum arg, int cacheid, uint32 hashvalue) { MySubscriptionValid = false; + + /* Invalidate relation map cache. */ + logicalrep_relmap_invalidate(); } /* diff --git a/src/include/replication/logicalrelation.h b/src/include/replication/logicalrelation.h index 3f0b3deefb..f5e70b75b0 100644 --- a/src/include/replication/logicalrelation.h +++ b/src/include/replication/logicalrelation.h @@ -49,4 +49,5 @@ extern void logicalrep_rel_close(LogicalRepRelMapEntry *rel, extern void logicalrep_typmap_update(LogicalRepTyp *remotetyp); extern char *logicalrep_typmap_gettypname(Oid remoteid); +extern void logicalrep_relmap_invalidate(void); #endif /* LOGICALRELATION_H */ -- 2.30.0 --=-=-=-- ^ permalink raw reply [nested|flat] 22+ messages in thread
* [PATCH v3 2/2] Invalidate relation map cache in subscriber syscache invalidation callbacks @ 2021-01-13 11:53 Bharath Rupireddy <[email protected]> 0 siblings, 0 replies; 22+ messages in thread From: Bharath Rupireddy @ 2021-01-13 11:53 UTC (permalink / raw) Currently, in logical replication, relation map cache in the subscriber is not getting invalidated when anything changes in pg_subscription_rel or pg_subscription catalogues. So we end up not reading the latest system catalogues always in logicalrep_rel_open using GetSubscriptionRelState. To fix this, invalidate the relation map cache entries in invalidate_syncing_table_states and subscription_change_cb which are invalidation callbacks for pg_subscription_rel and pg_subscription catalogues respectively. --- src/backend/replication/logical/relation.c | 26 +++++++++++++++++++++ src/backend/replication/logical/tablesync.c | 3 +++ src/backend/replication/logical/worker.c | 3 +++ src/include/replication/logicalrelation.h | 1 + 4 files changed, 33 insertions(+) diff --git a/src/backend/replication/logical/relation.c b/src/backend/replication/logical/relation.c index e861c0ff80..88ac772444 100644 --- a/src/backend/replication/logical/relation.c +++ b/src/backend/replication/logical/relation.c @@ -96,6 +96,32 @@ logicalrep_relmap_invalidate_cb(Datum arg, Oid reloid) } } +/* + * Invalidate relation map cache whenever syscache of pg_subscription_rel or + * pg_subscription gets changed. + */ +void +logicalrep_relmap_invalidate(void) +{ + LogicalRepRelMapEntry *entry; + HASH_SEQ_STATUS status; + + /* Just to be sure. */ + if (LogicalRepRelMap == NULL) + return; + + /* + * There is no way to find the cache entry for which the syscache has been + * changed, so we mark all the cache entries state as unknown. Because of + * this, in logicalrep_rel_open the cache entry state will be read from + * the system catalogue using GetSubscriptionRelState. + */ + hash_seq_init(&status, LogicalRepRelMap); + + while ((entry = (LogicalRepRelMapEntry *) hash_seq_search(&status)) != NULL) + entry->state = SUBREL_STATE_UNKNOWN; +} + /* * Initialize the relation map cache. */ diff --git a/src/backend/replication/logical/tablesync.c b/src/backend/replication/logical/tablesync.c index 863d196fd7..6b29173a5c 100644 --- a/src/backend/replication/logical/tablesync.c +++ b/src/backend/replication/logical/tablesync.c @@ -257,6 +257,9 @@ void invalidate_syncing_table_states(Datum arg, int cacheid, uint32 hashvalue) { table_states_valid = false; + + /* Invalidate relation map cache. */ + logicalrep_relmap_invalidate(); } /* diff --git a/src/backend/replication/logical/worker.c b/src/backend/replication/logical/worker.c index f2b2549a51..347264e4a8 100644 --- a/src/backend/replication/logical/worker.c +++ b/src/backend/replication/logical/worker.c @@ -2487,6 +2487,9 @@ static void subscription_change_cb(Datum arg, int cacheid, uint32 hashvalue) { MySubscriptionValid = false; + + /* Invalidate relation map cache. */ + logicalrep_relmap_invalidate(); } /* diff --git a/src/include/replication/logicalrelation.h b/src/include/replication/logicalrelation.h index 3f0b3deefb..f5e70b75b0 100644 --- a/src/include/replication/logicalrelation.h +++ b/src/include/replication/logicalrelation.h @@ -49,4 +49,5 @@ extern void logicalrep_rel_close(LogicalRepRelMapEntry *rel, extern void logicalrep_typmap_update(LogicalRepTyp *remotetyp); extern char *logicalrep_typmap_gettypname(Oid remoteid); +extern void logicalrep_relmap_invalidate(void); #endif /* LOGICALRELATION_H */ -- 2.30.0 --=-=-=-- ^ permalink raw reply [nested|flat] 22+ messages in thread
* Re: Proposal: Conflict log history table for Logical Replication @ 2026-01-02 06:36 shveta malik <[email protected]> 0 siblings, 0 replies; 22+ messages in thread From: shveta malik @ 2026-01-02 06:36 UTC (permalink / raw) To: vignesh C <[email protected]>; +Cc: Dilip Kumar <[email protected]>; Amit Kapila <[email protected]>; Masahiko Sawada <[email protected]>; Bharath Rupireddy <[email protected]>; PostgreSQL Hackers <[email protected]>; shveta malik <[email protected]> On Fri, Dec 26, 2025 at 8:58 PM vignesh C <[email protected]> wrote: > > > Here is a rebased version of the remaining patches. > Thank You Vignesh. Please find a few comments on 004: 1) IIUC, SubscriptionConflictrelIndexId is an unique index on sub-oid and conf-relid, but we use it only on relid as key. Why didn't we create it only on 'conf-relid' alone? Using a composite unique index is guaranteed to give unique row only when all keys are used, but for a single key, a unique row is not guaranteed. In our case, it will be a unique row as conflict-relid is not shared, but still as an overall general concept, it may not be. 2) IsConflictLogTable(): + if (OidIsValid(subform->subconflictlogrelid)) Do we need this check? Since we’ve already performed an index access using subconflictlogrelid as the key, isn’t it guaranteed to always be valid? 3) Please update the commit message to indicate that this patch makes CLT publishable if a publication is explicitly created on it, else few changes become very confusing due to unclear intent. 4) pg_relation_is_publishable(): /* Subscription conflict log tables are not published */ - result = is_publishable_class(relid, (Form_pg_class) GETSTRUCT(tuple)) && - !IsConflictLogTable(relid); Comment should be removed too. 5) We need to remove below comment: * Note: Conflict log tables are not publishable. However, we intentionally * skip this check here because this function is called for every change and * performing this check during every change publication is costly. To ensure * unpublishable entries are ignored without incurring performance overhead, * tuples inserted into the conflict log table uses the HEAP_INSERT_NO_LOGICAL * flag. This allows the decoding layer to bypass these entries automatically. */ bool is_publishable_relation(Relation rel) 6) get_rel_sync_entry: + /* is this relation used for conflict logging? */ + isconflictlogrel = IsConflictLogTable(relid); Shall we add a comment indicating the intent of change in this function. Something like: /* * Check whether this is a conflict log table. If so, avoid publishing it via * FOR ALL TABLES or FOR TABLES IN SCHEMA publications, but still allow it * to be published through a publication explicitly created for this table. */ thanks Shveta ^ permalink raw reply [nested|flat] 22+ messages in thread
end of thread, other threads:[~2026-01-02 06:36 UTC | newest] Thread overview: 22+ messages (download: mbox mbox.gz follow: Atom feed) -- links below jump to the message on this page -- 2021-01-13 11:53 [PATCH v3 2/2] Invalidate relation map cache in subscriber syscache invalidation callbacks Bharath Rupireddy <[email protected]> 2021-01-13 11:53 [PATCH v3 2/2] Invalidate relation map cache in subscriber syscache invalidation callbacks Bharath Rupireddy <[email protected]> 2021-01-13 11:53 [PATCH v3 2/2] Invalidate relation map cache in subscriber syscache invalidation callbacks Bharath Rupireddy <[email protected]> 2021-01-13 11:53 [PATCH v3 2/2] Invalidate relation map cache in subscriber syscache invalidation callbacks Bharath Rupireddy <[email protected]> 2021-01-13 11:53 [PATCH v3 2/2] Invalidate relation map cache in subscriber syscache invalidation callbacks Bharath Rupireddy <[email protected]> 2021-01-13 11:53 [PATCH v3 2/2] Invalidate relation map cache in subscriber syscache invalidation callbacks Bharath Rupireddy <[email protected]> 2021-01-13 11:53 [PATCH v3 2/2] Invalidate relation map cache in subscriber syscache invalidation callbacks Bharath Rupireddy <[email protected]> 2021-01-13 11:53 [PATCH v3 2/2] Invalidate relation map cache in subscriber syscache invalidation callbacks Bharath Rupireddy <[email protected]> 2021-01-13 11:53 [PATCH v3 2/2] Invalidate relation map cache in subscriber syscache invalidation callbacks Bharath Rupireddy <[email protected]> 2021-01-13 11:53 [PATCH v3 2/2] Invalidate relation map cache in subscriber syscache invalidation callbacks Bharath Rupireddy <[email protected]> 2021-01-13 11:53 [PATCH v3 2/2] Invalidate relation map cache in subscriber syscache invalidation callbacks Bharath Rupireddy <[email protected]> 2021-01-13 11:53 [PATCH v3 2/2] Invalidate relation map cache in subscriber syscache invalidation callbacks Bharath Rupireddy <[email protected]> 2021-01-13 11:53 [PATCH v3 2/2] Invalidate relation map cache in subscriber syscache invalidation callbacks Bharath Rupireddy <[email protected]> 2021-01-13 11:53 [PATCH v3 2/2] Invalidate relation map cache in subscriber syscache invalidation callbacks Bharath Rupireddy <[email protected]> 2021-01-13 11:53 [PATCH v3 2/2] Invalidate relation map cache in subscriber syscache invalidation callbacks Bharath Rupireddy <[email protected]> 2021-01-13 11:53 [PATCH v3 2/2] Invalidate relation map cache in subscriber syscache invalidation callbacks Bharath Rupireddy <[email protected]> 2021-01-13 11:53 [PATCH v3 2/2] Invalidate relation map cache in subscriber syscache invalidation callbacks Bharath Rupireddy <[email protected]> 2021-01-13 11:53 [PATCH v3 2/2] Invalidate relation map cache in subscriber syscache invalidation callbacks Bharath Rupireddy <[email protected]> 2021-01-13 11:53 [PATCH v3 2/2] Invalidate relation map cache in subscriber syscache invalidation callbacks Bharath Rupireddy <[email protected]> 2021-01-13 11:53 [PATCH v3 2/2] Invalidate relation map cache in subscriber syscache invalidation callbacks Bharath Rupireddy <[email protected]> 2021-01-13 11:53 [PATCH v3 2/2] Invalidate relation map cache in subscriber syscache invalidation callbacks Bharath Rupireddy <[email protected]> 2026-01-02 06:36 Re: Proposal: Conflict log history table for Logical Replication shveta malik <[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