PostgreSQL Source Code git master
Functions
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 "connectdb.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  ConnectDatabaseAhx (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 32 of file pg_backup_db.c.

33{
34 const char *remoteversion_str;
35 int remoteversion;
36 PGresult *res;
37
38 remoteversion_str = PQparameterStatus(AH->connection, "server_version");
39 remoteversion = PQserverVersion(AH->connection);
40 if (remoteversion == 0 || !remoteversion_str)
41 pg_fatal("could not get \"server_version\" from libpq");
42
43 AH->public.remoteVersionStr = pg_strdup(remoteversion_str);
44 AH->public.remoteVersion = remoteversion;
45 if (!AH->archiveRemoteVersion)
47
48 if (remoteversion != PG_VERSION_NUM
49 && (remoteversion < AH->public.minRemoteVersion ||
50 remoteversion > AH->public.maxRemoteVersion))
51 {
52 pg_log_error("aborting because of server version mismatch");
53 pg_log_error_detail("server version: %s; %s version: %s",
54 remoteversion_str, progname, PG_VERSION);
55 exit(1);
56 }
57
58 /*
59 * Check if server is in recovery mode, which means we are on a hot
60 * standby.
61 */
63 "SELECT pg_catalog.pg_is_in_recovery()");
64 AH->public.isStandby = (strcmp(PQgetvalue(res, 0, 0), "t") == 0);
65 PQclear(res);
66}
int PQserverVersion(const PGconn *conn)
Definition: fe-connect.c:7669
const char * PQparameterStatus(const PGconn *conn, const char *paramName)
Definition: fe-connect.c:7634
char * pg_strdup(const char *in)
Definition: fe_memutils.c:85
#define PQgetvalue
Definition: libpq-be-fe.h:253
#define PQclear
Definition: libpq-be-fe.h:245
#define pg_log_error(...)
Definition: logging.h:106
#define pg_log_error_detail(...)
Definition: logging.h:109
const char * progname
Definition: main.c:44
PGresult * ExecuteSqlQueryForSingleRow(Archive *fout, const char *query)
Definition: pg_backup_db.c:244
#define pg_fatal(...)
int remoteVersion
Definition: pg_backup.h:233
char * remoteVersionStr
Definition: pg_backup.h:232
bool isStandby
Definition: pg_backup.h:234
int maxRemoteVersion
Definition: pg_backup.h:237
PGconn * connection
Archive public
char * archiveRemoteVersion
Definition: libpq-int.h:165

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

Referenced by ConnectDatabaseAhx().

◆ CommitTransaction()

void CommitTransaction ( Archive *  AHX )

Definition at line 476 of file pg_backup_db.c.

477{
478 ArchiveHandle *AH = (ArchiveHandle *) AHX;
479
480 ExecuteSqlCommand(AH, "COMMIT", "could not commit database transaction");
481}
static void ExecuteSqlCommand(ArchiveHandle *AH, const char *qry, const char *desc)
Definition: pg_backup_db.c:267

References ExecuteSqlCommand().

Referenced by IssueCommandPerBlob().

◆ ConnectDatabaseAhx()

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

Definition at line 109 of file pg_backup_db.c.

