tablesync.c File Reference

#include "postgres.h"
#include "access/table.h"
#include "access/xact.h"
#include "catalog/indexing.h"
#include "catalog/pg_subscription_rel.h"
#include "catalog/pg_type.h"
#include "commands/copy.h"
#include "miscadmin.h"
#include "parser/parse_relation.h"
#include "pgstat.h"
#include "replication/logicallauncher.h"
#include "replication/logicalrelation.h"
#include "replication/walreceiver.h"
#include "replication/worker_internal.h"
#include "replication/slot.h"
#include "replication/origin.h"
#include "storage/ipc.h"
#include "storage/lmgr.h"
#include "utils/builtins.h"
#include "utils/lsyscache.h"
#include "utils/memutils.h"
#include "utils/snapmgr.h"
#include "utils/syscache.h"

Include dependency graph for tablesync.c:

Go to the source code of this file.

Functions
static bool	FetchTableStates (bool *started_tx)
static void	pg_attribute_noreturn ()
static bool	wait_for_relation_state_change (Oid relid, char expected_state)
static bool	wait_for_worker_state_change (char expected_state)
void	invalidate_syncing_table_states (Datum arg, int cacheid, uint32 hashvalue)
static void	process_syncing_tables_for_sync (XLogRecPtr current_lsn)
static void	process_syncing_tables_for_apply (XLogRecPtr current_lsn)
void	process_syncing_tables (XLogRecPtr current_lsn)
static List *	make_copy_attnamelist (LogicalRepRelMapEntry *rel)
static int	copy_read_data (void *outbuf, int minread, int maxread)
static void	fetch_remote_table_info (char *nspname, char *relname, LogicalRepRelation *lrel)
static void	copy_table (Relation rel)
void	ReplicationSlotNameForTablesync (Oid suboid, Oid relid, char *syncslotname, int szslot)
void	ReplicationOriginNameForTablesync (Oid suboid, Oid relid, char *originname, int szorgname)
char *	LogicalRepSyncTableStart (XLogRecPtr *origin_startpos)
bool	AllTablesyncsReady (void)
void	UpdateTwoPhaseState (Oid suboid, char new_state)

Variables
static bool	table_states_valid = false
static List *	table_states_not_ready = NIL
StringInfo	copybuf = NULL

Function Documentation

AllTablesyncsReady()

bool AllTablesyncsReady

(

void

)

Definition at line 1230 of file tablesync.c.

References CommitTransactionCommand(), FetchTableStates(), list_length(), and pgstat_report_stat().

Referenced by ApplyWorkerMain(), and process_syncing_tables_for_apply().

{
    bool        started_tx = false;
    bool        has_subrels = false;

    /* We need up-to-date sync state info for subscription tables here. */
    has_subrels = FetchTableStates(&started_tx);

    if (started_tx)
    {
        CommitTransactionCommand();
        pgstat_report_stat(false);
    }

    /*
     * Return false when there are no tables in subscription or not all tables
     * are in ready state; true otherwise.
     */
    return has_subrels && list_length(table_states_not_ready) == 0;
}

copy_read_data()

static int copy_read_data ( void *  outbuf, int  minread, int  maxread  )

static

Definition at line 619 of file tablesync.c.

References buf, CHECK_FOR_INTERRUPTS, StringInfoData::cursor, StringInfoData::data, fd(), StringInfoData::len, LogRepWorkerWalRcvConn, MyLatch, PGINVALID_SOCKET, ResetLatch(), WAIT_EVENT_LOGICAL_SYNC_DATA, WaitLatchOrSocket(), walrcv_receive, WL_EXIT_ON_PM_DEATH, WL_LATCH_SET, WL_SOCKET_READABLE, and WL_TIMEOUT.

Referenced by copy_table().

{
    int         bytesread = 0;
    int         avail;

    /* If there are some leftover data from previous read, use it. */
    avail = copybuf->len - copybuf->cursor;
    if (avail)
    {
        if (avail > maxread)
            avail = maxread;
        memcpy(outbuf, &copybuf->data[copybuf->cursor], avail);
        copybuf->cursor += avail;
        maxread -= avail;
        bytesread += avail;
    }

    while (maxread > 0 && bytesread < minread)
    {
        pgsocket    fd = PGINVALID_SOCKET;
        int         len;
        char       *buf = NULL;

        for (;;)
        {
            /* Try read the data. */
            len = walrcv_receive(LogRepWorkerWalRcvConn, &buf, &fd);

            CHECK_FOR_INTERRUPTS();

            if (len == 0)
                break;
            else if (len < 0)
                return bytesread;
            else
            {
                /* Process the data */
                copybuf->data = buf;
                copybuf->len = len;
                copybuf->cursor = 0;

                avail = copybuf->len - copybuf->cursor;
                if (avail > maxread)
                    avail = maxread;
                memcpy(outbuf, &copybuf->data[copybuf->cursor], avail);
                outbuf = (void *) ((char *) outbuf + avail);
                copybuf->cursor += avail;
                maxread -= avail;
                bytesread += avail;
            }

            if (maxread <= 0 || bytesread >= minread)
                return bytesread;
        }

        /*
         * Wait for more data or latch.
         */
        (void) WaitLatchOrSocket(MyLatch,
                                 WL_SOCKET_READABLE | WL_LATCH_SET |
                                 WL_TIMEOUT | WL_EXIT_ON_PM_DEATH,
                                 fd, 1000L, WAIT_EVENT_LOGICAL_SYNC_DATA);

        ResetLatch(MyLatch);
    }

    return bytesread;
}

copy_table()

static void copy_table ( Relation  rel )

static

Definition at line 808 of file tablesync.c.

References AccessShareLock, addRangeTableEntryForRelation(), appendStringInfo(), appendStringInfoString(), Assert, LogicalRepRelation::attnames, BeginCopyFrom(), copy_read_data(), CopyFrom(), StringInfoData::data, ereport, WalRcvExecResult::err, errcode(), errmsg(), ERROR, fetch_remote_table_info(), get_namespace_name(), i, initStringInfo(), LogicalRepRelMapEntry::localrel, logicalrep_rel_close(), logicalrep_rel_open(), logicalrep_relmap_update(), LogRepWorkerWalRcvConn, make_copy_attnamelist(), make_parsestate(), makeStringInfo(), LogicalRepRelation::natts, NIL, NoLock, LogicalRepRelation::nspname, pfree(), quote_identifier(), quote_qualified_identifier(), RelationGetNamespace, RelationGetRelationName, LogicalRepRelation::relkind, LogicalRepRelation::relname, LogicalRepRelation::remoteid, WalRcvExecResult::status, walrcv_clear_result(), walrcv_exec, and WALRCV_OK_COPY_OUT.

