pg_backup_db.c File Reference

#include "postgres_fe.h"
#include <unistd.h>
#include <ctype.h>
#include "common/connect.h"
#include "common/string.h"
#include "dumputils.h"
#include "fe_utils/string_utils.h"
#include "parallel.h"
#include "pg_backup_archiver.h"
#include "pg_backup_db.h"
#include "pg_backup_utils.h"

Include dependency graph for pg_backup_db.c:

Go to the source code of this file.

Functions
static void	_check_database_version (ArchiveHandle *AH)
static void	notice_processor (void *arg, const char *message)
void	ReconnectToServer (ArchiveHandle *AH, const char *dbname)
void	ConnectDatabase (Archive *AHX, const ConnParams *cparams, bool isReconnect)
void	DisconnectDatabase (Archive *AHX)
PGconn *	GetConnection (Archive *AHX)
static void	die_on_query_failure (ArchiveHandle *AH, const char *query)
void	ExecuteSqlStatement (Archive *AHX, const char *query)
PGresult *	ExecuteSqlQuery (Archive *AHX, const char *query, ExecStatusType status)
PGresult *	ExecuteSqlQueryForSingleRow (Archive *fout, const char *query)
static void	ExecuteSqlCommand (ArchiveHandle *AH, const char *qry, const char *desc)
static void	ExecuteSimpleCommands (ArchiveHandle *AH, const char *buf, size_t bufLen)
int	ExecuteSqlCommandBuf (Archive *AHX, const char *buf, size_t bufLen)
void	EndDBCopyMode (Archive *AHX, const char *tocEntryTag)
void	StartTransaction (Archive *AHX)
void	CommitTransaction (Archive *AHX)
void	DropLOIfExists (ArchiveHandle *AH, Oid oid)

Function Documentation

_check_database_version()

static void _check_database_version ( ArchiveHandle *  AH )

static

Definition at line 33 of file pg_backup_db.c.

{
    const char *remoteversion_str;
    int         remoteversion;
    PGresult   *res;
 
    remoteversion_str = PQparameterStatus(AH->connection, "server_version");
    remoteversion = PQserverVersion(AH->connection);
    if (remoteversion == 0 || !remoteversion_str)
        pg_fatal("could not get server_version from libpq");
 
    AH->public.remoteVersionStr = pg_strdup(remoteversion_str);
    AH->public.remoteVersion = remoteversion;
    if (!AH->archiveRemoteVersion)
        AH->archiveRemoteVersion = AH->public.remoteVersionStr;
 
    if (remoteversion != PG_VERSION_NUM
        && (remoteversion < AH->public.minRemoteVersion ||
            remoteversion > AH->public.maxRemoteVersion))
    {
        pg_log_error("aborting because of server version mismatch");
        pg_log_error_detail("server version: %s; %s version: %s",
                            remoteversion_str, progname, PG_VERSION);
        exit(1);
    }
 
    /*
     * Check if server is in recovery mode, which means we are on a hot
     * standby.
     */
    res = ExecuteSqlQueryForSingleRow((Archive *) AH,
                                      "SELECT pg_catalog.pg_is_in_recovery()");
    AH->public.isStandby = (strcmp(PQgetvalue(res, 0, 0), "t") == 0);
    PQclear(res);
}

References _archiveHandle::archiveRemoteVersion, _archiveHandle::connection, ExecuteSqlQueryForSingleRow(), exit(), Archive::isStandby, Archive::maxRemoteVersion, pg_fatal, pg_log_error, pg_log_error_detail, pg_strdup(), PQclear(), PQgetvalue(), PQparameterStatus(), PQserverVersion(), progname, _archiveHandle::public, Archive::remoteVersion, Archive::remoteVersionStr, and res.

Referenced by ConnectDatabase().

CommitTransaction()

void CommitTransaction

(

Archive *

AHX

)

Definition at line 537 of file pg_backup_db.c.

{
    ArchiveHandle *AH = (ArchiveHandle *) AHX;
 
    ExecuteSqlCommand(AH, "COMMIT", "could not commit database transaction");
}

References ExecuteSqlCommand().

ConnectDatabase()

void ConnectDatabase	(	Archive *	AHX,
		const ConnParams *	cparams,
		bool	isReconnect
	)

Definition at line 110 of file pg_backup_db.c.