112{
113 ArchiveHandle *AH = (ArchiveHandle *) AHX;
114 trivalue prompt_password;
115 char *password;
116
117 if (AH->connection)
118 pg_fatal("already connected to a database");
119
120 /* Never prompt for a password during a reconnection */
121 prompt_password = isReconnect ? TRI_NO : cparams->promptPassword;
122
124
125 if (prompt_password == TRI_YES && password == NULL)
126 password = simple_prompt("Password: ", false);
127
128 AH->connection = ConnectDatabase(cparams->dbname, NULL, cparams->pghost,
129 cparams->pgport, cparams->username,
130 prompt_password, true,
131 progname, NULL, NULL, password, cparams->override_dbname);
132
133 /* Start strict; later phases may override this. */
136
137 if (password && password != AH->savedPassword)
138 free(password);
139
140 /*
141 * We want to remember connection's actual password, whether or not we got
142 * it by prompting. So we don't just store the password variable.
143 */
145 {
146 free(AH->savedPassword);
148 }
149
150 /* check for version mismatch */
152
154
155 /* arrange for SIGINT to issue a query cancel on this connection */
157}
void set_archive_cancel_info(ArchiveHandle *AH, PGconn *conn)
Definition: parallel.c:732
#define ALWAYS_SECURE_SEARCH_PATH_SQL
Definition: connect.h:25
PGconn * ConnectDatabase(const char *dbname, const char *connection_string, const char *pghost, const char *pgport, const char *pguser, trivalue prompt_password, bool fail_on_error, const char *progname, const char **connstr, int *server_version, char *password, char *override_dbname)
Definition: connectdb.c:40
int PQconnectionUsedPassword(const PGconn *conn)
Definition: fe-connect.c:7747
char * PQpass(const PGconn *conn)
Definition: fe-connect.c:7529
PQnoticeProcessor PQsetNoticeProcessor(PGconn *conn, PQnoticeProcessor proc, void *arg)
Definition: fe-connect.c:7860
#define free(a)
Definition: header.h:65
static void _check_database_version(ArchiveHandle *AH)
Definition: pg_backup_db.c:32
static void notice_processor(void *arg, const char *message)
Definition: pg_backup_db.c:201
char * simple_prompt(const char *prompt, bool echo)
Definition: sprompt.c:38
static char * password
Definition: streamutil.c:51
char * savedPassword
char * override_dbname
Definition: pg_backup.h:93
char * pgport
Definition: pg_backup.h:87
char * pghost
Definition: pg_backup.h:88
trivalue promptPassword
Definition: pg_backup.h:90
char * username
Definition: pg_backup.h:89
char * dbname
Definition: pg_backup.h:86
trivalue
Definition: vacuumlo.c:35
@ TRI_YES
Definition: vacuumlo.c:38
@ TRI_NO
Definition: vacuumlo.c:37

References _check_database_version(), ALWAYS_SECURE_SEARCH_PATH_SQL, ConnectDatabase(), _archiveHandle::connection, _connParams::dbname, ExecuteSqlQueryForSingleRow(), free, notice_processor(), _connParams::override_dbname, password, pg_fatal, pg_strdup(), _connParams::pghost, _connParams::pgport, PQclear, PQconnectionUsedPassword(), PQpass(), PQsetNoticeProcessor(), progname, _connParams::promptPassword, _archiveHandle::savedPassword, set_archive_cancel_info(), simple_prompt(), TRI_NO, TRI_YES, and _connParams::username.

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 208 of file pg_backup_db.c.