Referenced by LogicalRepSyncTableStart().

{
    LogicalRepRelMapEntry *relmapentry;
    LogicalRepRelation lrel;
    WalRcvExecResult *res;
    StringInfoData cmd;
    CopyFromState cstate;
    List       *attnamelist;
    ParseState *pstate;

    /* Get the publisher relation info. */
    fetch_remote_table_info(get_namespace_name(RelationGetNamespace(rel)),
                            RelationGetRelationName(rel), &lrel);

    /* Put the relation into relmap. */
    logicalrep_relmap_update(&lrel);

    /* Map the publisher relation to local one. */
    relmapentry = logicalrep_rel_open(lrel.remoteid, NoLock);
    Assert(rel == relmapentry->localrel);

    /* Start copy on the publisher. */
    initStringInfo(&cmd);
    if (lrel.relkind == RELKIND_RELATION)
        appendStringInfo(&cmd, "COPY %s TO STDOUT",
                         quote_qualified_identifier(lrel.nspname, lrel.relname));
    else
    {
        /*
         * For non-tables, we need to do COPY (SELECT ...), but we can't just
         * do SELECT * because we need to not copy generated columns.
         */
        appendStringInfoString(&cmd, "COPY (SELECT ");
        for (int i = 0; i < lrel.natts; i++)
        {
            appendStringInfoString(&cmd, quote_identifier(lrel.attnames[i]));
            if (i < lrel.natts - 1)
                appendStringInfoString(&cmd, ", ");
        }
        appendStringInfo(&cmd, " FROM %s) TO STDOUT",
                         quote_qualified_identifier(lrel.nspname, lrel.relname));
    }
    res = walrcv_exec(LogRepWorkerWalRcvConn, cmd.data, 0, NULL);
    pfree(cmd.data);
    if (res->status != WALRCV_OK_COPY_OUT)
        ereport(ERROR,
                (errcode(ERRCODE_CONNECTION_FAILURE),
                 errmsg("could not start initial contents copy for table \"%s.%s\": %s",
                        lrel.nspname, lrel.relname, res->err)));
    walrcv_clear_result(res);

    copybuf = makeStringInfo();

    pstate = make_parsestate(NULL);
    (void) addRangeTableEntryForRelation(pstate, rel, AccessShareLock,
                                         NULL, false, false);

    attnamelist = make_copy_attnamelist(relmapentry);
    cstate = BeginCopyFrom(pstate, rel, NULL, NULL, false, copy_read_data, attnamelist, NIL);

    /* Do the copy */
    (void) CopyFrom(cstate);

    logicalrep_rel_close(relmapentry, NoLock);
}

fetch_remote_table_info()

static void fetch_remote_table_info ( char *  nspname, char *  relname, LogicalRepRelation *  lrel  )

static

Definition at line 694 of file tablesync.c.

References appendStringInfo(), Assert, LogicalRepRelation::attkeys, LogicalRepRelation::attnames, LogicalRepRelation::atttyps, bms_add_member(), StringInfoData::data, DatumGetBool, DatumGetChar, DatumGetObjectId, elog, ereport, WalRcvExecResult::err, errcode(), errmsg(), ERROR, ExecClearTuple(), ExecDropSingleTupleTableSlot(), initStringInfo(), lengthof, LogRepWorkerWalRcvConn, MakeSingleTupleTableSlot(), MaxTupleAttributeNumber, LogicalRepRelation::natts, LogicalRepRelation::nspname, palloc0(), pfree(), quote_literal_cstr(), LogicalRepRelation::relkind, relname, LogicalRepRelation::relname, LogicalRepRelation::remoteid, LogicalRepRelation::replident, resetStringInfo(), slot_getattr(), WalRcvExecResult::status, TextDatumGetCString, TTSOpsMinimalTuple, WalRcvExecResult::tupledesc, WalRcvExecResult::tuplestore, tuplestore_gettupleslot(), walrcv_clear_result(), walrcv_exec, WALRCV_OK_TUPLES, and walrcv_server_version.

Referenced by copy_table().

