subscriptioncmds.h File Reference

#include "catalog/objectaddress.h"
#include "nodes/parsenodes.h"

Include dependency graph for subscriptioncmds.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
ObjectAddress	CreateSubscription (CreateSubscriptionStmt *stmt, bool isTopLevel)
ObjectAddress	AlterSubscription (AlterSubscriptionStmt *stmt)
void	DropSubscription (DropSubscriptionStmt *stmt, bool isTopLevel)
ObjectAddress	AlterSubscriptionOwner (const char *name, Oid newOwnerId)
void	AlterSubscriptionOwner_oid (Oid subid, Oid newOwnerId)

Function Documentation

AlterSubscription()

ObjectAddress AlterSubscription

(

AlterSubscriptionStmt *

stmt

)

Definition at line 622 of file subscriptioncmds.c.

References AccessExclusiveLock, aclcheck_error(), ACLCHECK_NOT_OWNER, ALTER_SUBSCRIPTION_CONNECTION, ALTER_SUBSCRIPTION_ENABLED, ALTER_SUBSCRIPTION_OPTIONS, ALTER_SUBSCRIPTION_PUBLICATION, ALTER_SUBSCRIPTION_REFRESH, AlterSubscription_refresh(), ApplyLauncherWakeupAtCommit(), Assert, BoolGetDatum, CatalogTupleUpdate(), AlterSubscriptionStmt::conninfo, CStringGetDatum, CStringGetTextDatum, DirectFunctionCall1, elog, Subscription::enabled, ereport, errcode(), errhint(), errmsg(), ERROR, GETSTRUCT, GetSubscription(), GetUserId(), heap_freetuple(), heap_modify_tuple(), HeapTupleIsValid, InvokeObjectPostAlterHook, AlterSubscriptionStmt::kind, load_file(), LockSharedObject(), MyDatabaseId, namein(), OBJECT_SUBSCRIPTION, ObjectAddressSet, AlterSubscriptionStmt::options, parse_subscription_options(), pg_subscription_ownercheck(), AlterSubscriptionStmt::publication, publicationListToArray(), Subscription::publications, RelationGetDescr, RowExclusiveLock, SearchSysCacheCopy2, Subscription::slotname, AlterSubscriptionStmt::subname, SUBSCRIPTIONNAME, synchronous_commit, HeapTupleData::t_self, table_close(), table_open(), values, and walrcv_check_conninfo.

Referenced by ProcessUtilitySlow().

