#include "postgres.h"
#include "access/sysattr.h"
#include "access/table.h"
#include "catalog/namespace.h"
#include "catalog/pg_subscription_rel.h"
#include "executor/executor.h"
#include "nodes/makefuncs.h"
#include "replication/logicalrelation.h"
#include "replication/worker_internal.h"
#include "utils/builtins.h"
#include "utils/inval.h"
#include "utils/lsyscache.h"
#include "utils/memutils.h"
#include "utils/syscache.h"

Include dependency graph for relation.c:

Data Structures
struct	LogicalRepPartMapEntry

Typedefs
typedef struct LogicalRepPartMapEntry	LogicalRepPartMapEntry

Functions
static void	logicalrep_relmap_invalidate_cb (Datum arg, Oid reloid)

static void	logicalrep_relmap_init (void)

static void	logicalrep_relmap_free_entry (LogicalRepRelMapEntry *entry)

void	logicalrep_relmap_update (LogicalRepRelation *remoterel)

static int	logicalrep_rel_att_by_name (LogicalRepRelation remoterel, const char attname)

static void	logicalrep_report_missing_attrs (LogicalRepRelation remoterel, Bitmapset missingatts)

LogicalRepRelMapEntry *	logicalrep_rel_open (LogicalRepRelId remoteid, LOCKMODE lockmode)

void	logicalrep_rel_close (LogicalRepRelMapEntry *rel, LOCKMODE lockmode)

static void	logicalrep_typmap_free_entry (LogicalRepTyp *entry)

void	logicalrep_typmap_update (LogicalRepTyp *remotetyp)

char *	logicalrep_typmap_gettypname (Oid remoteid)

static void	logicalrep_partmap_invalidate_cb (Datum arg, Oid reloid)

static void	logicalrep_partmap_init (void)

LogicalRepRelMapEntry *	logicalrep_partition_open (LogicalRepRelMapEntry root, Relation partrel, AttrMap map)

Variables
static MemoryContext	LogicalRepRelMapContext = NULL

static HTAB *	LogicalRepRelMap = NULL

static HTAB *	LogicalRepTypMap = NULL

static MemoryContext	LogicalRepPartMapContext = NULL

static HTAB *	LogicalRepPartMap = NULL

Typedef Documentation

◆ LogicalRepPartMapEntry

typedef struct LogicalRepPartMapEntry LogicalRepPartMapEntry

Function Documentation

◆ logicalrep_partition_open()

LogicalRepRelMapEntry* logicalrep_partition_open	(	LogicalRepRelMapEntry *	root,
		Relation	partrel,
		AttrMap *	map
	)

Definition at line 629 of file relation.c.