{
    WalRcvExecResult *res;
    StringInfoData cmd;
    TupleTableSlot *slot;
    Oid         tableRow[] = {OIDOID, CHAROID, CHAROID};
    Oid         attrRow[] = {TEXTOID, OIDOID, BOOLOID};
    bool        isnull;
    int         natt;

    lrel->nspname = nspname;
    lrel->relname = relname;

    /* First fetch Oid and replica identity. */
    initStringInfo(&cmd);
    appendStringInfo(&cmd, "SELECT c.oid, c.relreplident, c.relkind"
                     "  FROM pg_catalog.pg_class c"
                     "  INNER JOIN pg_catalog.pg_namespace n"
                     "        ON (c.relnamespace = n.oid)"
                     " WHERE n.nspname = %s"
                     "   AND c.relname = %s",
                     quote_literal_cstr(nspname),
                     quote_literal_cstr(relname));
    res = walrcv_exec(LogRepWorkerWalRcvConn, cmd.data,
                      lengthof(tableRow), tableRow);

    if (res->status != WALRCV_OK_TUPLES)
        ereport(ERROR,
                (errcode(ERRCODE_CONNECTION_FAILURE),
                 errmsg("could not fetch table info for table \"%s.%s\" from publisher: %s",
                        nspname, relname, res->err)));

    slot = MakeSingleTupleTableSlot(res->tupledesc, &TTSOpsMinimalTuple);
    if (!tuplestore_gettupleslot(res->tuplestore, true, false, slot))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("table \"%s.%s\" not found on publisher",
                        nspname, relname)));

    lrel->remoteid = DatumGetObjectId(slot_getattr(slot, 1, &isnull));
    Assert(!isnull);
    lrel->replident = DatumGetChar(slot_getattr(slot, 2, &isnull));
    Assert(!isnull);
    lrel->relkind = DatumGetChar(slot_getattr(slot, 3, &isnull));
    Assert(!isnull);

    ExecDropSingleTupleTableSlot(slot);
    walrcv_clear_result(res);

    /* Now fetch columns. */
    resetStringInfo(&cmd);
    appendStringInfo(&cmd,
                     "SELECT a.attname,"
                     "       a.atttypid,"
                     "       a.attnum = ANY(i.indkey)"
                     "  FROM pg_catalog.pg_attribute a"
                     "  LEFT JOIN pg_catalog.pg_index i"
                     "       ON (i.indexrelid = pg_get_replica_identity_index(%u))"
                     " WHERE a.attnum > 0::pg_catalog.int2"
                     "   AND NOT a.attisdropped %s"
                     "   AND a.attrelid = %u"
                     " ORDER BY a.attnum",
                     lrel->remoteid,
                     (walrcv_server_version(LogRepWorkerWalRcvConn) >= 120000 ?
                      "AND a.attgenerated = ''" : ""),
                     lrel->remoteid);
    res = walrcv_exec(LogRepWorkerWalRcvConn, cmd.data,
                      lengthof(attrRow), attrRow);

    if (res->status != WALRCV_OK_TUPLES)
        ereport(ERROR,
                (errcode(ERRCODE_CONNECTION_FAILURE),
                 errmsg("could not fetch table info for table \"%s.%s\" from publisher: %s",
                        nspname, relname, res->err)));

    /* We don't know the number of rows coming, so allocate enough space. */
    lrel->attnames = palloc0(MaxTupleAttributeNumber * sizeof(char *));
    lrel->atttyps = palloc0(MaxTupleAttributeNumber * sizeof(Oid));
    lrel->attkeys = NULL;

    natt = 0;
    slot = MakeSingleTupleTableSlot(res->tupledesc, &TTSOpsMinimalTuple);
    while (tuplestore_gettupleslot(res->tuplestore, true, false, slot))
    {
        lrel->attnames[natt] =
            TextDatumGetCString(slot_getattr(slot, 1, &isnull));
        Assert(!isnull);
        lrel->atttyps[natt] = DatumGetObjectId(slot_getattr(slot, 2, &isnull));
        Assert(!isnull);
        if (DatumGetBool(slot_getattr(slot, 3, &isnull)))
            lrel->attkeys = bms_add_member(lrel->attkeys, natt);

        /* Should never happen. */
        if (++natt >= MaxTupleAttributeNumber)
            elog(ERROR, "too many columns in remote table \"%s.%s\"",
                 nspname, relname);

        ExecClearTuple(slot);
    }
    ExecDropSingleTupleTableSlot(slot);

    lrel->natts = natt;

    walrcv_clear_result(res);
    pfree(cmd.data);
}

FetchTableStates()

static bool FetchTableStates ( bool *  started_tx )

static

Definition at line 1169 of file tablesync.c.

References CacheMemoryContext, GetSubscriptionNotReadyRelations(), HasSubscriptionRelations(), IsTransactionState(), lappend(), lfirst, list_free_deep(), list_length(), MemoryContextSwitchTo(), MySubscription, NIL, Subscription::oid, palloc(), StartTransactionCommand(), and table_states_valid.

Referenced by AllTablesyncsReady(), and process_syncing_tables_for_apply().

{
    static bool has_subrels = false;

    *started_tx = false;

    if (!table_states_valid)
    {
        MemoryContext oldctx;
        List       *rstates;
        ListCell   *lc;
        SubscriptionRelState *rstate;

        /* Clean the old lists. */
        list_free_deep(table_states_not_ready);
        table_states_not_ready = NIL;

        if (!IsTransactionState())
        {
            StartTransactionCommand();
            *started_tx = true;
        }

        /* Fetch all non-ready tables. */
        rstates = GetSubscriptionNotReadyRelations(MySubscription->oid);

        /* Allocate the tracking info in a permanent memory context. */
        oldctx = MemoryContextSwitchTo(CacheMemoryContext);
        foreach(lc, rstates)
        {
            rstate = palloc(sizeof(SubscriptionRelState));
            memcpy(rstate, lfirst(lc), sizeof(SubscriptionRelState));
            table_states_not_ready = lappend(table_states_not_ready, rstate);
        }
        MemoryContextSwitchTo(oldctx);

        /*
         * Does the subscription have tables?
         *
         * If there were not-READY relations found then we know it does. But
         * if table_state_not_ready was empty we still need to check again to
         * see if there are 0 tables.
         */
        has_subrels = (list_length(table_states_not_ready) > 0) ||
            HasSubscriptionRelations(MySubscription->oid);

        table_states_valid = true;
    }

    return has_subrels;
}

invalidate_syncing_table_states()

void invalidate_syncing_table_states	(	Datum	arg,
		int	cacheid,
		uint32	hashvalue
	)

Definition at line 268 of file tablesync.c.

References table_states_valid.

Referenced by ApplyWorkerMain().

{
    table_states_valid = false;
}

LogicalRepSyncTableStart()

char* LogicalRepSyncTableStart

(

XLogRecPtr *

origin_startpos

)

Definition at line 920 of file tablesync.c.

References Assert, CommandCounterIncrement(), CommitTransactionCommand(), Subscription::conninfo, copy_table(), CRS_USE_SNAPSHOT, DEBUG1, elog, ereport, WalRcvExecResult::err, errcode(), ERRCODE_DUPLICATE_OBJECT, errmsg(), ERROR, GetSubscriptionRelState(), GetTransactionSnapshot(), HOLD_INTERRUPTS, InvalidXLogRecPtr, LockRelationOid(), LogRepWorkerWalRcvConn, LSN_FORMAT_ARGS, MyLogicalRepWorker, MySubscription, NAMEDATALEN, NoLock, Subscription::oid, OidIsValid, palloc(), pgstat_report_stat(), PopActiveSnapshot(), PushActiveSnapshot(), LogicalRepWorker::relid, LogicalRepWorker::relmutex, LogicalRepWorker::relstate, LogicalRepWorker::relstate_lsn, ReplicationOriginNameForTablesync(), ReplicationSlotDropAtPubNode(), ReplicationSlotNameForTablesync(), replorigin_advance(), replorigin_by_name(), replorigin_create(), replorigin_session_get_progress(), replorigin_session_origin, replorigin_session_setup(), RESUME_INTERRUPTS, RowExclusiveLock, SpinLockAcquire, SpinLockRelease, StartTransactionCommand(), WalRcvExecResult::status, LogicalRepWorker::subid, table_close(), table_open(), UnlockRelationOid(), UpdateSubscriptionRelState(), wait_for_worker_state_change(), walrcv_clear_result(), walrcv_connect, walrcv_create_slot, walrcv_exec, and WALRCV_OK_COMMAND.