{
    Relation    rel;
    ObjectAddress myself;
    bool        nulls[Natts_pg_subscription];
    bool        replaces[Natts_pg_subscription];
    Datum       values[Natts_pg_subscription];
    HeapTuple   tup;
    Oid         subid;
    bool        update_tuple = false;
    Subscription *sub;
    Form_pg_subscription form;

    rel = table_open(SubscriptionRelationId, RowExclusiveLock);

    /* Fetch the existing tuple. */
    tup = SearchSysCacheCopy2(SUBSCRIPTIONNAME, MyDatabaseId,
                              CStringGetDatum(stmt->subname));

    if (!HeapTupleIsValid(tup))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("subscription \"%s\" does not exist",
                        stmt->subname)));

    form = (Form_pg_subscription) GETSTRUCT(tup);
    subid = form->oid;

    /* must be owner */
    if (!pg_subscription_ownercheck(subid, GetUserId()))
        aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_SUBSCRIPTION,
                       stmt->subname);

    sub = GetSubscription(subid, false);

    /* Lock the subscription so nobody else can do anything with it. */
    LockSharedObject(SubscriptionRelationId, subid, 0, AccessExclusiveLock);

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

    switch (stmt->kind)
    {
        case ALTER_SUBSCRIPTION_OPTIONS:
            {
                char       *slotname;
                bool        slotname_given;
                char       *synchronous_commit;

                parse_subscription_options(stmt->options, NULL, NULL, NULL,
                                           NULL, &slotname_given, &slotname,
                                           NULL, &synchronous_commit, NULL);

                if (slotname_given)
                {
                    if (sub->enabled && !slotname)
                        ereport(ERROR,
                                (errcode(ERRCODE_SYNTAX_ERROR),
                                 errmsg("cannot set %s for enabled subscription",
                                        "slot_name = NONE")));

                    if (slotname)
                        values[Anum_pg_subscription_subslotname - 1] =
                            DirectFunctionCall1(namein, CStringGetDatum(slotname));
                    else
                        nulls[Anum_pg_subscription_subslotname - 1] = true;
                    replaces[Anum_pg_subscription_subslotname - 1] = true;
                }

                if (synchronous_commit)
                {
                    values[Anum_pg_subscription_subsynccommit - 1] =
                        CStringGetTextDatum(synchronous_commit);
                    replaces[Anum_pg_subscription_subsynccommit - 1] = true;
                }

                update_tuple = true;
                break;
            }

        case ALTER_SUBSCRIPTION_ENABLED:
            {
                bool        enabled,
                            enabled_given;

                parse_subscription_options(stmt->options, NULL,
                                           &enabled_given, &enabled, NULL,
                                           NULL, NULL, NULL, NULL, NULL);
                Assert(enabled_given);

                if (!sub->slotname && enabled)
                    ereport(ERROR,
                            (errcode(ERRCODE_SYNTAX_ERROR),
                             errmsg("cannot enable subscription that does not have a slot name")));

                values[Anum_pg_subscription_subenabled - 1] =
                    BoolGetDatum(enabled);
                replaces[Anum_pg_subscription_subenabled - 1] = true;

                if (enabled)
                    ApplyLauncherWakeupAtCommit();

                update_tuple = true;
                break;
            }

        case ALTER_SUBSCRIPTION_CONNECTION:
            /* Load the library providing us libpq calls. */
            load_file("libpqwalreceiver", false);
            /* Check the connection info string. */
            walrcv_check_conninfo(stmt->conninfo);

            values[Anum_pg_subscription_subconninfo - 1] =
                CStringGetTextDatum(stmt->conninfo);
            replaces[Anum_pg_subscription_subconninfo - 1] = true;
            update_tuple = true;
            break;

        case ALTER_SUBSCRIPTION_PUBLICATION:
            {
                bool        copy_data;
                bool        refresh;

                parse_subscription_options(stmt->options, NULL, NULL, NULL,
                                           NULL, NULL, NULL, &copy_data,
                                           NULL, &refresh);

                values[Anum_pg_subscription_subpublications - 1] =
                    publicationListToArray(stmt->publication);
                replaces[Anum_pg_subscription_subpublications - 1] = true;

                update_tuple = true;

                /* Refresh if user asked us to. */
                if (refresh)
                {
                    if (!sub->enabled)
                        ereport(ERROR,
                                (errcode(ERRCODE_SYNTAX_ERROR),
                                 errmsg("ALTER SUBSCRIPTION with refresh is not allowed for disabled subscriptions"),
                                 errhint("Use ALTER SUBSCRIPTION ... SET PUBLICATION ... WITH (refresh = false).")));

                    /* Make sure refresh sees the new list of publications. */
                    sub->publications = stmt->publication;

                    AlterSubscription_refresh(sub, copy_data);
                }

                break;
            }

        case ALTER_SUBSCRIPTION_REFRESH:
            {
                bool        copy_data;

                if (!sub->enabled)
                    ereport(ERROR,
                            (errcode(ERRCODE_SYNTAX_ERROR),
                             errmsg("ALTER SUBSCRIPTION ... REFRESH is not allowed for disabled subscriptions")));

                parse_subscription_options(stmt->options, NULL, NULL, NULL,
                                           NULL, NULL, NULL, &copy_data,
                                           NULL, NULL);

                AlterSubscription_refresh(sub, copy_data);

                break;
            }

        default:
            elog(ERROR, "unrecognized ALTER SUBSCRIPTION kind %d",
                 stmt->kind);
    }

    /* Update the catalog if needed. */
    if (update_tuple)
    {
        tup = heap_modify_tuple(tup, RelationGetDescr(rel), values, nulls,
                                replaces);

        CatalogTupleUpdate(rel, &tup->t_self, tup);

        heap_freetuple(tup);
    }

    table_close(rel, RowExclusiveLock);

    ObjectAddressSet(myself, SubscriptionRelationId, subid);

    InvokeObjectPostAlterHook(SubscriptionRelationId, subid, 0);

    return myself;
}