Referenced by apply_handle_tuple_routing().

 {
     LogicalRepRelMapEntry *entry;
     LogicalRepPartMapEntry *part_entry;
     LogicalRepRelation *remoterel = &root->remoterel;
     Oid         partOid = RelationGetRelid(partrel);
     AttrMap    *attrmap = root->attrmap;
     bool        found;
     int         i;
     MemoryContext oldctx;
 
     if (LogicalRepPartMap == NULL)
         logicalrep_partmap_init();
 
     /* Search for existing entry. */
     part_entry = (LogicalRepPartMapEntry *) hash_search(LogicalRepPartMap,
                                                         (void *) &partOid,
                                                         HASH_ENTER, &found);
 
     if (found)
         return &part_entry->relmapentry;
 
     memset(part_entry, 0, sizeof(LogicalRepPartMapEntry));
 
     /* Switch to longer-lived context. */
     oldctx = MemoryContextSwitchTo(LogicalRepPartMapContext);
 
     part_entry->partoid = partOid;
 
     /* Remote relation is used as-is from the root entry. */
     entry = &part_entry->relmapentry;
     entry->remoterel.remoteid = remoterel->remoteid;
     entry->remoterel.nspname = pstrdup(remoterel->nspname);
     entry->remoterel.relname = pstrdup(remoterel->relname);
     entry->remoterel.natts = remoterel->natts;
     entry->remoterel.attnames = palloc(remoterel->natts * sizeof(char *));
     entry->remoterel.atttyps = palloc(remoterel->natts * sizeof(Oid));
     for (i = 0; i < remoterel->natts; i++)
     {
         entry->remoterel.attnames[i] = pstrdup(remoterel->attnames[i]);
         entry->remoterel.atttyps[i] = remoterel->atttyps[i];
     }
     entry->remoterel.replident = remoterel->replident;
     entry->remoterel.attkeys = bms_copy(remoterel->attkeys);
 
     entry->localrel = partrel;
     entry->localreloid = partOid;
 
     /*
      * If the partition's attributes don't match the root relation's, we'll
      * need to make a new attrmap which maps partition attribute numbers to
      * remoterel's, instead of the original which maps root relation's
      * attribute numbers to remoterel's.
      *
      * Note that 'map' which comes from the tuple routing data structure
      * contains 1-based attribute numbers (of the parent relation).  However,
      * the map in 'entry', a logical replication data structure, contains
      * 0-based attribute numbers (of the remote relation).
      */
     if (map)
     {
         AttrNumber  attno;
 
         entry->attrmap = make_attrmap(map->maplen);
         for (attno = 0; attno < entry->attrmap->maplen; attno++)
         {
             AttrNumber  root_attno = map->attnums[attno];
 
             entry->attrmap->attnums[attno] = attrmap->attnums[root_attno - 1];
         }
     }
     else
         entry->attrmap = attrmap;
 
     entry->updatable = root->updatable;
 
     entry->localrelvalid = true;
 
     /* state and statelsn are left set to 0. */
     MemoryContextSwitchTo(oldctx);
 
     return entry;
 }

◆ logicalrep_partmap_init()

static void logicalrep_partmap_init ( void )

static

Definition at line 596 of file relation.c.

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, CacheMemoryContext, CacheRegisterRelcacheCallback(), HASHCTL::entrysize, HASH_BLOBS, HASH_CONTEXT, hash_create(), HASH_ELEM, HASHCTL::hcxt, HASHCTL::keysize, logicalrep_partmap_invalidate_cb(), and LogicalRepPartMapContext.

Referenced by logicalrep_partition_open().

 {
     HASHCTL     ctl;
 
     if (!LogicalRepPartMapContext)
         LogicalRepPartMapContext =
             AllocSetContextCreate(CacheMemoryContext,
                                   "LogicalRepPartMapContext",
                                   ALLOCSET_DEFAULT_SIZES);
 
     /* Initialize the relation hash table. */
     ctl.keysize = sizeof(Oid);  /* partition OID */
     ctl.entrysize = sizeof(LogicalRepPartMapEntry);
     ctl.hcxt = LogicalRepPartMapContext;
 
     LogicalRepPartMap = hash_create("logicalrep partition map cache", 64, &ctl,
                                     HASH_ELEM | HASH_BLOBS | HASH_CONTEXT);
 
     /* Watch for invalidation events. */
     CacheRegisterRelcacheCallback(logicalrep_partmap_invalidate_cb,
                                   (Datum) 0);
 }

◆ logicalrep_partmap_invalidate_cb()

static void logicalrep_partmap_invalidate_cb	(	Datum	arg,
		Oid	reloid
	)

static

Definition at line 555 of file relation.c.

References hash_seq_init(), hash_seq_search(), hash_seq_term(), InvalidOid, LogicalRepRelMapEntry::localreloid, LogicalRepRelMapEntry::localrelvalid, and status().

Referenced by logicalrep_partmap_init().

 {
     LogicalRepRelMapEntry *entry;
 
     /* Just to be sure. */
     if (LogicalRepPartMap == NULL)
         return;
 
     if (reloid != InvalidOid)
     {
         HASH_SEQ_STATUS status;
 
         hash_seq_init(&status, LogicalRepPartMap);
 
         /* TODO, use inverse lookup hashtable? */
         while ((entry = (LogicalRepRelMapEntry *) hash_seq_search(&status)) != NULL)
         {
             if (entry->localreloid == reloid)
             {
                 entry->localrelvalid = false;
                 hash_seq_term(&status);
                 break;
             }
         }
     }
     else
     {
         /* invalidate all cache entries */
         HASH_SEQ_STATUS status;
 
         hash_seq_init(&status, LogicalRepPartMap);
 
         while ((entry = (LogicalRepRelMapEntry *) hash_seq_search(&status)) != NULL)
             entry->localrelvalid = false;
     }
 }