Referenced by ApplyWorkerMain().

{
    char       *slotname;
    char       *err;
    char        relstate;
    XLogRecPtr  relstate_lsn;
    Relation    rel;
    WalRcvExecResult *res;
    char        originname[NAMEDATALEN];
    RepOriginId originid;

    /* Check the state of the table synchronization. */
    StartTransactionCommand();
    relstate = GetSubscriptionRelState(MyLogicalRepWorker->subid,
                                       MyLogicalRepWorker->relid,
                                       &relstate_lsn);
    CommitTransactionCommand();

    SpinLockAcquire(&MyLogicalRepWorker->relmutex);
    MyLogicalRepWorker->relstate = relstate;
    MyLogicalRepWorker->relstate_lsn = relstate_lsn;
    SpinLockRelease(&MyLogicalRepWorker->relmutex);

    /*
     * If synchronization is already done or no longer necessary, exit now
     * that we've updated shared memory state.
     */
    switch (relstate)
    {
        case SUBREL_STATE_SYNCDONE:
        case SUBREL_STATE_READY:
        case SUBREL_STATE_UNKNOWN:
            finish_sync_worker();   /* doesn't return */
    }

    /* Calculate the name of the tablesync slot. */
    slotname = (char *) palloc(NAMEDATALEN);
    ReplicationSlotNameForTablesync(MySubscription->oid,
                                    MyLogicalRepWorker->relid,
                                    slotname,
                                    NAMEDATALEN);

    /*
     * Here we use the slot name instead of the subscription name as the
     * application_name, so that it is different from the main apply worker,
     * so that synchronous replication can distinguish them.
     */
    LogRepWorkerWalRcvConn =
        walrcv_connect(MySubscription->conninfo, true, slotname, &err);
    if (LogRepWorkerWalRcvConn == NULL)
        ereport(ERROR,
                (errcode(ERRCODE_CONNECTION_FAILURE),
                 errmsg("could not connect to the publisher: %s", err)));

    Assert(MyLogicalRepWorker->relstate == SUBREL_STATE_INIT ||
           MyLogicalRepWorker->relstate == SUBREL_STATE_DATASYNC ||
           MyLogicalRepWorker->relstate == SUBREL_STATE_FINISHEDCOPY);

    /* Assign the origin tracking record name. */
    ReplicationOriginNameForTablesync(MySubscription->oid,
                                      MyLogicalRepWorker->relid,
                                      originname,
                                      sizeof(originname));

    if (MyLogicalRepWorker->relstate == SUBREL_STATE_DATASYNC)
    {
        /*
         * We have previously errored out before finishing the copy so the
         * replication slot might exist. We want to remove the slot if it
         * already exists and proceed.
         *
         * XXX We could also instead try to drop the slot, last time we failed
         * but for that, we might need to clean up the copy state as it might
         * be in the middle of fetching the rows. Also, if there is a network
         * breakdown then it wouldn't have succeeded so trying it next time
         * seems like a better bet.
         */
        ReplicationSlotDropAtPubNode(LogRepWorkerWalRcvConn, slotname, true);
    }
    else if (MyLogicalRepWorker->relstate == SUBREL_STATE_FINISHEDCOPY)
    {
        /*
         * The COPY phase was previously done, but tablesync then crashed
         * before it was able to finish normally.
         */
        StartTransactionCommand();

        /*
         * The origin tracking name must already exist. It was created first
         * time this tablesync was launched.
         */
        originid = replorigin_by_name(originname, false);
        replorigin_session_setup(originid);
        replorigin_session_origin = originid;
        *origin_startpos = replorigin_session_get_progress(false);

        CommitTransactionCommand();

        goto copy_table_done;
    }

    SpinLockAcquire(&MyLogicalRepWorker->relmutex);
    MyLogicalRepWorker->relstate = SUBREL_STATE_DATASYNC;
    MyLogicalRepWorker->relstate_lsn = InvalidXLogRecPtr;
    SpinLockRelease(&MyLogicalRepWorker->relmutex);

    /* Update the state and make it visible to others. */
    StartTransactionCommand();
    UpdateSubscriptionRelState(MyLogicalRepWorker->subid,
                               MyLogicalRepWorker->relid,
                               MyLogicalRepWorker->relstate,
                               MyLogicalRepWorker->relstate_lsn);
    CommitTransactionCommand();
    pgstat_report_stat(false);

    StartTransactionCommand();

    /*
     * Use a standard write lock here. It might be better to disallow access
     * to the table while it's being synchronized. But we don't want to block
     * the main apply process from working and it has to open the relation in
     * RowExclusiveLock when remapping remote relation id to local one.
     */
    rel = table_open(MyLogicalRepWorker->relid, RowExclusiveLock);

    /*
     * Start a transaction in the remote node in REPEATABLE READ mode.  This
     * ensures that both the replication slot we create (see below) and the
     * COPY are consistent with each other.
     */
    res = walrcv_exec(LogRepWorkerWalRcvConn,
                      "BEGIN READ ONLY ISOLATION LEVEL REPEATABLE READ",
                      0, NULL);
    if (res->status != WALRCV_OK_COMMAND)
        ereport(ERROR,
                (errcode(ERRCODE_CONNECTION_FAILURE),
                 errmsg("table copy could not start transaction on publisher: %s",
                        res->err)));
    walrcv_clear_result(res);

    /*
     * Create a new permanent logical decoding slot. This slot will be used
     * for the catchup phase after COPY is done, so tell it to use the
     * snapshot to make the final data consistent.
     *
     * Prevent cancel/die interrupts while creating slot here because it is
     * possible that before the server finishes this command, a concurrent
     * drop subscription happens which would complete without removing this
     * slot leading to a dangling slot on the server.
     */
    HOLD_INTERRUPTS();
    walrcv_create_slot(LogRepWorkerWalRcvConn,
                       slotname, false /* permanent */ , false /* two_phase */ ,
                       CRS_USE_SNAPSHOT, origin_startpos);
    RESUME_INTERRUPTS();

    /*
     * Setup replication origin tracking. The purpose of doing this before the
     * copy is to avoid doing the copy again due to any error in setting up
     * origin tracking.
     */
    originid = replorigin_by_name(originname, true);
    if (!OidIsValid(originid))
    {
        /*
         * Origin tracking does not exist, so create it now.
         *
         * Then advance to the LSN got from walrcv_create_slot. This is WAL
         * logged for the purpose of recovery. Locks are to prevent the
         * replication origin from vanishing while advancing.
         */
        originid = replorigin_create(originname);

        LockRelationOid(ReplicationOriginRelationId, RowExclusiveLock);
        replorigin_advance(originid, *origin_startpos, InvalidXLogRecPtr,
                           true /* go backward */ , true /* WAL log */ );
        UnlockRelationOid(ReplicationOriginRelationId, RowExclusiveLock);

        replorigin_session_setup(originid);
        replorigin_session_origin = originid;
    }
    else
    {
        ereport(ERROR,
                (errcode(ERRCODE_DUPLICATE_OBJECT),
                 errmsg("replication origin \"%s\" already exists",
                        originname)));
    }

    /* Now do the initial data copy */
    PushActiveSnapshot(GetTransactionSnapshot());
    copy_table(rel);
    PopActiveSnapshot();

    res = walrcv_exec(LogRepWorkerWalRcvConn, "COMMIT", 0, NULL);
    if (res->status != WALRCV_OK_COMMAND)
        ereport(ERROR,
                (errcode(ERRCODE_CONNECTION_FAILURE),
                 errmsg("table copy could not finish transaction on publisher: %s",
                        res->err)));
    walrcv_clear_result(res);

    table_close(rel, NoLock);

    /* Make the copy visible. */
    CommandCounterIncrement();

    /*
     * Update the persisted state to indicate the COPY phase is done; make it
     * visible to others.
     */
    UpdateSubscriptionRelState(MyLogicalRepWorker->subid,
                               MyLogicalRepWorker->relid,
                               SUBREL_STATE_FINISHEDCOPY,
                               MyLogicalRepWorker->relstate_lsn);

    CommitTransactionCommand();

copy_table_done:

    elog(DEBUG1,
         "LogicalRepSyncTableStart: '%s' origin_startpos lsn %X/%X",
         originname, LSN_FORMAT_ARGS(*origin_startpos));

    /*
     * We are done with the initial data synchronization, update the state.
     */
    SpinLockAcquire(&MyLogicalRepWorker->relmutex);
    MyLogicalRepWorker->relstate = SUBREL_STATE_SYNCWAIT;
    MyLogicalRepWorker->relstate_lsn = *origin_startpos;
    SpinLockRelease(&MyLogicalRepWorker->relmutex);

    /*
     * Finally, wait until the main apply worker tells us to catch up and then
     * return to let LogicalRepApplyLoop do it.
     */
    wait_for_worker_state_change(SUBREL_STATE_CATCHUP);
    return slotname;
}