AlterSubscriptionOwner()

ObjectAddress AlterSubscriptionOwner	(	const char *	name,
		Oid	newOwnerId
	)

Definition at line 1065 of file subscriptioncmds.c.

References AlterSubscriptionOwner_internal(), CStringGetDatum, ereport, errcode(), errmsg(), ERROR, GETSTRUCT, heap_freetuple(), HeapTupleIsValid, MyDatabaseId, ObjectAddressSet, RowExclusiveLock, SearchSysCacheCopy2, SUBSCRIPTIONNAME, table_close(), and table_open().

Referenced by ExecAlterOwnerStmt().

{
    Oid         subid;
    HeapTuple   tup;
    Relation    rel;
    ObjectAddress address;
    Form_pg_subscription form;

    rel = table_open(SubscriptionRelationId, RowExclusiveLock);

    tup = SearchSysCacheCopy2(SUBSCRIPTIONNAME, MyDatabaseId,
                              CStringGetDatum(name));

    if (!HeapTupleIsValid(tup))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("subscription \"%s\" does not exist", name)));

    form = (Form_pg_subscription) GETSTRUCT(tup);
    subid = form->oid;

    AlterSubscriptionOwner_internal(rel, tup, newOwnerId);

    ObjectAddressSet(address, SubscriptionRelationId, subid);

    heap_freetuple(tup);

    table_close(rel, RowExclusiveLock);

    return address;
}

AlterSubscriptionOwner_oid()

void AlterSubscriptionOwner_oid	(	Oid	subid,
		Oid	newOwnerId
	)

Definition at line 1101 of file subscriptioncmds.c.

References AlterSubscriptionOwner_internal(), ereport, errcode(), errmsg(), ERROR, heap_freetuple(), HeapTupleIsValid, ObjectIdGetDatum, RowExclusiveLock, SearchSysCacheCopy1, SUBSCRIPTIONOID, table_close(), and table_open().

Referenced by shdepReassignOwned().

{
    HeapTuple   tup;
    Relation    rel;

    rel = table_open(SubscriptionRelationId, RowExclusiveLock);

    tup = SearchSysCacheCopy1(SUBSCRIPTIONOID, ObjectIdGetDatum(subid));

    if (!HeapTupleIsValid(tup))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("subscription with OID %u does not exist", subid)));

    AlterSubscriptionOwner_internal(rel, tup, newOwnerId);

    heap_freetuple(tup);

    table_close(rel, RowExclusiveLock);
}

CreateSubscription()

ObjectAddress CreateSubscription	(	CreateSubscriptionStmt *	stmt,
		bool	isTopLevel
	)

Definition at line 307 of file subscriptioncmds.c.

References AccessShareLock, AddSubscriptionRelState(), ApplyLauncherWakeupAtCommit(), Assert, BoolGetDatum, CatalogTupleInsert(), CheckSubscriptionRelkind(), connect, CreateSubscriptionStmt::conninfo, create_slot, CRS_NOEXPORT_SNAPSHOT, CStringGetDatum, CStringGetTextDatum, DirectFunctionCall1, elog, ereport, errcode(), ERRCODE_DUPLICATE_OBJECT, errmsg(), ERROR, fetch_table_list(), get_rel_relkind(), GetNewOidWithIndex(), GetSysCacheOid2, GetUserId(), heap_form_tuple(), heap_freetuple(), InvalidXLogRecPtr, InvokeObjectPostCreateHook, lfirst, load_file(), MyDatabaseId, NAMEDATALEN, namein(), NOTICE, ObjectAddressSet, ObjectIdGetDatum, OidIsValid, CreateSubscriptionStmt::options, parse_subscription_options(), PG_END_TRY, PG_FINALLY, PG_TRY, PreventInTransactionBlock(), CreateSubscriptionStmt::publication, publicationListToArray(), RangeVarGetRelid, recordDependencyOnOwner(), RelationGetDescr, RangeVar::relname, replorigin_create(), RowExclusiveLock, RangeVar::schemaname, snprintf, CreateSubscriptionStmt::subname, SUBSCRIPTIONNAME, SubscriptionObjectIndexId, superuser(), synchronous_commit, table_close(), table_open(), values, walrcv_check_conninfo, walrcv_connect, walrcv_create_slot, walrcv_disconnect, WARNING, and wrconn.