{
    ArchiveHandle *AH = (ArchiveHandle *) AHX;
    trivalue    prompt_password;
    char       *password;
    bool        new_pass;
 
    if (AH->connection)
        pg_fatal("already connected to a database");
 
    /* Never prompt for a password during a reconnection */
    prompt_password = isReconnect ? TRI_NO : cparams->promptPassword;
 
    password = AH->savedPassword;
 
    if (prompt_password == TRI_YES && password == NULL)
        password = simple_prompt("Password: ", false);
 
    /*
     * Start the connection.  Loop until we have a password if requested by
     * backend.
     */
    do
    {
        const char *keywords[8];
        const char *values[8];
        int         i = 0;
 
        /*
         * If dbname is a connstring, its entries can override the other
         * values obtained from cparams; but in turn, override_dbname can
         * override the dbname component of it.
         */
        keywords[i] = "host";
        values[i++] = cparams->pghost;
        keywords[i] = "port";
        values[i++] = cparams->pgport;
        keywords[i] = "user";
        values[i++] = cparams->username;
        keywords[i] = "password";
        values[i++] = password;
        keywords[i] = "dbname";
        values[i++] = cparams->dbname;
        if (cparams->override_dbname)
        {
            keywords[i] = "dbname";
            values[i++] = cparams->override_dbname;
        }
        keywords[i] = "fallback_application_name";
        values[i++] = progname;
        keywords[i] = NULL;
        values[i++] = NULL;
        Assert(i <= lengthof(keywords));
 
        new_pass = false;
        AH->connection = PQconnectdbParams(keywords, values, true);
 
        if (!AH->connection)
            pg_fatal("could not connect to database");
 
        if (PQstatus(AH->connection) == CONNECTION_BAD &&
            PQconnectionNeedsPassword(AH->connection) &&
            password == NULL &&
            prompt_password != TRI_NO)
        {
            PQfinish(AH->connection);
            password = simple_prompt("Password: ", false);
            new_pass = true;
        }
    } while (new_pass);
 
    /* check to see that the backend connection was successfully made */
    if (PQstatus(AH->connection) == CONNECTION_BAD)
    {
        if (isReconnect)
            pg_fatal("reconnection failed: %s",
                     PQerrorMessage(AH->connection));
        else
            pg_fatal("%s",
                     PQerrorMessage(AH->connection));
    }
 
    /* Start strict; later phases may override this. */
    PQclear(ExecuteSqlQueryForSingleRow((Archive *) AH,
                                        ALWAYS_SECURE_SEARCH_PATH_SQL));
 
    if (password && password != AH->savedPassword)
        free(password);
 
    /*
     * We want to remember connection's actual password, whether or not we got
     * it by prompting.  So we don't just store the password variable.
     */
    if (PQconnectionUsedPassword(AH->connection))
    {
        free(AH->savedPassword);
        AH->savedPassword = pg_strdup(PQpass(AH->connection));
    }
 
    /* check for version mismatch */
    _check_database_version(AH);
 
    PQsetNoticeProcessor(AH->connection, notice_processor, NULL);
 
    /* arrange for SIGINT to issue a query cancel on this connection */
    set_archive_cancel_info(AH, AH->connection);
}

References _check_database_version(), ALWAYS_SECURE_SEARCH_PATH_SQL, Assert(), _archiveHandle::connection, CONNECTION_BAD, _connParams::dbname, ExecuteSqlQueryForSingleRow(), free, i, lengthof, notice_processor(), _connParams::override_dbname, password, pg_fatal, pg_strdup(), _connParams::pghost, _connParams::pgport, PQclear(), PQconnectdbParams(), PQconnectionNeedsPassword(), PQconnectionUsedPassword(), PQerrorMessage(), PQfinish(), PQpass(), PQsetNoticeProcessor(), PQstatus(), progname, _connParams::promptPassword, _archiveHandle::savedPassword, set_archive_cancel_info(), simple_prompt(), TRI_NO, TRI_YES, _connParams::username, and values.

Referenced by CloneArchive(), main(), ReconnectToServer(), restore_toc_entries_postfork(), and RestoreArchive().

die_on_query_failure()

static void die_on_query_failure ( ArchiveHandle *  AH, const char *  query  )

static

Definition at line 269 of file pg_backup_db.c.