make_copy_attnamelist()

static List* make_copy_attnamelist ( LogicalRepRelMapEntry *  rel )

static

Definition at line 599 of file tablesync.c.

References LogicalRepRelation::attnames, i, lappend(), makeString(), LogicalRepRelation::natts, NIL, and LogicalRepRelMapEntry::remoterel.

Referenced by copy_table().

{
    List       *attnamelist = NIL;
    int         i;

    for (i = 0; i < rel->remoterel.natts; i++)
    {
        attnamelist = lappend(attnamelist,
                              makeString(rel->remoterel.attnames[i]));
    }


    return attnamelist;
}

pg_attribute_noreturn()

static void pg_attribute_noreturn ( )

static

Definition at line 130 of file tablesync.c.

References CommitTransactionCommand(), ereport, errmsg(), get_rel_name(), GetXLogWriteRecPtr(), InvalidOid, IsTransactionState(), LOG, logicalrep_worker_wakeup(), MyLogicalRepWorker, MySubscription, Subscription::name, pgstat_report_stat(), proc_exit(), LogicalRepWorker::relid, StartTransactionCommand(), LogicalRepWorker::subid, and XLogFlush().

{
    /*
     * Commit any outstanding transaction. This is the usual case, unless
     * there was nothing to do for the table.
     */
    if (IsTransactionState())
    {
        CommitTransactionCommand();
        pgstat_report_stat(false);
    }

    /* And flush all writes. */
    XLogFlush(GetXLogWriteRecPtr());

    StartTransactionCommand();
    ereport(LOG,
            (errmsg("logical replication table synchronization worker for subscription \"%s\", table \"%s\" has finished",
                    MySubscription->name,
                    get_rel_name(MyLogicalRepWorker->relid))));
    CommitTransactionCommand();

    /* Find the main apply worker and signal it. */
    logicalrep_worker_wakeup(MyLogicalRepWorker->subid, InvalidOid);

    /* Stop gracefully */
    proc_exit(0);
}

process_syncing_tables()

void process_syncing_tables

(

XLogRecPtr

current_lsn

)

Definition at line 587 of file tablesync.c.

References am_tablesync_worker(), process_syncing_tables_for_apply(), and process_syncing_tables_for_sync().

Referenced by apply_handle_commit(), apply_handle_commit_prepared(), apply_handle_prepare(), apply_handle_rollback_prepared(), apply_handle_stream_commit(), apply_handle_stream_prepare(), and LogicalRepApplyLoop().

{
    if (am_tablesync_worker())
        process_syncing_tables_for_sync(current_lsn);
    else
        process_syncing_tables_for_apply(current_lsn);
}

process_syncing_tables_for_apply()

static void process_syncing_tables_for_apply ( XLogRecPtr  current_lsn )