Referenced by ProcessUtilitySlow().

{
    Relation    rel;
    ObjectAddress myself;
    Oid         subid;
    bool        nulls[Natts_pg_subscription];
    Datum       values[Natts_pg_subscription];
    Oid         owner = GetUserId();
    HeapTuple   tup;
    bool        connect;
    bool        enabled_given;
    bool        enabled;
    bool        copy_data;
    char       *synchronous_commit;
    char       *conninfo;
    char       *slotname;
    bool        slotname_given;
    char        originname[NAMEDATALEN];
    bool        create_slot;
    List       *publications;

    /*
     * Parse and check options.
     *
     * Connection and publication should not be specified here.
     */
    parse_subscription_options(stmt->options, &connect, &enabled_given,
                               &enabled, &create_slot, &slotname_given,
                               &slotname, &copy_data, &synchronous_commit,
                               NULL);

    /*
     * Since creating a replication slot is not transactional, rolling back
     * the transaction leaves the created replication slot.  So we cannot run
     * CREATE SUBSCRIPTION inside a transaction block if creating a
     * replication slot.
     */
    if (create_slot)
        PreventInTransactionBlock(isTopLevel, "CREATE SUBSCRIPTION ... WITH (create_slot = true)");

    if (!superuser())
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                 (errmsg("must be superuser to create subscriptions"))));

    /*
     * If built with appropriate switch, whine when regression-testing
     * conventions for subscription names are violated.
     */
#ifdef ENFORCE_REGRESSION_TEST_NAME_RESTRICTIONS
    if (strncmp(stmt->subname, "regress_", 8) != 0)
        elog(WARNING, "subscriptions created by regression test cases should have names starting with \"regress_\"");