◆ logicalrep_rel_att_by_name()

static int logicalrep_rel_att_by_name	(	LogicalRepRelation *	remoterel,
		const char *	attname
	)

static

Definition at line 216 of file relation.c.

References LogicalRepRelation::attnames, i, and LogicalRepRelation::natts.

Referenced by logicalrep_rel_open().

 {
     int         i;
 
     for (i = 0; i < remoterel->natts; i++)
     {
         if (strcmp(remoterel->attnames[i], attname) == 0)
             return i;
     }
 
     return -1;
 }

◆ logicalrep_rel_close()

void logicalrep_rel_close	(	LogicalRepRelMapEntry *	rel,
		LOCKMODE	lockmode
	)

Definition at line 447 of file relation.c.

References LogicalRepRelMapEntry::localrel, and table_close().

Referenced by apply_handle_delete(), apply_handle_insert(), apply_handle_truncate(), apply_handle_update(), and copy_table().

 {
     table_close(rel->localrel, lockmode);
     rel->localrel = NULL;
 }

◆ logicalrep_rel_open()

LogicalRepRelMapEntry* logicalrep_rel_open	(	LogicalRepRelId	remoteid,
		LOCKMODE	lockmode
	)

Definition at line 272 of file relation.c.

Referenced by apply_handle_delete(), apply_handle_insert(), apply_handle_truncate(), apply_handle_update(), and copy_table().

 {
     LogicalRepRelMapEntry *entry;
     bool        found;
     LogicalRepRelation *remoterel;
 
     if (LogicalRepRelMap == NULL)
         logicalrep_relmap_init();
 
     /* Search for existing entry. */
     entry = hash_search(LogicalRepRelMap, (void *) &remoteid,
                         HASH_FIND, &found);
 
     if (!found)
         elog(ERROR, "no relation map entry for remote relation ID %u",
              remoteid);
 
     remoterel = &entry->remoterel;
 
     /* Ensure we don't leak a relcache refcount. */
     if (entry->localrel)
         elog(ERROR, "remote relation ID %u is already open", remoteid);
 
     /*
      * When opening and locking a relation, pending invalidation messages are
      * processed which can invalidate the relation.  Hence, if the entry is
      * currently considered valid, try to open the local relation by OID and
      * see if invalidation ensues.
      */
     if (entry->localrelvalid)
     {
         entry->localrel = try_table_open(entry->localreloid, lockmode);
         if (!entry->localrel)
         {
             /* Table was renamed or dropped. */
             entry->localrelvalid = false;
         }
         else if (!entry->localrelvalid)
         {
             /* Note we release the no-longer-useful lock here. */
             table_close(entry->localrel, lockmode);
             entry->localrel = NULL;
         }
     }
 
     /*
      * If the entry has been marked invalid since we last had lock on it,
      * re-open the local relation by name and rebuild all derived data.
      */
     if (!entry->localrelvalid)
     {
         Oid         relid;
         Bitmapset  *idkey;
         TupleDesc   desc;
         MemoryContext oldctx;
         int         i;
         Bitmapset  *missingatts;
 
         /* Try to find and lock the relation by name. */
         relid = RangeVarGetRelid(makeRangeVar(remoterel->nspname,
                                               remoterel->relname, -1),
                                  lockmode, true);
         if (!OidIsValid(relid))
             ereport(ERROR,
                     (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                      errmsg("logical replication target relation \"%s.%s\" does not exist",
                             remoterel->nspname, remoterel->relname)));
         entry->localrel = table_open(relid, NoLock);
         entry->localreloid = relid;
 
         /* Check for supported relkind. */
         CheckSubscriptionRelkind(entry->localrel->rd_rel->relkind,
                                  remoterel->nspname, remoterel->relname);
 
         /*
          * Build the mapping of local attribute numbers to remote attribute
          * numbers and validate that we don't miss any replicated columns as
          * that would result in potentially unwanted data loss.
          */
         desc = RelationGetDescr(entry->localrel);
         oldctx = MemoryContextSwitchTo(LogicalRepRelMapContext);
         entry->attrmap = make_attrmap(desc->natts);
         MemoryContextSwitchTo(oldctx);
 
         /* check and report missing attrs, if any */
         missingatts = bms_add_range(NULL, 0, remoterel->natts - 1);
         for (i = 0; i < desc->natts; i++)
         {
             int         attnum;
             Form_pg_attribute attr = TupleDescAttr(desc, i);
 
             if (attr->attisdropped || attr->attgenerated)
             {
                 entry->attrmap->attnums[i] = -1;
                 continue;
             }
 
             attnum = logicalrep_rel_att_by_name(remoterel,
                                                 NameStr(attr->attname));
 
             entry->attrmap->attnums[i] = attnum;
             if (attnum >= 0)
                 missingatts = bms_del_member(missingatts, attnum);
         }
 
         logicalrep_report_missing_attrs(remoterel, missingatts);
 
         /* be tidy */
         bms_free(missingatts);
 
         /*
          * Check that replica identity matches. We allow for stricter replica
          * identity (fewer columns) on subscriber as that will not stop us
          * from finding unique tuple. IE, if publisher has identity
          * (id,timestamp) and subscriber just (id) this will not be a problem,
          * but in the opposite scenario it will.
          *
          * Don't throw any error here just mark the relation entry as not
          * updatable, as replica identity is only for updates and deletes but
          * inserts can be replicated even without it.
          */
         entry->updatable = true;
         idkey = RelationGetIndexAttrBitmap(entry->localrel,
                                            INDEX_ATTR_BITMAP_IDENTITY_KEY);
         /* fallback to PK if no replica identity */
         if (idkey == NULL)
         {
             idkey = RelationGetIndexAttrBitmap(entry->localrel,
                                                INDEX_ATTR_BITMAP_PRIMARY_KEY);
 
             /*
              * If no replica identity index and no PK, the published table
              * must have replica identity FULL.
              */
             if (idkey == NULL && remoterel->replident != REPLICA_IDENTITY_FULL)
                 entry->updatable = false;
         }
 
         i = -1;
         while ((i = bms_next_member(idkey, i)) >= 0)
         {
             int         attnum = i + FirstLowInvalidHeapAttributeNumber;
 
             if (!AttrNumberIsForUserDefinedAttr(attnum))
                 ereport(ERROR,
                         (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                          errmsg("logical replication target relation \"%s.%s\" uses "
                                 "system columns in REPLICA IDENTITY index",
                                 remoterel->nspname, remoterel->relname)));
 
             attnum = AttrNumberGetAttrOffset(attnum);
 
             if (entry->attrmap->attnums[attnum] < 0 ||
                 !bms_is_member(entry->attrmap->attnums[attnum], remoterel->attkeys))
             {
                 entry->updatable = false;
                 break;
             }
         }
 
         entry->localrelvalid = true;
     }
 
     if (entry->state != SUBREL_STATE_READY)
         entry->state = GetSubscriptionRelState(MySubscription->oid,
                                                entry->localreloid,
                                                &entry->statelsn);
 
     return entry;
 }

