2000-07-21 13:43:26 +02:00
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
*
|
2001-01-12 05:32:07 +01:00
|
|
|
* pg_backup_db.c
|
|
|
|
*
|
2001-03-22 05:01:46 +01:00
|
|
|
* Implements the basic DB functions used by the archiver.
|
2001-01-12 05:32:07 +01:00
|
|
|
*
|
|
|
|
* IDENTIFICATION
|
2010-02-26 03:01:40 +01:00
|
|
|
* $PostgreSQL: pgsql/src/bin/pg_dump/pg_backup_db.c,v 1.90 2010/02/26 02:01:16 momjian Exp $
|
2002-01-18 18:13:51 +01:00
|
|
|
*
|
UUNET is looking into offering PostgreSQL as a part of a managed web
hosting product, on both shared and dedicated machines. We currently
offer Oracle and MySQL, and it would be a nice middle-ground.
However, as shipped, PostgreSQL lacks the following features we need
that MySQL has:
1. The ability to listen only on a particular IP address. Each
hosting customer has their own IP address, on which all of their
servers (http, ftp, real media, etc.) run.
2. The ability to place the Unix-domain socket in a mode 700 directory.
This allows us to automatically create an empty database, with an
empty DBA password, for new or upgrading customers without having
to interactively set a DBA password and communicate it to (or from)
the customer. This in turn cuts down our install and upgrade times.
3. The ability to connect to the Unix-domain socket from within a
change-rooted environment. We run CGI programs chrooted to the
user's home directory, which is another reason why we need to be
able to specify where the Unix-domain socket is, instead of /tmp.
4. The ability to, if run as root, open a pid file in /var/run as
root, and then setuid to the desired user. (mysqld -u can almost
do this; I had to patch it, too).
The patch below fixes problem 1-3. I plan to address #4, also, but
haven't done so yet. These diffs are big enough that they should give
the PG development team something to think about in the meantime :-)
Also, I'm about to leave for 2 weeks' vacation, so I thought I'd get
out what I have, which works (for the problems it tackles), now.
With these changes, we can set up and run PostgreSQL with scripts the
same way we can with apache or proftpd or mysql.
In summary, this patch makes the following enhancements:
1. Adds an environment variable PGUNIXSOCKET, analogous to MYSQL_UNIX_PORT,
and command line options -k --unix-socket to the relevant programs.
2. Adds a -h option to postmaster to set the hostname or IP address to
listen on instead of the default INADDR_ANY.
3. Extends some library interfaces to support the above.
4. Fixes a few memory leaks in PQconnectdb().
The default behavior is unchanged from stock 7.0.2; if you don't use
any of these new features, they don't change the operation.
David J. MacKenzie
2000-11-13 16:18:15 +01:00
|
|
|
*-------------------------------------------------------------------------
|
2000-07-21 13:43:26 +02:00
|
|
|
*/
|
|
|
|
|
2001-02-10 03:31:31 +01:00
|
|
|
#include "pg_backup_db.h"
|
2002-08-27 20:57:26 +02:00
|
|
|
#include "dumputils.h"
|
2001-02-10 03:31:31 +01:00
|
|
|
|
2002-08-20 19:54:45 +02:00
|
|
|
#include <unistd.h>
|
2006-02-12 07:11:51 +01:00
|
|
|
|
2000-07-21 13:43:26 +02:00
|
|
|
#include <ctype.h>
|
|
|
|
|
|
|
|
#ifdef HAVE_TERMIOS_H
|
|
|
|
#include <termios.h>
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
2001-07-03 22:21:50 +02:00
|
|
|
static const char *modulename = gettext_noop("archiver (db)");
|
2000-07-21 13:43:26 +02:00
|
|
|
|
2008-04-13 05:49:22 +02:00
|
|
|
static void _check_database_version(ArchiveHandle *AH);
|
2001-08-22 22:23:24 +02:00
|
|
|
static PGconn *_connectDB(ArchiveHandle *AH, const char *newdbname, const char *newUser);
|
2001-08-12 21:02:39 +02:00
|
|
|
static void notice_processor(void *arg, const char *message);
|
2002-01-18 20:17:05 +01:00
|
|
|
static char *_sendSQLLine(ArchiveHandle *AH, char *qry, char *eos);
|
|
|
|
static char *_sendCopyLine(ArchiveHandle *AH, char *qry, char *eos);
|
2000-07-21 13:43:26 +02:00
|
|
|
|
2005-09-11 06:10:25 +02:00
|
|
|
static bool _isIdentChar(unsigned char c);
|
|
|
|
static bool _isDQChar(unsigned char c, bool atStart);
|
2000-07-21 13:43:26 +02:00
|
|
|
|
They are two different problems; the TOC entry is important for any
multiline command or to rerun the command easily later.
Whereas displaying the failed SQL command is a matter of fixing the
error
messages.
The latter is complicated by failed COPY commands which, with
die-on-errors
off, results in the data being processed as a command, so dumping the
command will dump all of the data.
In the case of long commands, should the whole command be dumped? eg.
(eg.
several pages of function definition).
In the case of the COPY command, I'm not sure what to do. Obviously, it
would be best to avoid sending the data, but the data and command are
combined (from memory). Also, the 'data' may be in the form of INSERT
statements.
Attached patch produces the first 125 chars of the command:
pg_restore: [archiver (db)] Error while PROCESSING TOC:
pg_restore: [archiver (db)] Error from TOC Entry 26; 1255 16449270
FUNCTION
plpgsql_call_handler() pjw
pg_restore: [archiver (db)] could not execute query: ERROR: function
"plpgsql_call_handler" already exists with same argument types
Command was: CREATE FUNCTION plpgsql_call_handler() RETURNS
language_handler
AS '/var/lib/pgsql-8.0b1/lib/plpgsql', 'plpgsql_call_han...
pg_restore: [archiver (db)] Error from TOC Entry 27; 1255 16449271
FUNCTION
plpgsql_validator(oid) pjw
pg_restore: [archiver (db)] could not execute query: ERROR: function
"plpgsql_validator" already exists with same argument types
Command was: CREATE FUNCTION plpgsql_validator(oid) RETURNS void
AS '/var/lib/pgsql-8.0b1/lib/plpgsql', 'plpgsql_validator'
LANGU...
Philip Warner
2004-08-20 22:00:34 +02:00
|
|
|
#define DB_MAX_ERR_STMT 128
|
|
|
|
|
2001-04-25 09:03:20 +02:00
|
|
|
static int
|
2001-10-25 07:50:21 +02:00
|
|
|
_parse_version(ArchiveHandle *AH, const char *versionString)
|
2001-04-25 09:03:20 +02:00
|
|
|
{
|
2002-09-07 18:14:33 +02:00
|
|
|
int v;
|
2001-04-25 09:03:20 +02:00
|
|
|
|
2002-09-07 18:14:33 +02:00
|
|
|
v = parse_version(versionString);
|
|
|
|
if (v < 0)
|
2003-07-23 10:47:41 +02:00
|
|
|
die_horribly(AH, modulename, "could not parse version string \"%s\"\n", versionString);
|
2001-04-25 09:03:20 +02:00
|
|
|
|
2002-09-07 18:14:33 +02:00
|
|
|
return v;
|
2001-04-25 09:03:20 +02:00
|
|
|
}
|
2000-07-21 13:43:26 +02:00
|
|
|
|
|
|
|
static void
|
2008-04-13 05:49:22 +02:00
|
|
|
_check_database_version(ArchiveHandle *AH)
|
2000-07-21 13:43:26 +02:00
|
|
|
{
|
2001-04-25 09:03:20 +02:00
|
|
|
int myversion;
|
2000-07-21 13:43:26 +02:00
|
|
|
const char *remoteversion_str;
|
2001-04-25 09:03:20 +02:00
|
|
|
int remoteversion;
|
2000-07-21 13:43:26 +02:00
|
|
|
|
2001-04-25 09:03:20 +02:00
|
|
|
myversion = _parse_version(AH, PG_VERSION);
|
|
|
|
|
2003-06-22 02:56:58 +02:00
|
|
|
remoteversion_str = PQparameterStatus(AH->connection, "server_version");
|
|
|
|
if (!remoteversion_str)
|
|
|
|
die_horribly(AH, modulename, "could not get server_version from libpq\n");
|
2000-07-21 13:43:26 +02:00
|
|
|
|
2003-06-22 02:56:58 +02:00
|
|
|
remoteversion = _parse_version(AH, remoteversion_str);
|
2001-04-25 09:03:20 +02:00
|
|
|
|
2004-11-06 20:36:02 +01:00
|
|
|
AH->public.remoteVersionStr = strdup(remoteversion_str);
|
2001-04-25 09:03:20 +02:00
|
|
|
AH->public.remoteVersion = remoteversion;
|
2010-02-24 03:42:55 +01:00
|
|
|
if (!AH->archiveRemoteVersion)
|
|
|
|
AH->archiveRemoteVersion = AH->public.remoteVersionStr;
|
2001-04-25 09:03:20 +02:00
|
|
|
|
2001-10-25 07:50:21 +02:00
|
|
|
if (myversion != remoteversion
|
2003-06-22 02:56:58 +02:00
|
|
|
&& (remoteversion < AH->public.minRemoteVersion ||
|
|
|
|
remoteversion > AH->public.maxRemoteVersion))
|
2000-07-21 13:43:26 +02:00
|
|
|
{
|
2001-08-12 21:02:39 +02:00
|
|
|
write_msg(NULL, "server version: %s; %s version: %s\n",
|
2001-06-27 23:21:37 +02:00
|
|
|
remoteversion_str, progname, PG_VERSION);
|
2008-04-13 05:49:22 +02:00
|
|
|
die_horribly(AH, NULL, "aborting because of server version mismatch\n");
|
2000-07-21 13:43:26 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2000-08-01 17:51:45 +02:00
|
|
|
/*
|
2001-08-22 22:23:24 +02:00
|
|
|
* Reconnect to the server. If dbname is not NULL, use that database,
|
|
|
|
* else the one associated with the archive handle. If username is
|
2001-10-25 07:50:21 +02:00
|
|
|
* not NULL, use that user name, else the one from the handle. If
|
2004-09-10 22:05:18 +02:00
|
|
|
* both the database and the user match the existing connection already,
|
|
|
|
* nothing will be done.
|
2001-08-22 22:23:24 +02:00
|
|
|
*
|
|
|
|
* Returns 1 in any case.
|
2000-08-01 17:51:45 +02:00
|
|
|
*/
|
2001-03-22 05:01:46 +01:00
|
|
|
int
|
2001-08-22 22:23:24 +02:00
|
|
|
ReconnectToServer(ArchiveHandle *AH, const char *dbname, const char *username)
|
2000-08-01 17:51:45 +02:00
|
|
|
{
|
2001-03-22 05:01:46 +01:00
|
|
|
PGconn *newConn;
|
2001-08-22 22:23:24 +02:00
|
|
|
const char *newdbname;
|
|
|
|
const char *newusername;
|
|
|
|
|
|
|
|
if (!dbname)
|
|
|
|
newdbname = PQdb(AH->connection);
|
|
|
|
else
|
|
|
|
newdbname = dbname;
|
2000-08-01 17:51:45 +02:00
|
|
|
|
2001-08-22 22:23:24 +02:00
|
|
|
if (!username)
|
|
|
|
newusername = PQuser(AH->connection);
|
2000-08-01 17:51:45 +02:00
|
|
|
else
|
2001-08-22 22:23:24 +02:00
|
|
|
newusername = username;
|
2000-08-01 17:51:45 +02:00
|
|
|
|
|
|
|
/* Let's see if the request is already satisfied */
|
2004-09-10 22:05:18 +02:00
|
|
|
if (strcmp(newdbname, PQdb(AH->connection)) == 0 &&
|
|
|
|
strcmp(newusername, PQuser(AH->connection)) == 0)
|
2000-08-01 17:51:45 +02:00
|
|
|
return 1;
|
|
|
|
|
2001-08-22 22:23:24 +02:00
|
|
|
newConn = _connectDB(AH, newdbname, newusername);
|
2000-08-01 17:51:45 +02:00
|
|
|
|
|
|
|
PQfinish(AH->connection);
|
|
|
|
AH->connection = newConn;
|
2001-08-22 22:23:24 +02:00
|
|
|
|
2000-08-01 17:51:45 +02:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Connect to the db again.
|
2009-02-02 21:07:37 +01:00
|
|
|
*
|
|
|
|
* Note: it's not really all that sensible to use a single-entry password
|
|
|
|
* cache if the username keeps changing. In current usage, however, the
|
2009-06-11 16:49:15 +02:00
|
|
|
* username never does change, so one savedPassword is sufficient. We do
|
2009-02-02 21:07:37 +01:00
|
|
|
* update the cache on the off chance that the password has changed since the
|
|
|
|
* start of the run.
|
2000-08-01 17:51:45 +02:00
|
|
|
*/
|
2001-03-22 05:01:46 +01:00
|
|
|
static PGconn *
|
2001-08-22 22:23:24 +02:00
|
|
|
_connectDB(ArchiveHandle *AH, const char *reqdb, const char *requser)
|
2000-07-24 08:24:26 +02:00
|
|
|
{
|
2001-03-22 05:01:46 +01:00
|
|
|
PGconn *newConn;
|
2009-02-02 21:07:37 +01:00
|
|
|
const char *newdb;
|
|
|
|
const char *newuser;
|
|
|
|
char *password = AH->savedPassword;
|
2007-07-08 21:07:38 +02:00
|
|
|
bool new_pass;
|
2000-07-24 08:24:26 +02:00
|
|
|
|
2001-08-22 22:23:24 +02:00
|
|
|
if (!reqdb)
|
2000-08-01 17:51:45 +02:00
|
|
|
newdb = PQdb(AH->connection);
|
|
|
|
else
|
2009-02-02 21:07:37 +01:00
|
|
|
newdb = reqdb;
|
2000-08-01 17:51:45 +02:00
|
|
|
|
2009-02-02 21:07:37 +01:00
|
|
|
if (!requser || strlen(requser) == 0)
|
2000-08-01 17:51:45 +02:00
|
|
|
newuser = PQuser(AH->connection);
|
|
|
|
else
|
2009-02-02 21:07:37 +01:00
|
|
|
newuser = requser;
|
2000-08-01 17:51:45 +02:00
|
|
|
|
2009-02-02 21:07:37 +01:00
|
|
|
ahlog(AH, 1, "connecting to database \"%s\" as user \"%s\"\n",
|
|
|
|
newdb, newuser);
|
2000-07-24 08:24:26 +02:00
|
|
|
|
2009-02-26 17:02:39 +01:00
|
|
|
if (AH->promptPassword == TRI_YES && password == NULL)
|
2001-05-17 23:12:49 +02:00
|
|
|
{
|
|
|
|
password = simple_prompt("Password: ", 100, false);
|
|
|
|
if (password == NULL)
|
2001-06-27 23:21:37 +02:00
|
|
|
die_horribly(AH, modulename, "out of memory\n");
|
2001-05-17 23:12:49 +02:00
|
|
|
}
|
|
|
|
|
2000-07-24 08:24:26 +02:00
|
|
|
do
|
|
|
|
{
|
2010-02-05 04:09:05 +01:00
|
|
|
#define PARAMS_ARRAY_SIZE 7
|
|
|
|
const char **keywords = malloc(PARAMS_ARRAY_SIZE * sizeof(*keywords));
|
|
|
|
const char **values = malloc(PARAMS_ARRAY_SIZE * sizeof(*values));
|
|
|
|
|
|
|
|
if (!keywords || !values)
|
|
|
|
die_horribly(AH, modulename, "out of memory\n");
|
|
|
|
|
2010-02-26 03:01:40 +01:00
|
|
|
keywords[0] = "host";
|
|
|
|
values[0] = PQhost(AH->connection);
|
|
|
|
keywords[1] = "port";
|
|
|
|
values[1] = PQport(AH->connection);
|
|
|
|
keywords[2] = "user";
|
|
|
|
values[2] = newuser;
|
|
|
|
keywords[3] = "password";
|
|
|
|
values[3] = password;
|
|
|
|
keywords[4] = "dbname";
|
|
|
|
values[4] = newdb;
|
|
|
|
keywords[5] = "fallback_application_name";
|
|
|
|
values[5] = progname;
|
|
|
|
keywords[6] = NULL;
|
|
|
|
values[6] = NULL;
|
2010-02-05 04:09:05 +01:00
|
|
|
|
2007-07-08 21:07:38 +02:00
|
|
|
new_pass = false;
|
2010-02-05 04:09:05 +01:00
|
|
|
newConn = PQconnectdbParams(keywords, values, true);
|
|
|
|
|
|
|
|
free(keywords);
|
|
|
|
free(values);
|
|
|
|
|
2000-08-01 17:51:45 +02:00
|
|
|
if (!newConn)
|
2001-06-27 23:21:37 +02:00
|
|
|
die_horribly(AH, modulename, "failed to reconnect to database\n");
|
2000-08-01 17:51:45 +02:00
|
|
|
|
|
|
|
if (PQstatus(newConn) == CONNECTION_BAD)
|
|
|
|
{
|
2007-12-09 20:01:40 +01:00
|
|
|
if (!PQconnectionNeedsPassword(newConn))
|
2001-06-27 23:21:37 +02:00
|
|
|
die_horribly(AH, modulename, "could not reconnect to database: %s",
|
|
|
|
PQerrorMessage(newConn));
|
2004-10-01 19:25:55 +02:00
|
|
|
PQfinish(newConn);
|
2007-07-08 21:07:38 +02:00
|
|
|
|
|
|
|
if (password)
|
|
|
|
fprintf(stderr, "Password incorrect\n");
|
|
|
|
|
|
|
|
fprintf(stderr, "Connecting to %s as %s\n",
|
|
|
|
newdb, newuser);
|
|
|
|
|
|
|
|
if (password)
|
|
|
|
free(password);
|
2009-02-26 17:02:39 +01:00
|
|
|
|
|
|
|
if (AH->promptPassword != TRI_NO)
|
|
|
|
password = simple_prompt("Password: ", 100, false);
|
|
|
|
else
|
|
|
|
die_horribly(AH, modulename, "connection needs password\n");
|
|
|
|
|
2009-02-02 21:07:37 +01:00
|
|
|
if (password == NULL)
|
|
|
|
die_horribly(AH, modulename, "out of memory\n");
|
2007-07-08 21:07:38 +02:00
|
|
|
new_pass = true;
|
2000-08-01 17:51:45 +02:00
|
|
|
}
|
2007-07-08 21:07:38 +02:00
|
|
|
} while (new_pass);
|
2000-07-24 08:24:26 +02:00
|
|
|
|
2009-02-02 21:07:37 +01:00
|
|
|
AH->savedPassword = password;
|
2001-05-17 23:12:49 +02:00
|
|
|
|
2003-02-14 20:40:42 +01:00
|
|
|
/* check for version mismatch */
|
2008-04-13 05:49:22 +02:00
|
|
|
_check_database_version(AH);
|
2003-02-14 20:40:42 +01:00
|
|
|
|
2001-08-12 21:02:39 +02:00
|
|
|
PQsetNoticeProcessor(newConn, notice_processor, NULL);
|
|
|
|
|
2000-08-01 17:51:45 +02:00
|
|
|
return newConn;
|
2000-07-24 08:24:26 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2001-05-17 23:12:49 +02:00
|
|
|
/*
|
|
|
|
* Make a database connection with the given parameters. The
|
|
|
|
* connection handle is returned, the parameters are stored in AHX.
|
|
|
|
* An interactive password prompt is automatically issued if required.
|
2009-02-02 21:07:37 +01:00
|
|
|
*
|
|
|
|
* Note: it's not really all that sensible to use a single-entry password
|
|
|
|
* cache if the username keeps changing. In current usage, however, the
|
|
|
|
* username never does change, so one savedPassword is sufficient.
|
2001-05-17 23:12:49 +02:00
|
|
|
*/
|
2001-03-22 05:01:46 +01:00
|
|
|
PGconn *
|
|
|
|
ConnectDatabase(Archive *AHX,
|
|
|
|
const char *dbname,
|
|
|
|
const char *pghost,
|
|
|
|
const char *pgport,
|
2001-05-17 23:12:49 +02:00
|
|
|
const char *username,
|
2009-02-26 17:02:39 +01:00
|
|
|
enum trivalue prompt_password)
|
2000-07-21 13:43:26 +02:00
|
|
|
{
|
2001-03-22 05:01:46 +01:00
|
|
|
ArchiveHandle *AH = (ArchiveHandle *) AHX;
|
2009-02-02 21:07:37 +01:00
|
|
|
char *password = AH->savedPassword;
|
2007-07-08 21:07:38 +02:00
|
|
|
bool new_pass;
|
2000-07-21 13:43:26 +02:00
|
|
|
|
|
|
|
if (AH->connection)
|
2001-07-03 22:21:50 +02:00
|
|
|
die_horribly(AH, modulename, "already connected to a database\n");
|
2000-07-21 13:43:26 +02:00
|
|
|
|
2009-02-26 17:02:39 +01:00
|
|
|
if (prompt_password == TRI_YES && password == NULL)
|
2000-07-21 13:43:26 +02:00
|
|
|
{
|
2001-05-17 23:12:49 +02:00
|
|
|
password = simple_prompt("Password: ", 100, false);
|
|
|
|
if (password == NULL)
|
2001-06-27 23:21:37 +02:00
|
|
|
die_horribly(AH, modulename, "out of memory\n");
|
2000-07-21 13:43:26 +02:00
|
|
|
}
|
2009-02-26 17:02:39 +01:00
|
|
|
AH->promptPassword = prompt_password;
|
2001-05-17 23:12:49 +02:00
|
|
|
|
|
|
|
/*
|
2005-10-15 04:49:52 +02:00
|
|
|
* Start the connection. Loop until we have a password if requested by
|
|
|
|
* backend.
|
2001-05-17 23:12:49 +02:00
|
|
|
*/
|
|
|
|
do
|
|
|
|
{
|
2010-02-05 04:09:05 +01:00
|
|
|
#define PARAMS_ARRAY_SIZE 7
|
|
|
|
const char **keywords = malloc(PARAMS_ARRAY_SIZE * sizeof(*keywords));
|
|
|
|
const char **values = malloc(PARAMS_ARRAY_SIZE * sizeof(*values));
|
|
|
|
|
|
|
|
if (!keywords || !values)
|
|
|
|
die_horribly(AH, modulename, "out of memory\n");
|
|
|
|
|
2010-02-26 03:01:40 +01:00
|
|
|
keywords[0] = "host";
|
|
|
|
values[0] = pghost;
|
|
|
|
keywords[1] = "port";
|
|
|
|
values[1] = pgport;
|
|
|
|
keywords[2] = "user";
|
|
|
|
values[2] = username;
|
|
|
|
keywords[3] = "password";
|
|
|
|
values[3] = password;
|
|
|
|
keywords[4] = "dbname";
|
|
|
|
values[4] = dbname;
|
|
|
|
keywords[5] = "fallback_application_name";
|
|
|
|
values[5] = progname;
|
|
|
|
keywords[6] = NULL;
|
|
|
|
values[6] = NULL;
|
2010-02-05 04:09:05 +01:00
|
|
|
|
2007-07-08 21:07:38 +02:00
|
|
|
new_pass = false;
|
2010-02-05 04:09:05 +01:00
|
|
|
AH->connection = PQconnectdbParams(keywords, values, true);
|
|
|
|
|
|
|
|
free(keywords);
|
|
|
|
free(values);
|
2001-05-17 23:12:49 +02:00
|
|
|
|
|
|
|
if (!AH->connection)
|
2001-06-27 23:21:37 +02:00
|
|
|
die_horribly(AH, modulename, "failed to connect to database\n");
|
2001-05-17 23:12:49 +02:00
|
|
|
|
|
|
|
if (PQstatus(AH->connection) == CONNECTION_BAD &&
|
2007-12-09 20:01:40 +01:00
|
|
|
PQconnectionNeedsPassword(AH->connection) &&
|
2009-02-26 17:02:39 +01:00
|
|
|
password == NULL &&
|
|
|
|
prompt_password != TRI_NO)
|
2001-05-17 23:12:49 +02:00
|
|
|
{
|
|
|
|
PQfinish(AH->connection);
|
|
|
|
password = simple_prompt("Password: ", 100, false);
|
2009-02-02 21:07:37 +01:00
|
|
|
if (password == NULL)
|
|
|
|
die_horribly(AH, modulename, "out of memory\n");
|
2007-07-08 21:07:38 +02:00
|
|
|
new_pass = true;
|
2001-05-17 23:12:49 +02:00
|
|
|
}
|
2007-07-08 21:07:38 +02:00
|
|
|
} while (new_pass);
|
2001-05-17 23:12:49 +02:00
|
|
|
|
2009-02-02 21:07:37 +01:00
|
|
|
AH->savedPassword = password;
|
2000-07-21 13:43:26 +02:00
|
|
|
|
|
|
|
/* check to see that the backend connection was successfully made */
|
|
|
|
if (PQstatus(AH->connection) == CONNECTION_BAD)
|
2001-06-27 23:21:37 +02:00
|
|
|
die_horribly(AH, modulename, "connection to database \"%s\" failed: %s",
|
2005-07-27 07:14:12 +02:00
|
|
|
PQdb(AH->connection), PQerrorMessage(AH->connection));
|
2000-07-21 13:43:26 +02:00
|
|
|
|
|
|
|
/* check for version mismatch */
|
2008-04-13 05:49:22 +02:00
|
|
|
_check_database_version(AH);
|
2000-07-21 13:43:26 +02:00
|
|
|
|
2001-08-12 21:02:39 +02:00
|
|
|
PQsetNoticeProcessor(AH->connection, notice_processor, NULL);
|
|
|
|
|
2000-07-21 13:43:26 +02:00
|
|
|
return AH->connection;
|
|
|
|
}
|
|
|
|
|
2001-08-12 21:02:39 +02:00
|
|
|
|
2001-10-25 07:50:21 +02:00
|
|
|
static void
|
|
|
|
notice_processor(void *arg, const char *message)
|
2001-08-12 21:02:39 +02:00
|
|
|
{
|
|
|
|
write_msg(NULL, "%s", message);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2000-08-01 17:51:45 +02:00
|
|
|
/* Public interface */
|
2000-07-21 13:43:26 +02:00
|
|
|
/* Convenience function to send a query. Monitors result to handle COPY statements */
|
2008-08-16 04:25:06 +02:00
|
|
|
static void
|
|
|
|
ExecuteSqlCommand(ArchiveHandle *AH, const char *qry, const char *desc)
|
2000-07-21 13:43:26 +02:00
|
|
|
{
|
2005-06-21 22:45:44 +02:00
|
|
|
PGconn *conn = AH->connection;
|
2001-03-22 05:01:46 +01:00
|
|
|
PGresult *res;
|
2004-08-29 07:07:03 +02:00
|
|
|
char errStmt[DB_MAX_ERR_STMT];
|
2000-07-21 13:43:26 +02:00
|
|
|
|
2008-08-16 04:25:06 +02:00
|
|
|
#ifdef NOT_USED
|
2009-06-11 16:49:15 +02:00
|
|
|
fprintf(stderr, "Executing: '%s'\n\n", qry);
|
2008-08-16 04:25:06 +02:00
|
|
|
#endif
|
|
|
|
res = PQexec(conn, qry);
|
2000-07-21 13:43:26 +02:00
|
|
|
|
2008-08-16 04:25:06 +02:00
|
|
|
switch (PQresultStatus(res))
|
2000-07-21 13:43:26 +02:00
|
|
|
{
|
2008-08-16 04:25:06 +02:00
|
|
|
case PGRES_COMMAND_OK:
|
|
|
|
case PGRES_TUPLES_OK:
|
|
|
|
/* A-OK */
|
|
|
|
break;
|
|
|
|
case PGRES_COPY_IN:
|
|
|
|
/* Assume this is an expected result */
|
2006-02-05 21:58:47 +01:00
|
|
|
AH->pgCopyIn = true;
|
2008-08-16 04:25:06 +02:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/* trouble */
|
|
|
|
strncpy(errStmt, qry, DB_MAX_ERR_STMT);
|
2004-08-29 07:07:03 +02:00
|
|
|
if (errStmt[DB_MAX_ERR_STMT - 1] != '\0')
|
|
|
|
{
|
|
|
|
errStmt[DB_MAX_ERR_STMT - 4] = '.';
|
|
|
|
errStmt[DB_MAX_ERR_STMT - 3] = '.';
|
|
|
|
errStmt[DB_MAX_ERR_STMT - 2] = '.';
|
|
|
|
errStmt[DB_MAX_ERR_STMT - 1] = '\0';
|
They are two different problems; the TOC entry is important for any
multiline command or to rerun the command easily later.
Whereas displaying the failed SQL command is a matter of fixing the
error
messages.
The latter is complicated by failed COPY commands which, with
die-on-errors
off, results in the data being processed as a command, so dumping the
command will dump all of the data.
In the case of long commands, should the whole command be dumped? eg.
(eg.
several pages of function definition).
In the case of the COPY command, I'm not sure what to do. Obviously, it
would be best to avoid sending the data, but the data and command are
combined (from memory). Also, the 'data' may be in the form of INSERT
statements.
Attached patch produces the first 125 chars of the command:
pg_restore: [archiver (db)] Error while PROCESSING TOC:
pg_restore: [archiver (db)] Error from TOC Entry 26; 1255 16449270
FUNCTION
plpgsql_call_handler() pjw
pg_restore: [archiver (db)] could not execute query: ERROR: function
"plpgsql_call_handler" already exists with same argument types
Command was: CREATE FUNCTION plpgsql_call_handler() RETURNS
language_handler
AS '/var/lib/pgsql-8.0b1/lib/plpgsql', 'plpgsql_call_han...
pg_restore: [archiver (db)] Error from TOC Entry 27; 1255 16449271
FUNCTION
plpgsql_validator(oid) pjw
pg_restore: [archiver (db)] could not execute query: ERROR: function
"plpgsql_validator" already exists with same argument types
Command was: CREATE FUNCTION plpgsql_validator(oid) RETURNS void
AS '/var/lib/pgsql-8.0b1/lib/plpgsql', 'plpgsql_validator'
LANGU...
Philip Warner
2004-08-20 22:00:34 +02:00
|
|
|
}
|
|
|
|
warn_or_die_horribly(AH, modulename, "%s: %s Command was: %s\n",
|
2008-08-16 04:25:06 +02:00
|
|
|
desc, PQerrorMessage(conn), errStmt);
|
|
|
|
break;
|
2000-07-21 13:43:26 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
PQclear(res);
|
|
|
|
}
|
|
|
|
|
2002-01-18 20:17:05 +01:00
|
|
|
/*
|
2002-01-18 18:13:51 +01:00
|
|
|
* Used by ExecuteSqlCommandBuf to send one buffered line when running a COPY command.
|
|
|
|
*/
|
2002-01-18 20:17:05 +01:00
|
|
|
static char *
|
|
|
|
_sendCopyLine(ArchiveHandle *AH, char *qry, char *eos)
|
2000-07-21 13:43:26 +02:00
|
|
|
{
|
2002-08-20 19:54:45 +02:00
|
|
|
size_t loc; /* Location of next newline */
|
2002-01-18 20:17:05 +01:00
|
|
|
int pos = 0; /* Current position */
|
|
|
|
int sPos = 0; /* Last pos of a slash char */
|
|
|
|
int isEnd = 0;
|
2000-07-21 13:43:26 +02:00
|
|
|
|
2002-01-18 18:13:51 +01:00
|
|
|
/* loop to find unquoted newline ending the line of COPY data */
|
2002-01-18 20:17:05 +01:00
|
|
|
for (;;)
|
|
|
|
{
|
2002-01-18 18:13:51 +01:00
|
|
|
loc = strcspn(&qry[pos], "\n") + pos;
|
2000-07-21 13:43:26 +02:00
|
|
|
|
2002-01-18 18:13:51 +01:00
|
|
|
/* If no match, then wait */
|
2002-01-18 20:17:05 +01:00
|
|
|
if (loc >= (eos - qry)) /* None found */
|
2001-03-22 05:01:46 +01:00
|
|
|
{
|
2002-01-18 18:13:51 +01:00
|
|
|
appendBinaryPQExpBuffer(AH->pgCopyBuf, qry, (eos - qry));
|
|
|
|
return eos;
|
|
|
|
}
|
2000-07-21 13:43:26 +02:00
|
|
|
|
2002-01-18 18:13:51 +01:00
|
|
|
/*
|
2005-10-15 04:49:52 +02:00
|
|
|
* fprintf(stderr, "Found cr at %d, prev char was %c, next was %c\n",
|
|
|
|
* loc, qry[loc-1], qry[loc+1]);
|
2002-01-18 18:13:51 +01:00
|
|
|
*/
|
2001-03-22 05:01:46 +01:00
|
|
|
|
2002-01-18 18:13:51 +01:00
|
|
|
/* Count the number of preceding slashes */
|
|
|
|
sPos = loc;
|
|
|
|
while (sPos > 0 && qry[sPos - 1] == '\\')
|
|
|
|
sPos--;
|
2000-07-21 13:43:26 +02:00
|
|
|
|
2002-01-18 18:13:51 +01:00
|
|
|
sPos = loc - sPos;
|
2000-07-21 13:43:26 +02:00
|
|
|
|
2002-01-18 18:13:51 +01:00
|
|
|
/*
|
2005-10-15 04:49:52 +02:00
|
|
|
* If an odd number of preceding slashes, then \n was escaped so set
|
|
|
|
* the next search pos, and loop (if any left).
|
2002-01-18 18:13:51 +01:00
|
|
|
*/
|
|
|
|
if ((sPos & 1) == 1)
|
|
|
|
{
|
|
|
|
/* fprintf(stderr, "cr was escaped\n"); */
|
|
|
|
pos = loc + 1;
|
|
|
|
if (pos >= (eos - qry))
|
2000-07-21 13:43:26 +02:00
|
|
|
{
|
2002-01-18 18:13:51 +01:00
|
|
|
appendBinaryPQExpBuffer(AH->pgCopyBuf, qry, (eos - qry));
|
|
|
|
return eos;
|
2000-07-21 13:43:26 +02:00
|
|
|
}
|
2002-01-18 18:13:51 +01:00
|
|
|
}
|
2002-01-18 20:17:05 +01:00
|
|
|
else
|
|
|
|
break;
|
2002-01-18 18:13:51 +01:00
|
|
|
}
|
2000-07-21 13:43:26 +02:00
|
|
|
|
2002-01-18 18:13:51 +01:00
|
|
|
/* We found an unquoted newline */
|
|
|
|
qry[loc] = '\0';
|
|
|
|
appendPQExpBuffer(AH->pgCopyBuf, "%s\n", qry);
|
|
|
|
isEnd = (strcmp(AH->pgCopyBuf->data, "\\.\n") == 0);
|
2001-03-22 05:01:46 +01:00
|
|
|
|
2006-02-05 21:58:47 +01:00
|
|
|
/*
|
2006-10-04 02:30:14 +02:00
|
|
|
* Note that 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.
|
2002-01-18 18:13:51 +01:00
|
|
|
*/
|
2006-03-04 00:38:30 +01:00
|
|
|
if (AH->pgCopyIn &&
|
|
|
|
PQputCopyData(AH->connection, AH->pgCopyBuf->data,
|
|
|
|
AH->pgCopyBuf->len) <= 0)
|
|
|
|
die_horribly(AH, modulename, "error returned by PQputCopyData: %s",
|
2006-02-09 19:28:29 +01:00
|
|
|
PQerrorMessage(AH->connection));
|
2000-07-21 13:43:26 +02:00
|
|
|
|
2002-01-18 18:13:51 +01:00
|
|
|
resetPQExpBuffer(AH->pgCopyBuf);
|
2000-07-21 13:43:26 +02:00
|
|
|
|
2006-03-04 00:38:30 +01:00
|
|
|
if (isEnd && AH->pgCopyIn)
|
2002-01-18 18:13:51 +01:00
|
|
|
{
|
2006-03-04 00:38:30 +01:00
|
|
|
PGresult *res;
|
|
|
|
|
|
|
|
if (PQputCopyEnd(AH->connection, NULL) <= 0)
|
|
|
|
die_horribly(AH, modulename, "error returned by PQputCopyEnd: %s",
|
2006-02-09 19:28:29 +01:00
|
|
|
PQerrorMessage(AH->connection));
|
2000-07-21 13:43:26 +02:00
|
|
|
|
2006-03-04 00:38:30 +01:00
|
|
|
/* Check command status and return to normal libpq state */
|
|
|
|
res = PQgetResult(AH->connection);
|
|
|
|
if (PQresultStatus(res) != PGRES_COMMAND_OK)
|
|
|
|
warn_or_die_horribly(AH, modulename, "COPY failed: %s",
|
|
|
|
PQerrorMessage(AH->connection));
|
|
|
|
PQclear(res);
|
|
|
|
|
2006-02-05 21:58:47 +01:00
|
|
|
AH->pgCopyIn = false;
|
2002-01-18 18:13:51 +01:00
|
|
|
}
|
2000-07-21 13:43:26 +02:00
|
|
|
|
2002-01-18 18:13:51 +01:00
|
|
|
return qry + loc + 1;
|
|
|
|
}
|
2000-07-21 13:43:26 +02:00
|
|
|
|
2002-01-18 20:17:05 +01:00
|
|
|
/*
|
2005-09-11 06:10:25 +02:00
|
|
|
* Used by ExecuteSqlCommandBuf to send one buffered line of SQL
|
|
|
|
* (not data for the copy command).
|
2002-01-18 18:13:51 +01:00
|
|
|
*/
|
2002-01-18 20:17:05 +01:00
|
|
|
static char *
|
|
|
|
_sendSQLLine(ArchiveHandle *AH, char *qry, char *eos)
|
2002-01-18 18:13:51 +01:00
|
|
|
{
|
|
|
|
/*
|
2002-01-18 20:17:05 +01:00
|
|
|
* The following is a mini state machine to assess the end of an SQL
|
2005-10-15 04:49:52 +02:00
|
|
|
* statement. It really only needs to parse good SQL, or at least that's
|
|
|
|
* the theory... End-of-statement is assumed to be an unquoted,
|
2005-09-11 06:10:25 +02:00
|
|
|
* un-commented semi-colon that's not within any parentheses.
|
|
|
|
*
|
|
|
|
* Note: the input can be split into bufferloads at arbitrary boundaries.
|
|
|
|
* Therefore all state must be kept in AH->sqlparse, not in local
|
2005-10-15 04:49:52 +02:00
|
|
|
* variables of this routine. We assume that AH->sqlparse was filled with
|
|
|
|
* zeroes when created.
|
2002-01-18 18:13:51 +01:00
|
|
|
*/
|
2005-09-11 06:10:25 +02:00
|
|
|
for (; qry < eos; qry++)
|
2002-01-18 18:13:51 +01:00
|
|
|
{
|
2005-09-11 06:10:25 +02:00
|
|
|
switch (AH->sqlparse.state)
|
2002-01-18 18:13:51 +01:00
|
|
|
{
|
2005-09-11 06:10:25 +02:00
|
|
|
case SQL_SCAN: /* Default state == 0, set in _allocAH */
|
|
|
|
if (*qry == ';' && AH->sqlparse.braceDepth == 0)
|
|
|
|
{
|
2004-08-29 07:07:03 +02:00
|
|
|
/*
|
2005-10-15 04:49:52 +02:00
|
|
|
* We've found the end of a statement. Send it and reset
|
|
|
|
* the buffer.
|
2002-01-18 18:13:51 +01:00
|
|
|
*/
|
2005-10-15 04:49:52 +02:00
|
|
|
appendPQExpBufferChar(AH->sqlBuf, ';'); /* inessential */
|
2008-08-16 04:25:06 +02:00
|
|
|
ExecuteSqlCommand(AH, AH->sqlBuf->data,
|
2005-09-11 06:10:25 +02:00
|
|
|
"could not execute query");
|
|
|
|
resetPQExpBuffer(AH->sqlBuf);
|
|
|
|
AH->sqlparse.lastChar = '\0';
|
2004-08-29 07:07:03 +02:00
|
|
|
|
2002-01-18 20:17:05 +01:00
|
|
|
/*
|
2005-10-15 04:49:52 +02:00
|
|
|
* Remove any following newlines - so that embedded COPY
|
|
|
|
* commands don't get a starting newline.
|
2002-01-18 18:13:51 +01:00
|
|
|
*/
|
2005-09-11 06:10:25 +02:00
|
|
|
qry++;
|
|
|
|
while (qry < eos && *qry == '\n')
|
|
|
|
qry++;
|
|
|
|
|
|
|
|
/* We've finished one line, so exit */
|
|
|
|
return qry;
|
|
|
|
}
|
|
|
|
else if (*qry == '\'')
|
|
|
|
{
|
|
|
|
if (AH->sqlparse.lastChar == 'E')
|
|
|
|
AH->sqlparse.state = SQL_IN_E_QUOTE;
|
2004-08-20 18:07:15 +02:00
|
|
|
else
|
2005-09-11 06:10:25 +02:00
|
|
|
AH->sqlparse.state = SQL_IN_SINGLE_QUOTE;
|
|
|
|
AH->sqlparse.backSlash = false;
|
|
|
|
}
|
|
|
|
else if (*qry == '"')
|
|
|
|
{
|
|
|
|
AH->sqlparse.state = SQL_IN_DOUBLE_QUOTE;
|
|
|
|
}
|
2005-10-15 04:49:52 +02:00
|
|
|
|
2005-09-11 06:10:25 +02:00
|
|
|
/*
|
|
|
|
* Look for dollar-quotes. We make the assumption that
|
2005-10-15 04:49:52 +02:00
|
|
|
* $-quotes will not have an ident character just before them
|
|
|
|
* in pg_dump output. XXX is this good enough?
|
2005-09-11 06:10:25 +02:00
|
|
|
*/
|
|
|
|
else if (*qry == '$' && !_isIdentChar(AH->sqlparse.lastChar))
|
|
|
|
{
|
|
|
|
AH->sqlparse.state = SQL_IN_DOLLAR_TAG;
|
|
|
|
/* initialize separate buffer with possible tag */
|
|
|
|
if (AH->sqlparse.tagBuf == NULL)
|
|
|
|
AH->sqlparse.tagBuf = createPQExpBuffer();
|
|
|
|
else
|
|
|
|
resetPQExpBuffer(AH->sqlparse.tagBuf);
|
|
|
|
appendPQExpBufferChar(AH->sqlparse.tagBuf, *qry);
|
|
|
|
}
|
|
|
|
else if (*qry == '-' && AH->sqlparse.lastChar == '-')
|
|
|
|
AH->sqlparse.state = SQL_IN_SQL_COMMENT;
|
|
|
|
else if (*qry == '*' && AH->sqlparse.lastChar == '/')
|
|
|
|
AH->sqlparse.state = SQL_IN_EXT_COMMENT;
|
|
|
|
else if (*qry == '(')
|
|
|
|
AH->sqlparse.braceDepth++;
|
|
|
|
else if (*qry == ')')
|
|
|
|
AH->sqlparse.braceDepth--;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SQL_IN_SQL_COMMENT:
|
|
|
|
if (*qry == '\n')
|
|
|
|
AH->sqlparse.state = SQL_SCAN;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SQL_IN_EXT_COMMENT:
|
2005-10-15 04:49:52 +02:00
|
|
|
|
2005-09-11 06:10:25 +02:00
|
|
|
/*
|
|
|
|
* This isn't fully correct, because we don't account for
|
|
|
|
* nested slash-stars, but pg_dump never emits such.
|
|
|
|
*/
|
|
|
|
if (AH->sqlparse.lastChar == '*' && *qry == '/')
|
|
|
|
AH->sqlparse.state = SQL_SCAN;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SQL_IN_SINGLE_QUOTE:
|
|
|
|
/* We needn't handle '' specially */
|
|
|
|
if (*qry == '\'' && !AH->sqlparse.backSlash)
|
|
|
|
AH->sqlparse.state = SQL_SCAN;
|
|
|
|
else if (*qry == '\\')
|
|
|
|
AH->sqlparse.backSlash = !AH->sqlparse.backSlash;
|
|
|
|
else
|
|
|
|
AH->sqlparse.backSlash = false;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SQL_IN_E_QUOTE:
|
2005-10-15 04:49:52 +02:00
|
|
|
|
2005-09-11 06:10:25 +02:00
|
|
|
/*
|
|
|
|
* Eventually we will need to handle '' specially, because
|
|
|
|
* after E'...''... we should still be in E_QUOTE state.
|
|
|
|
*
|
2005-10-15 04:49:52 +02:00
|
|
|
* XXX problem: how do we tell whether the dump was made by a
|
|
|
|
* version that thinks backslashes aren't special in non-E
|
|
|
|
* literals??
|
2005-09-11 06:10:25 +02:00
|
|
|
*/
|
|
|
|
if (*qry == '\'' && !AH->sqlparse.backSlash)
|
|
|
|
AH->sqlparse.state = SQL_SCAN;
|
|
|
|
else if (*qry == '\\')
|
|
|
|
AH->sqlparse.backSlash = !AH->sqlparse.backSlash;
|
|
|
|
else
|
|
|
|
AH->sqlparse.backSlash = false;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SQL_IN_DOUBLE_QUOTE:
|
|
|
|
/* We needn't handle "" specially */
|
|
|
|
if (*qry == '"')
|
|
|
|
AH->sqlparse.state = SQL_SCAN;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SQL_IN_DOLLAR_TAG:
|
|
|
|
if (*qry == '$')
|
|
|
|
{
|
|
|
|
/* Do not add the closing $ to tagBuf */
|
|
|
|
AH->sqlparse.state = SQL_IN_DOLLAR_QUOTE;
|
|
|
|
AH->sqlparse.minTagEndPos = AH->sqlBuf->len + AH->sqlparse.tagBuf->len + 1;
|
|
|
|
}
|
|
|
|
else if (_isDQChar(*qry, (AH->sqlparse.tagBuf->len == 1)))
|
|
|
|
{
|
|
|
|
/* Valid, so add to tag */
|
|
|
|
appendPQExpBufferChar(AH->sqlparse.tagBuf, *qry);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Ooops, we're not really in a dollar-tag. Valid tag
|
2005-10-15 04:49:52 +02:00
|
|
|
* chars do not include the various chars we look for in
|
|
|
|
* this state machine, so it's safe to just jump from this
|
|
|
|
* state back to SCAN. We have to back up the qry pointer
|
|
|
|
* so that the current character gets rescanned in SCAN
|
|
|
|
* state; and then "continue" so that the bottom-of-loop
|
|
|
|
* actions aren't done yet.
|
2005-09-11 06:10:25 +02:00
|
|
|
*/
|
|
|
|
AH->sqlparse.state = SQL_SCAN;
|
|
|
|
qry--;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SQL_IN_DOLLAR_QUOTE:
|
2005-10-15 04:49:52 +02:00
|
|
|
|
2005-09-11 06:10:25 +02:00
|
|
|
/*
|
|
|
|
* If we are at a $, see whether what precedes it matches
|
2005-10-15 04:49:52 +02:00
|
|
|
* tagBuf. (Remember that the trailing $ of the tag was not
|
|
|
|
* added to tagBuf.) However, don't compare until we have
|
|
|
|
* enough data to be a possible match --- this is needed to
|
|
|
|
* avoid false match on '$a$a$...'
|
2005-09-11 06:10:25 +02:00
|
|
|
*/
|
|
|
|
if (*qry == '$' &&
|
|
|
|
AH->sqlBuf->len >= AH->sqlparse.minTagEndPos &&
|
|
|
|
strcmp(AH->sqlparse.tagBuf->data,
|
|
|
|
AH->sqlBuf->data + AH->sqlBuf->len - AH->sqlparse.tagBuf->len) == 0)
|
|
|
|
AH->sqlparse.state = SQL_SCAN;
|
|
|
|
break;
|
|
|
|
}
|
2004-08-20 18:07:15 +02:00
|
|
|
|
2005-09-11 06:10:25 +02:00
|
|
|
appendPQExpBufferChar(AH->sqlBuf, *qry);
|
|
|
|
AH->sqlparse.lastChar = *qry;
|
2002-01-18 18:13:51 +01:00
|
|
|
}
|
2000-07-21 13:43:26 +02:00
|
|
|
|
2002-01-18 20:17:05 +01:00
|
|
|
/*
|
2005-09-11 06:10:25 +02:00
|
|
|
* If we get here, we've processed entire bufferload with no complete SQL
|
2002-01-18 20:17:05 +01:00
|
|
|
* stmt
|
|
|
|
*/
|
|
|
|
return eos;
|
2002-01-18 18:13:51 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Convenience function to send one or more queries. Monitors result to handle COPY statements */
|
|
|
|
int
|
2002-08-20 19:54:45 +02:00
|
|
|
ExecuteSqlCommandBuf(ArchiveHandle *AH, void *qryv, size_t bufLen)
|
2002-01-18 18:13:51 +01:00
|
|
|
{
|
|
|
|
char *qry = (char *) qryv;
|
|
|
|
char *eos = qry + bufLen;
|
|
|
|
|
|
|
|
/*
|
2005-10-15 04:49:52 +02:00
|
|
|
* fprintf(stderr, "\n\n*****\n Buffer:\n\n%s\n*******************\n\n",
|
|
|
|
* qry);
|
2002-01-18 18:13:51 +01:00
|
|
|
*/
|
|
|
|
|
|
|
|
/* Could switch between command and COPY IN mode at each line */
|
|
|
|
while (qry < eos)
|
|
|
|
{
|
2006-02-05 21:58:47 +01:00
|
|
|
/*
|
|
|
|
* If libpq is in CopyIn mode *or* if the archive structure shows we
|
2006-10-04 02:30:14 +02:00
|
|
|
* are sending COPY data, treat the data as COPY data. The pgCopyIn
|
2006-02-05 21:58:47 +01:00
|
|
|
* check is only needed for backwards compatibility with ancient
|
|
|
|
* archive files that might just issue a COPY command without marking
|
|
|
|
* it properly. Note that in an archive entry that has a copyStmt,
|
|
|
|
* all data up to the end of the entry will go to _sendCopyLine, and
|
|
|
|
* therefore will be dropped if libpq has failed to enter COPY mode.
|
|
|
|
* Also, if a "\." data terminator is found, anything remaining in the
|
|
|
|
* archive entry will be dropped.
|
|
|
|
*/
|
|
|
|
if (AH->pgCopyIn || AH->writingCopyData)
|
2002-01-18 18:13:51 +01:00
|
|
|
qry = _sendCopyLine(AH, qry, eos);
|
2002-01-18 20:17:05 +01:00
|
|
|
else
|
2002-01-18 18:13:51 +01:00
|
|
|
qry = _sendSQLLine(AH, qry, eos);
|
2000-07-21 13:43:26 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2001-03-22 05:01:46 +01:00
|
|
|
void
|
|
|
|
StartTransaction(ArchiveHandle *AH)
|
2000-07-21 13:43:26 +02:00
|
|
|
{
|
2008-08-16 04:25:06 +02:00
|
|
|
ExecuteSqlCommand(AH, "BEGIN", "could not start database transaction");
|
2000-07-21 13:43:26 +02:00
|
|
|
}
|
|
|
|
|
2001-03-22 05:01:46 +01:00
|
|
|
void
|
|
|
|
CommitTransaction(ArchiveHandle *AH)
|
2000-07-21 13:43:26 +02:00
|
|
|
{
|
2008-08-16 04:25:06 +02:00
|
|
|
ExecuteSqlCommand(AH, "COMMIT", "could not commit database transaction");
|
2000-10-31 15:20:30 +01:00
|
|
|
}
|
2004-08-20 18:07:15 +02:00
|
|
|
|
2009-12-14 01:39:11 +01:00
|
|
|
void
|
|
|
|
DropBlobIfExists(ArchiveHandle *AH, Oid oid)
|
|
|
|
{
|
2010-02-18 02:29:10 +01:00
|
|
|
/*
|
|
|
|
* If we are not restoring to a direct database connection, we have to
|
|
|
|
* guess about how to detect whether the blob exists. Assume new-style.
|
|
|
|
*/
|
|
|
|
if (AH->connection == NULL ||
|
|
|
|
PQserverVersion(AH->connection) >= 90000)
|
2009-12-14 01:39:11 +01:00
|
|
|
{
|
2010-02-18 02:29:10 +01:00
|
|
|
ahprintf(AH,
|
|
|
|
"SELECT pg_catalog.lo_unlink(oid) "
|
|
|
|
"FROM pg_catalog.pg_largeobject_metadata "
|
|
|
|
"WHERE oid = '%u';\n",
|
|
|
|
oid);
|
2009-12-14 01:39:11 +01:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2010-02-18 02:29:10 +01:00
|
|
|
/* 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",
|
2009-12-14 01:39:11 +01:00
|
|
|
oid, oid);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-09-11 06:10:25 +02:00
|
|
|
static bool
|
2004-08-29 07:07:03 +02:00
|
|
|
_isIdentChar(unsigned char c)
|
2004-08-20 18:07:15 +02:00
|
|
|
{
|
2004-08-29 07:07:03 +02:00
|
|
|
if ((c >= 'a' && c <= 'z')
|
|
|
|
|| (c >= 'A' && c <= 'Z')
|
|
|
|
|| (c >= '0' && c <= '9')
|
|
|
|
|| (c == '_')
|
|
|
|
|| (c == '$')
|
2005-10-15 04:49:52 +02:00
|
|
|
|| (c >= (unsigned char) '\200') /* no need to check <= \377 */
|
2004-08-29 07:07:03 +02:00
|
|
|
)
|
2005-09-11 06:10:25 +02:00
|
|
|
return true;
|
2004-08-20 18:07:15 +02:00
|
|
|
else
|
2005-09-11 06:10:25 +02:00
|
|
|
return false;
|
2004-08-20 18:07:15 +02:00
|
|
|
}
|
|
|
|
|
2005-09-11 06:10:25 +02:00
|
|
|
static bool
|
|
|
|
_isDQChar(unsigned char c, bool atStart)
|
2004-08-29 00:52:50 +02:00
|
|
|
{
|
2004-08-29 07:07:03 +02:00
|
|
|
if ((c >= 'a' && c <= 'z')
|
|
|
|
|| (c >= 'A' && c <= 'Z')
|
|
|
|
|| (c == '_')
|
2005-09-11 06:10:25 +02:00
|
|
|
|| (!atStart && c >= '0' && c <= '9')
|
2005-10-15 04:49:52 +02:00
|
|
|
|| (c >= (unsigned char) '\200') /* no need to check <= \377 */
|
2004-08-29 07:07:03 +02:00
|
|
|
)
|
2005-09-11 06:10:25 +02:00
|
|
|
return true;
|
2004-08-20 18:07:15 +02:00
|
|
|
else
|
2005-09-11 06:10:25 +02:00
|
|
|
return false;
|
2004-08-20 18:07:15 +02:00
|
|
|
}
|