static

Definition at line 362 of file tablesync.c.

References AllTablesyncsReady(), Assert, CommitTransactionCommand(), LogicalRepWorker::dbid, HASHCTL::entrysize, ereport, errmsg(), FetchTableStates(), GetCurrentTimestamp(), HASH_BLOBS, hash_create(), hash_destroy(), HASH_ELEM, HASH_ENTER, hash_search(), IsTransactionState(), HASHCTL::keysize, lfirst, LOG, logicalrep_sync_worker_count(), LOGICALREP_TWOPHASE_STATE_PENDING, logicalrep_worker_find(), logicalrep_worker_launch(), logicalrep_worker_wakeup_ptr(), SubscriptionRelState::lsn, LW_SHARED, LWLockAcquire(), LWLockRelease(), Max, max_sync_workers_per_subscription, MyLogicalRepWorker, MySubscription, Subscription::name, NAMEDATALEN, now(), Subscription::oid, pgstat_report_stat(), LogicalRepWorker::proc, proc_exit(), SubscriptionRelState::relid, LogicalRepWorker::relmutex, LogicalRepWorker::relstate, LogicalRepWorker::relstate_lsn, ReplicationOriginNameForTablesync(), replorigin_drop_by_name(), SpinLockAcquire, SpinLockRelease, StartTransactionCommand(), SubscriptionRelState::state, LogicalRepWorker::subid, TimestampDifferenceExceeds(), Subscription::twophasestate, UpdateSubscriptionRelState(), LogicalRepWorker::userid, wait_for_relation_state_change(), and wal_retrieve_retry_interval.

Referenced by process_syncing_tables().

{
    struct tablesync_start_time_mapping
    {
        Oid         relid;
        TimestampTz last_start_time;
    };
    static HTAB *last_start_times = NULL;
    ListCell   *lc;
    bool        started_tx = false;

    Assert(!IsTransactionState());

    /* We need up-to-date sync state info for subscription tables here. */
    FetchTableStates(&started_tx);

    /*
     * Prepare a hash table for tracking last start times of workers, to avoid
     * immediate restarts.  We don't need it if there are no tables that need
     * syncing.
     */
    if (table_states_not_ready && !last_start_times)
    {
        HASHCTL     ctl;

        ctl.keysize = sizeof(Oid);
        ctl.entrysize = sizeof(struct tablesync_start_time_mapping);
        last_start_times = hash_create("Logical replication table sync worker start times",
                                       256, &ctl, HASH_ELEM | HASH_BLOBS);
    }

    /*
     * Clean up the hash table when we're done with all tables (just to
     * release the bit of memory).
     */
    else if (!table_states_not_ready && last_start_times)
    {
        hash_destroy(last_start_times);
        last_start_times = NULL;
    }

    /*
     * Even when the two_phase mode is requested by the user, it remains as
     * 'pending' until all tablesyncs have reached READY state.
     *
     * When this happens, we restart the apply worker and (if the conditions
     * are still ok) then the two_phase tri-state will become 'enabled' at
     * that time.
     *
     * Note: If the subscription has no tables then leave the state as
     * PENDING, which allows ALTER SUBSCRIPTION ... REFRESH PUBLICATION to
     * work.
     */
    if (MySubscription->twophasestate == LOGICALREP_TWOPHASE_STATE_PENDING &&
        AllTablesyncsReady())
    {
        ereport(LOG,
                (errmsg("logical replication apply worker for subscription \"%s\" will restart so that two_phase can be enabled",
                        MySubscription->name)));

        proc_exit(0);
    }

    /*
     * Process all tables that are being synchronized.
     */
    foreach(lc, table_states_not_ready)
    {
        SubscriptionRelState *rstate = (SubscriptionRelState *) lfirst(lc);

        if (rstate->state == SUBREL_STATE_SYNCDONE)
        {
            /*
             * Apply has caught up to the position where the table sync has
             * finished.  Mark the table as ready so that the apply will just
             * continue to replicate it normally.
             */
            if (current_lsn >= rstate->lsn)
            {
                char        originname[NAMEDATALEN];

                rstate->state = SUBREL_STATE_READY;
                rstate->lsn = current_lsn;
                if (!started_tx)
                {
                    StartTransactionCommand();
                    started_tx = true;
                }

                /*
                 * Remove the tablesync origin tracking if exists.
                 *
                 * The normal case origin drop is done here instead of in the
                 * process_syncing_tables_for_sync function because we don't
                 * allow to drop the origin till the process owning the origin
                 * is alive.
                 *
                 * There is a chance that the user is concurrently performing
                 * refresh for the subscription where we remove the table
                 * state and its origin and by this time the origin might be
                 * already removed. So passing missing_ok = true.
                 */
                ReplicationOriginNameForTablesync(MyLogicalRepWorker->subid,
                                                  rstate->relid,
                                                  originname,
                                                  sizeof(originname));
                replorigin_drop_by_name(originname, true, false);

                /*
                 * Update the state to READY only after the origin cleanup.
                 */
                UpdateSubscriptionRelState(MyLogicalRepWorker->subid,
                                           rstate->relid, rstate->state,
                                           rstate->lsn);
            }
        }
        else
        {
            LogicalRepWorker *syncworker;

            /*
             * Look for a sync worker for this relation.
             */
            LWLockAcquire(LogicalRepWorkerLock, LW_SHARED);

            syncworker = logicalrep_worker_find(MyLogicalRepWorker->subid,
                                                rstate->relid, false);

            if (syncworker)
            {
                /* Found one, update our copy of its state */
                SpinLockAcquire(&syncworker->relmutex);
                rstate->state = syncworker->relstate;
                rstate->lsn = syncworker->relstate_lsn;
                if (rstate->state == SUBREL_STATE_SYNCWAIT)
                {
                    /*
                     * Sync worker is waiting for apply.  Tell sync worker it
                     * can catchup now.
                     */
                    syncworker->relstate = SUBREL_STATE_CATCHUP;
                    syncworker->relstate_lsn =
                        Max(syncworker->relstate_lsn, current_lsn);
                }
                SpinLockRelease(&syncworker->relmutex);

                /* If we told worker to catch up, wait for it. */
                if (rstate->state == SUBREL_STATE_SYNCWAIT)
                {
                    /* Signal the sync worker, as it may be waiting for us. */
                    if (syncworker->proc)
                        logicalrep_worker_wakeup_ptr(syncworker);

                    /* Now safe to release the LWLock */
                    LWLockRelease(LogicalRepWorkerLock);

                    /*
                     * Enter busy loop and wait for synchronization worker to
                     * reach expected state (or die trying).
                     */
                    if (!started_tx)
                    {
                        StartTransactionCommand();
                        started_tx = true;
                    }

                    wait_for_relation_state_change(rstate->relid,
                                                   SUBREL_STATE_SYNCDONE);
                }
                else
                    LWLockRelease(LogicalRepWorkerLock);
            }
            else
            {
                /*
                 * If there is no sync worker for this table yet, count
                 * running sync workers for this subscription, while we have
                 * the lock.
                 */
                int         nsyncworkers =
                logicalrep_sync_worker_count(MyLogicalRepWorker->subid);

                /* Now safe to release the LWLock */
                LWLockRelease(LogicalRepWorkerLock);

                /*
                 * If there are free sync worker slot(s), start a new sync
                 * worker for the table.
                 */
                if (nsyncworkers < max_sync_workers_per_subscription)
                {
                    TimestampTz now = GetCurrentTimestamp();
                    struct tablesync_start_time_mapping *hentry;
                    bool        found;

                    hentry = hash_search(last_start_times, &rstate->relid,
                                         HASH_ENTER, &found);

                    if (!found ||
                        TimestampDifferenceExceeds(hentry->last_start_time, now,
                                                   wal_retrieve_retry_interval))
                    {
                        logicalrep_worker_launch(MyLogicalRepWorker->dbid,
                                                 MySubscription->oid,
                                                 MySubscription->name,
                                                 MyLogicalRepWorker->userid,
                                                 rstate->relid);
                        hentry->last_start_time = now;
                    }
                }
            }
        }
    }

    if (started_tx)
    {
        CommitTransactionCommand();
        pgstat_report_stat(false);
    }
}