#endif

    rel = table_open(SubscriptionRelationId, RowExclusiveLock);

    /* Check if name is used */
    subid = GetSysCacheOid2(SUBSCRIPTIONNAME, Anum_pg_subscription_oid,
                            MyDatabaseId, CStringGetDatum(stmt->subname));
    if (OidIsValid(subid))
    {
        ereport(ERROR,
                (errcode(ERRCODE_DUPLICATE_OBJECT),
                 errmsg("subscription \"%s\" already exists",
                        stmt->subname)));
    }

    if (!slotname_given && slotname == NULL)
        slotname = stmt->subname;

    /* The default for synchronous_commit of subscriptions is off. */
    if (synchronous_commit == NULL)
        synchronous_commit = "off";

    conninfo = stmt->conninfo;
    publications = stmt->publication;

    /* Load the library providing us libpq calls. */
    load_file("libpqwalreceiver", false);

    /* Check the connection info string. */
    walrcv_check_conninfo(conninfo);

    /* Everything ok, form a new tuple. */
    memset(values, 0, sizeof(values));
    memset(nulls, false, sizeof(nulls));

    subid = GetNewOidWithIndex(rel, SubscriptionObjectIndexId,
                               Anum_pg_subscription_oid);
    values[Anum_pg_subscription_oid - 1] = ObjectIdGetDatum(subid);
    values[Anum_pg_subscription_subdbid - 1] = ObjectIdGetDatum(MyDatabaseId);
    values[Anum_pg_subscription_subname - 1] =
        DirectFunctionCall1(namein, CStringGetDatum(stmt->subname));
    values[Anum_pg_subscription_subowner - 1] = ObjectIdGetDatum(owner);
    values[Anum_pg_subscription_subenabled - 1] = BoolGetDatum(enabled);
    values[Anum_pg_subscription_subconninfo - 1] =
        CStringGetTextDatum(conninfo);
    if (slotname)
        values[Anum_pg_subscription_subslotname - 1] =
            DirectFunctionCall1(namein, CStringGetDatum(slotname));
    else
        nulls[Anum_pg_subscription_subslotname - 1] = true;
    values[Anum_pg_subscription_subsynccommit - 1] =
        CStringGetTextDatum(synchronous_commit);
    values[Anum_pg_subscription_subpublications - 1] =
        publicationListToArray(publications);

    tup = heap_form_tuple(RelationGetDescr(rel), values, nulls);

    /* Insert tuple into catalog. */
    CatalogTupleInsert(rel, tup);
    heap_freetuple(tup);

    recordDependencyOnOwner(SubscriptionRelationId, subid, owner);

    snprintf(originname, sizeof(originname), "pg_%u", subid);
    replorigin_create(originname);

    /*
     * Connect to remote side to execute requested commands and fetch table
     * info.
     */
    if (connect)
    {
        XLogRecPtr  lsn;
        char       *err;
        WalReceiverConn *wrconn;
        List       *tables;
        ListCell   *lc;
        char        table_state;

        /* Try to connect to the publisher. */
        wrconn = walrcv_connect(conninfo, true, stmt->subname, &err);
        if (!wrconn)
            ereport(ERROR,
                    (errmsg("could not connect to the publisher: %s", err)));

        PG_TRY();
        {
            /*
             * Set sync state based on if we were asked to do data copy or
             * not.
             */
            table_state = copy_data ? SUBREL_STATE_INIT : SUBREL_STATE_READY;

            /*
             * Get the table list from publisher and build local table status
             * info.
             */
            tables = fetch_table_list(wrconn, publications);
            foreach(lc, tables)
            {
                RangeVar   *rv = (RangeVar *) lfirst(lc);
                Oid         relid;

                relid = RangeVarGetRelid(rv, AccessShareLock, false);

                /* Check for supported relkind. */
                CheckSubscriptionRelkind(get_rel_relkind(relid),
                                         rv->schemaname, rv->relname);

                AddSubscriptionRelState(subid, relid, table_state,
                                        InvalidXLogRecPtr);
            }

            /*
             * If requested, create permanent slot for the subscription. We
             * won't use the initial snapshot for anything, so no need to
             * export it.
             */
            if (create_slot)
            {
                Assert(slotname);

                walrcv_create_slot(wrconn, slotname, false,
                                   CRS_NOEXPORT_SNAPSHOT, &lsn);
                ereport(NOTICE,
                        (errmsg("created replication slot \"%s\" on publisher",
                                slotname)));
            }
        }
        PG_FINALLY();
        {
            walrcv_disconnect(wrconn);
        }
        PG_END_TRY();
    }
    else
        ereport(WARNING,
        /* translator: %s is an SQL ALTER statement */
                (errmsg("tables were not subscribed, you will have to run %s to subscribe the tables",
                        "ALTER SUBSCRIPTION ... REFRESH PUBLICATION")));

    table_close(rel, RowExclusiveLock);

    if (enabled)
        ApplyLauncherWakeupAtCommit();

    ObjectAddressSet(myself, SubscriptionRelationId, subid);

    InvokeObjectPostCreateHook(SubscriptionRelationId, subid, 0);

    return myself;
}

DropSubscription()

void DropSubscription	(	DropSubscriptionStmt *	stmt,
		bool	isTopLevel
	)

Definition at line 822 of file subscriptioncmds.c.

