#include "postgres_fe.h"
#include <unistd.h>
#include <ctype.h>
#include "common/connect.h"
#include "common/string.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:

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	IssueCommandPerBlob (ArchiveHandle AH, TocEntry te, const char cmdBegin, const char cmdEnd)

void	IssueACLPerBlob (ArchiveHandle AH, TocEntry te)

void	DropLOIfExists (ArchiveHandle *AH, Oid oid)

Function Documentation

◆ _check_database_version()

static void _check_database_version ( ArchiveHandle * AH )

static

Definition at line 31 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 535 of file pg_backup_db.c.

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

References ExecuteSqlCommand().

Referenced by IssueCommandPerBlob().

◆ ConnectDatabase()

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

Definition at line 108 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 267 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 223 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 671 of file pg_backup_db.c.

 {
     ahprintf(AH,
              "SELECT pg_catalog.lo_unlink(oid) "
              "FROM pg_catalog.pg_largeobject_metadata "
              "WHERE oid = '%u';\n",
              oid);
 }

References ahprintf().

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

◆ EndDBCopyMode()

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

Definition at line 498 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 378 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 326 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 443 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 str.

Referenced by ahwrite().

◆ ExecuteSqlQuery()

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

Definition at line 288 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(), collectBinaryUpgradeClassOids(), collectComments(), collectRoleNames(), collectSecLabels(), collectSequences(), createViewAsClause(), dumpCompositeType(), dumpDatabase(), dumpDatabaseConfig(), dumpEnumType(), 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(), getSubscriptionTables(), getTableAttrs(), getTables(), getTransforms(), getTriggers(), getTSConfigurations(), getTSDictionaries(), getTSParsers(), getTSTemplates(), getTypes(), processExtensionTables(), and set_restrict_relation_kind().

◆ ExecuteSqlQueryForSingleRow()

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

Definition at line 303 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_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 276 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(), dumpOpr(), dumpRangeType(), dumpTable(), dumpTableAttach(), dumpTableData_insert(), expand_table_name_patterns(), getDomainConstraints(), getTables(), and setup_connection().

◆ GetConnection()

PGconn* GetConnection ( Archive * AHX )

Definition at line 252 of file pg_backup_db.c.

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

References _archiveHandle::connection.

◆ IssueACLPerBlob()

void IssueACLPerBlob	(	ArchiveHandle *	AH,
		TocEntry *	te
	)

Definition at line 597 of file pg_backup_db.c.

 {
     TocEntry   *blobte = getTocEntryByDumpId(AH, te->dependencies[0]);
     char       *buf;
     char       *st;
     char       *st2;
     char       *en;
     bool        inquotes;
  
     if (!blobte)
         pg_fatal("could not find entry for ID %d", te->dependencies[0]);
     Assert(strcmp(blobte->desc, "BLOB METADATA") == 0);
  
     /* Make a writable copy of the ACL commands string */
     buf = pg_strdup(te->defn);
  
     /*
      * We have to parse out the commands sufficiently to locate the blob OIDs
      * and find the command-ending semicolons.  The commands should not
      * contain anything hard to parse except for double-quoted role names,
      * which are easy to ignore.  Once we've split apart the first and second
      * halves of a command, apply IssueCommandPerBlob.  (This means the
      * updates on the blobs are interleaved if there's multiple commands, but
      * that should cause no trouble.)
      */
     inquotes = false;
     st = en = buf;
     st2 = NULL;
     while (*en)
     {
         /* Ignore double-quoted material */
         if (*en == '"')
             inquotes = !inquotes;
         if (inquotes)
         {
             en++;
             continue;
         }
         /* If we found "LARGE OBJECT", that's the end of the first half */
         if (strncmp(en, "LARGE OBJECT ", 13) == 0)
         {
             /* Terminate the first-half string */
             en += 13;
             Assert(isdigit((unsigned char) *en));
             *en++ = '\0';
             /* Skip the rest of the blob OID */
             while (isdigit((unsigned char) *en))
                 en++;
             /* Second half starts here */
             Assert(st2 == NULL);
             st2 = en;
         }
         /* If we found semicolon, that's the end of the second half */
         else if (*en == ';')
         {
             /* Terminate the second-half string */
             *en++ = '\0';
             Assert(st2 != NULL);
             /* Issue this command for each blob */
             IssueCommandPerBlob(AH, blobte, st, st2);
             /* For neatness, skip whitespace before the next command */
             while (isspace((unsigned char) *en))
                 en++;
             /* Reset for new command */
             st = en;
             st2 = NULL;
         }
         else
             en++;
     }
     pg_free(buf);
 }

References Assert, buf, _tocEntry::defn, _tocEntry::dependencies, _tocEntry::desc, getTocEntryByDumpId(), IssueCommandPerBlob(), pg_fatal, pg_free(), and pg_strdup().

Referenced by _printTocEntry().

◆ IssueCommandPerBlob()

void IssueCommandPerBlob	(	ArchiveHandle *	AH,
		TocEntry *	te,
		const char *	cmdBegin,
		const char *	cmdEnd
	)

Definition at line 550 of file pg_backup_db.c.

 {
     /* Make a writable copy of the command string */
     char       *buf = pg_strdup(te->defn);
     RestoreOptions *ropt = AH->public.ropt;
     char       *st;
     char       *en;
  
     st = buf;
     while ((en = strchr(st, '\n')) != NULL)
     {
         *en++ = '\0';
         ahprintf(AH, "%s%s%s;\n", cmdBegin, st, cmdEnd);
  
         /* In --transaction-size mode, count each command as an action */
         if (ropt && ropt->txn_size > 0)
         {
             if (++AH->txnCount >= ropt->txn_size)
             {
                 if (AH->connection)
                 {
                     CommitTransaction(&AH->public);
                     StartTransaction(&AH->public);
                 }
                 else
                     ahprintf(AH, "COMMIT;\nBEGIN;\n\n");
                 AH->txnCount = 0;
             }
         }
  
         st = en;
     }
     ahprintf(AH, "\n");
     pg_free(buf);
 }

References ahprintf(), buf, CommitTransaction(), _archiveHandle::connection, _tocEntry::defn, pg_free(), pg_strdup(), _archiveHandle::public, Archive::ropt, StartTransaction(), _restoreOptions::txn_size, and _archiveHandle::txnCount.

Referenced by _printTocEntry(), IssueACLPerBlob(), and RestoreArchive().

◆ notice_processor()

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

static

Definition at line 260 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 72 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 527 of file pg_backup_db.c.

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

References ExecuteSqlCommand().

Referenced by IssueCommandPerBlob().

Functions

Function Documentation

◆ _check_database_version()

◆ CommitTransaction()

◆ ConnectDatabase()

◆ die_on_query_failure()

◆ DisconnectDatabase()

◆ DropLOIfExists()

◆ EndDBCopyMode()

◆ ExecuteSimpleCommands()

◆ ExecuteSqlCommand()

◆ ExecuteSqlCommandBuf()

◆ ExecuteSqlQuery()

◆ ExecuteSqlQueryForSingleRow()

◆ ExecuteSqlStatement()

◆ GetConnection()

◆ IssueACLPerBlob()

◆ IssueCommandPerBlob()

◆ notice_processor()

◆ ReconnectToServer()

◆ StartTransaction()