209{
210 pg_log_error("query failed: %s",
212 pg_log_error_detail("Query was: %s", query);
213 exit(1);
214}
char * PQerrorMessage(const PGconn *conn)
Definition: fe-connect.c:7679

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

Referenced by ExecuteSqlQuery(), and ExecuteSqlStatement().

◆ DisconnectDatabase()

void DisconnectDatabase ( Archive *  AHX )

Definition at line 164 of file pg_backup_db.c.

165{
166 ArchiveHandle *AH = (ArchiveHandle *) AHX;
167 char errbuf[1];
168
169 if (!AH->connection)
170 return;
171
172 if (AH->connCancel)
173 {
174 /*
175 * If we have an active query, send a cancel before closing, ignoring
176 * any errors. This is of no use for a normal exit, but might be
177 * helpful during pg_fatal().
178 */
180 (void) PQcancel(AH->connCancel, errbuf, sizeof(errbuf));
181
182 /*
183 * Prevent signal handler from sending a cancel after this.
184 */
185 set_archive_cancel_info(AH, NULL);
186 }
187
188 PQfinish(AH->connection);
189 AH->connection = NULL;
190}
int PQcancel(PGcancel *cancel, char *errbuf, int errbufsize)
Definition: fe-cancel.c:548
PGTransactionStatusType PQtransactionStatus(const PGconn *conn)
Definition: fe-connect.c:7624
void PQfinish(PGconn *conn)
Definition: fe-connect.c:5305
@ PQTRANS_ACTIVE
Definition: libpq-fe.h:148
PGcancel *volatile connCancel

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 612 of file pg_backup_db.c.

613{
614 ahprintf(AH,
615 "SELECT pg_catalog.lo_unlink(oid) "
616 "FROM pg_catalog.pg_largeobject_metadata "
617 "WHERE oid = '%u';\n",
618 oid);
619}
int ahprintf(ArchiveHandle *AH, const char *fmt,...)

References ahprintf().

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

◆ EndDBCopyMode()

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

Definition at line 439 of file pg_backup_db.c.

440{
441 ArchiveHandle *AH = (ArchiveHandle *) AHX;
442
443 if (AH->pgCopyIn)
444 {
445 PGresult *res;
446
447 if (PQputCopyEnd(AH->connection, NULL) <= 0)
448 pg_fatal("error returned by PQputCopyEnd: %s",
450
451 /* Check command status and return to normal libpq state */
452 res = PQgetResult(AH->connection);
454 warn_or_exit_horribly(AH, "COPY failed for table \"%s\": %s",
455 tocEntryTag, PQerrorMessage(AH->connection));
456 PQclear(res);
457
458 /* Do this to ensure we've pumped libpq back to idle state */
459 if (PQgetResult(AH->connection) != NULL)
460 pg_log_warning("unexpected extra results during COPY of table \"%s\"",
461 tocEntryTag);
462
463 AH->pgCopyIn = false;
464 }
465}
int PQputCopyEnd(PGconn *conn, const char *errormsg)
Definition: fe-exec.c:2760
#define PQgetResult
Definition: libpq-be-fe.h:246
#define PQresultStatus
Definition: libpq-be-fe.h:247
@ PGRES_COMMAND_OK
Definition: libpq-fe.h:125
void warn_or_exit_horribly(ArchiveHandle *AH, const char *fmt,...)
#define pg_log_warning(...)
Definition: pgfnames.c:24
bool pgCopyIn

References _archiveHandle::connection, pg_fatal, pg_log_warning, _archiveHandle::pgCopyIn, PGRES_COMMAND_OK, PQclear, PQerrorMessage(), PQgetResult, PQputCopyEnd(), PQresultStatus, 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 319 of file pg_backup_db.c.

320{
321 const char *qry = buf;
322 const char *eos = buf + bufLen;
323
324 /* initialize command buffer if first time through */
325 if (AH->sqlparse.curCmd == NULL)
327
328 for (; qry < eos; qry++)
329 {
330 char ch = *qry;
331
332 /* For neatness, we skip any newlines between commands */
333 if (!(ch == '\n' && AH->sqlparse.curCmd->len == 0))
335
336 switch (AH->sqlparse.state)
337 {
338 case SQL_SCAN: /* Default state == 0, set in _allocAH */
339 if (ch == ';')
340 {
341 /*
342 * We've found the end of a statement. Send it and reset
343 * the buffer.
344 */
346 "could not execute query");
348 }
349 else if (ch == '\'')
350 {
352 AH->sqlparse.backSlash = false;
353 }
354 else if (ch == '"')
355 {
357 }
358 break;
359
361 /* We needn't handle '' specially */
362 if (ch == '\'' && !AH->sqlparse.backSlash)
363 AH->sqlparse.state = SQL_SCAN;
364 else if (ch == '\\' && !AH->public.std_strings)
366 else
367 AH->sqlparse.backSlash = false;
368 break;
369
371 /* We needn't handle "" specially */
372 if (ch == '"')
373 AH->sqlparse.state = SQL_SCAN;
374 break;
375 }
376 }
377}
@ SQL_IN_DOUBLE_QUOTE
@ SQL_IN_SINGLE_QUOTE
@ SQL_SCAN
static char * buf
Definition: pg_test_fsync.c:72
PQExpBuffer createPQExpBuffer(void)
Definition: pqexpbuffer.c:72
void resetPQExpBuffer(PQExpBuffer str)
Definition: pqexpbuffer.c:146
void appendPQExpBufferChar(PQExpBuffer str, char ch)
Definition: pqexpbuffer.c:378
bool std_strings
Definition: pg_backup.h:244
char * data
Definition: pqexpbuffer.h:46
size_t len
Definition: pqexpbuffer.h:47
sqlparseInfo sqlparse
PQExpBuffer curCmd
sqlparseState state

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 267 of file pg_backup_db.c.

268{
269 PGconn *conn = AH->connection;
270 PGresult *res;
271
272#ifdef NOT_USED
273 fprintf(stderr, "Executing: '%s'\n\n", qry);
274#endif
275 res = PQexec(conn, qry);
276
277 switch (PQresultStatus(res))
278 {
279 case PGRES_COMMAND_OK:
280 case PGRES_TUPLES_OK:
282 /* A-OK */
283 break;
284 case PGRES_COPY_IN:
285 /* Assume this is an expected result */
286 AH->pgCopyIn = true;
287 break;
288 default:
289 /* trouble */
290 warn_or_exit_horribly(AH, "%s: %sCommand was: %s",
291 desc, PQerrorMessage(conn), qry);
292 break;
293 }
294
295 PQclear(res);
296}
#define fprintf(file, fmt, msg)
Definition: cubescan.l:21
PGresult * PQexec(PGconn *conn, const char *query)
Definition: fe-exec.c:2273
@ PGRES_COPY_IN
Definition: libpq-fe.h:132
@ PGRES_EMPTY_QUERY
Definition: libpq-fe.h:124
@ PGRES_TUPLES_OK
Definition: libpq-fe.h:128
PGconn * conn
Definition: streamutil.c:52
Definition: libpq-int.h:372

References conn, _archiveHandle::connection, fprintf, _archiveHandle::pgCopyIn, PGRES_COMMAND_OK, PGRES_COPY_IN, PGRES_EMPTY_QUERY, PGRES_TUPLES_OK, PQclear, PQerrorMessage(), PQexec(), PQresultStatus, 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 384 of file pg_backup_db.c.

385{
386 ArchiveHandle *AH = (ArchiveHandle *) AHX;
387
388 if (AH->outputKind == OUTPUT_COPYDATA)
389 {
390 /*
391 * COPY data.
392 *
393 * We drop the data on the floor if libpq has failed to enter COPY
394 * mode; this allows us to behave reasonably when trying to continue
395 * after an error in a COPY command.
396 */
397 if (AH->pgCopyIn &&
398 PQputCopyData(AH->connection, buf, bufLen) <= 0)
399 pg_fatal("error returned by PQputCopyData: %s",
401 }
402 else if (AH->outputKind == OUTPUT_OTHERDATA)
403 {
404 /*
405 * Table data expressed as INSERT commands; or, in old dump files,
406 * BLOB COMMENTS data (which is expressed as COMMENT ON commands).
407 */
408 ExecuteSimpleCommands(AH, buf, bufLen);
409 }
410 else
411 {
412 /*
413 * General SQL commands; we assume that commands will not be split
414 * across calls.
415 *
416 * In most cases the data passed to us will be a null-terminated
417 * string, but if it's not, we have to add a trailing null.
418 */
419 if (buf[bufLen] == '0円')
420 ExecuteSqlCommand(AH, buf, "could not execute query");
421 else
422 {
423 char *str = (char *) pg_malloc(bufLen + 1);
424
425 memcpy(str, buf, bufLen);
426 str[bufLen] = '0円';
427 ExecuteSqlCommand(AH, str, "could not execute query");
428 free(str);
429 }
430 }
431
432 return bufLen;
433}
int PQputCopyData(PGconn *conn, const char *buffer, int nbytes)
Definition: fe-exec.c:2706
void * pg_malloc(size_t size)
Definition: fe_memutils.c:47
const char * str
@ OUTPUT_COPYDATA
@ OUTPUT_OTHERDATA
static void ExecuteSimpleCommands(ArchiveHandle *AH, const char *buf, size_t bufLen)
Definition: pg_backup_db.c:319
ArchiverOutput outputKind

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 229 of file pg_backup_db.c.

230{
231 ArchiveHandle *AH = (ArchiveHandle *) AHX;
232 PGresult *res;
233
234 res = PQexec(AH->connection, query);
235 if (PQresultStatus(res) != status)
236 die_on_query_failure(AH, query);
237 return res;
238}
static void die_on_query_failure(ArchiveHandle *AH, const char *query)
Definition: pg_backup_db.c:208

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

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(), fetchAttributeStats(), 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 244 of file pg_backup_db.c.

245{
246 PGresult *res;
247 int ntups;
248
249 res = ExecuteSqlQuery(fout, query, PGRES_TUPLES_OK);
250
251 /* Expecting a single result only */
252 ntups = PQntuples(res);
253 if (ntups != 1)
254 pg_fatal(ngettext("query returned %d row instead of one: %s",
255 "query returned %d rows instead of one: %s",
256 ntups),
257 ntups, query);
258
259 return res;
260}
#define ngettext(s, p, n)
Definition: c.h:1180
#define PQntuples
Definition: libpq-be-fe.h:251
PGresult * ExecuteSqlQuery(Archive *AHX, const char *query, ExecStatusType status)
Definition: pg_backup_db.c:229

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

Referenced by _check_database_version(), binary_upgrade_set_type_oids_by_type_oid(), ConnectDatabaseAhx(), 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 217 of file pg_backup_db.c.

218{
219 ArchiveHandle *AH = (ArchiveHandle *) AHX;
220 PGresult *res;
221
222 res = PQexec(AH->connection, query);
224 die_on_query_failure(AH, query);
225 PQclear(res);
226}

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

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

◆ GetConnection()

PGconn * GetConnection ( Archive *  AHX )

Definition at line 193 of file pg_backup_db.c.

194{
195 ArchiveHandle *AH = (ArchiveHandle *) AHX;
196
197 return AH->connection;
198}

References _archiveHandle::connection.

◆ IssueACLPerBlob()

void IssueACLPerBlob ( ArchiveHandle *  AH,
TocEntry *  te 
)

Definition at line 538 of file pg_backup_db.c.

539{
540 TocEntry *blobte = getTocEntryByDumpId(AH, te->dependencies[0]);
541 char *buf;
542 char *st;
543 char *st2;
544 char *en;
545 bool inquotes;
546
547 if (!blobte)
548 pg_fatal("could not find entry for ID %d", te->dependencies[0]);
549 Assert(strcmp(blobte->desc, "BLOB METADATA") == 0);
550
551 /* Make a writable copy of the ACL commands string */
552 buf = pg_strdup(te->defn);
553
554 /*
555 * We have to parse out the commands sufficiently to locate the blob OIDs
556 * and find the command-ending semicolons. The commands should not
557 * contain anything hard to parse except for double-quoted role names,
558 * which are easy to ignore. Once we've split apart the first and second
559 * halves of a command, apply IssueCommandPerBlob. (This means the
560 * updates on the blobs are interleaved if there's multiple commands, but
561 * that should cause no trouble.)
562 */
563 inquotes = false;
564 st = en = buf;
565 st2 = NULL;
566 while (*en)
567 {
568 /* Ignore double-quoted material */
569 if (*en == '"')
570 inquotes = !inquotes;
571 if (inquotes)
572 {
573 en++;
574 continue;
575 }
576 /* If we found "LARGE OBJECT", that's the end of the first half */
577 if (strncmp(en, "LARGE OBJECT ", 13) == 0)
578 {
579 /* Terminate the first-half string */
580 en += 13;
581 Assert(isdigit((unsigned char) *en));
582 *en++ = '0円';
583 /* Skip the rest of the blob OID */
584 while (isdigit((unsigned char) *en))
585 en++;
586 /* Second half starts here */
587 Assert(st2 == NULL);
588 st2 = en;
589 }
590 /* If we found semicolon, that's the end of the second half */
591 else if (*en == ';')
592 {
593 /* Terminate the second-half string */
594 *en++ = '0円';
595 Assert(st2 != NULL);
596 /* Issue this command for each blob */
597 IssueCommandPerBlob(AH, blobte, st, st2);
598 /* For neatness, skip whitespace before the next command */
599 while (isspace((unsigned char) *en))
600 en++;
601 /* Reset for new command */
602 st = en;
603 st2 = NULL;
604 }
605 else
606 en++;
607 }
608 pg_free(buf);
609}
void pg_free(void *ptr)
Definition: fe_memutils.c:105
Assert(PointerIsAligned(start, uint64))
TocEntry * getTocEntryByDumpId(ArchiveHandle *AH, DumpId id)
void IssueCommandPerBlob(ArchiveHandle *AH, TocEntry *te, const char *cmdBegin, const char *cmdEnd)
Definition: pg_backup_db.c:491
char * defn
DumpId * dependencies
char * desc

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 491 of file pg_backup_db.c.

493{
494 /* Make a writable copy of the command string */
495 char *buf = pg_strdup(te->defn);
496 RestoreOptions *ropt = AH->public.ropt;
497 char *st;
498 char *en;
499
500 st = buf;
501 while ((en = strchr(st, '\n')) != NULL)
502 {
503 *en++ = '0円';
504 ahprintf(AH, "%s%s%s;\n", cmdBegin, st, cmdEnd);
505
506 /* In --transaction-size mode, count each command as an action */
507 if (ropt && ropt->txn_size > 0)
508 {
509 if (++AH->txnCount >= ropt->txn_size)
510 {
511 if (AH->connection)
512 {
515 }
516 else
517 ahprintf(AH, "COMMIT;\nBEGIN;\n\n");
518 AH->txnCount = 0;
519 }
520 }
521
522 st = en;
523 }
524 ahprintf(AH, "\n");
525 pg_free(buf);
526}
void StartTransaction(Archive *AHX)
Definition: pg_backup_db.c:468
void CommitTransaction(Archive *AHX)
Definition: pg_backup_db.c:476
RestoreOptions * ropt
Definition: pg_backup.h:229
int txnCount
Definition: pg_backup.h:97
int txn_size
Definition: pg_backup.h:155

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 201 of file pg_backup_db.c.

202{
203 pg_log_info("%s", message);
204}
#define pg_log_info(...)
Definition: logging.h:124

References pg_log_info.

Referenced by ConnectDatabaseAhx().

◆ ReconnectToServer()

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

Definition at line 73 of file pg_backup_db.c.

74{
75 PGconn *oldConn = AH->connection;
76 RestoreOptions *ropt = AH->public.ropt;
77
78 /*
79 * Save the dbname, if given, in override_dbname so that it will also
80 * affect any later reconnection attempt.
81 */
82 if (dbname)
84
85 /*
86 * Note: we want to establish the new connection, and in particular update
87 * ArchiveHandle's connCancel, before closing old connection. Otherwise
88 * an ill-timed SIGINT could try to access a dead connection.
89 */
90 AH->connection = NULL; /* dodge error check in ConnectDatabaseAhx */
91
92 ConnectDatabaseAhx((Archive *) AH, &ropt->cparams, true);
93
94 PQfinish(oldConn);
95}
void ConnectDatabaseAhx(Archive *AHX, const ConnParams *cparams, bool isReconnect)
Definition: pg_backup_db.c:109
char * dbname
Definition: streamutil.c:49
ConnParams cparams
Definition: pg_backup.h:145

References ConnectDatabaseAhx(), _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 468 of file pg_backup_db.c.

469{
470 ArchiveHandle *AH = (ArchiveHandle *) AHX;
471
472 ExecuteSqlCommand(AH, "BEGIN", "could not start database transaction");
473}

References ExecuteSqlCommand().

Referenced by IssueCommandPerBlob().

AltStyle によって変換されたページ (->オリジナル) /