◆ logicalrep_relmap_free_entry()

static void logicalrep_relmap_free_entry ( LogicalRepRelMapEntry * entry )

static

Definition at line 139 of file relation.c.

References LogicalRepRelation::attkeys, LogicalRepRelation::attnames, LogicalRepRelMapEntry::attrmap, LogicalRepRelation::atttyps, bms_free(), i, LogicalRepRelation::natts, LogicalRepRelation::nspname, pfree(), LogicalRepRelation::relname, and LogicalRepRelMapEntry::remoterel.

Referenced by logicalrep_relmap_update().

 {
     LogicalRepRelation *remoterel;
 
     remoterel = &entry->remoterel;
 
     pfree(remoterel->nspname);
     pfree(remoterel->relname);
 
     if (remoterel->natts > 0)
     {
         int         i;
 
         for (i = 0; i < remoterel->natts; i++)
             pfree(remoterel->attnames[i]);
 
         pfree(remoterel->attnames);
         pfree(remoterel->atttyps);
     }
     bms_free(remoterel->attkeys);
 
     if (entry->attrmap)
         pfree(entry->attrmap);
 }

◆ logicalrep_relmap_init()

static void logicalrep_relmap_init ( void )

static

Definition at line 103 of file relation.c.

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, CacheMemoryContext, CacheRegisterRelcacheCallback(), HASHCTL::entrysize, HASH_BLOBS, HASH_CONTEXT, hash_create(), HASH_ELEM, HASHCTL::hcxt, HASHCTL::keysize, logicalrep_relmap_invalidate_cb(), and LogicalRepRelMapContext.