{
    pg_log_error("query failed: %s",
                 PQerrorMessage(AH->connection));
    pg_log_error_detail("Query was: %s", query);
    exit(1);
}

References _archiveHandle::connection, exit(), pg_log_error, pg_log_error_detail, and PQerrorMessage().

Referenced by ExecuteSqlQuery(), and ExecuteSqlStatement().

DisconnectDatabase()

void DisconnectDatabase

(

Archive *

AHX

)

Definition at line 225 of file pg_backup_db.c.

{
    ArchiveHandle *AH = (ArchiveHandle *) AHX;
    char        errbuf[1];
 
    if (!AH->connection)
        return;
 
    if (AH->connCancel)
    {
        /*
         * If we have an active query, send a cancel before closing, ignoring
         * any errors.  This is of no use for a normal exit, but might be
         * helpful during pg_fatal().
         */
        if (PQtransactionStatus(AH->connection) == PQTRANS_ACTIVE)
            (void) PQcancel(AH->connCancel, errbuf, sizeof(errbuf));
 
        /*
         * Prevent signal handler from sending a cancel after this.
         */
        set_archive_cancel_info(AH, NULL);
    }
 
    PQfinish(AH->connection);
    AH->connection = NULL;
}

References _archiveHandle::connCancel, _archiveHandle::connection, PQcancel(), PQfinish(), PQTRANS_ACTIVE, PQtransactionStatus(), and set_archive_cancel_info().

Referenced by archive_close_connection(), restore_toc_entries_prefork(), RestoreArchive(), and RunWorker().

DropLOIfExists()

void DropLOIfExists	(	ArchiveHandle *	AH,
		Oid	oid
	)

Definition at line 545 of file pg_backup_db.c.

{
    /*
     * If we are not restoring to a direct database connection, we have to
     * guess about how to detect whether the LO exists.  Assume new-style.
     */
    if (AH->connection == NULL ||
        PQserverVersion(AH->connection) >= 90000)
    {
        ahprintf(AH,
                 "SELECT pg_catalog.lo_unlink(oid) "
                 "FROM pg_catalog.pg_largeobject_metadata "
                 "WHERE oid = '%u';\n",
                 oid);
    }
    else
    {
        /* Restoring to pre-9.0 server, so do it the old way */
        ahprintf(AH,
                 "SELECT CASE WHEN EXISTS("
                 "SELECT 1 FROM pg_catalog.pg_largeobject WHERE loid = '%u'"
                 ") THEN pg_catalog.lo_unlink('%u') END;\n",
                 oid, oid);
    }
}

References ahprintf(), _archiveHandle::connection, and PQserverVersion().

Referenced by _StartLO(), RestoreArchive(), and StartRestoreLO().

EndDBCopyMode()

void EndDBCopyMode	(	Archive *	AHX,
		const char *	tocEntryTag
	)

Definition at line 500 of file pg_backup_db.c.

{
    ArchiveHandle *AH = (ArchiveHandle *) AHX;
 
    if (AH->pgCopyIn)
    {
        PGresult   *res;
 
        if (PQputCopyEnd(AH->connection, NULL) <= 0)
            pg_fatal("error returned by PQputCopyEnd: %s",
                     PQerrorMessage(AH->connection));
 
        /* Check command status and return to normal libpq state */
        res = PQgetResult(AH->connection);
        if (PQresultStatus(res) != PGRES_COMMAND_OK)
            warn_or_exit_horribly(AH, "COPY failed for table \"%s\": %s",
                                  tocEntryTag, PQerrorMessage(AH->connection));
        PQclear(res);
 
        /* Do this to ensure we've pumped libpq back to idle state */
        if (PQgetResult(AH->connection) != NULL)
            pg_log_warning("unexpected extra results during COPY of table \"%s\"",
                           tocEntryTag);
 
        AH->pgCopyIn = false;
    }
}

References _archiveHandle::connection, pg_fatal, pg_log_warning, _archiveHandle::pgCopyIn, PGRES_COMMAND_OK, PQclear(), PQerrorMessage(), PQgetResult(), PQputCopyEnd(), PQresultStatus(), res, and warn_or_exit_horribly().

Referenced by restore_toc_entry().

ExecuteSimpleCommands()