References AccessExclusiveLock, aclcheck_error(), ACLCHECK_NOT_OWNER, appendStringInfo(), Assert, CatalogTupleDelete(), CStringGetDatum, StringInfoData::data, DatumGetName, deleteSharedDependencyRecordsFor(), ereport, WalRcvExecResult::err, errcode(), errdetail(), errhint(), errmsg(), ERROR, EventTriggerSQLDropAddObject(), GETSTRUCT, GetUserId(), HeapTupleIsValid, initStringInfo(), InvalidOid, InvalidRepOriginId, InvokeObjectDropHook, lfirst, list_free(), load_file(), LockSharedObject(), logicalrep_worker_stop(), logicalrep_workers_find(), LW_SHARED, LWLockAcquire(), LWLockRelease(), DropSubscriptionStmt::missing_ok, MyDatabaseId, NAMEDATALEN, NameStr, NoLock, NOTICE, OBJECT_SUBSCRIPTION, ObjectAddressSet, pfree(), PG_END_TRY, PG_FINALLY, pg_subscription_ownercheck(), PG_TRY, PreventInTransactionBlock(), pstrdup(), quote_identifier(), ReleaseSysCache(), LogicalRepWorker::relid, RemoveSubscriptionRel(), replorigin_by_name(), replorigin_drop(), SearchSysCache2(), snprintf, WalRcvExecResult::status, LogicalRepWorker::subid, subname, DropSubscriptionStmt::subname, SUBSCRIPTIONNAME, SUBSCRIPTIONOID, SysCacheGetAttr(), HeapTupleData::t_self, table_close(), table_open(), TextDatumGetCString, walrcv_clear_result(), walrcv_connect, walrcv_disconnect, walrcv_exec, WALRCV_OK_COMMAND, and wrconn.

Referenced by ProcessUtilitySlow().