Referenced by logicalrep_rel_open(), logicalrep_relmap_update(), and logicalrep_typmap_update().

 {
     HASHCTL     ctl;
 
     if (!LogicalRepRelMapContext)
         LogicalRepRelMapContext =
             AllocSetContextCreate(CacheMemoryContext,
                                   "LogicalRepRelMapContext",
                                   ALLOCSET_DEFAULT_SIZES);
 
     /* Initialize the relation hash table. */
     ctl.keysize = sizeof(LogicalRepRelId);
     ctl.entrysize = sizeof(LogicalRepRelMapEntry);
     ctl.hcxt = LogicalRepRelMapContext;
 
     LogicalRepRelMap = hash_create("logicalrep relation map cache", 128, &ctl,
                                    HASH_ELEM | HASH_BLOBS | HASH_CONTEXT);
 
     /* Initialize the type hash table. */
     ctl.keysize = sizeof(Oid);
     ctl.entrysize = sizeof(LogicalRepTyp);
     ctl.hcxt = LogicalRepRelMapContext;
 
     /* This will usually be small. */
     LogicalRepTypMap = hash_create("logicalrep type map cache", 2, &ctl,
                                    HASH_ELEM | HASH_BLOBS | HASH_CONTEXT);
 
     /* Watch for invalidation events. */
     CacheRegisterRelcacheCallback(logicalrep_relmap_invalidate_cb,
                                   (Datum) 0);
 }

◆ logicalrep_relmap_invalidate_cb()

static void logicalrep_relmap_invalidate_cb	(	Datum	arg,
		Oid	reloid
	)

static

Definition at line 62 of file relation.c.

References hash_seq_init(), hash_seq_search(), hash_seq_term(), InvalidOid, LogicalRepRelMapEntry::localreloid, LogicalRepRelMapEntry::localrelvalid, and status().

Referenced by logicalrep_relmap_init().

 {
     LogicalRepRelMapEntry *entry;
 
     /* Just to be sure. */
     if (LogicalRepRelMap == NULL)
         return;
 
     if (reloid != InvalidOid)
     {
         HASH_SEQ_STATUS status;
 
         hash_seq_init(&status, LogicalRepRelMap);
 
         /* TODO, use inverse lookup hashtable? */
         while ((entry = (LogicalRepRelMapEntry *) hash_seq_search(&status)) != NULL)
         {
             if (entry->localreloid == reloid)
             {
                 entry->localrelvalid = false;
                 hash_seq_term(&status);
                 break;
             }
         }
     }
     else
     {
         /* invalidate all cache entries */
         HASH_SEQ_STATUS status;
 
         hash_seq_init(&status, LogicalRepRelMap);
 
         while ((entry = (LogicalRepRelMapEntry *) hash_seq_search(&status)) != NULL)
             entry->localrelvalid = false;
     }
 }

◆ logicalrep_relmap_update()

void logicalrep_relmap_update ( LogicalRepRelation * remoterel )

Definition at line 171 of file relation.c.

References LogicalRepRelation::attkeys, LogicalRepRelation::attnames, LogicalRepRelation::atttyps, bms_copy(), HASH_ENTER, hash_search(), i, logicalrep_relmap_free_entry(), logicalrep_relmap_init(), MemoryContextSwitchTo(), LogicalRepRelation::natts, LogicalRepRelation::nspname, palloc(), pstrdup(), LogicalRepRelation::relname, LogicalRepRelation::remoteid, LogicalRepRelMapEntry::remoterel, and LogicalRepRelation::replident.