process_syncing_tables_for_sync()

static void process_syncing_tables_for_sync ( XLogRecPtr  current_lsn )

static

Definition at line 282 of file tablesync.c.

References IsTransactionState(), LogRepWorkerWalRcvConn, MyLogicalRepWorker, NAMEDATALEN, LogicalRepWorker::relid, LogicalRepWorker::relmutex, LogicalRepWorker::relstate, LogicalRepWorker::relstate_lsn, ReplicationSlotDropAtPubNode(), ReplicationSlotNameForTablesync(), SpinLockAcquire, SpinLockRelease, StartTransactionCommand(), LogicalRepWorker::subid, UpdateSubscriptionRelState(), and walrcv_endstreaming.

Referenced by process_syncing_tables().

{
    SpinLockAcquire(&MyLogicalRepWorker->relmutex);

    if (MyLogicalRepWorker->relstate == SUBREL_STATE_CATCHUP &&
        current_lsn >= MyLogicalRepWorker->relstate_lsn)
    {
        TimeLineID  tli;
        char        syncslotname[NAMEDATALEN] = {0};

        MyLogicalRepWorker->relstate = SUBREL_STATE_SYNCDONE;
        MyLogicalRepWorker->relstate_lsn = current_lsn;

        SpinLockRelease(&MyLogicalRepWorker->relmutex);

        /*
         * UpdateSubscriptionRelState must be called within a transaction.
         * That transaction will be ended within the finish_sync_worker().
         */
        if (!IsTransactionState())
            StartTransactionCommand();

        UpdateSubscriptionRelState(MyLogicalRepWorker->subid,
                                   MyLogicalRepWorker->relid,
                                   MyLogicalRepWorker->relstate,
                                   MyLogicalRepWorker->relstate_lsn);

        /*
         * End streaming so that LogRepWorkerWalRcvConn can be used to drop
         * the slot.
         */
        walrcv_endstreaming(LogRepWorkerWalRcvConn, &tli);

        /*
         * Cleanup the tablesync slot.
         *
         * This has to be done after updating the state because otherwise if
         * there is an error while doing the database operations we won't be
         * able to rollback dropped slot.
         */
        ReplicationSlotNameForTablesync(MyLogicalRepWorker->subid,
                                        MyLogicalRepWorker->relid,
                                        syncslotname,
                                        sizeof(syncslotname));

        /*
         * It is important to give an error if we are unable to drop the slot,
         * otherwise, it won't be dropped till the corresponding subscription
         * is dropped. So passing missing_ok = false.
         */
        ReplicationSlotDropAtPubNode(LogRepWorkerWalRcvConn, syncslotname, false);

        finish_sync_worker();
    }
    else
        SpinLockRelease(&MyLogicalRepWorker->relmutex);
}

ReplicationOriginNameForTablesync()

void ReplicationOriginNameForTablesync	(	Oid	suboid,
		Oid	relid,
		char *	originname,
		int	szorgname
	)

Definition at line 905 of file tablesync.c.

References snprintf.

Referenced by AlterSubscription_refresh(), DropSubscription(), LogicalRepSyncTableStart(), and process_syncing_tables_for_apply().

{
    snprintf(originname, szorgname, "pg_%u_%u", suboid, relid);
}

ReplicationSlotNameForTablesync()

void ReplicationSlotNameForTablesync	(	Oid	suboid,
		Oid	relid,
		char *	syncslotname,
		int	szslot
	)

Definition at line 892 of file tablesync.c.

References GetSystemIdentifier(), snprintf, and UINT64_FORMAT.

Referenced by AlterSubscription_refresh(), DropSubscription(), LogicalRepSyncTableStart(), process_syncing_tables_for_sync(), and ReportSlotConnectionError().

{
    snprintf(syncslotname, szslot, "pg_%u_sync_%u_" UINT64_FORMAT, suboid,
             relid, GetSystemIdentifier());
}

UpdateTwoPhaseState()

void UpdateTwoPhaseState	(	Oid	suboid,
		char	new_state
	)

Definition at line 1255 of file tablesync.c.