{
    Relation    rel;
    ObjectAddress myself;
    HeapTuple   tup;
    Oid         subid;
    Datum       datum;
    bool        isnull;
    char       *subname;
    char       *conninfo;
    char       *slotname;
    List       *subworkers;
    ListCell   *lc;
    char        originname[NAMEDATALEN];
    char       *err = NULL;
    RepOriginId originid;
    WalReceiverConn *wrconn = NULL;
    StringInfoData cmd;
    Form_pg_subscription form;

    /*
     * Lock pg_subscription with AccessExclusiveLock to ensure that the
     * launcher doesn't restart new worker during dropping the subscription
     */
    rel = table_open(SubscriptionRelationId, AccessExclusiveLock);

    tup = SearchSysCache2(SUBSCRIPTIONNAME, MyDatabaseId,
                          CStringGetDatum(stmt->subname));

    if (!HeapTupleIsValid(tup))
    {
        table_close(rel, NoLock);

        if (!stmt->missing_ok)
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_OBJECT),
                     errmsg("subscription \"%s\" does not exist",
                            stmt->subname)));
        else
            ereport(NOTICE,
                    (errmsg("subscription \"%s\" does not exist, skipping",
                            stmt->subname)));

        return;
    }

    form = (Form_pg_subscription) GETSTRUCT(tup);
    subid = form->oid;

    /* must be owner */
    if (!pg_subscription_ownercheck(subid, GetUserId()))
        aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_SUBSCRIPTION,
                       stmt->subname);

    /* DROP hook for the subscription being removed */
    InvokeObjectDropHook(SubscriptionRelationId, subid, 0);

    /*
     * Lock the subscription so nobody else can do anything with it (including
     * the replication workers).
     */
    LockSharedObject(SubscriptionRelationId, subid, 0, AccessExclusiveLock);

    /* Get subname */
    datum = SysCacheGetAttr(SUBSCRIPTIONOID, tup,
                            Anum_pg_subscription_subname, &isnull);
    Assert(!isnull);
    subname = pstrdup(NameStr(*DatumGetName(datum)));

    /* Get conninfo */
    datum = SysCacheGetAttr(SUBSCRIPTIONOID, tup,
                            Anum_pg_subscription_subconninfo, &isnull);
    Assert(!isnull);
    conninfo = TextDatumGetCString(datum);

    /* Get slotname */
    datum = SysCacheGetAttr(SUBSCRIPTIONOID, tup,
                            Anum_pg_subscription_subslotname, &isnull);
    if (!isnull)
        slotname = pstrdup(NameStr(*DatumGetName(datum)));
    else
        slotname = NULL;

    /*
     * Since dropping a replication slot is not transactional, the replication
     * slot stays dropped even if the transaction rolls back.  So we cannot
     * run DROP SUBSCRIPTION inside a transaction block if dropping the
     * replication slot.
     *
     * XXX The command name should really be something like "DROP SUBSCRIPTION
     * of a subscription that is associated with a replication slot", but we
     * don't have the proper facilities for that.
     */
    if (slotname)
        PreventInTransactionBlock(isTopLevel, "DROP SUBSCRIPTION");


    ObjectAddressSet(myself, SubscriptionRelationId, subid);
    EventTriggerSQLDropAddObject(&myself, true, true);

    /* Remove the tuple from catalog. */
    CatalogTupleDelete(rel, &tup->t_self);

    ReleaseSysCache(tup);

    /*
     * Stop all the subscription workers immediately.
     *
     * This is necessary if we are dropping the replication slot, so that the
     * slot becomes accessible.
     *
     * It is also necessary if the subscription is disabled and was disabled
     * in the same transaction.  Then the workers haven't seen the disabling
     * yet and will still be running, leading to hangs later when we want to
     * drop the replication origin.  If the subscription was disabled before
     * this transaction, then there shouldn't be any workers left, so this
     * won't make a difference.
     *
     * New workers won't be started because we hold an exclusive lock on the
     * subscription till the end of the transaction.
     */
    LWLockAcquire(LogicalRepWorkerLock, LW_SHARED);
    subworkers = logicalrep_workers_find(subid, false);
    LWLockRelease(LogicalRepWorkerLock);
    foreach(lc, subworkers)
    {
        LogicalRepWorker *w = (LogicalRepWorker *) lfirst(lc);

        logicalrep_worker_stop(w->subid, w->relid);
    }
    list_free(subworkers);

    /* Clean up dependencies */
    deleteSharedDependencyRecordsFor(SubscriptionRelationId, subid, 0);

    /* Remove any associated relation synchronization states. */
    RemoveSubscriptionRel(subid, InvalidOid);

    /* Remove the origin tracking if exists. */
    snprintf(originname, sizeof(originname), "pg_%u", subid);
    originid = replorigin_by_name(originname, true);
    if (originid != InvalidRepOriginId)
        replorigin_drop(originid, false);

    /*
     * If there is no slot associated with the subscription, we can finish
     * here.
     */
    if (!slotname)
    {
        table_close(rel, NoLock);
        return;
    }

    /*
     * Otherwise drop the replication slot at the publisher node using the
     * replication connection.
     */
    load_file("libpqwalreceiver", false);

    initStringInfo(&cmd);
    appendStringInfo(&cmd, "DROP_REPLICATION_SLOT %s WAIT", quote_identifier(slotname));

    wrconn = walrcv_connect(conninfo, true, subname, &err);
    if (wrconn == NULL)
        ereport(ERROR,
                (errmsg("could not connect to publisher when attempting to "
                        "drop the replication slot \"%s\"", slotname),
                 errdetail("The error was: %s", err),
        /* translator: %s is an SQL ALTER command */
                 errhint("Use %s to disassociate the subscription from the slot.",
                         "ALTER SUBSCRIPTION ... SET (slot_name = NONE)")));

    PG_TRY();
    {
        WalRcvExecResult *res;

        res = walrcv_exec(wrconn, cmd.data, 0, NULL);

        if (res->status != WALRCV_OK_COMMAND)
            ereport(ERROR,
                    (errmsg("could not drop the replication slot \"%s\" on publisher",
                            slotname),
                     errdetail("The error was: %s", res->err)));
        else
            ereport(NOTICE,
                    (errmsg("dropped replication slot \"%s\" on publisher",
                            slotname)));

        walrcv_clear_result(res);
    }
    PG_FINALLY();
    {
        walrcv_disconnect(wrconn);
    }
    PG_END_TRY();

    pfree(cmd.data);

    table_close(rel, NoLock);
}