static void ExecuteSimpleCommands ( ArchiveHandle *  AH, const char *  buf, size_t  bufLen  )

static

Definition at line 380 of file pg_backup_db.c.

{
    const char *qry = buf;
    const char *eos = buf + bufLen;
 
    /* initialize command buffer if first time through */
    if (AH->sqlparse.curCmd == NULL)
        AH->sqlparse.curCmd = createPQExpBuffer();
 
    for (; qry < eos; qry++)
    {
        char        ch = *qry;
 
        /* For neatness, we skip any newlines between commands */
        if (!(ch == '\n' && AH->sqlparse.curCmd->len == 0))
            appendPQExpBufferChar(AH->sqlparse.curCmd, ch);
 
        switch (AH->sqlparse.state)
        {
            case SQL_SCAN:      /* Default state == 0, set in _allocAH */
                if (ch == ';')
                {
                    /*
                     * We've found the end of a statement. Send it and reset
                     * the buffer.
                     */
                    ExecuteSqlCommand(AH, AH->sqlparse.curCmd->data,
                                      "could not execute query");
                    resetPQExpBuffer(AH->sqlparse.curCmd);
                }
                else if (ch == '\'')
                {
                    AH->sqlparse.state = SQL_IN_SINGLE_QUOTE;
                    AH->sqlparse.backSlash = false;
                }
                else if (ch == '"')
                {
                    AH->sqlparse.state = SQL_IN_DOUBLE_QUOTE;
                }
                break;
 
            case SQL_IN_SINGLE_QUOTE:
                /* We needn't handle '' specially */
                if (ch == '\'' && !AH->sqlparse.backSlash)
                    AH->sqlparse.state = SQL_SCAN;
                else if (ch == '\\' && !AH->public.std_strings)
                    AH->sqlparse.backSlash = !AH->sqlparse.backSlash;
                else
                    AH->sqlparse.backSlash = false;
                break;
 
            case SQL_IN_DOUBLE_QUOTE:
                /* We needn't handle "" specially */
                if (ch == '"')
                    AH->sqlparse.state = SQL_SCAN;
                break;
        }
    }
}

References appendPQExpBufferChar(), sqlparseInfo::backSlash, buf, createPQExpBuffer(), sqlparseInfo::curCmd, PQExpBufferData::data, ExecuteSqlCommand(), PQExpBufferData::len, _archiveHandle::public, resetPQExpBuffer(), SQL_IN_DOUBLE_QUOTE, SQL_IN_SINGLE_QUOTE, SQL_SCAN, _archiveHandle::sqlparse, sqlparseInfo::state, and Archive::std_strings.

Referenced by ExecuteSqlCommandBuf().

ExecuteSqlCommand()

static void ExecuteSqlCommand ( ArchiveHandle *  AH, const char *  qry, const char *  desc  )

static

Definition at line 328 of file pg_backup_db.c.

{
    PGconn     *conn = AH->connection;
    PGresult   *res;
 
#ifdef NOT_USED
    fprintf(stderr, "Executing: '%s'\n\n", qry);
#endif
    res = PQexec(conn, qry);
 
    switch (PQresultStatus(res))
    {
        case PGRES_COMMAND_OK:
        case PGRES_TUPLES_OK:
        case PGRES_EMPTY_QUERY:
            /* A-OK */
            break;
        case PGRES_COPY_IN:
            /* Assume this is an expected result */
            AH->pgCopyIn = true;
            break;
        default:
            /* trouble */
            warn_or_exit_horribly(AH, "%s: %sCommand was: %s",
                                  desc, PQerrorMessage(conn), qry);
            break;
    }
 
    PQclear(res);
}

References conn, _archiveHandle::connection, fprintf, _archiveHandle::pgCopyIn, PGRES_COMMAND_OK, PGRES_COPY_IN, PGRES_EMPTY_QUERY, PGRES_TUPLES_OK, PQclear(), PQerrorMessage(), PQexec(), PQresultStatus(), res, and warn_or_exit_horribly().

Referenced by CommitTransaction(), ExecuteSimpleCommands(), ExecuteSqlCommandBuf(), and StartTransaction().

ExecuteSqlCommandBuf()

int ExecuteSqlCommandBuf	(	Archive *	AHX,
		const char *	buf,
		size_t	bufLen
	)

Definition at line 445 of file pg_backup_db.c.