Referenced by apply_handle_relation(), and copy_table().

 {
     MemoryContext oldctx;
     LogicalRepRelMapEntry *entry;
     bool        found;
     int         i;
 
     if (LogicalRepRelMap == NULL)
         logicalrep_relmap_init();
 
     /*
      * HASH_ENTER returns the existing entry if present or creates a new one.
      */
     entry = hash_search(LogicalRepRelMap, (void *) &remoterel->remoteid,
                         HASH_ENTER, &found);
 
     if (found)
         logicalrep_relmap_free_entry(entry);
 
     memset(entry, 0, sizeof(LogicalRepRelMapEntry));
 
     /* Make cached copy of the data */
     oldctx = MemoryContextSwitchTo(LogicalRepRelMapContext);
     entry->remoterel.remoteid = remoterel->remoteid;
     entry->remoterel.nspname = pstrdup(remoterel->nspname);
     entry->remoterel.relname = pstrdup(remoterel->relname);
     entry->remoterel.natts = remoterel->natts;
     entry->remoterel.attnames = palloc(remoterel->natts * sizeof(char *));
     entry->remoterel.atttyps = palloc(remoterel->natts * sizeof(Oid));
     for (i = 0; i < remoterel->natts; i++)
     {
         entry->remoterel.attnames[i] = pstrdup(remoterel->attnames[i]);
         entry->remoterel.atttyps[i] = remoterel->atttyps[i];
     }
     entry->remoterel.replident = remoterel->replident;
     entry->remoterel.attkeys = bms_copy(remoterel->attkeys);
     MemoryContextSwitchTo(oldctx);
 }

◆ logicalrep_report_missing_attrs()

static void logicalrep_report_missing_attrs	(	LogicalRepRelation *	remoterel,
		Bitmapset *	missingatts
	)

static

Definition at line 233 of file relation.c.

References _, appendStringInfo(), LogicalRepRelation::attnames, bms_first_member(), bms_is_empty(), StringInfoData::data, ereport, errcode(), errmsg_plural(), ERROR, i, initStringInfo(), LogicalRepRelation::nspname, and LogicalRepRelation::relname.

Referenced by logicalrep_rel_open().

 {
     if (!bms_is_empty(missingatts))
     {
         StringInfoData missingattsbuf;
         int         missingattcnt = 0;
         int         i;
 
         initStringInfo(&missingattsbuf);
 
         while ((i = bms_first_member(missingatts)) >= 0)
         {
             missingattcnt++;
             if (missingattcnt == 1)
                 appendStringInfo(&missingattsbuf, _("\"%s\""),
                                  remoterel->attnames[i]);
             else
                 appendStringInfo(&missingattsbuf, _(", \"%s\""),
                                  remoterel->attnames[i]);
         }
 
         ereport(ERROR,
                 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                  errmsg_plural("logical replication target relation \"%s.%s\" is missing replicated column: %s",
                                "logical replication target relation \"%s.%s\" is missing replicated columns: %s",
                                missingattcnt,
                                remoterel->nspname,
                                remoterel->relname,
                                missingattsbuf.data)));
     }
 }

◆ logicalrep_typmap_free_entry()

static void logicalrep_typmap_free_entry ( LogicalRepTyp * entry )

static

Definition at line 457 of file relation.c.

References LogicalRepTyp::nspname, pfree(), and LogicalRepTyp::typname.

Referenced by logicalrep_typmap_update().

 {
     pfree(entry->nspname);
     pfree(entry->typname);
 }

◆ logicalrep_typmap_gettypname()

char* logicalrep_typmap_gettypname ( Oid remoteid )

Definition at line 501 of file relation.c.

References Assert, FirstGenbkiObjectId, format_type_be(), get_typisdefined(), HASH_FIND, hash_search(), LogicalRepTyp::nspname, OidIsValid, psprintf(), LogicalRepTyp::remoteid, and LogicalRepTyp::typname.