References Assert, CatalogTupleUpdate(), CharGetDatum, elog, ERROR, heap_freetuple(), heap_modify_tuple(), HeapTupleIsValid, LOGICALREP_TWOPHASE_STATE_DISABLED, LOGICALREP_TWOPHASE_STATE_ENABLED, LOGICALREP_TWOPHASE_STATE_PENDING, ObjectIdGetDatum, RelationGetDescr, RowExclusiveLock, SearchSysCacheCopy1, SUBSCRIPTIONOID, HeapTupleData::t_self, table_close(), table_open(), and values.

Referenced by ApplyWorkerMain(), and CreateSubscription().

{
    Relation    rel;
    HeapTuple   tup;
    bool        nulls[Natts_pg_subscription];
    bool        replaces[Natts_pg_subscription];
    Datum       values[Natts_pg_subscription];

    Assert(new_state == LOGICALREP_TWOPHASE_STATE_DISABLED ||
           new_state == LOGICALREP_TWOPHASE_STATE_PENDING ||
           new_state == LOGICALREP_TWOPHASE_STATE_ENABLED);

    rel = table_open(SubscriptionRelationId, RowExclusiveLock);
    tup = SearchSysCacheCopy1(SUBSCRIPTIONOID, ObjectIdGetDatum(suboid));
    if (!HeapTupleIsValid(tup))
        elog(ERROR,
             "cache lookup failed for subscription oid %u",
             suboid);

    /* Form a new tuple. */
    memset(values, 0, sizeof(values));
    memset(nulls, false, sizeof(nulls));
    memset(replaces, false, sizeof(replaces));

    /* And update/set two_phase state */
    values[Anum_pg_subscription_subtwophasestate - 1] = CharGetDatum(new_state);
    replaces[Anum_pg_subscription_subtwophasestate - 1] = true;

    tup = heap_modify_tuple(tup, RelationGetDescr(rel),
                            values, nulls, replaces);
    CatalogTupleUpdate(rel, &tup->t_self, tup);

    heap_freetuple(tup);
    table_close(rel, RowExclusiveLock);
}

wait_for_relation_state_change()

static bool wait_for_relation_state_change ( Oid  relid, char  expected_state  )

static

Definition at line 171 of file tablesync.c.

References CHECK_FOR_INTERRUPTS, GetSubscriptionRelState(), InvalidateCatalogSnapshot(), logicalrep_worker_find(), LW_SHARED, LWLockAcquire(), LWLockRelease(), MyLatch, MyLogicalRepWorker, ResetLatch(), LogicalRepWorker::subid, WAIT_EVENT_LOGICAL_SYNC_STATE_CHANGE, WaitLatch(), WL_EXIT_ON_PM_DEATH, WL_LATCH_SET, and WL_TIMEOUT.

Referenced by process_syncing_tables_for_apply().

{
    char        state;

    for (;;)
    {
        LogicalRepWorker *worker;
        XLogRecPtr  statelsn;

        CHECK_FOR_INTERRUPTS();

        InvalidateCatalogSnapshot();
        state = GetSubscriptionRelState(MyLogicalRepWorker->subid,
                                        relid, &statelsn);

        if (state == SUBREL_STATE_UNKNOWN)
            break;

        if (state == expected_state)
            return true;

        /* Check if the sync worker is still running and bail if not. */
        LWLockAcquire(LogicalRepWorkerLock, LW_SHARED);
        worker = logicalrep_worker_find(MyLogicalRepWorker->subid, relid,
                                        false);
        LWLockRelease(LogicalRepWorkerLock);
        if (!worker)
            break;

        (void) WaitLatch(MyLatch,
                         WL_LATCH_SET | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH,
                         1000L, WAIT_EVENT_LOGICAL_SYNC_STATE_CHANGE);

        ResetLatch(MyLatch);
    }

    return false;
}

wait_for_worker_state_change()

static bool wait_for_worker_state_change ( char  expected_state )

static

Definition at line 219 of file tablesync.c.

References CHECK_FOR_INTERRUPTS, InvalidOid, logicalrep_worker_find(), logicalrep_worker_wakeup_ptr(), LW_SHARED, LWLockAcquire(), LWLockRelease(), MyLatch, MyLogicalRepWorker, LogicalRepWorker::proc, LogicalRepWorker::relstate, ResetLatch(), LogicalRepWorker::subid, WAIT_EVENT_LOGICAL_SYNC_STATE_CHANGE, WaitLatch(), WL_EXIT_ON_PM_DEATH, WL_LATCH_SET, and WL_TIMEOUT.

Referenced by LogicalRepSyncTableStart().

{
    int         rc;

    for (;;)
    {
        LogicalRepWorker *worker;

        CHECK_FOR_INTERRUPTS();

        /*
         * Done if already in correct state.  (We assume this fetch is atomic
         * enough to not give a misleading answer if we do it with no lock.)
         */
        if (MyLogicalRepWorker->relstate == expected_state)
            return true;

        /*
         * Bail out if the apply worker has died, else signal it we're
         * waiting.
         */
        LWLockAcquire(LogicalRepWorkerLock, LW_SHARED);
        worker = logicalrep_worker_find(MyLogicalRepWorker->subid,
                                        InvalidOid, false);
        if (worker && worker->proc)
            logicalrep_worker_wakeup_ptr(worker);
        LWLockRelease(LogicalRepWorkerLock);
        if (!worker)
            break;

        /*
         * Wait.  We expect to get a latch signal back from the apply worker,
         * but use a timeout in case it dies without sending one.
         */
        rc = WaitLatch(MyLatch,
                       WL_LATCH_SET | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH,
                       1000L, WAIT_EVENT_LOGICAL_SYNC_STATE_CHANGE);

        if (rc & WL_LATCH_SET)
            ResetLatch(MyLatch);
    }

    return false;
}

Variable Documentation

copybuf

StringInfo copybuf = NULL

Definition at line 124 of file tablesync.c.

Referenced by CopyStreamReceive(), dumpTableData_copy(), HandleCopyStream(), ReceiveCopyData(), and StreamLogicalLog().

table_states_not_ready

List* table_states_not_ready = NIL

static

Definition at line 121 of file tablesync.c.

table_states_valid

bool table_states_valid = false

static

Definition at line 120 of file tablesync.c.

Referenced by FetchTableStates(), and invalidate_syncing_table_states().