{
    ArchiveHandle *AH = (ArchiveHandle *) AHX;
 
    if (AH->outputKind == OUTPUT_COPYDATA)
    {
        /*
         * COPY data.
         *
         * We drop the data on the floor if libpq has failed to enter COPY
         * mode; this allows us to behave reasonably when trying to continue
         * after an error in a COPY command.
         */
        if (AH->pgCopyIn &&
            PQputCopyData(AH->connection, buf, bufLen) <= 0)
            pg_fatal("error returned by PQputCopyData: %s",
                     PQerrorMessage(AH->connection));
    }
    else if (AH->outputKind == OUTPUT_OTHERDATA)
    {
        /*
         * Table data expressed as INSERT commands; or, in old dump files,
         * BLOB COMMENTS data (which is expressed as COMMENT ON commands).
         */
        ExecuteSimpleCommands(AH, buf, bufLen);
    }
    else
    {
        /*
         * General SQL commands; we assume that commands will not be split
         * across calls.
         *
         * In most cases the data passed to us will be a null-terminated
         * string, but if it's not, we have to add a trailing null.
         */
        if (buf[bufLen] == '\0')
            ExecuteSqlCommand(AH, buf, "could not execute query");
        else
        {
            char       *str = (char *) pg_malloc(bufLen + 1);
 
            memcpy(str, buf, bufLen);
            str[bufLen] = '\0';
            ExecuteSqlCommand(AH, str, "could not execute query");
            free(str);
        }
    }
 
    return bufLen;
}

References buf, _archiveHandle::connection, ExecuteSimpleCommands(), ExecuteSqlCommand(), free, OUTPUT_COPYDATA, OUTPUT_OTHERDATA, _archiveHandle::outputKind, pg_fatal, pg_malloc(), _archiveHandle::pgCopyIn, PQerrorMessage(), PQputCopyData(), and generate_unaccent_rules::str.

Referenced by ahwrite().

ExecuteSqlQuery()

PGresult* ExecuteSqlQuery	(	Archive *	AHX,
		const char *	query,
		ExecStatusType	status
	)

Definition at line 290 of file pg_backup_db.c.

{
    ArchiveHandle *AH = (ArchiveHandle *) AHX;
    PGresult   *res;
 
    res = PQexec(AH->connection, query);
    if (PQresultStatus(res) != status)
        die_on_query_failure(AH, query);
    return res;
}

References _archiveHandle::connection, die_on_query_failure(), PQexec(), PQresultStatus(), and res.

Referenced by append_depends_on_extension(), buildMatViewRefreshDependencies(), collectComments(), collectRoleNames(), collectSecLabels(), createViewAsClause(), dumpCompositeType(), dumpDatabase(), dumpDatabaseConfig(), dumpEnumType(), dumpLOs(), dumpOpclass(), dumpOpfamily(), dumpRule(), dumpSequence(), dumpSequenceData(), dumpTable(), dumpTableData_copy(), dumpTableData_insert(), dumpTSConfig(), dumpUserMappings(), ExecuteSqlQueryForSingleRow(), expand_extension_name_patterns(), expand_foreign_server_name_patterns(), expand_schema_name_patterns(), expand_table_name_patterns(), getAccessMethods(), getAdditionalACLs(), getAggregates(), getCasts(), getCollations(), getConstraints(), getConversions(), getDefaultACLs(), getDependencies(), getDomainConstraints(), getEventTriggers(), getExtendedStatistics(), getExtensionMembership(), getExtensions(), getForeignDataWrappers(), getForeignServers(), getFuncs(), getIndexes(), getInherits(), getLOs(), getNamespaces(), getOpclasses(), getOperators(), getOpfamilies(), getPartitioningInfo(), getPolicies(), getProcLangs(), getPublicationNamespaces(), getPublications(), getPublicationTables(), getRules(), getSubscriptions(), getTableAttrs(), getTables(), getTransforms(), getTriggers(), getTSConfigurations(), getTSDictionaries(), getTSParsers(), getTSTemplates(), getTypes(), and processExtensionTables().

ExecuteSqlQueryForSingleRow()

PGresult* ExecuteSqlQueryForSingleRow	(	Archive *	fout,
		const char *	query
	)

Definition at line 305 of file pg_backup_db.c.