Referenced by slot_store_error_callback().

 {
     LogicalRepTyp *entry;
     bool        found;
 
     /* Internal types are mapped directly. */
     if (remoteid < FirstGenbkiObjectId)
     {
         if (!get_typisdefined(remoteid))
         {
             /*
              * This can be caused by having a publisher with a higher
              * PostgreSQL major version than the subscriber.
              */
             return psprintf("unrecognized %u", remoteid);
         }
 
         return format_type_be(remoteid);
     }
 
     if (LogicalRepTypMap == NULL)
     {
         /*
          * If the typemap is not initialized yet, we cannot possibly attempt
          * to search the hash table; but there's no way we know the type
          * locally yet, since we haven't received a message about this type,
          * so this is the best we can do.
          */
         return psprintf("unrecognized %u", remoteid);
     }
 
     /* search the mapping */
     entry = hash_search(LogicalRepTypMap, (void *) &remoteid,
                         HASH_FIND, &found);
     if (!found)
         return psprintf("unrecognized %u", remoteid);
 
     Assert(OidIsValid(entry->remoteid));
     return psprintf("%s.%s", entry->nspname, entry->typname);
 }

◆ logicalrep_typmap_update()

void logicalrep_typmap_update ( LogicalRepTyp * remotetyp )

Definition at line 467 of file relation.c.

References HASH_ENTER, hash_search(), logicalrep_relmap_init(), logicalrep_typmap_free_entry(), MemoryContextSwitchTo(), LogicalRepTyp::nspname, pstrdup(), LogicalRepTyp::remoteid, and LogicalRepTyp::typname.

Referenced by apply_handle_type().

 {
     MemoryContext oldctx;
     LogicalRepTyp *entry;
     bool        found;
 
     if (LogicalRepTypMap == NULL)
         logicalrep_relmap_init();
 
     /*
      * HASH_ENTER returns the existing entry if present or creates a new one.
      */
     entry = hash_search(LogicalRepTypMap, (void *) &remotetyp->remoteid,
                         HASH_ENTER, &found);
 
     if (found)
         logicalrep_typmap_free_entry(entry);
 
     /* Make cached copy of the data */
     entry->remoteid = remotetyp->remoteid;
     oldctx = MemoryContextSwitchTo(LogicalRepRelMapContext);
     entry->nspname = pstrdup(remotetyp->nspname);
     entry->typname = pstrdup(remotetyp->typname);
     MemoryContextSwitchTo(oldctx);
 }

Variable Documentation

◆ LogicalRepPartMap

HTAB* LogicalRepPartMap = NULL

static

Definition at line 51 of file relation.c.

◆ LogicalRepPartMapContext

MemoryContext LogicalRepPartMapContext = NULL

static

Definition at line 50 of file relation.c.

Referenced by logicalrep_partmap_init().

◆ LogicalRepRelMap

HTAB* LogicalRepRelMap = NULL

static

Definition at line 36 of file relation.c.

◆ LogicalRepRelMapContext

MemoryContext LogicalRepRelMapContext = NULL

static

Definition at line 34 of file relation.c.

Referenced by logicalrep_relmap_init().

◆ LogicalRepTypMap

HTAB* LogicalRepTypMap = NULL

static

Definition at line 37 of file relation.c.

Data Structures

Typedefs

Functions

Variables

Typedef Documentation

◆ LogicalRepPartMapEntry

Function Documentation

◆ logicalrep_partition_open()

◆ logicalrep_partmap_init()

◆ logicalrep_partmap_invalidate_cb()

◆ logicalrep_rel_att_by_name()

◆ logicalrep_rel_close()

◆ logicalrep_rel_open()

◆ logicalrep_relmap_free_entry()

◆ logicalrep_relmap_init()

◆ logicalrep_relmap_invalidate_cb()

◆ logicalrep_relmap_update()

◆ logicalrep_report_missing_attrs()

◆ logicalrep_typmap_free_entry()

◆ logicalrep_typmap_gettypname()

◆ logicalrep_typmap_update()

Variable Documentation

◆ LogicalRepPartMap

◆ LogicalRepPartMapContext

◆ LogicalRepRelMap

◆ LogicalRepRelMapContext

◆ LogicalRepTypMap