{
    PGresult   *res;
    int         ntups;
 
    res = ExecuteSqlQuery(fout, query, PGRES_TUPLES_OK);
 
    /* Expecting a single result only */
    ntups = PQntuples(res);
    if (ntups != 1)
        pg_fatal(ngettext("query returned %d row instead of one: %s",
                          "query returned %d rows instead of one: %s",
                          ntups),
                 ntups, query);
 
    return res;
}

References ExecuteSqlQuery(), ngettext, pg_fatal, PGRES_TUPLES_OK, PQntuples(), and res.

Referenced by _check_database_version(), binary_upgrade_set_pg_class_oids(), binary_upgrade_set_type_oids_by_type_oid(), ConnectDatabase(), convertTSFunction(), dumpAgg(), dumpBaseType(), dumpCollation(), dumpConversion(), dumpDatabase(), dumpDomain(), dumpForeignServer(), dumpFunc(), dumpOpclass(), dumpOpfamily(), dumpOpr(), dumpRangeType(), dumpSearchPath(), dumpStatisticsExt(), dumpTableAttach(), dumpTableSchema(), dumpTSConfig(), dumpTSDictionary(), expand_table_name_patterns(), get_language_name(), get_next_possible_free_pg_type_oid(), get_synchronized_snapshot(), getFormattedTypeName(), and setup_connection().

ExecuteSqlStatement()

void ExecuteSqlStatement	(	Archive *	AHX,
		const char *	query
	)

Definition at line 278 of file pg_backup_db.c.

{
    ArchiveHandle *AH = (ArchiveHandle *) AHX;
    PGresult   *res;
 
    res = PQexec(AH->connection, query);
    if (PQresultStatus(res) != PGRES_COMMAND_OK)
        die_on_query_failure(AH, query);
    PQclear(res);
}

References _archiveHandle::connection, die_on_query_failure(), PGRES_COMMAND_OK, PQclear(), PQexec(), PQresultStatus(), and res.

Referenced by dumpAgg(), dumpBaseType(), dumpCompositeType(), dumpDomain(), dumpEnumType(), dumpFunc(), dumpLOs(), dumpOpr(), dumpRangeType(), dumpTable(), dumpTableAttach(), dumpTableData_insert(), expand_table_name_patterns(), getDomainConstraints(), getTables(), and setup_connection().

GetConnection()

PGconn* GetConnection

(

Archive *

AHX

)

Definition at line 254 of file pg_backup_db.c.

{
    ArchiveHandle *AH = (ArchiveHandle *) AHX;
 
    return AH->connection;
}

References _archiveHandle::connection.

notice_processor()

static void notice_processor ( void *  arg, const char *  message  )

static

Definition at line 262 of file pg_backup_db.c.

{
    pg_log_info("%s", message);
}

References pg_log_info.

Referenced by ConnectDatabase().

ReconnectToServer()

void ReconnectToServer	(	ArchiveHandle *	AH,
		const char *	dbname
	)

Definition at line 74 of file pg_backup_db.c.

{
    PGconn     *oldConn = AH->connection;
    RestoreOptions *ropt = AH->public.ropt;
 
    /*
     * Save the dbname, if given, in override_dbname so that it will also
     * affect any later reconnection attempt.
     */
    if (dbname)
        ropt->cparams.override_dbname = pg_strdup(dbname);
 
    /*
     * Note: we want to establish the new connection, and in particular update
     * ArchiveHandle's connCancel, before closing old connection.  Otherwise
     * an ill-timed SIGINT could try to access a dead connection.
     */
    AH->connection = NULL;      /* dodge error check in ConnectDatabase */
 
    ConnectDatabase((Archive *) AH, &ropt->cparams, true);
 
    PQfinish(oldConn);
}

References ConnectDatabase(), _archiveHandle::connection, _restoreOptions::cparams, dbname, _connParams::override_dbname, pg_strdup(), PQfinish(), _archiveHandle::public, and Archive::ropt.

Referenced by _reconnectToDB().

StartTransaction()

void StartTransaction

(

Archive *

AHX

)

Definition at line 529 of file pg_backup_db.c.

{
    ArchiveHandle *AH = (ArchiveHandle *) AHX;
 
    ExecuteSqlCommand(AH, "BEGIN", "could not start database transaction");
}

References ExecuteSqlCommand().